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_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2524 {
2525         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2526         return NDR_ERR_SUCCESS;
2527 }
2528
2529 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2530 {
2531         uint32_t v;
2532         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2533         *r = v;
2534         return NDR_ERR_SUCCESS;
2535 }
2536
2537 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
2538 {
2539         ndr_print_uint32(ndr, name, r);
2540         ndr->depth++;
2541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
2542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
2543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
2544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
2545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
2546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
2547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
2548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
2549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
2550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
2551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
2552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
2553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
2554         ndr->depth--;
2555 }
2556
2557 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2558 {
2559         if (ndr_flags & NDR_SCALARS) {
2560                 NDR_CHECK(ndr_push_align(ndr, 4));
2561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2562                 {
2563                         uint32_t _flags_save_string = ndr->flags;
2564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2566                         ndr->flags = _flags_save_string;
2567                 }
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2572                         ndr->flags = _flags_save_string;
2573                 }
2574                 {
2575                         uint32_t _flags_save_string = ndr->flags;
2576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2578                         ndr->flags = _flags_save_string;
2579                 }
2580                 {
2581                         uint32_t _flags_save_string = ndr->flags;
2582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2584                         ndr->flags = _flags_save_string;
2585                 }
2586                 {
2587                         uint32_t _flags_save_string = ndr->flags;
2588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2590                         ndr->flags = _flags_save_string;
2591                 }
2592                 {
2593                         uint32_t _flags_save_string = ndr->flags;
2594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2596                         ndr->flags = _flags_save_string;
2597                 }
2598                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2603                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2604         }
2605         if (ndr_flags & NDR_BUFFERS) {
2606                 {
2607                         uint32_t _flags_save_string = ndr->flags;
2608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2609                         if (r->printer_name) {
2610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615                 {
2616                         uint32_t _flags_save_string = ndr->flags;
2617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2618                         if (r->server_name) {
2619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2621                         }
2622                         ndr->flags = _flags_save_string;
2623                 }
2624                 {
2625                         uint32_t _flags_save_string = ndr->flags;
2626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2627                         if (r->user_name) {
2628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2630                         }
2631                         ndr->flags = _flags_save_string;
2632                 }
2633                 {
2634                         uint32_t _flags_save_string = ndr->flags;
2635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2636                         if (r->document_name) {
2637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2639                         }
2640                         ndr->flags = _flags_save_string;
2641                 }
2642                 {
2643                         uint32_t _flags_save_string = ndr->flags;
2644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2645                         if (r->data_type) {
2646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2648                         }
2649                         ndr->flags = _flags_save_string;
2650                 }
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->text_status) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660         }
2661         return NDR_ERR_SUCCESS;
2662 }
2663
2664 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2665 {
2666         uint32_t _ptr_printer_name;
2667         TALLOC_CTX *_mem_save_printer_name_0;
2668         uint32_t _ptr_server_name;
2669         TALLOC_CTX *_mem_save_server_name_0;
2670         uint32_t _ptr_user_name;
2671         TALLOC_CTX *_mem_save_user_name_0;
2672         uint32_t _ptr_document_name;
2673         TALLOC_CTX *_mem_save_document_name_0;
2674         uint32_t _ptr_data_type;
2675         TALLOC_CTX *_mem_save_data_type_0;
2676         uint32_t _ptr_text_status;
2677         TALLOC_CTX *_mem_save_text_status_0;
2678         if (ndr_flags & NDR_SCALARS) {
2679                 NDR_CHECK(ndr_pull_align(ndr, 4));
2680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2685                         if (_ptr_printer_name) {
2686                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2688                         } else {
2689                                 r->printer_name = NULL;
2690                         }
2691                         ndr->flags = _flags_save_string;
2692                 }
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2697                         if (_ptr_server_name) {
2698                                 NDR_PULL_ALLOC(ndr, r->server_name);
2699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2700                         } else {
2701                                 r->server_name = NULL;
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705                 {
2706                         uint32_t _flags_save_string = ndr->flags;
2707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2708                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2709                         if (_ptr_user_name) {
2710                                 NDR_PULL_ALLOC(ndr, r->user_name);
2711                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2712                         } else {
2713                                 r->user_name = NULL;
2714                         }
2715                         ndr->flags = _flags_save_string;
2716                 }
2717                 {
2718                         uint32_t _flags_save_string = ndr->flags;
2719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2721                         if (_ptr_document_name) {
2722                                 NDR_PULL_ALLOC(ndr, r->document_name);
2723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2724                         } else {
2725                                 r->document_name = NULL;
2726                         }
2727                         ndr->flags = _flags_save_string;
2728                 }
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2733                         if (_ptr_data_type) {
2734                                 NDR_PULL_ALLOC(ndr, r->data_type);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2736                         } else {
2737                                 r->data_type = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2745                         if (_ptr_text_status) {
2746                                 NDR_PULL_ALLOC(ndr, r->text_status);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2748                         } else {
2749                                 r->text_status = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2758                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2759         }
2760         if (ndr_flags & NDR_BUFFERS) {
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         if (r->printer_name) {
2765                                 uint32_t _relative_save_offset;
2766                                 _relative_save_offset = ndr->offset;
2767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2768                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2769                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2772                                 ndr->offset = _relative_save_offset;
2773                         }
2774                         ndr->flags = _flags_save_string;
2775                 }
2776                 {
2777                         uint32_t _flags_save_string = ndr->flags;
2778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2779                         if (r->server_name) {
2780                                 uint32_t _relative_save_offset;
2781                                 _relative_save_offset = ndr->offset;
2782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2783                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2787                                 ndr->offset = _relative_save_offset;
2788                         }
2789                         ndr->flags = _flags_save_string;
2790                 }
2791                 {
2792                         uint32_t _flags_save_string = ndr->flags;
2793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2794                         if (r->user_name) {
2795                                 uint32_t _relative_save_offset;
2796                                 _relative_save_offset = ndr->offset;
2797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2798                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2799                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2802                                 ndr->offset = _relative_save_offset;
2803                         }
2804                         ndr->flags = _flags_save_string;
2805                 }
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->document_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2813                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2817                                 ndr->offset = _relative_save_offset;
2818                         }
2819                         ndr->flags = _flags_save_string;
2820                 }
2821                 {
2822                         uint32_t _flags_save_string = ndr->flags;
2823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2824                         if (r->data_type) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2828                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2832                                 ndr->offset = _relative_save_offset;
2833                         }
2834                         ndr->flags = _flags_save_string;
2835                 }
2836                 {
2837                         uint32_t _flags_save_string = ndr->flags;
2838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2839                         if (r->text_status) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2843                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851         }
2852         return NDR_ERR_SUCCESS;
2853 }
2854
2855 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2856 {
2857         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2858         ndr->depth++;
2859         ndr_print_uint32(ndr, "job_id", r->job_id);
2860         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2861         ndr->depth++;
2862         if (r->printer_name) {
2863                 ndr_print_string(ndr, "printer_name", r->printer_name);
2864         }
2865         ndr->depth--;
2866         ndr_print_ptr(ndr, "server_name", r->server_name);
2867         ndr->depth++;
2868         if (r->server_name) {
2869                 ndr_print_string(ndr, "server_name", r->server_name);
2870         }
2871         ndr->depth--;
2872         ndr_print_ptr(ndr, "user_name", r->user_name);
2873         ndr->depth++;
2874         if (r->user_name) {
2875                 ndr_print_string(ndr, "user_name", r->user_name);
2876         }
2877         ndr->depth--;
2878         ndr_print_ptr(ndr, "document_name", r->document_name);
2879         ndr->depth++;
2880         if (r->document_name) {
2881                 ndr_print_string(ndr, "document_name", r->document_name);
2882         }
2883         ndr->depth--;
2884         ndr_print_ptr(ndr, "data_type", r->data_type);
2885         ndr->depth++;
2886         if (r->data_type) {
2887                 ndr_print_string(ndr, "data_type", r->data_type);
2888         }
2889         ndr->depth--;
2890         ndr_print_ptr(ndr, "text_status", r->text_status);
2891         ndr->depth++;
2892         if (r->text_status) {
2893                 ndr_print_string(ndr, "text_status", r->text_status);
2894         }
2895         ndr->depth--;
2896         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2897         ndr_print_uint32(ndr, "priority", r->priority);
2898         ndr_print_uint32(ndr, "position", r->position);
2899         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2900         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2901         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2902         ndr->depth--;
2903 }
2904
2905 static enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2906 {
2907         if (ndr_flags & NDR_SCALARS) {
2908                 NDR_CHECK(ndr_push_align(ndr, 4));
2909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2910                 {
2911                         uint32_t _flags_save_string = ndr->flags;
2912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2913                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2914                         ndr->flags = _flags_save_string;
2915                 }
2916                 {
2917                         uint32_t _flags_save_string = ndr->flags;
2918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2919                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2920                         ndr->flags = _flags_save_string;
2921                 }
2922                 {
2923                         uint32_t _flags_save_string = ndr->flags;
2924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2925                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2926                         ndr->flags = _flags_save_string;
2927                 }
2928                 {
2929                         uint32_t _flags_save_string = ndr->flags;
2930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2931                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2932                         ndr->flags = _flags_save_string;
2933                 }
2934                 {
2935                         uint32_t _flags_save_string = ndr->flags;
2936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2937                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2938                         ndr->flags = _flags_save_string;
2939                 }
2940                 {
2941                         uint32_t _flags_save_string = ndr->flags;
2942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2944                         ndr->flags = _flags_save_string;
2945                 }
2946                 {
2947                         uint32_t _flags_save_string = ndr->flags;
2948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2949                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
2950                         ndr->flags = _flags_save_string;
2951                 }
2952                 {
2953                         uint32_t _flags_save_string = ndr->flags;
2954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2955                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
2956                         ndr->flags = _flags_save_string;
2957                 }
2958                 {
2959                         uint32_t _flags_save_string = ndr->flags;
2960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2961                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
2962                         ndr->flags = _flags_save_string;
2963                 }
2964                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2965                 {
2966                         uint32_t _flags_save_string = ndr->flags;
2967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2968                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2969                         ndr->flags = _flags_save_string;
2970                 }
2971                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2972                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
2976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
2977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2979                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2982         }
2983         if (ndr_flags & NDR_BUFFERS) {
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         if (r->printer_name) {
2988                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2989                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2990                         }
2991                         ndr->flags = _flags_save_string;
2992                 }
2993                 {
2994                         uint32_t _flags_save_string = ndr->flags;
2995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2996                         if (r->server_name) {
2997                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2998                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2999                         }
3000                         ndr->flags = _flags_save_string;
3001                 }
3002                 {
3003                         uint32_t _flags_save_string = ndr->flags;
3004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3005                         if (r->user_name) {
3006                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3007                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3008                         }
3009                         ndr->flags = _flags_save_string;
3010                 }
3011                 {
3012                         uint32_t _flags_save_string = ndr->flags;
3013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3014                         if (r->document_name) {
3015                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3016                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3017                         }
3018                         ndr->flags = _flags_save_string;
3019                 }
3020                 {
3021                         uint32_t _flags_save_string = ndr->flags;
3022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3023                         if (r->notify_name) {
3024                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3025                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3026                         }
3027                         ndr->flags = _flags_save_string;
3028                 }
3029                 {
3030                         uint32_t _flags_save_string = ndr->flags;
3031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3032                         if (r->data_type) {
3033                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3034                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3035                         }
3036                         ndr->flags = _flags_save_string;
3037                 }
3038                 {
3039                         uint32_t _flags_save_string = ndr->flags;
3040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3041                         if (r->print_processor) {
3042                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3043                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3044                         }
3045                         ndr->flags = _flags_save_string;
3046                 }
3047                 {
3048                         uint32_t _flags_save_string = ndr->flags;
3049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3050                         if (r->parameters) {
3051                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3052                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3053                         }
3054                         ndr->flags = _flags_save_string;
3055                 }
3056                 {
3057                         uint32_t _flags_save_string = ndr->flags;
3058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3059                         if (r->driver_name) {
3060                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3061                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3062                         }
3063                         ndr->flags = _flags_save_string;
3064                 }
3065                 if (r->devmode) {
3066                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3067                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3068                 }
3069                 {
3070                         uint32_t _flags_save_string = ndr->flags;
3071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3072                         if (r->text_status) {
3073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3075                         }
3076                         ndr->flags = _flags_save_string;
3077                 }
3078                 if (r->secdesc) {
3079                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3080                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3081                 }
3082         }
3083         return NDR_ERR_SUCCESS;
3084 }
3085
3086 static enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3087 {
3088         uint32_t _ptr_printer_name;
3089         TALLOC_CTX *_mem_save_printer_name_0;
3090         uint32_t _ptr_server_name;
3091         TALLOC_CTX *_mem_save_server_name_0;
3092         uint32_t _ptr_user_name;
3093         TALLOC_CTX *_mem_save_user_name_0;
3094         uint32_t _ptr_document_name;
3095         TALLOC_CTX *_mem_save_document_name_0;
3096         uint32_t _ptr_notify_name;
3097         TALLOC_CTX *_mem_save_notify_name_0;
3098         uint32_t _ptr_data_type;
3099         TALLOC_CTX *_mem_save_data_type_0;
3100         uint32_t _ptr_print_processor;
3101         TALLOC_CTX *_mem_save_print_processor_0;
3102         uint32_t _ptr_parameters;
3103         TALLOC_CTX *_mem_save_parameters_0;
3104         uint32_t _ptr_driver_name;
3105         TALLOC_CTX *_mem_save_driver_name_0;
3106         uint32_t _ptr_devmode;
3107         TALLOC_CTX *_mem_save_devmode_0;
3108         uint32_t _ptr_text_status;
3109         TALLOC_CTX *_mem_save_text_status_0;
3110         uint32_t _ptr_secdesc;
3111         TALLOC_CTX *_mem_save_secdesc_0;
3112         if (ndr_flags & NDR_SCALARS) {
3113                 NDR_CHECK(ndr_pull_align(ndr, 4));
3114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3115                 {
3116                         uint32_t _flags_save_string = ndr->flags;
3117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3118                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3119                         if (_ptr_printer_name) {
3120                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3121                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3122                         } else {
3123                                 r->printer_name = NULL;
3124                         }
3125                         ndr->flags = _flags_save_string;
3126                 }
3127                 {
3128                         uint32_t _flags_save_string = ndr->flags;
3129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3130                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3131                         if (_ptr_server_name) {
3132                                 NDR_PULL_ALLOC(ndr, r->server_name);
3133                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3134                         } else {
3135                                 r->server_name = NULL;
3136                         }
3137                         ndr->flags = _flags_save_string;
3138                 }
3139                 {
3140                         uint32_t _flags_save_string = ndr->flags;
3141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3142                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3143                         if (_ptr_user_name) {
3144                                 NDR_PULL_ALLOC(ndr, r->user_name);
3145                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3146                         } else {
3147                                 r->user_name = NULL;
3148                         }
3149                         ndr->flags = _flags_save_string;
3150                 }
3151                 {
3152                         uint32_t _flags_save_string = ndr->flags;
3153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3154                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3155                         if (_ptr_document_name) {
3156                                 NDR_PULL_ALLOC(ndr, r->document_name);
3157                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3158                         } else {
3159                                 r->document_name = NULL;
3160                         }
3161                         ndr->flags = _flags_save_string;
3162                 }
3163                 {
3164                         uint32_t _flags_save_string = ndr->flags;
3165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3166                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3167                         if (_ptr_notify_name) {
3168                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3169                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3170                         } else {
3171                                 r->notify_name = NULL;
3172                         }
3173                         ndr->flags = _flags_save_string;
3174                 }
3175                 {
3176                         uint32_t _flags_save_string = ndr->flags;
3177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3178                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3179                         if (_ptr_data_type) {
3180                                 NDR_PULL_ALLOC(ndr, r->data_type);
3181                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3182                         } else {
3183                                 r->data_type = NULL;
3184                         }
3185                         ndr->flags = _flags_save_string;
3186                 }
3187                 {
3188                         uint32_t _flags_save_string = ndr->flags;
3189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3190                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3191                         if (_ptr_print_processor) {
3192                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3193                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3194                         } else {
3195                                 r->print_processor = NULL;
3196                         }
3197                         ndr->flags = _flags_save_string;
3198                 }
3199                 {
3200                         uint32_t _flags_save_string = ndr->flags;
3201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3202                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3203                         if (_ptr_parameters) {
3204                                 NDR_PULL_ALLOC(ndr, r->parameters);
3205                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3206                         } else {
3207                                 r->parameters = NULL;
3208                         }
3209                         ndr->flags = _flags_save_string;
3210                 }
3211                 {
3212                         uint32_t _flags_save_string = ndr->flags;
3213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3215                         if (_ptr_driver_name) {
3216                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3218                         } else {
3219                                 r->driver_name = NULL;
3220                         }
3221                         ndr->flags = _flags_save_string;
3222                 }
3223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3224                 if (_ptr_devmode) {
3225                         NDR_PULL_ALLOC(ndr, r->devmode);
3226                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3227                 } else {
3228                         r->devmode = NULL;
3229                 }
3230                 {
3231                         uint32_t _flags_save_string = ndr->flags;
3232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3233                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3234                         if (_ptr_text_status) {
3235                                 NDR_PULL_ALLOC(ndr, r->text_status);
3236                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3237                         } else {
3238                                 r->text_status = NULL;
3239                         }
3240                         ndr->flags = _flags_save_string;
3241                 }
3242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3243                 if (_ptr_secdesc) {
3244                         NDR_PULL_ALLOC(ndr, r->secdesc);
3245                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3246                 } else {
3247                         r->secdesc = NULL;
3248                 }
3249                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3251                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3252                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3256                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3259         }
3260         if (ndr_flags & NDR_BUFFERS) {
3261                 {
3262                         uint32_t _flags_save_string = ndr->flags;
3263                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3264                         if (r->printer_name) {
3265                                 uint32_t _relative_save_offset;
3266                                 _relative_save_offset = ndr->offset;
3267                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3268                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3269                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3270                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3271                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3272                                 ndr->offset = _relative_save_offset;
3273                         }
3274                         ndr->flags = _flags_save_string;
3275                 }
3276                 {
3277                         uint32_t _flags_save_string = ndr->flags;
3278                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3279                         if (r->server_name) {
3280                                 uint32_t _relative_save_offset;
3281                                 _relative_save_offset = ndr->offset;
3282                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3283                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3284                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3285                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3286                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3287                                 ndr->offset = _relative_save_offset;
3288                         }
3289                         ndr->flags = _flags_save_string;
3290                 }
3291                 {
3292                         uint32_t _flags_save_string = ndr->flags;
3293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3294                         if (r->user_name) {
3295                                 uint32_t _relative_save_offset;
3296                                 _relative_save_offset = ndr->offset;
3297                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3298                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3299                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3300                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3301                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3302                                 ndr->offset = _relative_save_offset;
3303                         }
3304                         ndr->flags = _flags_save_string;
3305                 }
3306                 {
3307                         uint32_t _flags_save_string = ndr->flags;
3308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3309                         if (r->document_name) {
3310                                 uint32_t _relative_save_offset;
3311                                 _relative_save_offset = ndr->offset;
3312                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3313                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3314                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3315                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3316                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3317                                 ndr->offset = _relative_save_offset;
3318                         }
3319                         ndr->flags = _flags_save_string;
3320                 }
3321                 {
3322                         uint32_t _flags_save_string = ndr->flags;
3323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3324                         if (r->notify_name) {
3325                                 uint32_t _relative_save_offset;
3326                                 _relative_save_offset = ndr->offset;
3327                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3328                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3329                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3330                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3331                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3332                                 ndr->offset = _relative_save_offset;
3333                         }
3334                         ndr->flags = _flags_save_string;
3335                 }
3336                 {
3337                         uint32_t _flags_save_string = ndr->flags;
3338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3339                         if (r->data_type) {
3340                                 uint32_t _relative_save_offset;
3341                                 _relative_save_offset = ndr->offset;
3342                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3343                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3344                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3345                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3346                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3347                                 ndr->offset = _relative_save_offset;
3348                         }
3349                         ndr->flags = _flags_save_string;
3350                 }
3351                 {
3352                         uint32_t _flags_save_string = ndr->flags;
3353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3354                         if (r->print_processor) {
3355                                 uint32_t _relative_save_offset;
3356                                 _relative_save_offset = ndr->offset;
3357                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3358                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3359                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3360                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3361                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3362                                 ndr->offset = _relative_save_offset;
3363                         }
3364                         ndr->flags = _flags_save_string;
3365                 }
3366                 {
3367                         uint32_t _flags_save_string = ndr->flags;
3368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3369                         if (r->parameters) {
3370                                 uint32_t _relative_save_offset;
3371                                 _relative_save_offset = ndr->offset;
3372                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3373                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3374                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3375                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3376                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3377                                 ndr->offset = _relative_save_offset;
3378                         }
3379                         ndr->flags = _flags_save_string;
3380                 }
3381                 {
3382                         uint32_t _flags_save_string = ndr->flags;
3383                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3384                         if (r->driver_name) {
3385                                 uint32_t _relative_save_offset;
3386                                 _relative_save_offset = ndr->offset;
3387                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3388                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3389                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3390                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3391                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3392                                 ndr->offset = _relative_save_offset;
3393                         }
3394                         ndr->flags = _flags_save_string;
3395                 }
3396                 if (r->devmode) {
3397                         uint32_t _relative_save_offset;
3398                         _relative_save_offset = ndr->offset;
3399                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3400                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3401                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3402                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3404                         ndr->offset = _relative_save_offset;
3405                 }
3406                 {
3407                         uint32_t _flags_save_string = ndr->flags;
3408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3409                         if (r->text_status) {
3410                                 uint32_t _relative_save_offset;
3411                                 _relative_save_offset = ndr->offset;
3412                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3413                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3414                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3415                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3416                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3417                                 ndr->offset = _relative_save_offset;
3418                         }
3419                         ndr->flags = _flags_save_string;
3420                 }
3421                 if (r->secdesc) {
3422                         uint32_t _relative_save_offset;
3423                         _relative_save_offset = ndr->offset;
3424                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3425                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3426                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3427                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3428                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3429                         ndr->offset = _relative_save_offset;
3430                 }
3431         }
3432         return NDR_ERR_SUCCESS;
3433 }
3434
3435 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3436 {
3437         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3438         ndr->depth++;
3439         ndr_print_uint32(ndr, "job_id", r->job_id);
3440         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3441         ndr->depth++;
3442         if (r->printer_name) {
3443                 ndr_print_string(ndr, "printer_name", r->printer_name);
3444         }
3445         ndr->depth--;
3446         ndr_print_ptr(ndr, "server_name", r->server_name);
3447         ndr->depth++;
3448         if (r->server_name) {
3449                 ndr_print_string(ndr, "server_name", r->server_name);
3450         }
3451         ndr->depth--;
3452         ndr_print_ptr(ndr, "user_name", r->user_name);
3453         ndr->depth++;
3454         if (r->user_name) {
3455                 ndr_print_string(ndr, "user_name", r->user_name);
3456         }
3457         ndr->depth--;
3458         ndr_print_ptr(ndr, "document_name", r->document_name);
3459         ndr->depth++;
3460         if (r->document_name) {
3461                 ndr_print_string(ndr, "document_name", r->document_name);
3462         }
3463         ndr->depth--;
3464         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3465         ndr->depth++;
3466         if (r->notify_name) {
3467                 ndr_print_string(ndr, "notify_name", r->notify_name);
3468         }
3469         ndr->depth--;
3470         ndr_print_ptr(ndr, "data_type", r->data_type);
3471         ndr->depth++;
3472         if (r->data_type) {
3473                 ndr_print_string(ndr, "data_type", r->data_type);
3474         }
3475         ndr->depth--;
3476         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3477         ndr->depth++;
3478         if (r->print_processor) {
3479                 ndr_print_string(ndr, "print_processor", r->print_processor);
3480         }
3481         ndr->depth--;
3482         ndr_print_ptr(ndr, "parameters", r->parameters);
3483         ndr->depth++;
3484         if (r->parameters) {
3485                 ndr_print_string(ndr, "parameters", r->parameters);
3486         }
3487         ndr->depth--;
3488         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3489         ndr->depth++;
3490         if (r->driver_name) {
3491                 ndr_print_string(ndr, "driver_name", r->driver_name);
3492         }
3493         ndr->depth--;
3494         ndr_print_ptr(ndr, "devmode", r->devmode);
3495         ndr->depth++;
3496         if (r->devmode) {
3497                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3498         }
3499         ndr->depth--;
3500         ndr_print_ptr(ndr, "text_status", r->text_status);
3501         ndr->depth++;
3502         if (r->text_status) {
3503                 ndr_print_string(ndr, "text_status", r->text_status);
3504         }
3505         ndr->depth--;
3506         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3507         ndr->depth++;
3508         if (r->secdesc) {
3509                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3510         }
3511         ndr->depth--;
3512         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3513         ndr_print_uint32(ndr, "priority", r->priority);
3514         ndr_print_uint32(ndr, "position", r->position);
3515         ndr_print_uint32(ndr, "start_time", r->start_time);
3516         ndr_print_uint32(ndr, "until_time", r->until_time);
3517         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3518         ndr_print_uint32(ndr, "size", r->size);
3519         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3520         ndr_print_uint32(ndr, "time", r->time);
3521         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3522         ndr->depth--;
3523 }
3524
3525 static enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3526 {
3527         if (ndr_flags & NDR_SCALARS) {
3528                 NDR_CHECK(ndr_push_align(ndr, 4));
3529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3532         }
3533         if (ndr_flags & NDR_BUFFERS) {
3534         }
3535         return NDR_ERR_SUCCESS;
3536 }
3537
3538 static enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3539 {
3540         if (ndr_flags & NDR_SCALARS) {
3541                 NDR_CHECK(ndr_pull_align(ndr, 4));
3542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3545         }
3546         if (ndr_flags & NDR_BUFFERS) {
3547         }
3548         return NDR_ERR_SUCCESS;
3549 }
3550
3551 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3552 {
3553         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3554         ndr->depth++;
3555         ndr_print_uint32(ndr, "job_id", r->job_id);
3556         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3557         ndr_print_uint32(ndr, "reserved", r->reserved);
3558         ndr->depth--;
3559 }
3560
3561 static enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3562 {
3563         if (ndr_flags & NDR_SCALARS) {
3564                 NDR_CHECK(ndr_push_align(ndr, 4));
3565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3566                 {
3567                         uint32_t _flags_save_string = ndr->flags;
3568                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3569                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3570                         ndr->flags = _flags_save_string;
3571                 }
3572                 {
3573                         uint32_t _flags_save_string = ndr->flags;
3574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3576                         ndr->flags = _flags_save_string;
3577                 }
3578                 {
3579                         uint32_t _flags_save_string = ndr->flags;
3580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3582                         ndr->flags = _flags_save_string;
3583                 }
3584                 {
3585                         uint32_t _flags_save_string = ndr->flags;
3586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3588                         ndr->flags = _flags_save_string;
3589                 }
3590                 {
3591                         uint32_t _flags_save_string = ndr->flags;
3592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3594                         ndr->flags = _flags_save_string;
3595                 }
3596                 {
3597                         uint32_t _flags_save_string = ndr->flags;
3598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3600                         ndr->flags = _flags_save_string;
3601                 }
3602                 {
3603                         uint32_t _flags_save_string = ndr->flags;
3604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3606                         ndr->flags = _flags_save_string;
3607                 }
3608                 {
3609                         uint32_t _flags_save_string = ndr->flags;
3610                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3611                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3612                         ndr->flags = _flags_save_string;
3613                 }
3614                 {
3615                         uint32_t _flags_save_string = ndr->flags;
3616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3617                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3618                         ndr->flags = _flags_save_string;
3619                 }
3620                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3621                 {
3622                         uint32_t _flags_save_string = ndr->flags;
3623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3625                         ndr->flags = _flags_save_string;
3626                 }
3627                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3628                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3635                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3639         }
3640         if (ndr_flags & NDR_BUFFERS) {
3641                 {
3642                         uint32_t _flags_save_string = ndr->flags;
3643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3644                         if (r->printer_name) {
3645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3647                         }
3648                         ndr->flags = _flags_save_string;
3649                 }
3650                 {
3651                         uint32_t _flags_save_string = ndr->flags;
3652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3653                         if (r->server_name) {
3654                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3656                         }
3657                         ndr->flags = _flags_save_string;
3658                 }
3659                 {
3660                         uint32_t _flags_save_string = ndr->flags;
3661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3662                         if (r->user_name) {
3663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3665                         }
3666                         ndr->flags = _flags_save_string;
3667                 }
3668                 {
3669                         uint32_t _flags_save_string = ndr->flags;
3670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3671                         if (r->document_name) {
3672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3674                         }
3675                         ndr->flags = _flags_save_string;
3676                 }
3677                 {
3678                         uint32_t _flags_save_string = ndr->flags;
3679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3680                         if (r->notify_name) {
3681                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3682                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3683                         }
3684                         ndr->flags = _flags_save_string;
3685                 }
3686                 {
3687                         uint32_t _flags_save_string = ndr->flags;
3688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3689                         if (r->data_type) {
3690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3692                         }
3693                         ndr->flags = _flags_save_string;
3694                 }
3695                 {
3696                         uint32_t _flags_save_string = ndr->flags;
3697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3698                         if (r->print_processor) {
3699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3701                         }
3702                         ndr->flags = _flags_save_string;
3703                 }
3704                 {
3705                         uint32_t _flags_save_string = ndr->flags;
3706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3707                         if (r->parameters) {
3708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3710                         }
3711                         ndr->flags = _flags_save_string;
3712                 }
3713                 {
3714                         uint32_t _flags_save_string = ndr->flags;
3715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3716                         if (r->driver_name) {
3717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3719                         }
3720                         ndr->flags = _flags_save_string;
3721                 }
3722                 if (r->devmode) {
3723                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3724                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3725                 }
3726                 {
3727                         uint32_t _flags_save_string = ndr->flags;
3728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3729                         if (r->text_status) {
3730                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3731                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3732                         }
3733                         ndr->flags = _flags_save_string;
3734                 }
3735                 if (r->secdesc) {
3736                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3737                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3738                 }
3739         }
3740         return NDR_ERR_SUCCESS;
3741 }
3742
3743 static enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3744 {
3745         uint32_t _ptr_printer_name;
3746         TALLOC_CTX *_mem_save_printer_name_0;
3747         uint32_t _ptr_server_name;
3748         TALLOC_CTX *_mem_save_server_name_0;
3749         uint32_t _ptr_user_name;
3750         TALLOC_CTX *_mem_save_user_name_0;
3751         uint32_t _ptr_document_name;
3752         TALLOC_CTX *_mem_save_document_name_0;
3753         uint32_t _ptr_notify_name;
3754         TALLOC_CTX *_mem_save_notify_name_0;
3755         uint32_t _ptr_data_type;
3756         TALLOC_CTX *_mem_save_data_type_0;
3757         uint32_t _ptr_print_processor;
3758         TALLOC_CTX *_mem_save_print_processor_0;
3759         uint32_t _ptr_parameters;
3760         TALLOC_CTX *_mem_save_parameters_0;
3761         uint32_t _ptr_driver_name;
3762         TALLOC_CTX *_mem_save_driver_name_0;
3763         uint32_t _ptr_devmode;
3764         TALLOC_CTX *_mem_save_devmode_0;
3765         uint32_t _ptr_text_status;
3766         TALLOC_CTX *_mem_save_text_status_0;
3767         uint32_t _ptr_secdesc;
3768         TALLOC_CTX *_mem_save_secdesc_0;
3769         if (ndr_flags & NDR_SCALARS) {
3770                 NDR_CHECK(ndr_pull_align(ndr, 4));
3771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3772                 {
3773                         uint32_t _flags_save_string = ndr->flags;
3774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3776                         if (_ptr_printer_name) {
3777                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3779                         } else {
3780                                 r->printer_name = NULL;
3781                         }
3782                         ndr->flags = _flags_save_string;
3783                 }
3784                 {
3785                         uint32_t _flags_save_string = ndr->flags;
3786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3788                         if (_ptr_server_name) {
3789                                 NDR_PULL_ALLOC(ndr, r->server_name);
3790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3791                         } else {
3792                                 r->server_name = NULL;
3793                         }
3794                         ndr->flags = _flags_save_string;
3795                 }
3796                 {
3797                         uint32_t _flags_save_string = ndr->flags;
3798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3800                         if (_ptr_user_name) {
3801                                 NDR_PULL_ALLOC(ndr, r->user_name);
3802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3803                         } else {
3804                                 r->user_name = NULL;
3805                         }
3806                         ndr->flags = _flags_save_string;
3807                 }
3808                 {
3809                         uint32_t _flags_save_string = ndr->flags;
3810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3812                         if (_ptr_document_name) {
3813                                 NDR_PULL_ALLOC(ndr, r->document_name);
3814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3815                         } else {
3816                                 r->document_name = NULL;
3817                         }
3818                         ndr->flags = _flags_save_string;
3819                 }
3820                 {
3821                         uint32_t _flags_save_string = ndr->flags;
3822                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3823                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3824                         if (_ptr_notify_name) {
3825                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3826                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3827                         } else {
3828                                 r->notify_name = NULL;
3829                         }
3830                         ndr->flags = _flags_save_string;
3831                 }
3832                 {
3833                         uint32_t _flags_save_string = ndr->flags;
3834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3835                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3836                         if (_ptr_data_type) {
3837                                 NDR_PULL_ALLOC(ndr, r->data_type);
3838                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3839                         } else {
3840                                 r->data_type = NULL;
3841                         }
3842                         ndr->flags = _flags_save_string;
3843                 }
3844                 {
3845                         uint32_t _flags_save_string = ndr->flags;
3846                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3847                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3848                         if (_ptr_print_processor) {
3849                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3850                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3851                         } else {
3852                                 r->print_processor = NULL;
3853                         }
3854                         ndr->flags = _flags_save_string;
3855                 }
3856                 {
3857                         uint32_t _flags_save_string = ndr->flags;
3858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3859                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3860                         if (_ptr_parameters) {
3861                                 NDR_PULL_ALLOC(ndr, r->parameters);
3862                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3863                         } else {
3864                                 r->parameters = NULL;
3865                         }
3866                         ndr->flags = _flags_save_string;
3867                 }
3868                 {
3869                         uint32_t _flags_save_string = ndr->flags;
3870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3871                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3872                         if (_ptr_driver_name) {
3873                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3874                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3875                         } else {
3876                                 r->driver_name = NULL;
3877                         }
3878                         ndr->flags = _flags_save_string;
3879                 }
3880                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3881                 if (_ptr_devmode) {
3882                         NDR_PULL_ALLOC(ndr, r->devmode);
3883                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3884                 } else {
3885                         r->devmode = NULL;
3886                 }
3887                 {
3888                         uint32_t _flags_save_string = ndr->flags;
3889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3891                         if (_ptr_text_status) {
3892                                 NDR_PULL_ALLOC(ndr, r->text_status);
3893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3894                         } else {
3895                                 r->text_status = NULL;
3896                         }
3897                         ndr->flags = _flags_save_string;
3898                 }
3899                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3900                 if (_ptr_secdesc) {
3901                         NDR_PULL_ALLOC(ndr, r->secdesc);
3902                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3903                 } else {
3904                         r->secdesc = NULL;
3905                 }
3906                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3913                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3914                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3917         }
3918         if (ndr_flags & NDR_BUFFERS) {
3919                 {
3920                         uint32_t _flags_save_string = ndr->flags;
3921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3922                         if (r->printer_name) {
3923                                 uint32_t _relative_save_offset;
3924                                 _relative_save_offset = ndr->offset;
3925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3926                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3927                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3930                                 ndr->offset = _relative_save_offset;
3931                         }
3932                         ndr->flags = _flags_save_string;
3933                 }
3934                 {
3935                         uint32_t _flags_save_string = ndr->flags;
3936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3937                         if (r->server_name) {
3938                                 uint32_t _relative_save_offset;
3939                                 _relative_save_offset = ndr->offset;
3940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3941                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3945                                 ndr->offset = _relative_save_offset;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 {
3950                         uint32_t _flags_save_string = ndr->flags;
3951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3952                         if (r->user_name) {
3953                                 uint32_t _relative_save_offset;
3954                                 _relative_save_offset = ndr->offset;
3955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3956                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3957                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3960                                 ndr->offset = _relative_save_offset;
3961                         }
3962                         ndr->flags = _flags_save_string;
3963                 }
3964                 {
3965                         uint32_t _flags_save_string = ndr->flags;
3966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3967                         if (r->document_name) {
3968                                 uint32_t _relative_save_offset;
3969                                 _relative_save_offset = ndr->offset;
3970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3971                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3975                                 ndr->offset = _relative_save_offset;
3976                         }
3977                         ndr->flags = _flags_save_string;
3978                 }
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->notify_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3986                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3990                                 ndr->offset = _relative_save_offset;
3991                         }
3992                         ndr->flags = _flags_save_string;
3993                 }
3994                 {
3995                         uint32_t _flags_save_string = ndr->flags;
3996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3997                         if (r->data_type) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4001                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4005                                 ndr->offset = _relative_save_offset;
4006                         }
4007                         ndr->flags = _flags_save_string;
4008                 }
4009                 {
4010                         uint32_t _flags_save_string = ndr->flags;
4011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4012                         if (r->print_processor) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4016                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4020                                 ndr->offset = _relative_save_offset;
4021                         }
4022                         ndr->flags = _flags_save_string;
4023                 }
4024                 {
4025                         uint32_t _flags_save_string = ndr->flags;
4026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4027                         if (r->parameters) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4031                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4035                                 ndr->offset = _relative_save_offset;
4036                         }
4037                         ndr->flags = _flags_save_string;
4038                 }
4039                 {
4040                         uint32_t _flags_save_string = ndr->flags;
4041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4042                         if (r->driver_name) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4046                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4050                                 ndr->offset = _relative_save_offset;
4051                         }
4052                         ndr->flags = _flags_save_string;
4053                 }
4054                 if (r->devmode) {
4055                         uint32_t _relative_save_offset;
4056                         _relative_save_offset = ndr->offset;
4057                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4058                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4059                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4060                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4061                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4062                         ndr->offset = _relative_save_offset;
4063                 }
4064                 {
4065                         uint32_t _flags_save_string = ndr->flags;
4066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4067                         if (r->text_status) {
4068                                 uint32_t _relative_save_offset;
4069                                 _relative_save_offset = ndr->offset;
4070                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4071                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4072                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4073                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4074                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4075                                 ndr->offset = _relative_save_offset;
4076                         }
4077                         ndr->flags = _flags_save_string;
4078                 }
4079                 if (r->secdesc) {
4080                         uint32_t _relative_save_offset;
4081                         _relative_save_offset = ndr->offset;
4082                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4083                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4084                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4085                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4087                         ndr->offset = _relative_save_offset;
4088                 }
4089         }
4090         return NDR_ERR_SUCCESS;
4091 }
4092
4093 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4094 {
4095         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4096         ndr->depth++;
4097         ndr_print_uint32(ndr, "job_id", r->job_id);
4098         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4099         ndr->depth++;
4100         if (r->printer_name) {
4101                 ndr_print_string(ndr, "printer_name", r->printer_name);
4102         }
4103         ndr->depth--;
4104         ndr_print_ptr(ndr, "server_name", r->server_name);
4105         ndr->depth++;
4106         if (r->server_name) {
4107                 ndr_print_string(ndr, "server_name", r->server_name);
4108         }
4109         ndr->depth--;
4110         ndr_print_ptr(ndr, "user_name", r->user_name);
4111         ndr->depth++;
4112         if (r->user_name) {
4113                 ndr_print_string(ndr, "user_name", r->user_name);
4114         }
4115         ndr->depth--;
4116         ndr_print_ptr(ndr, "document_name", r->document_name);
4117         ndr->depth++;
4118         if (r->document_name) {
4119                 ndr_print_string(ndr, "document_name", r->document_name);
4120         }
4121         ndr->depth--;
4122         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4123         ndr->depth++;
4124         if (r->notify_name) {
4125                 ndr_print_string(ndr, "notify_name", r->notify_name);
4126         }
4127         ndr->depth--;
4128         ndr_print_ptr(ndr, "data_type", r->data_type);
4129         ndr->depth++;
4130         if (r->data_type) {
4131                 ndr_print_string(ndr, "data_type", r->data_type);
4132         }
4133         ndr->depth--;
4134         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4135         ndr->depth++;
4136         if (r->print_processor) {
4137                 ndr_print_string(ndr, "print_processor", r->print_processor);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "parameters", r->parameters);
4141         ndr->depth++;
4142         if (r->parameters) {
4143                 ndr_print_string(ndr, "parameters", r->parameters);
4144         }
4145         ndr->depth--;
4146         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4147         ndr->depth++;
4148         if (r->driver_name) {
4149                 ndr_print_string(ndr, "driver_name", r->driver_name);
4150         }
4151         ndr->depth--;
4152         ndr_print_ptr(ndr, "devmode", r->devmode);
4153         ndr->depth++;
4154         if (r->devmode) {
4155                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4156         }
4157         ndr->depth--;
4158         ndr_print_ptr(ndr, "text_status", r->text_status);
4159         ndr->depth++;
4160         if (r->text_status) {
4161                 ndr_print_string(ndr, "text_status", r->text_status);
4162         }
4163         ndr->depth--;
4164         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4165         ndr->depth++;
4166         if (r->secdesc) {
4167                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4168         }
4169         ndr->depth--;
4170         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4171         ndr_print_uint32(ndr, "priority", r->priority);
4172         ndr_print_uint32(ndr, "position", r->position);
4173         ndr_print_uint32(ndr, "start_time", r->start_time);
4174         ndr_print_uint32(ndr, "until_time", r->until_time);
4175         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4176         ndr_print_uint32(ndr, "size", r->size);
4177         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4178         ndr_print_uint32(ndr, "time", r->time);
4179         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4180         ndr_print_uint32(ndr, "size_high", r->size_high);
4181         ndr->depth--;
4182 }
4183
4184 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4185 {
4186         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4187         if (ndr_flags & NDR_SCALARS) {
4188                 int level = ndr_push_get_switch_value(ndr, r);
4189                 switch (level) {
4190                         case 1: {
4191                                 NDR_CHECK(ndr_push_align(ndr, 4));
4192                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4193                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4194                         break; }
4195
4196                         case 2: {
4197                                 NDR_CHECK(ndr_push_align(ndr, 4));
4198                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4199                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4200                         break; }
4201
4202                         case 3: {
4203                                 NDR_CHECK(ndr_push_align(ndr, 4));
4204                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4205                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4206                         break; }
4207
4208                         case 4: {
4209                                 NDR_CHECK(ndr_push_align(ndr, 4));
4210                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4211                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4212                         break; }
4213
4214                         default: {
4215                         break; }
4216
4217                 }
4218         }
4219         if (ndr_flags & NDR_BUFFERS) {
4220                 int level = ndr_push_get_switch_value(ndr, r);
4221                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4222                 switch (level) {
4223                         case 1:
4224                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4225                         break;
4226
4227                         case 2:
4228                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4229                         break;
4230
4231                         case 3:
4232                         break;
4233
4234                         case 4:
4235                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4236                         break;
4237
4238                         default:
4239                         break;
4240
4241                 }
4242         }
4243         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4244         return NDR_ERR_SUCCESS;
4245 }
4246
4247 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4248 {
4249         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4250         int level;
4251         level = ndr_pull_get_switch_value(ndr, r);
4252         if (ndr_flags & NDR_SCALARS) {
4253                 switch (level) {
4254                         case 1: {
4255                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4256                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4257                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4258                         break; }
4259
4260                         case 2: {
4261                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4262                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4263                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4264                         break; }
4265
4266                         case 3: {
4267                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4268                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4269                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4270                         break; }
4271
4272                         case 4: {
4273                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4274                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4275                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4276                         break; }
4277
4278                         default: {
4279                         break; }
4280
4281                 }
4282         }
4283         if (ndr_flags & NDR_BUFFERS) {
4284                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4285                 switch (level) {
4286                         case 1:
4287                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4288                         break;
4289
4290                         case 2:
4291                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4292                         break;
4293
4294                         case 3:
4295                         break;
4296
4297                         case 4:
4298                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4299                         break;
4300
4301                         default:
4302                         break;
4303
4304                 }
4305         }
4306         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4307         return NDR_ERR_SUCCESS;
4308 }
4309
4310 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4311 {
4312         int level;
4313         level = ndr_print_get_switch_value(ndr, r);
4314         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4315         switch (level) {
4316                 case 1:
4317                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4318                 break;
4319
4320                 case 2:
4321                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4322                 break;
4323
4324                 case 3:
4325                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4326                 break;
4327
4328                 case 4:
4329                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4330                 break;
4331
4332                 default:
4333                 break;
4334
4335         }
4336 }
4337
4338 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
4339 {
4340         if (ndr_flags & NDR_SCALARS) {
4341                 NDR_CHECK(ndr_push_align(ndr, 4));
4342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
4343                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
4344                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
4345         }
4346         if (ndr_flags & NDR_BUFFERS) {
4347                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
4348         }
4349         return NDR_ERR_SUCCESS;
4350 }
4351
4352 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
4353 {
4354         if (ndr_flags & NDR_SCALARS) {
4355                 NDR_CHECK(ndr_pull_align(ndr, 4));
4356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
4357                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
4358                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
4359         }
4360         if (ndr_flags & NDR_BUFFERS) {
4361                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
4362         }
4363         return NDR_ERR_SUCCESS;
4364 }
4365
4366 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
4367 {
4368         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
4369         ndr->depth++;
4370         ndr_print_uint32(ndr, "level", r->level);
4371         ndr_print_set_switch_value(ndr, &r->info, r->level);
4372         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
4373         ndr->depth--;
4374 }
4375
4376 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
4377 {
4378         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4379         return NDR_ERR_SUCCESS;
4380 }
4381
4382 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
4383 {
4384         uint32_t v;
4385         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4386         *r = v;
4387         return NDR_ERR_SUCCESS;
4388 }
4389
4390 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
4391 {
4392         const char *val = NULL;
4393
4394         switch (r) {
4395                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
4396                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
4397                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
4398                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
4399                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
4400                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
4401                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
4402                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
4403                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
4404         }
4405         ndr_print_enum(ndr, name, "ENUM", val, r);
4406 }
4407
4408 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
4409 {
4410         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
4411         return NDR_ERR_SUCCESS;
4412 }
4413
4414 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
4415 {
4416         uint32_t v;
4417         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
4418         *r = v;
4419         return NDR_ERR_SUCCESS;
4420 }
4421
4422 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
4423 {
4424         const char *val = NULL;
4425
4426         switch (r) {
4427                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
4428                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
4429                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
4430                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
4431                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
4432         }
4433         ndr_print_enum(ndr, name, "ENUM", val, r);
4434 }
4435
4436 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
4437 {
4438         if (ndr_flags & NDR_SCALARS) {
4439                 NDR_CHECK(ndr_push_align(ndr, 4));
4440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
4441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4442                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
4443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
4444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
4445                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
4446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
4447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
4449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
4450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
4451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
4452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
4453                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
4454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
4455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
4456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
4457                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
4458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
4459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
4460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
4461                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
4462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
4463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
4464                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
4465                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
4466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
4467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
4468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
4469         }
4470         if (ndr_flags & NDR_BUFFERS) {
4471                 if (r->servername) {
4472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
4473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
4475                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4476                 }
4477                 if (r->printername) {
4478                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4481                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4482                 }
4483         }
4484         return NDR_ERR_SUCCESS;
4485 }
4486
4487 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
4488 {
4489         uint32_t _ptr_servername;
4490         TALLOC_CTX *_mem_save_servername_0;
4491         uint32_t _ptr_printername;
4492         TALLOC_CTX *_mem_save_printername_0;
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_pull_align(ndr, 4));
4495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
4496                 if (_ptr_servername) {
4497                         NDR_PULL_ALLOC(ndr, r->servername);
4498                 } else {
4499                         r->servername = NULL;
4500                 }
4501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4502                 if (_ptr_printername) {
4503                         NDR_PULL_ALLOC(ndr, r->printername);
4504                 } else {
4505                         r->printername = NULL;
4506                 }
4507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
4508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
4509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
4510                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
4511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
4512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
4514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
4515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
4516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
4517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
4518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
4519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
4520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
4521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
4522                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
4523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
4524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
4525                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
4526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
4527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
4528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
4529                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
4530                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
4531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
4532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
4533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
4534         }
4535         if (ndr_flags & NDR_BUFFERS) {
4536                 if (r->servername) {
4537                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4538                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
4539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
4540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
4541                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
4542                                 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));
4543                         }
4544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
4545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
4546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
4547                 }
4548                 if (r->printername) {
4549                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4550                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4552                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4553                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4554                                 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));
4555                         }
4556                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4557                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4559                 }
4560         }
4561         return NDR_ERR_SUCCESS;
4562 }
4563
4564 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
4565 {
4566         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
4567         ndr->depth++;
4568         ndr_print_ptr(ndr, "servername", r->servername);
4569         ndr->depth++;
4570         if (r->servername) {
4571                 ndr_print_string(ndr, "servername", r->servername);
4572         }
4573         ndr->depth--;
4574         ndr_print_ptr(ndr, "printername", r->printername);
4575         ndr->depth++;
4576         if (r->printername) {
4577                 ndr_print_string(ndr, "printername", r->printername);
4578         }
4579         ndr->depth--;
4580         ndr_print_uint32(ndr, "cjobs", r->cjobs);
4581         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
4582         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
4583         ndr_print_spoolss_Time(ndr, "time", &r->time);
4584         ndr_print_uint32(ndr, "global_counter", r->global_counter);
4585         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4586         ndr_print_uint32(ndr, "version", r->version);
4587         ndr_print_uint32(ndr, "free_build", r->free_build);
4588         ndr_print_uint32(ndr, "spooling", r->spooling);
4589         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
4590         ndr_print_uint32(ndr, "session_counter", r->session_counter);
4591         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
4592         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
4593         ndr_print_uint32(ndr, "job_error", r->job_error);
4594         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
4595         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
4596         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
4597         ndr_print_uint32(ndr, "change_id", r->change_id);
4598         ndr_print_WERROR(ndr, "last_error", r->last_error);
4599         ndr_print_uint32(ndr, "status", r->status);
4600         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
4601         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
4602         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
4603         ndr_print_uint16(ndr, "processor_level", r->processor_level);
4604         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
4605         ndr_print_uint32(ndr, "reserved2", r->reserved2);
4606         ndr_print_uint32(ndr, "reserved3", r->reserved3);
4607         ndr->depth--;
4608 }
4609
4610 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
4611 {
4612         if (ndr_flags & NDR_SCALARS) {
4613                 NDR_CHECK(ndr_push_align(ndr, 4));
4614                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
4615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
4616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
4617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4618         }
4619         if (ndr_flags & NDR_BUFFERS) {
4620                 if (r->name) {
4621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
4624                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4625                 }
4626                 if (r->description) {
4627                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
4628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
4630                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4631                 }
4632                 if (r->comment) {
4633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4635                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4636                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4637                 }
4638         }
4639         return NDR_ERR_SUCCESS;
4640 }
4641
4642 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
4643 {
4644         uint32_t _ptr_name;
4645         TALLOC_CTX *_mem_save_name_0;
4646         uint32_t _ptr_description;
4647         TALLOC_CTX *_mem_save_description_0;
4648         uint32_t _ptr_comment;
4649         TALLOC_CTX *_mem_save_comment_0;
4650         if (ndr_flags & NDR_SCALARS) {
4651                 NDR_CHECK(ndr_pull_align(ndr, 4));
4652                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
4653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
4654                 if (_ptr_name) {
4655                         NDR_PULL_ALLOC(ndr, r->name);
4656                 } else {
4657                         r->name = NULL;
4658                 }
4659                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
4660                 if (_ptr_description) {
4661                         NDR_PULL_ALLOC(ndr, r->description);
4662                 } else {
4663                         r->description = NULL;
4664                 }
4665                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4666                 if (_ptr_comment) {
4667                         NDR_PULL_ALLOC(ndr, r->comment);
4668                 } else {
4669                         r->comment = NULL;
4670                 }
4671         }
4672         if (ndr_flags & NDR_BUFFERS) {
4673                 if (r->name) {
4674                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4675                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
4676                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
4677                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
4678                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
4679                                 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));
4680                         }
4681                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
4682                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
4683                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
4684                 }
4685                 if (r->description) {
4686                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
4687                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
4688                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
4689                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
4690                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
4691                                 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));
4692                         }
4693                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
4694                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
4695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
4696                 }
4697                 if (r->comment) {
4698                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
4699                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
4700                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
4701                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
4702                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
4703                                 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));
4704                         }
4705                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
4706                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
4707                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
4708                 }
4709         }
4710         return NDR_ERR_SUCCESS;
4711 }
4712
4713 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
4714 {
4715         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
4716         ndr->depth++;
4717         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
4718         ndr_print_ptr(ndr, "name", r->name);
4719         ndr->depth++;
4720         if (r->name) {
4721                 ndr_print_string(ndr, "name", r->name);
4722         }
4723         ndr->depth--;
4724         ndr_print_ptr(ndr, "description", r->description);
4725         ndr->depth++;
4726         if (r->description) {
4727                 ndr_print_string(ndr, "description", r->description);
4728         }
4729         ndr->depth--;
4730         ndr_print_ptr(ndr, "comment", r->comment);
4731         ndr->depth++;
4732         if (r->comment) {
4733                 ndr_print_string(ndr, "comment", r->comment);
4734         }
4735         ndr->depth--;
4736         ndr->depth--;
4737 }
4738
4739 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
4740 {
4741         if (ndr_flags & NDR_SCALARS) {
4742                 NDR_CHECK(ndr_push_align(ndr, 4));
4743                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
4744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
4745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
4746                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
4747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
4748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
4749                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
4750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
4751                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
4752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
4753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
4754                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4755                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
4756                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
4757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
4759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
4760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
4761                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
4762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
4763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
4764         }
4765         if (ndr_flags & NDR_BUFFERS) {
4766                 if (r->servername) {
4767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
4768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
4770                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4771                 }
4772                 if (r->printername) {
4773                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
4776                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4777                 }
4778                 if (r->sharename) {
4779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
4780                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4781                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
4782                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4783                 }
4784                 if (r->portname) {
4785                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
4788                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4789                 }
4790                 if (r->drivername) {
4791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
4792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4793                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
4794                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4795                 }
4796                 if (r->comment) {
4797                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4799                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
4800                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4801                 }
4802                 if (r->location) {
4803                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
4804                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
4806                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4807                 }
4808                 if (r->devmode) {
4809                         {
4810                                 struct ndr_push *_ndr_devmode;
4811                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
4812                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
4813                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
4814                         }
4815                 }
4816                 if (r->sepfile) {
4817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
4818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
4820                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4821                 }
4822                 if (r->printprocessor) {
4823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
4824                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4825                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
4826                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4827                 }
4828                 if (r->datatype) {
4829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
4830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4831                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
4832                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4833                 }
4834                 if (r->parameters) {
4835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4838                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4839                 }
4840                 if (r->secdesc) {
4841                         {
4842                                 struct ndr_push *_ndr_secdesc;
4843                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
4844                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4845                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
4846                         }
4847                 }
4848         }
4849         return NDR_ERR_SUCCESS;
4850 }
4851
4852 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
4853 {
4854         uint32_t _ptr_servername;
4855         TALLOC_CTX *_mem_save_servername_0;
4856         uint32_t _ptr_printername;
4857         TALLOC_CTX *_mem_save_printername_0;
4858         uint32_t _ptr_sharename;
4859         TALLOC_CTX *_mem_save_sharename_0;
4860         uint32_t _ptr_portname;
4861         TALLOC_CTX *_mem_save_portname_0;
4862         uint32_t _ptr_drivername;
4863         TALLOC_CTX *_mem_save_drivername_0;
4864         uint32_t _ptr_comment;
4865         TALLOC_CTX *_mem_save_comment_0;
4866         uint32_t _ptr_location;
4867         TALLOC_CTX *_mem_save_location_0;
4868         uint32_t _ptr_devmode;
4869         TALLOC_CTX *_mem_save_devmode_0;
4870         uint32_t _ptr_sepfile;
4871         TALLOC_CTX *_mem_save_sepfile_0;
4872         uint32_t _ptr_printprocessor;
4873         TALLOC_CTX *_mem_save_printprocessor_0;
4874         uint32_t _ptr_datatype;
4875         TALLOC_CTX *_mem_save_datatype_0;
4876         uint32_t _ptr_parameters;
4877         TALLOC_CTX *_mem_save_parameters_0;
4878         uint32_t _ptr_secdesc;
4879         TALLOC_CTX *_mem_save_secdesc_0;
4880         if (ndr_flags & NDR_SCALARS) {
4881                 NDR_CHECK(ndr_pull_align(ndr, 4));
4882                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
4883                 if (_ptr_servername) {
4884                         NDR_PULL_ALLOC(ndr, r->servername);
4885                 } else {
4886                         r->servername = NULL;
4887                 }
4888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
4889                 if (_ptr_printername) {
4890                         NDR_PULL_ALLOC(ndr, r->printername);
4891                 } else {
4892                         r->printername = NULL;
4893                 }
4894                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
4895                 if (_ptr_sharename) {
4896                         NDR_PULL_ALLOC(ndr, r->sharename);
4897                 } else {
4898                         r->sharename = NULL;
4899                 }
4900                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
4901                 if (_ptr_portname) {
4902                         NDR_PULL_ALLOC(ndr, r->portname);
4903                 } else {
4904                         r->portname = NULL;
4905                 }
4906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
4907                 if (_ptr_drivername) {
4908                         NDR_PULL_ALLOC(ndr, r->drivername);
4909                 } else {
4910                         r->drivername = NULL;
4911                 }
4912                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
4913                 if (_ptr_comment) {
4914                         NDR_PULL_ALLOC(ndr, r->comment);
4915                 } else {
4916                         r->comment = NULL;
4917                 }
4918                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
4919                 if (_ptr_location) {
4920                         NDR_PULL_ALLOC(ndr, r->location);
4921                 } else {
4922                         r->location = NULL;
4923                 }
4924                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
4925                 if (_ptr_devmode) {
4926                         NDR_PULL_ALLOC(ndr, r->devmode);
4927                 } else {
4928                         r->devmode = NULL;
4929                 }
4930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
4931                 if (_ptr_sepfile) {
4932                         NDR_PULL_ALLOC(ndr, r->sepfile);
4933                 } else {
4934                         r->sepfile = NULL;
4935                 }
4936                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
4937                 if (_ptr_printprocessor) {
4938                         NDR_PULL_ALLOC(ndr, r->printprocessor);
4939                 } else {
4940                         r->printprocessor = NULL;
4941                 }
4942                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
4943                 if (_ptr_datatype) {
4944                         NDR_PULL_ALLOC(ndr, r->datatype);
4945                 } else {
4946                         r->datatype = NULL;
4947                 }
4948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4949                 if (_ptr_parameters) {
4950                         NDR_PULL_ALLOC(ndr, r->parameters);
4951                 } else {
4952                         r->parameters = NULL;
4953                 }
4954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
4955                 if (_ptr_secdesc) {
4956                         NDR_PULL_ALLOC(ndr, r->secdesc);
4957                 } else {
4958                         r->secdesc = NULL;
4959                 }
4960                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
4961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
4963                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
4964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
4965                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
4966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
4967                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
4968         }
4969         if (ndr_flags & NDR_BUFFERS) {
4970                 if (r->servername) {
4971                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4972                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
4973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
4974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
4975                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
4976                                 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));
4977                         }
4978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
4979                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
4980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
4981                 }
4982                 if (r->printername) {
4983                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
4984                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
4985                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
4986                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
4987                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
4988                                 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));
4989                         }
4990                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
4991                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
4992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
4993                 }
4994                 if (r->sharename) {
4995                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
4996                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
4997                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
4998                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
4999                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
5000                                 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));
5001                         }
5002                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
5003                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
5004                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
5005                 }
5006                 if (r->portname) {
5007                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
5008                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
5009                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
5010                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
5011                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
5012                                 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));
5013                         }
5014                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
5015                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
5016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
5017                 }
5018                 if (r->drivername) {
5019                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5020                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
5021                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
5022                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
5023                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
5024                                 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));
5025                         }
5026                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
5027                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
5028                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
5029                 }
5030                 if (r->comment) {
5031                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
5032                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
5033                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
5034                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
5035                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
5036                                 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));
5037                         }
5038                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
5039                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
5040                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
5041                 }
5042                 if (r->location) {
5043                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
5044                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
5045                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
5046                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
5047                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
5048                                 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));
5049                         }
5050                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
5051                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
5052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
5053                 }
5054                 if (r->devmode) {
5055                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
5056                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
5057                         {
5058                                 struct ndr_pull *_ndr_devmode;
5059                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
5060                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
5061                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
5062                         }
5063                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
5064                 }
5065                 if (r->sepfile) {
5066                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
5067                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
5068                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
5069                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
5070                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
5071                                 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));
5072                         }
5073                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
5074                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
5075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
5076                 }
5077                 if (r->printprocessor) {
5078                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5079                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
5080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
5081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
5082                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
5083                                 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));
5084                         }
5085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
5086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
5087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
5088                 }
5089                 if (r->datatype) {
5090                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5091                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
5092                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
5093                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
5094                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
5095                                 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));
5096                         }
5097                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
5098                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
5099                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
5100                 }
5101                 if (r->parameters) {
5102                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5103                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5106                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5107                                 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));
5108                         }
5109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5112                 }
5113                 if (r->secdesc) {
5114                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
5115                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
5116                         {
5117                                 struct ndr_pull *_ndr_secdesc;
5118                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
5119                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
5120                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
5121                         }
5122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
5123                 }
5124         }
5125         return NDR_ERR_SUCCESS;
5126 }
5127
5128 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
5129 {
5130         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
5131         ndr->depth++;
5132         ndr_print_ptr(ndr, "servername", r->servername);
5133         ndr->depth++;
5134         if (r->servername) {
5135                 ndr_print_string(ndr, "servername", r->servername);
5136         }
5137         ndr->depth--;
5138         ndr_print_ptr(ndr, "printername", r->printername);
5139         ndr->depth++;
5140         if (r->printername) {
5141                 ndr_print_string(ndr, "printername", r->printername);
5142         }
5143         ndr->depth--;
5144         ndr_print_ptr(ndr, "sharename", r->sharename);
5145         ndr->depth++;
5146         if (r->sharename) {
5147                 ndr_print_string(ndr, "sharename", r->sharename);
5148         }
5149         ndr->depth--;
5150         ndr_print_ptr(ndr, "portname", r->portname);
5151         ndr->depth++;
5152         if (r->portname) {
5153                 ndr_print_string(ndr, "portname", r->portname);
5154         }
5155         ndr->depth--;
5156         ndr_print_ptr(ndr, "drivername", r->drivername);
5157         ndr->depth++;
5158         if (r->drivername) {
5159                 ndr_print_string(ndr, "drivername", r->drivername);
5160         }
5161         ndr->depth--;
5162         ndr_print_ptr(ndr, "comment", r->comment);
5163         ndr->depth++;
5164         if (r->comment) {
5165                 ndr_print_string(ndr, "comment", r->comment);
5166         }
5167         ndr->depth--;
5168         ndr_print_ptr(ndr, "location", r->location);
5169         ndr->depth++;
5170         if (r->location) {
5171                 ndr_print_string(ndr, "location", r->location);
5172         }
5173         ndr->depth--;
5174         ndr_print_ptr(ndr, "devmode", r->devmode);
5175         ndr->depth++;
5176         if (r->devmode) {
5177                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
5178         }
5179         ndr->depth--;
5180         ndr_print_ptr(ndr, "sepfile", r->sepfile);
5181         ndr->depth++;
5182         if (r->sepfile) {
5183                 ndr_print_string(ndr, "sepfile", r->sepfile);
5184         }
5185         ndr->depth--;
5186         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
5187         ndr->depth++;
5188         if (r->printprocessor) {
5189                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
5190         }
5191         ndr->depth--;
5192         ndr_print_ptr(ndr, "datatype", r->datatype);
5193         ndr->depth++;
5194         if (r->datatype) {
5195                 ndr_print_string(ndr, "datatype", r->datatype);
5196         }
5197         ndr->depth--;
5198         ndr_print_ptr(ndr, "parameters", r->parameters);
5199         ndr->depth++;
5200         if (r->parameters) {
5201                 ndr_print_string(ndr, "parameters", r->parameters);
5202         }
5203         ndr->depth--;
5204         ndr_print_ptr(ndr, "secdesc", r->secdesc);
5205         ndr->depth++;
5206         if (r->secdesc) {
5207                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
5208         }
5209         ndr->depth--;
5210         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
5211         ndr_print_uint32(ndr, "priority", r->priority);
5212         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
5213         ndr_print_uint32(ndr, "starttime", r->starttime);
5214         ndr_print_uint32(ndr, "untiltime", r->untiltime);
5215         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
5216         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5217         ndr_print_uint32(ndr, "averageppm", r->averageppm);
5218         ndr->depth--;
5219 }
5220
5221 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
5222 {
5223         if (ndr_flags & NDR_SCALARS) {
5224                 NDR_CHECK(ndr_push_align(ndr, 4));
5225                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
5226         }
5227         if (ndr_flags & NDR_BUFFERS) {
5228         }
5229         return NDR_ERR_SUCCESS;
5230 }
5231
5232 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
5233 {
5234         if (ndr_flags & NDR_SCALARS) {
5235                 NDR_CHECK(ndr_pull_align(ndr, 4));
5236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
5237         }
5238         if (ndr_flags & NDR_BUFFERS) {
5239         }
5240         return NDR_ERR_SUCCESS;
5241 }
5242
5243 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
5244 {
5245         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
5246         ndr->depth++;
5247         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
5248         ndr->depth--;
5249 }
5250
5251 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
5252 {
5253         if (ndr_flags & NDR_SCALARS) {
5254                 NDR_CHECK(ndr_push_align(ndr, 4));
5255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5256                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5257                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
5258         }
5259         if (ndr_flags & NDR_BUFFERS) {
5260                 if (r->printername) {
5261                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5262                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5263                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5264                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5265                 }
5266                 if (r->servername) {
5267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5270                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5271                 }
5272         }
5273         return NDR_ERR_SUCCESS;
5274 }
5275
5276 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
5277 {
5278         uint32_t _ptr_printername;
5279         TALLOC_CTX *_mem_save_printername_0;
5280         uint32_t _ptr_servername;
5281         TALLOC_CTX *_mem_save_servername_0;
5282         if (ndr_flags & NDR_SCALARS) {
5283                 NDR_CHECK(ndr_pull_align(ndr, 4));
5284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5285                 if (_ptr_printername) {
5286                         NDR_PULL_ALLOC(ndr, r->printername);
5287                 } else {
5288                         r->printername = NULL;
5289                 }
5290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5291                 if (_ptr_servername) {
5292                         NDR_PULL_ALLOC(ndr, r->servername);
5293                 } else {
5294                         r->servername = NULL;
5295                 }
5296                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
5297         }
5298         if (ndr_flags & NDR_BUFFERS) {
5299                 if (r->printername) {
5300                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5301                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5302                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5303                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5304                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5305                                 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));
5306                         }
5307                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5308                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5310                 }
5311                 if (r->servername) {
5312                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5313                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5314                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5315                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5316                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5317                                 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));
5318                         }
5319                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5320                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5321                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5322                 }
5323         }
5324         return NDR_ERR_SUCCESS;
5325 }
5326
5327 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
5328 {
5329         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
5330         ndr->depth++;
5331         ndr_print_ptr(ndr, "printername", r->printername);
5332         ndr->depth++;
5333         if (r->printername) {
5334                 ndr_print_string(ndr, "printername", r->printername);
5335         }
5336         ndr->depth--;
5337         ndr_print_ptr(ndr, "servername", r->servername);
5338         ndr->depth++;
5339         if (r->servername) {
5340                 ndr_print_string(ndr, "servername", r->servername);
5341         }
5342         ndr->depth--;
5343         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
5344         ndr->depth--;
5345 }
5346
5347 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
5348 {
5349         if (ndr_flags & NDR_SCALARS) {
5350                 NDR_CHECK(ndr_push_align(ndr, 4));
5351                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5352                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
5353                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
5354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
5355                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
5356         }
5357         if (ndr_flags & NDR_BUFFERS) {
5358                 if (r->printername) {
5359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5361                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5362                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5363                 }
5364                 if (r->portname) {
5365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
5366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
5368                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5369                 }
5370         }
5371         return NDR_ERR_SUCCESS;
5372 }
5373
5374 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
5375 {
5376         uint32_t _ptr_printername;
5377         TALLOC_CTX *_mem_save_printername_0;
5378         uint32_t _ptr_portname;
5379         TALLOC_CTX *_mem_save_portname_0;
5380         if (ndr_flags & NDR_SCALARS) {
5381                 NDR_CHECK(ndr_pull_align(ndr, 4));
5382                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5383                 if (_ptr_printername) {
5384                         NDR_PULL_ALLOC(ndr, r->printername);
5385                 } else {
5386                         r->printername = NULL;
5387                 }
5388                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
5389                 if (_ptr_portname) {
5390                         NDR_PULL_ALLOC(ndr, r->portname);
5391                 } else {
5392                         r->portname = NULL;
5393                 }
5394                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
5395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
5396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
5397         }
5398         if (ndr_flags & NDR_BUFFERS) {
5399                 if (r->printername) {
5400                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5401                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5402                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5403                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5404                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5405                                 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));
5406                         }
5407                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5408                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5409                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5410                 }
5411                 if (r->portname) {
5412                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
5413                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
5414                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
5415                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
5416                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
5417                                 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));
5418                         }
5419                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
5420                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
5421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
5422                 }
5423         }
5424         return NDR_ERR_SUCCESS;
5425 }
5426
5427 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
5428 {
5429         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
5430         ndr->depth++;
5431         ndr_print_ptr(ndr, "printername", r->printername);
5432         ndr->depth++;
5433         if (r->printername) {
5434                 ndr_print_string(ndr, "printername", r->printername);
5435         }
5436         ndr->depth--;
5437         ndr_print_ptr(ndr, "portname", r->portname);
5438         ndr->depth++;
5439         if (r->portname) {
5440                 ndr_print_string(ndr, "portname", r->portname);
5441         }
5442         ndr->depth--;
5443         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
5444         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
5445         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
5446         ndr->depth--;
5447 }
5448
5449 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
5450 {
5451         if (ndr_flags & NDR_SCALARS) {
5452                 NDR_CHECK(ndr_push_align(ndr, 4));
5453                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
5454         }
5455         if (ndr_flags & NDR_BUFFERS) {
5456         }
5457         return NDR_ERR_SUCCESS;
5458 }
5459
5460 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
5461 {
5462         if (ndr_flags & NDR_SCALARS) {
5463                 NDR_CHECK(ndr_pull_align(ndr, 4));
5464                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
5465         }
5466         if (ndr_flags & NDR_BUFFERS) {
5467         }
5468         return NDR_ERR_SUCCESS;
5469 }
5470
5471 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
5472 {
5473         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
5474         ndr->depth++;
5475         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
5476         ndr->depth--;
5477 }
5478
5479 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
5480 {
5481         if (ndr_flags & NDR_SCALARS) {
5482                 NDR_CHECK(ndr_push_align(ndr, 4));
5483                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
5484                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
5485         }
5486         if (ndr_flags & NDR_BUFFERS) {
5487                 if (r->guid) {
5488                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
5489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5490                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
5491                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5492                 }
5493         }
5494         return NDR_ERR_SUCCESS;
5495 }
5496
5497 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
5498 {
5499         uint32_t _ptr_guid;
5500         TALLOC_CTX *_mem_save_guid_0;
5501         if (ndr_flags & NDR_SCALARS) {
5502                 NDR_CHECK(ndr_pull_align(ndr, 4));
5503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
5504                 if (_ptr_guid) {
5505                         NDR_PULL_ALLOC(ndr, r->guid);
5506                 } else {
5507                         r->guid = NULL;
5508                 }
5509                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
5510         }
5511         if (ndr_flags & NDR_BUFFERS) {
5512                 if (r->guid) {
5513                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
5514                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
5515                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
5516                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
5517                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
5518                                 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));
5519                         }
5520                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
5521                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
5522                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
5523                 }
5524         }
5525         return NDR_ERR_SUCCESS;
5526 }
5527
5528 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
5529 {
5530         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
5531         ndr->depth++;
5532         ndr_print_ptr(ndr, "guid", r->guid);
5533         ndr->depth++;
5534         if (r->guid) {
5535                 ndr_print_string(ndr, "guid", r->guid);
5536         }
5537         ndr->depth--;
5538         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
5539         ndr->depth--;
5540 }
5541
5542 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
5543 {
5544         if (ndr_flags & NDR_SCALARS) {
5545                 int level = ndr_push_get_switch_value(ndr, r);
5546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5547                 switch (level) {
5548                         case 0: {
5549                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
5550                         break; }
5551
5552                         case 1: {
5553                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5554                         break; }
5555
5556                         case 2: {
5557                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5558                         break; }
5559
5560                         case 3: {
5561                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5562                         break; }
5563
5564                         case 4: {
5565                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5566                         break; }
5567
5568                         case 5: {
5569                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
5570                         break; }
5571
5572                         case 6: {
5573                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
5574                         break; }
5575
5576                         case 7: {
5577                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
5578                         break; }
5579
5580                         case 8: {
5581                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
5582                         break; }
5583
5584                         case 9: {
5585                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
5586                         break; }
5587
5588                         default: {
5589                         break; }
5590
5591                 }
5592         }
5593         if (ndr_flags & NDR_BUFFERS) {
5594                 int level = ndr_push_get_switch_value(ndr, r);
5595                 switch (level) {
5596                         case 0:
5597                                 if (r->info0) {
5598                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5599                                 }
5600                         break;
5601
5602                         case 1:
5603                                 if (r->info1) {
5604                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5605                                 }
5606                         break;
5607
5608                         case 2:
5609                                 if (r->info2) {
5610                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5611                                 }
5612                         break;
5613
5614                         case 3:
5615                                 if (r->info3) {
5616                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
5617                                 }
5618                         break;
5619
5620                         case 4:
5621                                 if (r->info4) {
5622                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5623                                 }
5624                         break;
5625
5626                         case 5:
5627                                 if (r->info5) {
5628                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
5629                                 }
5630                         break;
5631
5632                         case 6:
5633                                 if (r->info6) {
5634                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
5635                                 }
5636                         break;
5637
5638                         case 7:
5639                                 if (r->info7) {
5640                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
5641                                 }
5642                         break;
5643
5644                         case 8:
5645                                 if (r->info8) {
5646                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
5647                                 }
5648                         break;
5649
5650                         case 9:
5651                                 if (r->info9) {
5652                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
5653                                 }
5654                         break;
5655
5656                         default:
5657                         break;
5658
5659                 }
5660         }
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
5665 {
5666         int level;
5667         uint32_t _level;
5668         TALLOC_CTX *_mem_save_info0_0;
5669         TALLOC_CTX *_mem_save_info1_0;
5670         TALLOC_CTX *_mem_save_info2_0;
5671         TALLOC_CTX *_mem_save_info3_0;
5672         TALLOC_CTX *_mem_save_info4_0;
5673         TALLOC_CTX *_mem_save_info5_0;
5674         TALLOC_CTX *_mem_save_info6_0;
5675         TALLOC_CTX *_mem_save_info7_0;
5676         TALLOC_CTX *_mem_save_info8_0;
5677         TALLOC_CTX *_mem_save_info9_0;
5678         level = ndr_pull_get_switch_value(ndr, r);
5679         if (ndr_flags & NDR_SCALARS) {
5680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5681                 if (_level != level) {
5682                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5683                 }
5684                 switch (level) {
5685                         case 0: {
5686                                 uint32_t _ptr_info0;
5687                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
5688                                 if (_ptr_info0) {
5689                                         NDR_PULL_ALLOC(ndr, r->info0);
5690                                 } else {
5691                                         r->info0 = NULL;
5692                                 }
5693                         break; }
5694
5695                         case 1: {
5696                                 uint32_t _ptr_info1;
5697                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5698                                 if (_ptr_info1) {
5699                                         NDR_PULL_ALLOC(ndr, r->info1);
5700                                 } else {
5701                                         r->info1 = NULL;
5702                                 }
5703                         break; }
5704
5705                         case 2: {
5706                                 uint32_t _ptr_info2;
5707                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5708                                 if (_ptr_info2) {
5709                                         NDR_PULL_ALLOC(ndr, r->info2);
5710                                 } else {
5711                                         r->info2 = NULL;
5712                                 }
5713                         break; }
5714
5715                         case 3: {
5716                                 uint32_t _ptr_info3;
5717                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5718                                 if (_ptr_info3) {
5719                                         NDR_PULL_ALLOC(ndr, r->info3);
5720                                 } else {
5721                                         r->info3 = NULL;
5722                                 }
5723                         break; }
5724
5725                         case 4: {
5726                                 uint32_t _ptr_info4;
5727                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5728                                 if (_ptr_info4) {
5729                                         NDR_PULL_ALLOC(ndr, r->info4);
5730                                 } else {
5731                                         r->info4 = NULL;
5732                                 }
5733                         break; }
5734
5735                         case 5: {
5736                                 uint32_t _ptr_info5;
5737                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
5738                                 if (_ptr_info5) {
5739                                         NDR_PULL_ALLOC(ndr, r->info5);
5740                                 } else {
5741                                         r->info5 = NULL;
5742                                 }
5743                         break; }
5744
5745                         case 6: {
5746                                 uint32_t _ptr_info6;
5747                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
5748                                 if (_ptr_info6) {
5749                                         NDR_PULL_ALLOC(ndr, r->info6);
5750                                 } else {
5751                                         r->info6 = NULL;
5752                                 }
5753                         break; }
5754
5755                         case 7: {
5756                                 uint32_t _ptr_info7;
5757                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
5758                                 if (_ptr_info7) {
5759                                         NDR_PULL_ALLOC(ndr, r->info7);
5760                                 } else {
5761                                         r->info7 = NULL;
5762                                 }
5763                         break; }
5764
5765                         case 8: {
5766                                 uint32_t _ptr_info8;
5767                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
5768                                 if (_ptr_info8) {
5769                                         NDR_PULL_ALLOC(ndr, r->info8);
5770                                 } else {
5771                                         r->info8 = NULL;
5772                                 }
5773                         break; }
5774
5775                         case 9: {
5776                                 uint32_t _ptr_info9;
5777                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
5778                                 if (_ptr_info9) {
5779                                         NDR_PULL_ALLOC(ndr, r->info9);
5780                                 } else {
5781                                         r->info9 = NULL;
5782                                 }
5783                         break; }
5784
5785                         default: {
5786                         break; }
5787
5788                 }
5789         }
5790         if (ndr_flags & NDR_BUFFERS) {
5791                 switch (level) {
5792                         case 0:
5793                                 if (r->info0) {
5794                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
5795                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
5796                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
5797                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
5798                                 }
5799                         break;
5800
5801                         case 1:
5802                                 if (r->info1) {
5803                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5804                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5805                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5806                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5807                                 }
5808                         break;
5809
5810                         case 2:
5811                                 if (r->info2) {
5812                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5813                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5814                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5815                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5816                                 }
5817                         break;
5818
5819                         case 3:
5820                                 if (r->info3) {
5821                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5822                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5823                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
5824                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5825                                 }
5826                         break;
5827
5828                         case 4:
5829                                 if (r->info4) {
5830                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5831                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5832                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5833                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5834                                 }
5835                         break;
5836
5837                         case 5:
5838                                 if (r->info5) {
5839                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
5840                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
5841                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
5842                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
5843                                 }
5844                         break;
5845
5846                         case 6:
5847                                 if (r->info6) {
5848                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
5849                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
5850                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
5851                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
5852                                 }
5853                         break;
5854
5855                         case 7:
5856                                 if (r->info7) {
5857                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
5858                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
5859                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
5860                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
5861                                 }
5862                         break;
5863
5864                         case 8:
5865                                 if (r->info8) {
5866                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
5867                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
5868                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
5869                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
5870                                 }
5871                         break;
5872
5873                         case 9:
5874                                 if (r->info9) {
5875                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
5876                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
5877                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
5878                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
5879                                 }
5880                         break;
5881
5882                         default:
5883                         break;
5884
5885                 }
5886         }
5887         return NDR_ERR_SUCCESS;
5888 }
5889
5890 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
5891 {
5892         int level;
5893         level = ndr_print_get_switch_value(ndr, r);
5894         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
5895         switch (level) {
5896                 case 0:
5897                         ndr_print_ptr(ndr, "info0", r->info0);
5898                         ndr->depth++;
5899                         if (r->info0) {
5900                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
5901                         }
5902                         ndr->depth--;
5903                 break;
5904
5905                 case 1:
5906                         ndr_print_ptr(ndr, "info1", r->info1);
5907                         ndr->depth++;
5908                         if (r->info1) {
5909                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
5910                         }
5911                         ndr->depth--;
5912                 break;
5913
5914                 case 2:
5915                         ndr_print_ptr(ndr, "info2", r->info2);
5916                         ndr->depth++;
5917                         if (r->info2) {
5918                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
5919                         }
5920                         ndr->depth--;
5921                 break;
5922
5923                 case 3:
5924                         ndr_print_ptr(ndr, "info3", r->info3);
5925                         ndr->depth++;
5926                         if (r->info3) {
5927                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
5928                         }
5929                         ndr->depth--;
5930                 break;
5931
5932                 case 4:
5933                         ndr_print_ptr(ndr, "info4", r->info4);
5934                         ndr->depth++;
5935                         if (r->info4) {
5936                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
5937                         }
5938                         ndr->depth--;
5939                 break;
5940
5941                 case 5:
5942                         ndr_print_ptr(ndr, "info5", r->info5);
5943                         ndr->depth++;
5944                         if (r->info5) {
5945                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
5946                         }
5947                         ndr->depth--;
5948                 break;
5949
5950                 case 6:
5951                         ndr_print_ptr(ndr, "info6", r->info6);
5952                         ndr->depth++;
5953                         if (r->info6) {
5954                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
5955                         }
5956                         ndr->depth--;
5957                 break;
5958
5959                 case 7:
5960                         ndr_print_ptr(ndr, "info7", r->info7);
5961                         ndr->depth++;
5962                         if (r->info7) {
5963                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
5964                         }
5965                         ndr->depth--;
5966                 break;
5967
5968                 case 8:
5969                         ndr_print_ptr(ndr, "info8", r->info8);
5970                         ndr->depth++;
5971                         if (r->info8) {
5972                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
5973                         }
5974                         ndr->depth--;
5975                 break;
5976
5977                 case 9:
5978                         ndr_print_ptr(ndr, "info9", r->info9);
5979                         ndr->depth++;
5980                         if (r->info9) {
5981                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
5982                         }
5983                         ndr->depth--;
5984                 break;
5985
5986                 default:
5987                 break;
5988
5989         }
5990 }
5991
5992 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
5993 {
5994         if (ndr_flags & NDR_SCALARS) {
5995                 NDR_CHECK(ndr_push_align(ndr, 4));
5996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5997                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5998                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
5999         }
6000         if (ndr_flags & NDR_BUFFERS) {
6001                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
6002         }
6003         return NDR_ERR_SUCCESS;
6004 }
6005
6006 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
6007 {
6008         if (ndr_flags & NDR_SCALARS) {
6009                 NDR_CHECK(ndr_pull_align(ndr, 4));
6010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
6011                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
6012                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
6013         }
6014         if (ndr_flags & NDR_BUFFERS) {
6015                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
6016         }
6017         return NDR_ERR_SUCCESS;
6018 }
6019
6020 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
6021 {
6022         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
6023         ndr->depth++;
6024         ndr_print_uint32(ndr, "level", r->level);
6025         ndr_print_set_switch_value(ndr, &r->info, r->level);
6026         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
6027         ndr->depth--;
6028 }
6029
6030 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
6031 {
6032         if (ndr_flags & NDR_SCALARS) {
6033                 NDR_CHECK(ndr_push_align(ndr, 4));
6034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
6035                 {
6036                         uint32_t _flags_save_string_array = ndr->flags;
6037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6038                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
6039                         ndr->flags = _flags_save_string_array;
6040                 }
6041         }
6042         if (ndr_flags & NDR_BUFFERS) {
6043         }
6044         return NDR_ERR_SUCCESS;
6045 }
6046
6047 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
6048 {
6049         if (ndr_flags & NDR_SCALARS) {
6050                 NDR_CHECK(ndr_pull_align(ndr, 4));
6051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
6052                 {
6053                         uint32_t _flags_save_string_array = ndr->flags;
6054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6055                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
6056                         ndr->flags = _flags_save_string_array;
6057                 }
6058         }
6059         if (ndr_flags & NDR_BUFFERS) {
6060         }
6061         return NDR_ERR_SUCCESS;
6062 }
6063
6064 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
6065 {
6066         ndr_print_struct(ndr, name, "spoolss_StringArray");
6067         ndr->depth++;
6068         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);
6069         ndr_print_string_array(ndr, "string", r->string);
6070         ndr->depth--;
6071 }
6072
6073 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
6074 {
6075         if (ndr_flags & NDR_SCALARS) {
6076                 NDR_CHECK(ndr_push_align(ndr, 4));
6077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6078         }
6079         if (ndr_flags & NDR_BUFFERS) {
6080                 if (r->driver_name) {
6081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6084                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6085                 }
6086         }
6087         return NDR_ERR_SUCCESS;
6088 }
6089
6090 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
6091 {
6092         uint32_t _ptr_driver_name;
6093         TALLOC_CTX *_mem_save_driver_name_0;
6094         if (ndr_flags & NDR_SCALARS) {
6095                 NDR_CHECK(ndr_pull_align(ndr, 4));
6096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6097                 if (_ptr_driver_name) {
6098                         NDR_PULL_ALLOC(ndr, r->driver_name);
6099                 } else {
6100                         r->driver_name = NULL;
6101                 }
6102         }
6103         if (ndr_flags & NDR_BUFFERS) {
6104                 if (r->driver_name) {
6105                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6106                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6107                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6108                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6109                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6110                                 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));
6111                         }
6112                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6113                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6114                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6115                 }
6116         }
6117         return NDR_ERR_SUCCESS;
6118 }
6119
6120 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
6121 {
6122         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
6123         ndr->depth++;
6124         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6125         ndr->depth++;
6126         if (r->driver_name) {
6127                 ndr_print_string(ndr, "driver_name", r->driver_name);
6128         }
6129         ndr->depth--;
6130         ndr->depth--;
6131 }
6132
6133 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
6134 {
6135         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6136         return NDR_ERR_SUCCESS;
6137 }
6138
6139 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
6140 {
6141         uint32_t v;
6142         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6143         *r = v;
6144         return NDR_ERR_SUCCESS;
6145 }
6146
6147 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
6148 {
6149         const char *val = NULL;
6150
6151         switch (r) {
6152                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
6153                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
6154                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
6155                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
6156         }
6157         ndr_print_enum(ndr, name, "ENUM", val, r);
6158 }
6159
6160 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
6161 {
6162         if (ndr_flags & NDR_SCALARS) {
6163                 NDR_CHECK(ndr_push_align(ndr, 4));
6164                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6166                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6167                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6168                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6170         }
6171         if (ndr_flags & NDR_BUFFERS) {
6172                 if (r->driver_name) {
6173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6175                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6176                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6177                 }
6178                 if (r->architecture) {
6179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6182                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6183                 }
6184                 if (r->driver_path) {
6185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6187                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6188                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6189                 }
6190                 if (r->data_file) {
6191                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6192                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6193                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6194                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6195                 }
6196                 if (r->config_file) {
6197                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6200                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6201                 }
6202         }
6203         return NDR_ERR_SUCCESS;
6204 }
6205
6206 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
6207 {
6208         uint32_t _ptr_driver_name;
6209         TALLOC_CTX *_mem_save_driver_name_0;
6210         uint32_t _ptr_architecture;
6211         TALLOC_CTX *_mem_save_architecture_0;
6212         uint32_t _ptr_driver_path;
6213         TALLOC_CTX *_mem_save_driver_path_0;
6214         uint32_t _ptr_data_file;
6215         TALLOC_CTX *_mem_save_data_file_0;
6216         uint32_t _ptr_config_file;
6217         TALLOC_CTX *_mem_save_config_file_0;
6218         if (ndr_flags & NDR_SCALARS) {
6219                 NDR_CHECK(ndr_pull_align(ndr, 4));
6220                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6222                 if (_ptr_driver_name) {
6223                         NDR_PULL_ALLOC(ndr, r->driver_name);
6224                 } else {
6225                         r->driver_name = NULL;
6226                 }
6227                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6228                 if (_ptr_architecture) {
6229                         NDR_PULL_ALLOC(ndr, r->architecture);
6230                 } else {
6231                         r->architecture = NULL;
6232                 }
6233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6234                 if (_ptr_driver_path) {
6235                         NDR_PULL_ALLOC(ndr, r->driver_path);
6236                 } else {
6237                         r->driver_path = NULL;
6238                 }
6239                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6240                 if (_ptr_data_file) {
6241                         NDR_PULL_ALLOC(ndr, r->data_file);
6242                 } else {
6243                         r->data_file = NULL;
6244                 }
6245                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6246                 if (_ptr_config_file) {
6247                         NDR_PULL_ALLOC(ndr, r->config_file);
6248                 } else {
6249                         r->config_file = NULL;
6250                 }
6251         }
6252         if (ndr_flags & NDR_BUFFERS) {
6253                 if (r->driver_name) {
6254                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6255                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6258                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6259                                 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));
6260                         }
6261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6264                 }
6265                 if (r->architecture) {
6266                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6267                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6270                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6271                                 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));
6272                         }
6273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6276                 }
6277                 if (r->driver_path) {
6278                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6279                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6282                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6283                                 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));
6284                         }
6285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6288                 }
6289                 if (r->data_file) {
6290                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6291                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6294                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6295                                 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));
6296                         }
6297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6300                 }
6301                 if (r->config_file) {
6302                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6303                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6305                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6306                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6307                                 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));
6308                         }
6309                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6312                 }
6313         }
6314         return NDR_ERR_SUCCESS;
6315 }
6316
6317 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
6318 {
6319         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
6320         ndr->depth++;
6321         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6322         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6323         ndr->depth++;
6324         if (r->driver_name) {
6325                 ndr_print_string(ndr, "driver_name", r->driver_name);
6326         }
6327         ndr->depth--;
6328         ndr_print_ptr(ndr, "architecture", r->architecture);
6329         ndr->depth++;
6330         if (r->architecture) {
6331                 ndr_print_string(ndr, "architecture", r->architecture);
6332         }
6333         ndr->depth--;
6334         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6335         ndr->depth++;
6336         if (r->driver_path) {
6337                 ndr_print_string(ndr, "driver_path", r->driver_path);
6338         }
6339         ndr->depth--;
6340         ndr_print_ptr(ndr, "data_file", r->data_file);
6341         ndr->depth++;
6342         if (r->data_file) {
6343                 ndr_print_string(ndr, "data_file", r->data_file);
6344         }
6345         ndr->depth--;
6346         ndr_print_ptr(ndr, "config_file", r->config_file);
6347         ndr->depth++;
6348         if (r->config_file) {
6349                 ndr_print_string(ndr, "config_file", r->config_file);
6350         }
6351         ndr->depth--;
6352         ndr->depth--;
6353 }
6354
6355 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
6356 {
6357         if (ndr_flags & NDR_SCALARS) {
6358                 NDR_CHECK(ndr_push_align(ndr, 4));
6359                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6362                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6363                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6370         }
6371         if (ndr_flags & NDR_BUFFERS) {
6372                 if (r->driver_name) {
6373                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6376                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6377                 }
6378                 if (r->architecture) {
6379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6382                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6383                 }
6384                 if (r->driver_path) {
6385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6388                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6389                 }
6390                 if (r->data_file) {
6391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6394                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6395                 }
6396                 if (r->config_file) {
6397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6400                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6401                 }
6402                 if (r->help_file) {
6403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6406                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6407                 }
6408                 if (r->monitor_name) {
6409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6413                 }
6414                 if (r->default_datatype) {
6415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6417                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6418                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6419                 }
6420                 if (r->dependent_files) {
6421                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6422                 }
6423         }
6424         return NDR_ERR_SUCCESS;
6425 }
6426
6427 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
6428 {
6429         uint32_t _ptr_driver_name;
6430         TALLOC_CTX *_mem_save_driver_name_0;
6431         uint32_t _ptr_architecture;
6432         TALLOC_CTX *_mem_save_architecture_0;
6433         uint32_t _ptr_driver_path;
6434         TALLOC_CTX *_mem_save_driver_path_0;
6435         uint32_t _ptr_data_file;
6436         TALLOC_CTX *_mem_save_data_file_0;
6437         uint32_t _ptr_config_file;
6438         TALLOC_CTX *_mem_save_config_file_0;
6439         uint32_t _ptr_help_file;
6440         TALLOC_CTX *_mem_save_help_file_0;
6441         uint32_t _ptr_monitor_name;
6442         TALLOC_CTX *_mem_save_monitor_name_0;
6443         uint32_t _ptr_default_datatype;
6444         TALLOC_CTX *_mem_save_default_datatype_0;
6445         uint32_t _ptr_dependent_files;
6446         TALLOC_CTX *_mem_save_dependent_files_0;
6447         if (ndr_flags & NDR_SCALARS) {
6448                 NDR_CHECK(ndr_pull_align(ndr, 4));
6449                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6451                 if (_ptr_driver_name) {
6452                         NDR_PULL_ALLOC(ndr, r->driver_name);
6453                 } else {
6454                         r->driver_name = NULL;
6455                 }
6456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6457                 if (_ptr_architecture) {
6458                         NDR_PULL_ALLOC(ndr, r->architecture);
6459                 } else {
6460                         r->architecture = NULL;
6461                 }
6462                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6463                 if (_ptr_driver_path) {
6464                         NDR_PULL_ALLOC(ndr, r->driver_path);
6465                 } else {
6466                         r->driver_path = NULL;
6467                 }
6468                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6469                 if (_ptr_data_file) {
6470                         NDR_PULL_ALLOC(ndr, r->data_file);
6471                 } else {
6472                         r->data_file = NULL;
6473                 }
6474                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6475                 if (_ptr_config_file) {
6476                         NDR_PULL_ALLOC(ndr, r->config_file);
6477                 } else {
6478                         r->config_file = NULL;
6479                 }
6480                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6481                 if (_ptr_help_file) {
6482                         NDR_PULL_ALLOC(ndr, r->help_file);
6483                 } else {
6484                         r->help_file = NULL;
6485                 }
6486                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6487                 if (_ptr_monitor_name) {
6488                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6489                 } else {
6490                         r->monitor_name = NULL;
6491                 }
6492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6493                 if (_ptr_default_datatype) {
6494                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6495                 } else {
6496                         r->default_datatype = NULL;
6497                 }
6498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6499                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6500                 if (_ptr_dependent_files) {
6501                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6502                 } else {
6503                         r->dependent_files = NULL;
6504                 }
6505         }
6506         if (ndr_flags & NDR_BUFFERS) {
6507                 if (r->driver_name) {
6508                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6509                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6512                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6513                                 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));
6514                         }
6515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6518                 }
6519                 if (r->architecture) {
6520                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6521                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6522                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6523                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6524                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6525                                 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));
6526                         }
6527                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6528                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6530                 }
6531                 if (r->driver_path) {
6532                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6533                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6534                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6535                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6536                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6537                                 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));
6538                         }
6539                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6540                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6541                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6542                 }
6543                 if (r->data_file) {
6544                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6545                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6547                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6548                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6549                                 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));
6550                         }
6551                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6552                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6554                 }
6555                 if (r->config_file) {
6556                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6557                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6558                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6559                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6560                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6561                                 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));
6562                         }
6563                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6564                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6566                 }
6567                 if (r->help_file) {
6568                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6569                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6572                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6573                                 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));
6574                         }
6575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6578                 }
6579                 if (r->monitor_name) {
6580                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6581                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6584                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6585                                 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));
6586                         }
6587                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6588                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6590                 }
6591                 if (r->default_datatype) {
6592                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6593                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6596                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6597                                 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));
6598                         }
6599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6602                 }
6603                 if (r->dependent_files) {
6604                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6605                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6606                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6607                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6608                 }
6609         }
6610         return NDR_ERR_SUCCESS;
6611 }
6612
6613 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
6614 {
6615         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
6616         ndr->depth++;
6617         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6618         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6619         ndr->depth++;
6620         if (r->driver_name) {
6621                 ndr_print_string(ndr, "driver_name", r->driver_name);
6622         }
6623         ndr->depth--;
6624         ndr_print_ptr(ndr, "architecture", r->architecture);
6625         ndr->depth++;
6626         if (r->architecture) {
6627                 ndr_print_string(ndr, "architecture", r->architecture);
6628         }
6629         ndr->depth--;
6630         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6631         ndr->depth++;
6632         if (r->driver_path) {
6633                 ndr_print_string(ndr, "driver_path", r->driver_path);
6634         }
6635         ndr->depth--;
6636         ndr_print_ptr(ndr, "data_file", r->data_file);
6637         ndr->depth++;
6638         if (r->data_file) {
6639                 ndr_print_string(ndr, "data_file", r->data_file);
6640         }
6641         ndr->depth--;
6642         ndr_print_ptr(ndr, "config_file", r->config_file);
6643         ndr->depth++;
6644         if (r->config_file) {
6645                 ndr_print_string(ndr, "config_file", r->config_file);
6646         }
6647         ndr->depth--;
6648         ndr_print_ptr(ndr, "help_file", r->help_file);
6649         ndr->depth++;
6650         if (r->help_file) {
6651                 ndr_print_string(ndr, "help_file", r->help_file);
6652         }
6653         ndr->depth--;
6654         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6655         ndr->depth++;
6656         if (r->monitor_name) {
6657                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6658         }
6659         ndr->depth--;
6660         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
6661         ndr->depth++;
6662         if (r->default_datatype) {
6663                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
6664         }
6665         ndr->depth--;
6666         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);
6667         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
6668         ndr->depth++;
6669         if (r->dependent_files) {
6670                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
6671         }
6672         ndr->depth--;
6673         ndr->depth--;
6674 }
6675
6676 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
6677 {
6678         if (ndr_flags & NDR_SCALARS) {
6679                 NDR_CHECK(ndr_push_align(ndr, 4));
6680                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
6681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
6682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
6683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
6684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
6685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
6686                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
6687                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
6688                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
6689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
6691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
6692                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
6693         }
6694         if (ndr_flags & NDR_BUFFERS) {
6695                 if (r->driver_name) {
6696                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
6699                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6700                 }
6701                 if (r->architecture) {
6702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
6705                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6706                 }
6707                 if (r->driver_path) {
6708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
6711                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6712                 }
6713                 if (r->data_file) {
6714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
6717                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6718                 }
6719                 if (r->config_file) {
6720                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6721                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6722                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
6723                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6724                 }
6725                 if (r->help_file) {
6726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
6729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6730                 }
6731                 if (r->monitor_name) {
6732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
6735                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6736                 }
6737                 if (r->default_datatype) {
6738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
6741                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6742                 }
6743                 if (r->dependent_files) {
6744                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6745                 }
6746                 if (r->previous_names) {
6747                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6748                 }
6749         }
6750         return NDR_ERR_SUCCESS;
6751 }
6752
6753 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
6754 {
6755         uint32_t _ptr_driver_name;
6756         TALLOC_CTX *_mem_save_driver_name_0;
6757         uint32_t _ptr_architecture;
6758         TALLOC_CTX *_mem_save_architecture_0;
6759         uint32_t _ptr_driver_path;
6760         TALLOC_CTX *_mem_save_driver_path_0;
6761         uint32_t _ptr_data_file;
6762         TALLOC_CTX *_mem_save_data_file_0;
6763         uint32_t _ptr_config_file;
6764         TALLOC_CTX *_mem_save_config_file_0;
6765         uint32_t _ptr_help_file;
6766         TALLOC_CTX *_mem_save_help_file_0;
6767         uint32_t _ptr_monitor_name;
6768         TALLOC_CTX *_mem_save_monitor_name_0;
6769         uint32_t _ptr_default_datatype;
6770         TALLOC_CTX *_mem_save_default_datatype_0;
6771         uint32_t _ptr_dependent_files;
6772         TALLOC_CTX *_mem_save_dependent_files_0;
6773         uint32_t _ptr_previous_names;
6774         TALLOC_CTX *_mem_save_previous_names_0;
6775         if (ndr_flags & NDR_SCALARS) {
6776                 NDR_CHECK(ndr_pull_align(ndr, 4));
6777                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
6778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
6779                 if (_ptr_driver_name) {
6780                         NDR_PULL_ALLOC(ndr, r->driver_name);
6781                 } else {
6782                         r->driver_name = NULL;
6783                 }
6784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
6785                 if (_ptr_architecture) {
6786                         NDR_PULL_ALLOC(ndr, r->architecture);
6787                 } else {
6788                         r->architecture = NULL;
6789                 }
6790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
6791                 if (_ptr_driver_path) {
6792                         NDR_PULL_ALLOC(ndr, r->driver_path);
6793                 } else {
6794                         r->driver_path = NULL;
6795                 }
6796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
6797                 if (_ptr_data_file) {
6798                         NDR_PULL_ALLOC(ndr, r->data_file);
6799                 } else {
6800                         r->data_file = NULL;
6801                 }
6802                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
6803                 if (_ptr_config_file) {
6804                         NDR_PULL_ALLOC(ndr, r->config_file);
6805                 } else {
6806                         r->config_file = NULL;
6807                 }
6808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
6809                 if (_ptr_help_file) {
6810                         NDR_PULL_ALLOC(ndr, r->help_file);
6811                 } else {
6812                         r->help_file = NULL;
6813                 }
6814                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
6815                 if (_ptr_monitor_name) {
6816                         NDR_PULL_ALLOC(ndr, r->monitor_name);
6817                 } else {
6818                         r->monitor_name = NULL;
6819                 }
6820                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
6821                 if (_ptr_default_datatype) {
6822                         NDR_PULL_ALLOC(ndr, r->default_datatype);
6823                 } else {
6824                         r->default_datatype = NULL;
6825                 }
6826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
6827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
6828                 if (_ptr_dependent_files) {
6829                         NDR_PULL_ALLOC(ndr, r->dependent_files);
6830                 } else {
6831                         r->dependent_files = NULL;
6832                 }
6833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
6834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
6835                 if (_ptr_previous_names) {
6836                         NDR_PULL_ALLOC(ndr, r->previous_names);
6837                 } else {
6838                         r->previous_names = NULL;
6839                 }
6840         }
6841         if (ndr_flags & NDR_BUFFERS) {
6842                 if (r->driver_name) {
6843                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6844                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
6845                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
6846                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
6847                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
6848                                 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));
6849                         }
6850                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
6851                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
6852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
6853                 }
6854                 if (r->architecture) {
6855                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
6856                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
6857                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
6858                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
6859                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
6860                                 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));
6861                         }
6862                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
6863                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
6864                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
6865                 }
6866                 if (r->driver_path) {
6867                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
6868                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
6869                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
6870                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
6871                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
6872                                 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));
6873                         }
6874                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
6875                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
6876                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
6877                 }
6878                 if (r->data_file) {
6879                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6880                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
6881                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
6882                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
6883                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
6884                                 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));
6885                         }
6886                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
6887                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
6888                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
6889                 }
6890                 if (r->config_file) {
6891                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6892                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
6893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
6894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
6895                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
6896                                 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));
6897                         }
6898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
6899                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
6900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
6901                 }
6902                 if (r->help_file) {
6903                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6904                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
6905                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
6906                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
6907                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
6908                                 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));
6909                         }
6910                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
6911                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
6912                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
6913                 }
6914                 if (r->monitor_name) {
6915                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6916                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
6917                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
6918                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
6919                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
6920                                 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));
6921                         }
6922                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
6923                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
6924                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
6925                 }
6926                 if (r->default_datatype) {
6927                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6928                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
6929                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
6930                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
6931                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
6932                                 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));
6933                         }
6934                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
6935                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
6936                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
6937                 }
6938                 if (r->dependent_files) {
6939                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
6940                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
6941                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
6942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
6943                 }
6944                 if (r->previous_names) {
6945                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
6946                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
6947                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
6948                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
6949                 }
6950         }
6951         return NDR_ERR_SUCCESS;
6952 }
6953
6954 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
6955 {
6956         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
6957         ndr->depth++;
6958         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
6959         ndr_print_ptr(ndr, "driver_name", r->driver_name);
6960         ndr->depth++;
6961         if (r->driver_name) {
6962                 ndr_print_string(ndr, "driver_name", r->driver_name);
6963         }
6964         ndr->depth--;
6965         ndr_print_ptr(ndr, "architecture", r->architecture);
6966         ndr->depth++;
6967         if (r->architecture) {
6968                 ndr_print_string(ndr, "architecture", r->architecture);
6969         }
6970         ndr->depth--;
6971         ndr_print_ptr(ndr, "driver_path", r->driver_path);
6972         ndr->depth++;
6973         if (r->driver_path) {
6974                 ndr_print_string(ndr, "driver_path", r->driver_path);
6975         }
6976         ndr->depth--;
6977         ndr_print_ptr(ndr, "data_file", r->data_file);
6978         ndr->depth++;
6979         if (r->data_file) {
6980                 ndr_print_string(ndr, "data_file", r->data_file);
6981         }
6982         ndr->depth--;
6983         ndr_print_ptr(ndr, "config_file", r->config_file);
6984         ndr->depth++;
6985         if (r->config_file) {
6986                 ndr_print_string(ndr, "config_file", r->config_file);
6987         }
6988         ndr->depth--;
6989         ndr_print_ptr(ndr, "help_file", r->help_file);
6990         ndr->depth++;
6991         if (r->help_file) {
6992                 ndr_print_string(ndr, "help_file", r->help_file);
6993         }
6994         ndr->depth--;
6995         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
6996         ndr->depth++;
6997         if (r->monitor_name) {
6998                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
6999         }
7000         ndr->depth--;
7001         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7002         ndr->depth++;
7003         if (r->default_datatype) {
7004                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7005         }
7006         ndr->depth--;
7007         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);
7008         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7009         ndr->depth++;
7010         if (r->dependent_files) {
7011                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7012         }
7013         ndr->depth--;
7014         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);
7015         ndr_print_ptr(ndr, "previous_names", r->previous_names);
7016         ndr->depth++;
7017         if (r->previous_names) {
7018                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
7019         }
7020         ndr->depth--;
7021         ndr->depth--;
7022 }
7023
7024 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
7025 {
7026         if (ndr_flags & NDR_SCALARS) {
7027                 NDR_CHECK(ndr_push_align(ndr, 8));
7028                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
7041                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
7042                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
7043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
7044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
7045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
7046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
7047         }
7048         if (ndr_flags & NDR_BUFFERS) {
7049                 if (r->driver_name) {
7050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7053                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7054                 }
7055                 if (r->architecture) {
7056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7060                 }
7061                 if (r->driver_path) {
7062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7066                 }
7067                 if (r->data_file) {
7068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7072                 }
7073                 if (r->config_file) {
7074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7078                 }
7079                 if (r->help_file) {
7080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7084                 }
7085                 if (r->monitor_name) {
7086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7090                 }
7091                 if (r->default_datatype) {
7092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7096                 }
7097                 if (r->dependent_files) {
7098                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7099                 }
7100                 if (r->previous_names) {
7101                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
7102                 }
7103                 if (r->manufacturer_name) {
7104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
7105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
7107                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7108                 }
7109                 if (r->manufacturer_url) {
7110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
7111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
7113                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7114                 }
7115                 if (r->hardware_id) {
7116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
7117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
7119                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7120                 }
7121                 if (r->provider) {
7122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
7123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
7125                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7126                 }
7127         }
7128         return NDR_ERR_SUCCESS;
7129 }
7130
7131 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
7132 {
7133         uint32_t _ptr_driver_name;
7134         TALLOC_CTX *_mem_save_driver_name_0;
7135         uint32_t _ptr_architecture;
7136         TALLOC_CTX *_mem_save_architecture_0;
7137         uint32_t _ptr_driver_path;
7138         TALLOC_CTX *_mem_save_driver_path_0;
7139         uint32_t _ptr_data_file;
7140         TALLOC_CTX *_mem_save_data_file_0;
7141         uint32_t _ptr_config_file;
7142         TALLOC_CTX *_mem_save_config_file_0;
7143         uint32_t _ptr_help_file;
7144         TALLOC_CTX *_mem_save_help_file_0;
7145         uint32_t _ptr_monitor_name;
7146         TALLOC_CTX *_mem_save_monitor_name_0;
7147         uint32_t _ptr_default_datatype;
7148         TALLOC_CTX *_mem_save_default_datatype_0;
7149         uint32_t _ptr_dependent_files;
7150         TALLOC_CTX *_mem_save_dependent_files_0;
7151         uint32_t _ptr_previous_names;
7152         TALLOC_CTX *_mem_save_previous_names_0;
7153         uint32_t _ptr_manufacturer_name;
7154         TALLOC_CTX *_mem_save_manufacturer_name_0;
7155         uint32_t _ptr_manufacturer_url;
7156         TALLOC_CTX *_mem_save_manufacturer_url_0;
7157         uint32_t _ptr_hardware_id;
7158         TALLOC_CTX *_mem_save_hardware_id_0;
7159         uint32_t _ptr_provider;
7160         TALLOC_CTX *_mem_save_provider_0;
7161         if (ndr_flags & NDR_SCALARS) {
7162                 NDR_CHECK(ndr_pull_align(ndr, 8));
7163                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7165                 if (_ptr_driver_name) {
7166                         NDR_PULL_ALLOC(ndr, r->driver_name);
7167                 } else {
7168                         r->driver_name = NULL;
7169                 }
7170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7171                 if (_ptr_architecture) {
7172                         NDR_PULL_ALLOC(ndr, r->architecture);
7173                 } else {
7174                         r->architecture = NULL;
7175                 }
7176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7177                 if (_ptr_driver_path) {
7178                         NDR_PULL_ALLOC(ndr, r->driver_path);
7179                 } else {
7180                         r->driver_path = NULL;
7181                 }
7182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7183                 if (_ptr_data_file) {
7184                         NDR_PULL_ALLOC(ndr, r->data_file);
7185                 } else {
7186                         r->data_file = NULL;
7187                 }
7188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7189                 if (_ptr_config_file) {
7190                         NDR_PULL_ALLOC(ndr, r->config_file);
7191                 } else {
7192                         r->config_file = NULL;
7193                 }
7194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7195                 if (_ptr_help_file) {
7196                         NDR_PULL_ALLOC(ndr, r->help_file);
7197                 } else {
7198                         r->help_file = NULL;
7199                 }
7200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7201                 if (_ptr_monitor_name) {
7202                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7203                 } else {
7204                         r->monitor_name = NULL;
7205                 }
7206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7207                 if (_ptr_default_datatype) {
7208                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7209                 } else {
7210                         r->default_datatype = NULL;
7211                 }
7212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7214                 if (_ptr_dependent_files) {
7215                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7216                 } else {
7217                         r->dependent_files = NULL;
7218                 }
7219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
7220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
7221                 if (_ptr_previous_names) {
7222                         NDR_PULL_ALLOC(ndr, r->previous_names);
7223                 } else {
7224                         r->previous_names = NULL;
7225                 }
7226                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
7227                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
7228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
7229                 if (_ptr_manufacturer_name) {
7230                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
7231                 } else {
7232                         r->manufacturer_name = NULL;
7233                 }
7234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
7235                 if (_ptr_manufacturer_url) {
7236                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
7237                 } else {
7238                         r->manufacturer_url = NULL;
7239                 }
7240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
7241                 if (_ptr_hardware_id) {
7242                         NDR_PULL_ALLOC(ndr, r->hardware_id);
7243                 } else {
7244                         r->hardware_id = NULL;
7245                 }
7246                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
7247                 if (_ptr_provider) {
7248                         NDR_PULL_ALLOC(ndr, r->provider);
7249                 } else {
7250                         r->provider = NULL;
7251                 }
7252         }
7253         if (ndr_flags & NDR_BUFFERS) {
7254                 if (r->driver_name) {
7255                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7256                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7259                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7260                                 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));
7261                         }
7262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7265                 }
7266                 if (r->architecture) {
7267                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7268                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7270                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7271                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7272                                 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));
7273                         }
7274                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7275                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7277                 }
7278                 if (r->driver_path) {
7279                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7280                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7283                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7284                                 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));
7285                         }
7286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7289                 }
7290                 if (r->data_file) {
7291                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7292                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7295                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7296                                 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));
7297                         }
7298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7301                 }
7302                 if (r->config_file) {
7303                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7304                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7307                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7308                                 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));
7309                         }
7310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7313                 }
7314                 if (r->help_file) {
7315                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7316                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7319                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7320                                 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));
7321                         }
7322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7325                 }
7326                 if (r->monitor_name) {
7327                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7328                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7331                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7332                                 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));
7333                         }
7334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7337                 }
7338                 if (r->default_datatype) {
7339                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7340                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7343                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7344                                 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));
7345                         }
7346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7349                 }
7350                 if (r->dependent_files) {
7351                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7352                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7353                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7355                 }
7356                 if (r->previous_names) {
7357                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7358                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
7359                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
7360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
7361                 }
7362                 if (r->manufacturer_name) {
7363                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7364                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
7365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
7366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
7367                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
7368                                 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));
7369                         }
7370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
7371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
7372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
7373                 }
7374                 if (r->manufacturer_url) {
7375                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
7376                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
7377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
7378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
7379                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
7380                                 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));
7381                         }
7382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
7383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
7384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
7385                 }
7386                 if (r->hardware_id) {
7387                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
7388                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
7389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
7390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
7391                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
7392                                 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));
7393                         }
7394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
7395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
7396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
7397                 }
7398                 if (r->provider) {
7399                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
7400                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
7401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
7402                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
7403                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
7404                                 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));
7405                         }
7406                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
7407                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
7408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
7409                 }
7410         }
7411         return NDR_ERR_SUCCESS;
7412 }
7413
7414 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
7415 {
7416         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
7417         ndr->depth++;
7418         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7419         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7420         ndr->depth++;
7421         if (r->driver_name) {
7422                 ndr_print_string(ndr, "driver_name", r->driver_name);
7423         }
7424         ndr->depth--;
7425         ndr_print_ptr(ndr, "architecture", r->architecture);
7426         ndr->depth++;
7427         if (r->architecture) {
7428                 ndr_print_string(ndr, "architecture", r->architecture);
7429         }
7430         ndr->depth--;
7431         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7432         ndr->depth++;
7433         if (r->driver_path) {
7434                 ndr_print_string(ndr, "driver_path", r->driver_path);
7435         }
7436         ndr->depth--;
7437         ndr_print_ptr(ndr, "data_file", r->data_file);
7438         ndr->depth++;
7439         if (r->data_file) {
7440                 ndr_print_string(ndr, "data_file", r->data_file);
7441         }
7442         ndr->depth--;
7443         ndr_print_ptr(ndr, "config_file", r->config_file);
7444         ndr->depth++;
7445         if (r->config_file) {
7446                 ndr_print_string(ndr, "config_file", r->config_file);
7447         }
7448         ndr->depth--;
7449         ndr_print_ptr(ndr, "help_file", r->help_file);
7450         ndr->depth++;
7451         if (r->help_file) {
7452                 ndr_print_string(ndr, "help_file", r->help_file);
7453         }
7454         ndr->depth--;
7455         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7456         ndr->depth++;
7457         if (r->monitor_name) {
7458                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7459         }
7460         ndr->depth--;
7461         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7462         ndr->depth++;
7463         if (r->default_datatype) {
7464                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7465         }
7466         ndr->depth--;
7467         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);
7468         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7469         ndr->depth++;
7470         if (r->dependent_files) {
7471                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7472         }
7473         ndr->depth--;
7474         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);
7475         ndr_print_ptr(ndr, "previous_names", r->previous_names);
7476         ndr->depth++;
7477         if (r->previous_names) {
7478                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
7479         }
7480         ndr->depth--;
7481         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
7482         ndr_print_hyper(ndr, "driver_version", r->driver_version);
7483         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
7484         ndr->depth++;
7485         if (r->manufacturer_name) {
7486                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
7487         }
7488         ndr->depth--;
7489         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
7490         ndr->depth++;
7491         if (r->manufacturer_url) {
7492                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
7493         }
7494         ndr->depth--;
7495         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
7496         ndr->depth++;
7497         if (r->hardware_id) {
7498                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
7499         }
7500         ndr->depth--;
7501         ndr_print_ptr(ndr, "provider", r->provider);
7502         ndr->depth++;
7503         if (r->provider) {
7504                 ndr_print_string(ndr, "provider", r->provider);
7505         }
7506         ndr->depth--;
7507         ndr->depth--;
7508 }
7509
7510 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
7511 {
7512         if (ndr_flags & NDR_SCALARS) {
7513                 NDR_CHECK(ndr_push_align(ndr, 8));
7514                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7515                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7522                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7524                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
7527                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
7528                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
7529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
7530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
7531                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
7532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
7533                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
7534                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
7535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7536                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
7537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
7538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
7539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7540                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
7541                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
7542                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
7543         }
7544         if (ndr_flags & NDR_BUFFERS) {
7545                 if (r->driver_name) {
7546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7549                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7550                 }
7551                 if (r->architecture) {
7552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7555                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7556                 }
7557                 if (r->driver_path) {
7558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7562                 }
7563                 if (r->data_file) {
7564                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7565                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7566                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7567                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7568                 }
7569                 if (r->config_file) {
7570                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7571                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7572                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7573                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7574                 }
7575                 if (r->help_file) {
7576                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7577                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7578                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7579                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7580                 }
7581                 if (r->monitor_name) {
7582                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7583                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7584                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7585                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7586                 }
7587                 if (r->default_datatype) {
7588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7592                 }
7593                 if (r->dependent_files) {
7594                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7595                 }
7596                 if (r->previous_names) {
7597                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
7598                 }
7599                 if (r->manufacturer_name) {
7600                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
7601                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7602                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
7603                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7604                 }
7605                 if (r->manufacturer_url) {
7606                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
7607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
7609                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7610                 }
7611                 if (r->hardware_id) {
7612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
7613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
7615                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7616                 }
7617                 if (r->provider) {
7618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
7619                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
7621                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7622                 }
7623                 if (r->print_processor) {
7624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
7625                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7626                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
7627                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7628                 }
7629                 if (r->vendor_setup) {
7630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
7631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
7633                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7634                 }
7635                 if (r->color_profiles) {
7636                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
7637                 }
7638                 if (r->inf_path) {
7639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
7640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
7642                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7643                 }
7644                 if (r->core_driver_dependencies) {
7645                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
7646                 }
7647         }
7648         return NDR_ERR_SUCCESS;
7649 }
7650
7651 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
7652 {
7653         uint32_t _ptr_driver_name;
7654         TALLOC_CTX *_mem_save_driver_name_0;
7655         uint32_t _ptr_architecture;
7656         TALLOC_CTX *_mem_save_architecture_0;
7657         uint32_t _ptr_driver_path;
7658         TALLOC_CTX *_mem_save_driver_path_0;
7659         uint32_t _ptr_data_file;
7660         TALLOC_CTX *_mem_save_data_file_0;
7661         uint32_t _ptr_config_file;
7662         TALLOC_CTX *_mem_save_config_file_0;
7663         uint32_t _ptr_help_file;
7664         TALLOC_CTX *_mem_save_help_file_0;
7665         uint32_t _ptr_monitor_name;
7666         TALLOC_CTX *_mem_save_monitor_name_0;
7667         uint32_t _ptr_default_datatype;
7668         TALLOC_CTX *_mem_save_default_datatype_0;
7669         uint32_t _ptr_dependent_files;
7670         TALLOC_CTX *_mem_save_dependent_files_0;
7671         uint32_t _ptr_previous_names;
7672         TALLOC_CTX *_mem_save_previous_names_0;
7673         uint32_t _ptr_manufacturer_name;
7674         TALLOC_CTX *_mem_save_manufacturer_name_0;
7675         uint32_t _ptr_manufacturer_url;
7676         TALLOC_CTX *_mem_save_manufacturer_url_0;
7677         uint32_t _ptr_hardware_id;
7678         TALLOC_CTX *_mem_save_hardware_id_0;
7679         uint32_t _ptr_provider;
7680         TALLOC_CTX *_mem_save_provider_0;
7681         uint32_t _ptr_print_processor;
7682         TALLOC_CTX *_mem_save_print_processor_0;
7683         uint32_t _ptr_vendor_setup;
7684         TALLOC_CTX *_mem_save_vendor_setup_0;
7685         uint32_t _ptr_color_profiles;
7686         TALLOC_CTX *_mem_save_color_profiles_0;
7687         uint32_t _ptr_inf_path;
7688         TALLOC_CTX *_mem_save_inf_path_0;
7689         uint32_t _ptr_core_driver_dependencies;
7690         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
7691         if (ndr_flags & NDR_SCALARS) {
7692                 NDR_CHECK(ndr_pull_align(ndr, 8));
7693                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7695                 if (_ptr_driver_name) {
7696                         NDR_PULL_ALLOC(ndr, r->driver_name);
7697                 } else {
7698                         r->driver_name = NULL;
7699                 }
7700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7701                 if (_ptr_architecture) {
7702                         NDR_PULL_ALLOC(ndr, r->architecture);
7703                 } else {
7704                         r->architecture = NULL;
7705                 }
7706                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7707                 if (_ptr_driver_path) {
7708                         NDR_PULL_ALLOC(ndr, r->driver_path);
7709                 } else {
7710                         r->driver_path = NULL;
7711                 }
7712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7713                 if (_ptr_data_file) {
7714                         NDR_PULL_ALLOC(ndr, r->data_file);
7715                 } else {
7716                         r->data_file = NULL;
7717                 }
7718                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7719                 if (_ptr_config_file) {
7720                         NDR_PULL_ALLOC(ndr, r->config_file);
7721                 } else {
7722                         r->config_file = NULL;
7723                 }
7724                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7725                 if (_ptr_help_file) {
7726                         NDR_PULL_ALLOC(ndr, r->help_file);
7727                 } else {
7728                         r->help_file = NULL;
7729                 }
7730                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7731                 if (_ptr_monitor_name) {
7732                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7733                 } else {
7734                         r->monitor_name = NULL;
7735                 }
7736                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7737                 if (_ptr_default_datatype) {
7738                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7739                 } else {
7740                         r->default_datatype = NULL;
7741                 }
7742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7743                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7744                 if (_ptr_dependent_files) {
7745                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7746                 } else {
7747                         r->dependent_files = NULL;
7748                 }
7749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
7750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
7751                 if (_ptr_previous_names) {
7752                         NDR_PULL_ALLOC(ndr, r->previous_names);
7753                 } else {
7754                         r->previous_names = NULL;
7755                 }
7756                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
7757                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
7758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
7759                 if (_ptr_manufacturer_name) {
7760                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
7761                 } else {
7762                         r->manufacturer_name = NULL;
7763                 }
7764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
7765                 if (_ptr_manufacturer_url) {
7766                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
7767                 } else {
7768                         r->manufacturer_url = NULL;
7769                 }
7770                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
7771                 if (_ptr_hardware_id) {
7772                         NDR_PULL_ALLOC(ndr, r->hardware_id);
7773                 } else {
7774                         r->hardware_id = NULL;
7775                 }
7776                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
7777                 if (_ptr_provider) {
7778                         NDR_PULL_ALLOC(ndr, r->provider);
7779                 } else {
7780                         r->provider = NULL;
7781                 }
7782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
7783                 if (_ptr_print_processor) {
7784                         NDR_PULL_ALLOC(ndr, r->print_processor);
7785                 } else {
7786                         r->print_processor = NULL;
7787                 }
7788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
7789                 if (_ptr_vendor_setup) {
7790                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
7791                 } else {
7792                         r->vendor_setup = NULL;
7793                 }
7794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
7795                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
7796                 if (_ptr_color_profiles) {
7797                         NDR_PULL_ALLOC(ndr, r->color_profiles);
7798                 } else {
7799                         r->color_profiles = NULL;
7800                 }
7801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
7802                 if (_ptr_inf_path) {
7803                         NDR_PULL_ALLOC(ndr, r->inf_path);
7804                 } else {
7805                         r->inf_path = NULL;
7806                 }
7807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
7808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
7809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
7810                 if (_ptr_core_driver_dependencies) {
7811                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
7812                 } else {
7813                         r->core_driver_dependencies = NULL;
7814                 }
7815                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
7816                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
7817         }
7818         if (ndr_flags & NDR_BUFFERS) {
7819                 if (r->driver_name) {
7820                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7821                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7822                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7823                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7824                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7825                                 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));
7826                         }
7827                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7828                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7830                 }
7831                 if (r->architecture) {
7832                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7833                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7834                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7835                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7836                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7837                                 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));
7838                         }
7839                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7840                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7841                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7842                 }
7843                 if (r->driver_path) {
7844                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7845                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7846                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7847                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7848                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7849                                 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));
7850                         }
7851                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7852                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7853                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7854                 }
7855                 if (r->data_file) {
7856                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7857                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7858                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7859                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7860                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7861                                 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));
7862                         }
7863                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7864                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7866                 }
7867                 if (r->config_file) {
7868                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7869                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7870                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7871                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7872                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7873                                 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));
7874                         }
7875                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7876                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7878                 }
7879                 if (r->help_file) {
7880                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7881                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7882                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7883                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7884                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7885                                 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));
7886                         }
7887                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7888                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7890                 }
7891                 if (r->monitor_name) {
7892                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7893                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7896                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7897                                 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));
7898                         }
7899                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7900                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7902                 }
7903                 if (r->default_datatype) {
7904                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7905                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7908                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7909                                 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));
7910                         }
7911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7914                 }
7915                 if (r->dependent_files) {
7916                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7917                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7918                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7920                 }
7921                 if (r->previous_names) {
7922                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
7923                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
7924                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
7925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
7926                 }
7927                 if (r->manufacturer_name) {
7928                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7929                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
7930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
7931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
7932                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
7933                                 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));
7934                         }
7935                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
7936                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
7937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
7938                 }
7939                 if (r->manufacturer_url) {
7940                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
7941                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
7942                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
7943                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
7944                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
7945                                 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));
7946                         }
7947                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
7948                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
7949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
7950                 }
7951                 if (r->hardware_id) {
7952                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
7953                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
7954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
7955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
7956                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
7957                                 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));
7958                         }
7959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
7960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
7961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
7962                 }
7963                 if (r->provider) {
7964                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
7965                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
7966                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
7967                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
7968                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
7969                                 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));
7970                         }
7971                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
7972                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
7973                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
7974                 }
7975                 if (r->print_processor) {
7976                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
7977                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
7978                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
7979                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
7980                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
7981                                 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));
7982                         }
7983                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
7984                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
7985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
7986                 }
7987                 if (r->vendor_setup) {
7988                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
7989                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
7990                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
7991                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
7992                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
7993                                 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));
7994                         }
7995                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
7996                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
7997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
7998                 }
7999                 if (r->color_profiles) {
8000                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
8001                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
8002                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8003                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
8004                 }
8005                 if (r->inf_path) {
8006                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8007                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
8008                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
8009                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
8010                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
8011                                 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));
8012                         }
8013                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
8014                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
8015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
8016                 }
8017                 if (r->core_driver_dependencies) {
8018                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
8019                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
8020                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8021                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
8022                 }
8023         }
8024         return NDR_ERR_SUCCESS;
8025 }
8026
8027 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
8028 {
8029         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
8030         ndr->depth++;
8031         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8032         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8033         ndr->depth++;
8034         if (r->driver_name) {
8035                 ndr_print_string(ndr, "driver_name", r->driver_name);
8036         }
8037         ndr->depth--;
8038         ndr_print_ptr(ndr, "architecture", r->architecture);
8039         ndr->depth++;
8040         if (r->architecture) {
8041                 ndr_print_string(ndr, "architecture", r->architecture);
8042         }
8043         ndr->depth--;
8044         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8045         ndr->depth++;
8046         if (r->driver_path) {
8047                 ndr_print_string(ndr, "driver_path", r->driver_path);
8048         }
8049         ndr->depth--;
8050         ndr_print_ptr(ndr, "data_file", r->data_file);
8051         ndr->depth++;
8052         if (r->data_file) {
8053                 ndr_print_string(ndr, "data_file", r->data_file);
8054         }
8055         ndr->depth--;
8056         ndr_print_ptr(ndr, "config_file", r->config_file);
8057         ndr->depth++;
8058         if (r->config_file) {
8059                 ndr_print_string(ndr, "config_file", r->config_file);
8060         }
8061         ndr->depth--;
8062         ndr_print_ptr(ndr, "help_file", r->help_file);
8063         ndr->depth++;
8064         if (r->help_file) {
8065                 ndr_print_string(ndr, "help_file", r->help_file);
8066         }
8067         ndr->depth--;
8068         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8069         ndr->depth++;
8070         if (r->monitor_name) {
8071                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8072         }
8073         ndr->depth--;
8074         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8075         ndr->depth++;
8076         if (r->default_datatype) {
8077                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8078         }
8079         ndr->depth--;
8080         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);
8081         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8082         ndr->depth++;
8083         if (r->dependent_files) {
8084                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8085         }
8086         ndr->depth--;
8087         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);
8088         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8089         ndr->depth++;
8090         if (r->previous_names) {
8091                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8092         }
8093         ndr->depth--;
8094         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8095         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8096         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8097         ndr->depth++;
8098         if (r->manufacturer_name) {
8099                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8100         }
8101         ndr->depth--;
8102         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8103         ndr->depth++;
8104         if (r->manufacturer_url) {
8105                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8106         }
8107         ndr->depth--;
8108         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8109         ndr->depth++;
8110         if (r->hardware_id) {
8111                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8112         }
8113         ndr->depth--;
8114         ndr_print_ptr(ndr, "provider", r->provider);
8115         ndr->depth++;
8116         if (r->provider) {
8117                 ndr_print_string(ndr, "provider", r->provider);
8118         }
8119         ndr->depth--;
8120         ndr_print_ptr(ndr, "print_processor", r->print_processor);
8121         ndr->depth++;
8122         if (r->print_processor) {
8123                 ndr_print_string(ndr, "print_processor", r->print_processor);
8124         }
8125         ndr->depth--;
8126         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
8127         ndr->depth++;
8128         if (r->vendor_setup) {
8129                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
8130         }
8131         ndr->depth--;
8132         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);
8133         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
8134         ndr->depth++;
8135         if (r->color_profiles) {
8136                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
8137         }
8138         ndr->depth--;
8139         ndr_print_ptr(ndr, "inf_path", r->inf_path);
8140         ndr->depth++;
8141         if (r->inf_path) {
8142                 ndr_print_string(ndr, "inf_path", r->inf_path);
8143         }
8144         ndr->depth--;
8145         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
8146         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);
8147         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
8148         ndr->depth++;
8149         if (r->core_driver_dependencies) {
8150                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
8151         }
8152         ndr->depth--;
8153         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
8154         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
8155         ndr->depth--;
8156 }
8157
8158 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
8159 {
8160         if (ndr_flags & NDR_SCALARS) {
8161                 int level = ndr_push_get_switch_value(ndr, r);
8162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8163                 switch (level) {
8164                         case 1: {
8165                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
8166                         break; }
8167
8168                         case 2: {
8169                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
8170                         break; }
8171
8172                         case 3: {
8173                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
8174                         break; }
8175
8176                         case 4: {
8177                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
8178                         break; }
8179
8180                         case 6: {
8181                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
8182                         break; }
8183
8184                         case 8: {
8185                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
8186                         break; }
8187
8188                         default:
8189                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8190                 }
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193                 int level = ndr_push_get_switch_value(ndr, r);
8194                 switch (level) {
8195                         case 1:
8196                                 if (r->info1) {
8197                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
8198                                 }
8199                         break;
8200
8201                         case 2:
8202                                 if (r->info2) {
8203                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
8204                                 }
8205                         break;
8206
8207                         case 3:
8208                                 if (r->info3) {
8209                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
8210                                 }
8211                         break;
8212
8213                         case 4:
8214                                 if (r->info4) {
8215                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
8216                                 }
8217                         break;
8218
8219                         case 6:
8220                                 if (r->info6) {
8221                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
8222                                 }
8223                         break;
8224
8225                         case 8:
8226                                 if (r->info8) {
8227                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
8228                                 }
8229                         break;
8230
8231                         default:
8232                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8233                 }
8234         }
8235         return NDR_ERR_SUCCESS;
8236 }
8237
8238 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
8239 {
8240         int level;
8241         uint32_t _level;
8242         TALLOC_CTX *_mem_save_info1_0;
8243         TALLOC_CTX *_mem_save_info2_0;
8244         TALLOC_CTX *_mem_save_info3_0;
8245         TALLOC_CTX *_mem_save_info4_0;
8246         TALLOC_CTX *_mem_save_info6_0;
8247         TALLOC_CTX *_mem_save_info8_0;
8248         level = ndr_pull_get_switch_value(ndr, r);
8249         if (ndr_flags & NDR_SCALARS) {
8250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8251                 if (_level != level) {
8252                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8253                 }
8254                 switch (level) {
8255                         case 1: {
8256                                 uint32_t _ptr_info1;
8257                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
8258                                 if (_ptr_info1) {
8259                                         NDR_PULL_ALLOC(ndr, r->info1);
8260                                 } else {
8261                                         r->info1 = NULL;
8262                                 }
8263                         break; }
8264
8265                         case 2: {
8266                                 uint32_t _ptr_info2;
8267                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
8268                                 if (_ptr_info2) {
8269                                         NDR_PULL_ALLOC(ndr, r->info2);
8270                                 } else {
8271                                         r->info2 = NULL;
8272                                 }
8273                         break; }
8274
8275                         case 3: {
8276                                 uint32_t _ptr_info3;
8277                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
8278                                 if (_ptr_info3) {
8279                                         NDR_PULL_ALLOC(ndr, r->info3);
8280                                 } else {
8281                                         r->info3 = NULL;
8282                                 }
8283                         break; }
8284
8285                         case 4: {
8286                                 uint32_t _ptr_info4;
8287                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
8288                                 if (_ptr_info4) {
8289                                         NDR_PULL_ALLOC(ndr, r->info4);
8290                                 } else {
8291                                         r->info4 = NULL;
8292                                 }
8293                         break; }
8294
8295                         case 6: {
8296                                 uint32_t _ptr_info6;
8297                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
8298                                 if (_ptr_info6) {
8299                                         NDR_PULL_ALLOC(ndr, r->info6);
8300                                 } else {
8301                                         r->info6 = NULL;
8302                                 }
8303                         break; }
8304
8305                         case 8: {
8306                                 uint32_t _ptr_info8;
8307                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
8308                                 if (_ptr_info8) {
8309                                         NDR_PULL_ALLOC(ndr, r->info8);
8310                                 } else {
8311                                         r->info8 = NULL;
8312                                 }
8313                         break; }
8314
8315                         default:
8316                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8317                 }
8318         }
8319         if (ndr_flags & NDR_BUFFERS) {
8320                 switch (level) {
8321                         case 1:
8322                                 if (r->info1) {
8323                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
8324                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
8325                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
8326                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
8327                                 }
8328                         break;
8329
8330                         case 2:
8331                                 if (r->info2) {
8332                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
8333                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
8334                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
8335                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
8336                                 }
8337                         break;
8338
8339                         case 3:
8340                                 if (r->info3) {
8341                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
8342                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
8343                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
8344                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
8345                                 }
8346                         break;
8347
8348                         case 4:
8349                                 if (r->info4) {
8350                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
8351                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
8352                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
8353                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
8354                                 }
8355                         break;
8356
8357                         case 6:
8358                                 if (r->info6) {
8359                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
8360                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
8361                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
8362                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
8363                                 }
8364                         break;
8365
8366                         case 8:
8367                                 if (r->info8) {
8368                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
8369                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
8370                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
8371                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
8372                                 }
8373                         break;
8374
8375                         default:
8376                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8377                 }
8378         }
8379         return NDR_ERR_SUCCESS;
8380 }
8381
8382 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
8383 {
8384         int level;
8385         level = ndr_print_get_switch_value(ndr, r);
8386         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
8387         switch (level) {
8388                 case 1:
8389                         ndr_print_ptr(ndr, "info1", r->info1);
8390                         ndr->depth++;
8391                         if (r->info1) {
8392                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
8393                         }
8394                         ndr->depth--;
8395                 break;
8396
8397                 case 2:
8398                         ndr_print_ptr(ndr, "info2", r->info2);
8399                         ndr->depth++;
8400                         if (r->info2) {
8401                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
8402                         }
8403                         ndr->depth--;
8404                 break;
8405
8406                 case 3:
8407                         ndr_print_ptr(ndr, "info3", r->info3);
8408                         ndr->depth++;
8409                         if (r->info3) {
8410                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
8411                         }
8412                         ndr->depth--;
8413                 break;
8414
8415                 case 4:
8416                         ndr_print_ptr(ndr, "info4", r->info4);
8417                         ndr->depth++;
8418                         if (r->info4) {
8419                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
8420                         }
8421                         ndr->depth--;
8422                 break;
8423
8424                 case 6:
8425                         ndr_print_ptr(ndr, "info6", r->info6);
8426                         ndr->depth++;
8427                         if (r->info6) {
8428                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
8429                         }
8430                         ndr->depth--;
8431                 break;
8432
8433                 case 8:
8434                         ndr_print_ptr(ndr, "info8", r->info8);
8435                         ndr->depth++;
8436                         if (r->info8) {
8437                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
8438                         }
8439                         ndr->depth--;
8440                 break;
8441
8442                 default:
8443                         ndr_print_bad_level(ndr, name, level);
8444         }
8445 }
8446
8447 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
8448 {
8449         if (ndr_flags & NDR_SCALARS) {
8450                 NDR_CHECK(ndr_push_align(ndr, 4));
8451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
8452                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
8453                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
8454         }
8455         if (ndr_flags & NDR_BUFFERS) {
8456                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
8457         }
8458         return NDR_ERR_SUCCESS;
8459 }
8460
8461 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
8462 {
8463         if (ndr_flags & NDR_SCALARS) {
8464                 NDR_CHECK(ndr_pull_align(ndr, 4));
8465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
8466                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
8467                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
8468         }
8469         if (ndr_flags & NDR_BUFFERS) {
8470                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
8471         }
8472         return NDR_ERR_SUCCESS;
8473 }
8474
8475 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
8476 {
8477         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
8478         ndr->depth++;
8479         ndr_print_uint32(ndr, "level", r->level);
8480         ndr_print_set_switch_value(ndr, &r->info, r->level);
8481         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
8482         ndr->depth--;
8483 }
8484
8485 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
8486 {
8487         if (ndr_flags & NDR_SCALARS) {
8488                 NDR_CHECK(ndr_push_align(ndr, 4));
8489                 {
8490                         uint32_t _flags_save_string = ndr->flags;
8491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8493                         ndr->flags = _flags_save_string;
8494                 }
8495         }
8496         if (ndr_flags & NDR_BUFFERS) {
8497                 {
8498                         uint32_t _flags_save_string = ndr->flags;
8499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8500                         if (r->driver_name) {
8501                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8502                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8503                         }
8504                         ndr->flags = _flags_save_string;
8505                 }
8506         }
8507         return NDR_ERR_SUCCESS;
8508 }
8509
8510 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
8511 {
8512         uint32_t _ptr_driver_name;
8513         TALLOC_CTX *_mem_save_driver_name_0;
8514         if (ndr_flags & NDR_SCALARS) {
8515                 NDR_CHECK(ndr_pull_align(ndr, 4));
8516                 {
8517                         uint32_t _flags_save_string = ndr->flags;
8518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8519                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8520                         if (_ptr_driver_name) {
8521                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8522                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8523                         } else {
8524                                 r->driver_name = NULL;
8525                         }
8526                         ndr->flags = _flags_save_string;
8527                 }
8528         }
8529         if (ndr_flags & NDR_BUFFERS) {
8530                 {
8531                         uint32_t _flags_save_string = ndr->flags;
8532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8533                         if (r->driver_name) {
8534                                 uint32_t _relative_save_offset;
8535                                 _relative_save_offset = ndr->offset;
8536                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8537                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8538                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8539                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8540                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8541                                 ndr->offset = _relative_save_offset;
8542                         }
8543                         ndr->flags = _flags_save_string;
8544                 }
8545         }
8546         return NDR_ERR_SUCCESS;
8547 }
8548
8549 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
8550 {
8551         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
8552         ndr->depth++;
8553         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8554         ndr->depth++;
8555         if (r->driver_name) {
8556                 ndr_print_string(ndr, "driver_name", r->driver_name);
8557         }
8558         ndr->depth--;
8559         ndr->depth--;
8560 }
8561
8562 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
8563 {
8564         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
8565 }
8566
8567 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
8568 {
8569         if (ndr_flags & NDR_SCALARS) {
8570                 NDR_CHECK(ndr_push_align(ndr, 4));
8571                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8572                 {
8573                         uint32_t _flags_save_string = ndr->flags;
8574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8575                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8576                         ndr->flags = _flags_save_string;
8577                 }
8578                 {
8579                         uint32_t _flags_save_string = ndr->flags;
8580                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8581                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8582                         ndr->flags = _flags_save_string;
8583                 }
8584                 {
8585                         uint32_t _flags_save_string = ndr->flags;
8586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8594                         ndr->flags = _flags_save_string;
8595                 }
8596                 {
8597                         uint32_t _flags_save_string = ndr->flags;
8598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8600                         ndr->flags = _flags_save_string;
8601                 }
8602         }
8603         if (ndr_flags & NDR_BUFFERS) {
8604                 {
8605                         uint32_t _flags_save_string = ndr->flags;
8606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8607                         if (r->driver_name) {
8608                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8610                         }
8611                         ndr->flags = _flags_save_string;
8612                 }
8613                 {
8614                         uint32_t _flags_save_string = ndr->flags;
8615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8616                         if (r->architecture) {
8617                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8618                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8619                         }
8620                         ndr->flags = _flags_save_string;
8621                 }
8622                 {
8623                         uint32_t _flags_save_string = ndr->flags;
8624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8625                         if (r->driver_path) {
8626                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8627                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8628                         }
8629                         ndr->flags = _flags_save_string;
8630                 }
8631                 {
8632                         uint32_t _flags_save_string = ndr->flags;
8633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8634                         if (r->data_file) {
8635                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8637                         }
8638                         ndr->flags = _flags_save_string;
8639                 }
8640                 {
8641                         uint32_t _flags_save_string = ndr->flags;
8642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8643                         if (r->config_file) {
8644                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8645                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8646                         }
8647                         ndr->flags = _flags_save_string;
8648                 }
8649         }
8650         return NDR_ERR_SUCCESS;
8651 }
8652
8653 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
8654 {
8655         uint32_t _ptr_driver_name;
8656         TALLOC_CTX *_mem_save_driver_name_0;
8657         uint32_t _ptr_architecture;
8658         TALLOC_CTX *_mem_save_architecture_0;
8659         uint32_t _ptr_driver_path;
8660         TALLOC_CTX *_mem_save_driver_path_0;
8661         uint32_t _ptr_data_file;
8662         TALLOC_CTX *_mem_save_data_file_0;
8663         uint32_t _ptr_config_file;
8664         TALLOC_CTX *_mem_save_config_file_0;
8665         if (ndr_flags & NDR_SCALARS) {
8666                 NDR_CHECK(ndr_pull_align(ndr, 4));
8667                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8668                 {
8669                         uint32_t _flags_save_string = ndr->flags;
8670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8671                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8672                         if (_ptr_driver_name) {
8673                                 NDR_PULL_ALLOC(ndr, r->driver_name);
8674                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
8675                         } else {
8676                                 r->driver_name = NULL;
8677                         }
8678                         ndr->flags = _flags_save_string;
8679                 }
8680                 {
8681                         uint32_t _flags_save_string = ndr->flags;
8682                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8683                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8684                         if (_ptr_architecture) {
8685                                 NDR_PULL_ALLOC(ndr, r->architecture);
8686                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
8687                         } else {
8688                                 r->architecture = NULL;
8689                         }
8690                         ndr->flags = _flags_save_string;
8691                 }
8692                 {
8693                         uint32_t _flags_save_string = ndr->flags;
8694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8695                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8696                         if (_ptr_driver_path) {
8697                                 NDR_PULL_ALLOC(ndr, r->driver_path);
8698                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
8699                         } else {
8700                                 r->driver_path = NULL;
8701                         }
8702                         ndr->flags = _flags_save_string;
8703                 }
8704                 {
8705                         uint32_t _flags_save_string = ndr->flags;
8706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8708                         if (_ptr_data_file) {
8709                                 NDR_PULL_ALLOC(ndr, r->data_file);
8710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
8711                         } else {
8712                                 r->data_file = NULL;
8713                         }
8714                         ndr->flags = _flags_save_string;
8715                 }
8716                 {
8717                         uint32_t _flags_save_string = ndr->flags;
8718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8720                         if (_ptr_config_file) {
8721                                 NDR_PULL_ALLOC(ndr, r->config_file);
8722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
8723                         } else {
8724                                 r->config_file = NULL;
8725                         }
8726                         ndr->flags = _flags_save_string;
8727                 }
8728         }
8729         if (ndr_flags & NDR_BUFFERS) {
8730                 {
8731                         uint32_t _flags_save_string = ndr->flags;
8732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8733                         if (r->driver_name) {
8734                                 uint32_t _relative_save_offset;
8735                                 _relative_save_offset = ndr->offset;
8736                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
8737                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8738                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8739                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
8740                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8741                                 ndr->offset = _relative_save_offset;
8742                         }
8743                         ndr->flags = _flags_save_string;
8744                 }
8745                 {
8746                         uint32_t _flags_save_string = ndr->flags;
8747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8748                         if (r->architecture) {
8749                                 uint32_t _relative_save_offset;
8750                                 _relative_save_offset = ndr->offset;
8751                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
8752                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8753                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8754                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
8755                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8756                                 ndr->offset = _relative_save_offset;
8757                         }
8758                         ndr->flags = _flags_save_string;
8759                 }
8760                 {
8761                         uint32_t _flags_save_string = ndr->flags;
8762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8763                         if (r->driver_path) {
8764                                 uint32_t _relative_save_offset;
8765                                 _relative_save_offset = ndr->offset;
8766                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
8767                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8768                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8769                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
8770                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8771                                 ndr->offset = _relative_save_offset;
8772                         }
8773                         ndr->flags = _flags_save_string;
8774                 }
8775                 {
8776                         uint32_t _flags_save_string = ndr->flags;
8777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8778                         if (r->data_file) {
8779                                 uint32_t _relative_save_offset;
8780                                 _relative_save_offset = ndr->offset;
8781                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
8782                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8783                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8784                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
8785                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8786                                 ndr->offset = _relative_save_offset;
8787                         }
8788                         ndr->flags = _flags_save_string;
8789                 }
8790                 {
8791                         uint32_t _flags_save_string = ndr->flags;
8792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8793                         if (r->config_file) {
8794                                 uint32_t _relative_save_offset;
8795                                 _relative_save_offset = ndr->offset;
8796                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
8797                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8798                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8799                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
8800                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8801                                 ndr->offset = _relative_save_offset;
8802                         }
8803                         ndr->flags = _flags_save_string;
8804                 }
8805         }
8806         return NDR_ERR_SUCCESS;
8807 }
8808
8809 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
8810 {
8811         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
8812         ndr->depth++;
8813         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8814         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8815         ndr->depth++;
8816         if (r->driver_name) {
8817                 ndr_print_string(ndr, "driver_name", r->driver_name);
8818         }
8819         ndr->depth--;
8820         ndr_print_ptr(ndr, "architecture", r->architecture);
8821         ndr->depth++;
8822         if (r->architecture) {
8823                 ndr_print_string(ndr, "architecture", r->architecture);
8824         }
8825         ndr->depth--;
8826         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8827         ndr->depth++;
8828         if (r->driver_path) {
8829                 ndr_print_string(ndr, "driver_path", r->driver_path);
8830         }
8831         ndr->depth--;
8832         ndr_print_ptr(ndr, "data_file", r->data_file);
8833         ndr->depth++;
8834         if (r->data_file) {
8835                 ndr_print_string(ndr, "data_file", r->data_file);
8836         }
8837         ndr->depth--;
8838         ndr_print_ptr(ndr, "config_file", r->config_file);
8839         ndr->depth++;
8840         if (r->config_file) {
8841                 ndr_print_string(ndr, "config_file", r->config_file);
8842         }
8843         ndr->depth--;
8844         ndr->depth--;
8845 }
8846
8847 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
8848 {
8849         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
8850 }
8851
8852 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
8853 {
8854         if (ndr_flags & NDR_SCALARS) {
8855                 NDR_CHECK(ndr_push_align(ndr, 4));
8856                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8857                 {
8858                         uint32_t _flags_save_string = ndr->flags;
8859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8860                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
8861                         ndr->flags = _flags_save_string;
8862                 }
8863                 {
8864                         uint32_t _flags_save_string = ndr->flags;
8865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8866                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
8867                         ndr->flags = _flags_save_string;
8868                 }
8869                 {
8870                         uint32_t _flags_save_string = ndr->flags;
8871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8872                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
8873                         ndr->flags = _flags_save_string;
8874                 }
8875                 {
8876                         uint32_t _flags_save_string = ndr->flags;
8877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8878                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
8879                         ndr->flags = _flags_save_string;
8880                 }
8881                 {
8882                         uint32_t _flags_save_string = ndr->flags;
8883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8884                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
8885                         ndr->flags = _flags_save_string;
8886                 }
8887                 {
8888                         uint32_t _flags_save_string = ndr->flags;
8889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8890                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
8891                         ndr->flags = _flags_save_string;
8892                 }
8893                 {
8894                         uint32_t _flags_save_string_array = ndr->flags;
8895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8896                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
8897                         ndr->flags = _flags_save_string_array;
8898                 }
8899                 {
8900                         uint32_t _flags_save_string = ndr->flags;
8901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8902                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
8903                         ndr->flags = _flags_save_string;
8904                 }
8905                 {
8906                         uint32_t _flags_save_string = ndr->flags;
8907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
8909                         ndr->flags = _flags_save_string;
8910                 }
8911         }
8912         if (ndr_flags & NDR_BUFFERS) {
8913                 {
8914                         uint32_t _flags_save_string = ndr->flags;
8915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8916                         if (r->driver_name) {
8917                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
8918                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
8919                         }
8920                         ndr->flags = _flags_save_string;
8921                 }
8922                 {
8923                         uint32_t _flags_save_string = ndr->flags;
8924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8925                         if (r->architecture) {
8926                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
8927                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
8928                         }
8929                         ndr->flags = _flags_save_string;
8930                 }
8931                 {
8932                         uint32_t _flags_save_string = ndr->flags;
8933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8934                         if (r->driver_path) {
8935                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
8936                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
8937                         }
8938                         ndr->flags = _flags_save_string;
8939                 }
8940                 {
8941                         uint32_t _flags_save_string = ndr->flags;
8942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8943                         if (r->data_file) {
8944                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
8945                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
8946                         }
8947                         ndr->flags = _flags_save_string;
8948                 }
8949                 {
8950                         uint32_t _flags_save_string = ndr->flags;
8951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8952                         if (r->config_file) {
8953                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
8954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
8955                         }
8956                         ndr->flags = _flags_save_string;
8957                 }
8958                 {
8959                         uint32_t _flags_save_string = ndr->flags;
8960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8961                         if (r->help_file) {
8962                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
8963                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
8964                         }
8965                         ndr->flags = _flags_save_string;
8966                 }
8967                 {
8968                         uint32_t _flags_save_string_array = ndr->flags;
8969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8970                         if (r->dependent_files) {
8971                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
8972                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
8973                         }
8974                         ndr->flags = _flags_save_string_array;
8975                 }
8976                 {
8977                         uint32_t _flags_save_string = ndr->flags;
8978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8979                         if (r->monitor_name) {
8980                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
8981                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
8982                         }
8983                         ndr->flags = _flags_save_string;
8984                 }
8985                 {
8986                         uint32_t _flags_save_string = ndr->flags;
8987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
8988                         if (r->default_datatype) {
8989                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
8990                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
8991                         }
8992                         ndr->flags = _flags_save_string;
8993                 }
8994         }
8995         return NDR_ERR_SUCCESS;
8996 }
8997
8998 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
8999 {
9000         uint32_t _ptr_driver_name;
9001         TALLOC_CTX *_mem_save_driver_name_0;
9002         uint32_t _ptr_architecture;
9003         TALLOC_CTX *_mem_save_architecture_0;
9004         uint32_t _ptr_driver_path;
9005         TALLOC_CTX *_mem_save_driver_path_0;
9006         uint32_t _ptr_data_file;
9007         TALLOC_CTX *_mem_save_data_file_0;
9008         uint32_t _ptr_config_file;
9009         TALLOC_CTX *_mem_save_config_file_0;
9010         uint32_t _ptr_help_file;
9011         TALLOC_CTX *_mem_save_help_file_0;
9012         uint32_t _ptr_dependent_files;
9013         TALLOC_CTX *_mem_save_dependent_files_0;
9014         uint32_t _ptr_monitor_name;
9015         TALLOC_CTX *_mem_save_monitor_name_0;
9016         uint32_t _ptr_default_datatype;
9017         TALLOC_CTX *_mem_save_default_datatype_0;
9018         if (ndr_flags & NDR_SCALARS) {
9019                 NDR_CHECK(ndr_pull_align(ndr, 4));
9020                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9021                 {
9022                         uint32_t _flags_save_string = ndr->flags;
9023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9025                         if (_ptr_driver_name) {
9026                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9028                         } else {
9029                                 r->driver_name = NULL;
9030                         }
9031                         ndr->flags = _flags_save_string;
9032                 }
9033                 {
9034                         uint32_t _flags_save_string = ndr->flags;
9035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9036                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9037                         if (_ptr_architecture) {
9038                                 NDR_PULL_ALLOC(ndr, r->architecture);
9039                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9040                         } else {
9041                                 r->architecture = NULL;
9042                         }
9043                         ndr->flags = _flags_save_string;
9044                 }
9045                 {
9046                         uint32_t _flags_save_string = ndr->flags;
9047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9048                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9049                         if (_ptr_driver_path) {
9050                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9051                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9052                         } else {
9053                                 r->driver_path = NULL;
9054                         }
9055                         ndr->flags = _flags_save_string;
9056                 }
9057                 {
9058                         uint32_t _flags_save_string = ndr->flags;
9059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9060                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9061                         if (_ptr_data_file) {
9062                                 NDR_PULL_ALLOC(ndr, r->data_file);
9063                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9064                         } else {
9065                                 r->data_file = NULL;
9066                         }
9067                         ndr->flags = _flags_save_string;
9068                 }
9069                 {
9070                         uint32_t _flags_save_string = ndr->flags;
9071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9072                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9073                         if (_ptr_config_file) {
9074                                 NDR_PULL_ALLOC(ndr, r->config_file);
9075                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9076                         } else {
9077                                 r->config_file = NULL;
9078                         }
9079                         ndr->flags = _flags_save_string;
9080                 }
9081                 {
9082                         uint32_t _flags_save_string = ndr->flags;
9083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9084                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9085                         if (_ptr_help_file) {
9086                                 NDR_PULL_ALLOC(ndr, r->help_file);
9087                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9088                         } else {
9089                                 r->help_file = NULL;
9090                         }
9091                         ndr->flags = _flags_save_string;
9092                 }
9093                 {
9094                         uint32_t _flags_save_string_array = ndr->flags;
9095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9096                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9097                         if (_ptr_dependent_files) {
9098                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9099                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9100                         } else {
9101                                 r->dependent_files = NULL;
9102                         }
9103                         ndr->flags = _flags_save_string_array;
9104                 }
9105                 {
9106                         uint32_t _flags_save_string = ndr->flags;
9107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9108                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9109                         if (_ptr_monitor_name) {
9110                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9111                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9112                         } else {
9113                                 r->monitor_name = NULL;
9114                         }
9115                         ndr->flags = _flags_save_string;
9116                 }
9117                 {
9118                         uint32_t _flags_save_string = ndr->flags;
9119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9120                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9121                         if (_ptr_default_datatype) {
9122                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9123                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9124                         } else {
9125                                 r->default_datatype = NULL;
9126                         }
9127                         ndr->flags = _flags_save_string;
9128                 }
9129         }
9130         if (ndr_flags & NDR_BUFFERS) {
9131                 {
9132                         uint32_t _flags_save_string = ndr->flags;
9133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9134                         if (r->driver_name) {
9135                                 uint32_t _relative_save_offset;
9136                                 _relative_save_offset = ndr->offset;
9137                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9138                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9139                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9140                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9141                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9142                                 ndr->offset = _relative_save_offset;
9143                         }
9144                         ndr->flags = _flags_save_string;
9145                 }
9146                 {
9147                         uint32_t _flags_save_string = ndr->flags;
9148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9149                         if (r->architecture) {
9150                                 uint32_t _relative_save_offset;
9151                                 _relative_save_offset = ndr->offset;
9152                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9153                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9154                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9155                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9156                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9157                                 ndr->offset = _relative_save_offset;
9158                         }
9159                         ndr->flags = _flags_save_string;
9160                 }
9161                 {
9162                         uint32_t _flags_save_string = ndr->flags;
9163                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9164                         if (r->driver_path) {
9165                                 uint32_t _relative_save_offset;
9166                                 _relative_save_offset = ndr->offset;
9167                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9168                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9169                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9170                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9171                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9172                                 ndr->offset = _relative_save_offset;
9173                         }
9174                         ndr->flags = _flags_save_string;
9175                 }
9176                 {
9177                         uint32_t _flags_save_string = ndr->flags;
9178                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9179                         if (r->data_file) {
9180                                 uint32_t _relative_save_offset;
9181                                 _relative_save_offset = ndr->offset;
9182                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9183                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9184                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9185                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9186                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9187                                 ndr->offset = _relative_save_offset;
9188                         }
9189                         ndr->flags = _flags_save_string;
9190                 }
9191                 {
9192                         uint32_t _flags_save_string = ndr->flags;
9193                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9194                         if (r->config_file) {
9195                                 uint32_t _relative_save_offset;
9196                                 _relative_save_offset = ndr->offset;
9197                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9198                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9199                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9200                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9201                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9202                                 ndr->offset = _relative_save_offset;
9203                         }
9204                         ndr->flags = _flags_save_string;
9205                 }
9206                 {
9207                         uint32_t _flags_save_string = ndr->flags;
9208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9209                         if (r->help_file) {
9210                                 uint32_t _relative_save_offset;
9211                                 _relative_save_offset = ndr->offset;
9212                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9213                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9214                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9215                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9216                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9217                                 ndr->offset = _relative_save_offset;
9218                         }
9219                         ndr->flags = _flags_save_string;
9220                 }
9221                 {
9222                         uint32_t _flags_save_string_array = ndr->flags;
9223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9224                         if (r->dependent_files) {
9225                                 uint32_t _relative_save_offset;
9226                                 _relative_save_offset = ndr->offset;
9227                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9228                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9229                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9230                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9231                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9232                                 ndr->offset = _relative_save_offset;
9233                         }
9234                         ndr->flags = _flags_save_string_array;
9235                 }
9236                 {
9237                         uint32_t _flags_save_string = ndr->flags;
9238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9239                         if (r->monitor_name) {
9240                                 uint32_t _relative_save_offset;
9241                                 _relative_save_offset = ndr->offset;
9242                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9243                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9245                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9246                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9247                                 ndr->offset = _relative_save_offset;
9248                         }
9249                         ndr->flags = _flags_save_string;
9250                 }
9251                 {
9252                         uint32_t _flags_save_string = ndr->flags;
9253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9254                         if (r->default_datatype) {
9255                                 uint32_t _relative_save_offset;
9256                                 _relative_save_offset = ndr->offset;
9257                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9258                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9259                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9260                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9261                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9262                                 ndr->offset = _relative_save_offset;
9263                         }
9264                         ndr->flags = _flags_save_string;
9265                 }
9266         }
9267         return NDR_ERR_SUCCESS;
9268 }
9269
9270 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
9271 {
9272         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
9273         ndr->depth++;
9274         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9275         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9276         ndr->depth++;
9277         if (r->driver_name) {
9278                 ndr_print_string(ndr, "driver_name", r->driver_name);
9279         }
9280         ndr->depth--;
9281         ndr_print_ptr(ndr, "architecture", r->architecture);
9282         ndr->depth++;
9283         if (r->architecture) {
9284                 ndr_print_string(ndr, "architecture", r->architecture);
9285         }
9286         ndr->depth--;
9287         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9288         ndr->depth++;
9289         if (r->driver_path) {
9290                 ndr_print_string(ndr, "driver_path", r->driver_path);
9291         }
9292         ndr->depth--;
9293         ndr_print_ptr(ndr, "data_file", r->data_file);
9294         ndr->depth++;
9295         if (r->data_file) {
9296                 ndr_print_string(ndr, "data_file", r->data_file);
9297         }
9298         ndr->depth--;
9299         ndr_print_ptr(ndr, "config_file", r->config_file);
9300         ndr->depth++;
9301         if (r->config_file) {
9302                 ndr_print_string(ndr, "config_file", r->config_file);
9303         }
9304         ndr->depth--;
9305         ndr_print_ptr(ndr, "help_file", r->help_file);
9306         ndr->depth++;
9307         if (r->help_file) {
9308                 ndr_print_string(ndr, "help_file", r->help_file);
9309         }
9310         ndr->depth--;
9311         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9312         ndr->depth++;
9313         if (r->dependent_files) {
9314                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9315         }
9316         ndr->depth--;
9317         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9318         ndr->depth++;
9319         if (r->monitor_name) {
9320                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9321         }
9322         ndr->depth--;
9323         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9324         ndr->depth++;
9325         if (r->default_datatype) {
9326                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9327         }
9328         ndr->depth--;
9329         ndr->depth--;
9330 }
9331
9332 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
9333 {
9334         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
9335 }
9336
9337 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
9338 {
9339         if (ndr_flags & NDR_SCALARS) {
9340                 NDR_CHECK(ndr_push_align(ndr, 4));
9341                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9342                 {
9343                         uint32_t _flags_save_string = ndr->flags;
9344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9345                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9346                         ndr->flags = _flags_save_string;
9347                 }
9348                 {
9349                         uint32_t _flags_save_string = ndr->flags;
9350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9351                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9352                         ndr->flags = _flags_save_string;
9353                 }
9354                 {
9355                         uint32_t _flags_save_string = ndr->flags;
9356                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9357                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9364                         ndr->flags = _flags_save_string;
9365                 }
9366                 {
9367                         uint32_t _flags_save_string = ndr->flags;
9368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9369                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9370                         ndr->flags = _flags_save_string;
9371                 }
9372                 {
9373                         uint32_t _flags_save_string = ndr->flags;
9374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9375                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
9376                         ndr->flags = _flags_save_string;
9377                 }
9378                 {
9379                         uint32_t _flags_save_string_array = ndr->flags;
9380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9381                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
9382                         ndr->flags = _flags_save_string_array;
9383                 }
9384                 {
9385                         uint32_t _flags_save_string = ndr->flags;
9386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9387                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
9388                         ndr->flags = _flags_save_string;
9389                 }
9390                 {
9391                         uint32_t _flags_save_string = ndr->flags;
9392                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9393                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
9394                         ndr->flags = _flags_save_string;
9395                 }
9396                 {
9397                         uint32_t _flags_save_string_array = ndr->flags;
9398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9399                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
9400                         ndr->flags = _flags_save_string_array;
9401                 }
9402         }
9403         if (ndr_flags & NDR_BUFFERS) {
9404                 {
9405                         uint32_t _flags_save_string = ndr->flags;
9406                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9407                         if (r->driver_name) {
9408                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9409                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9410                         }
9411                         ndr->flags = _flags_save_string;
9412                 }
9413                 {
9414                         uint32_t _flags_save_string = ndr->flags;
9415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9416                         if (r->architecture) {
9417                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9418                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9419                         }
9420                         ndr->flags = _flags_save_string;
9421                 }
9422                 {
9423                         uint32_t _flags_save_string = ndr->flags;
9424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9425                         if (r->driver_path) {
9426                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9427                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9428                         }
9429                         ndr->flags = _flags_save_string;
9430                 }
9431                 {
9432                         uint32_t _flags_save_string = ndr->flags;
9433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9434                         if (r->data_file) {
9435                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9436                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9437                         }
9438                         ndr->flags = _flags_save_string;
9439                 }
9440                 {
9441                         uint32_t _flags_save_string = ndr->flags;
9442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9443                         if (r->config_file) {
9444                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9445                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9446                         }
9447                         ndr->flags = _flags_save_string;
9448                 }
9449                 {
9450                         uint32_t _flags_save_string = ndr->flags;
9451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9452                         if (r->help_file) {
9453                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
9454                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
9455                         }
9456                         ndr->flags = _flags_save_string;
9457                 }
9458                 {
9459                         uint32_t _flags_save_string_array = ndr->flags;
9460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9461                         if (r->dependent_files) {
9462                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
9463                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
9464                         }
9465                         ndr->flags = _flags_save_string_array;
9466                 }
9467                 {
9468                         uint32_t _flags_save_string = ndr->flags;
9469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9470                         if (r->monitor_name) {
9471                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
9472                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
9473                         }
9474                         ndr->flags = _flags_save_string;
9475                 }
9476                 {
9477                         uint32_t _flags_save_string = ndr->flags;
9478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9479                         if (r->default_datatype) {
9480                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
9481                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
9482                         }
9483                         ndr->flags = _flags_save_string;
9484                 }
9485                 {
9486                         uint32_t _flags_save_string_array = ndr->flags;
9487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9488                         if (r->previous_names) {
9489                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
9490                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
9491                         }
9492                         ndr->flags = _flags_save_string_array;
9493                 }
9494         }
9495         return NDR_ERR_SUCCESS;
9496 }
9497
9498 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
9499 {
9500         uint32_t _ptr_driver_name;
9501         TALLOC_CTX *_mem_save_driver_name_0;
9502         uint32_t _ptr_architecture;
9503         TALLOC_CTX *_mem_save_architecture_0;
9504         uint32_t _ptr_driver_path;
9505         TALLOC_CTX *_mem_save_driver_path_0;
9506         uint32_t _ptr_data_file;
9507         TALLOC_CTX *_mem_save_data_file_0;
9508         uint32_t _ptr_config_file;
9509         TALLOC_CTX *_mem_save_config_file_0;
9510         uint32_t _ptr_help_file;
9511         TALLOC_CTX *_mem_save_help_file_0;
9512         uint32_t _ptr_dependent_files;
9513         TALLOC_CTX *_mem_save_dependent_files_0;
9514         uint32_t _ptr_monitor_name;
9515         TALLOC_CTX *_mem_save_monitor_name_0;
9516         uint32_t _ptr_default_datatype;
9517         TALLOC_CTX *_mem_save_default_datatype_0;
9518         uint32_t _ptr_previous_names;
9519         TALLOC_CTX *_mem_save_previous_names_0;
9520         if (ndr_flags & NDR_SCALARS) {
9521                 NDR_CHECK(ndr_pull_align(ndr, 4));
9522                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9523                 {
9524                         uint32_t _flags_save_string = ndr->flags;
9525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9526                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9527                         if (_ptr_driver_name) {
9528                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9529                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9530                         } else {
9531                                 r->driver_name = NULL;
9532                         }
9533                         ndr->flags = _flags_save_string;
9534                 }
9535                 {
9536                         uint32_t _flags_save_string = ndr->flags;
9537                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9538                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9539                         if (_ptr_architecture) {
9540                                 NDR_PULL_ALLOC(ndr, r->architecture);
9541                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9542                         } else {
9543                                 r->architecture = NULL;
9544                         }
9545                         ndr->flags = _flags_save_string;
9546                 }
9547                 {
9548                         uint32_t _flags_save_string = ndr->flags;
9549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9550                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9551                         if (_ptr_driver_path) {
9552                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9553                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9554                         } else {
9555                                 r->driver_path = NULL;
9556                         }
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_pull_generic_ptr(ndr, &_ptr_data_file));
9563                         if (_ptr_data_file) {
9564                                 NDR_PULL_ALLOC(ndr, r->data_file);
9565                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9566                         } else {
9567                                 r->data_file = NULL;
9568                         }
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_pull_generic_ptr(ndr, &_ptr_config_file));
9575                         if (_ptr_config_file) {
9576                                 NDR_PULL_ALLOC(ndr, r->config_file);
9577                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
9578                         } else {
9579                                 r->config_file = NULL;
9580                         }
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_pull_generic_ptr(ndr, &_ptr_help_file));
9587                         if (_ptr_help_file) {
9588                                 NDR_PULL_ALLOC(ndr, r->help_file);
9589                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
9590                         } else {
9591                                 r->help_file = NULL;
9592                         }
9593                         ndr->flags = _flags_save_string;
9594                 }
9595                 {
9596                         uint32_t _flags_save_string_array = ndr->flags;
9597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9598                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9599                         if (_ptr_dependent_files) {
9600                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
9601                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
9602                         } else {
9603                                 r->dependent_files = NULL;
9604                         }
9605                         ndr->flags = _flags_save_string_array;
9606                 }
9607                 {
9608                         uint32_t _flags_save_string = ndr->flags;
9609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9610                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9611                         if (_ptr_monitor_name) {
9612                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
9613                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
9614                         } else {
9615                                 r->monitor_name = NULL;
9616                         }
9617                         ndr->flags = _flags_save_string;
9618                 }
9619                 {
9620                         uint32_t _flags_save_string = ndr->flags;
9621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9622                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9623                         if (_ptr_default_datatype) {
9624                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
9625                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
9626                         } else {
9627                                 r->default_datatype = NULL;
9628                         }
9629                         ndr->flags = _flags_save_string;
9630                 }
9631                 {
9632                         uint32_t _flags_save_string_array = ndr->flags;
9633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9634                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9635                         if (_ptr_previous_names) {
9636                                 NDR_PULL_ALLOC(ndr, r->previous_names);
9637                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
9638                         } else {
9639                                 r->previous_names = NULL;
9640                         }
9641                         ndr->flags = _flags_save_string_array;
9642                 }
9643         }
9644         if (ndr_flags & NDR_BUFFERS) {
9645                 {
9646                         uint32_t _flags_save_string = ndr->flags;
9647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9648                         if (r->driver_name) {
9649                                 uint32_t _relative_save_offset;
9650                                 _relative_save_offset = ndr->offset;
9651                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9652                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9653                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9654                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9655                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9656                                 ndr->offset = _relative_save_offset;
9657                         }
9658                         ndr->flags = _flags_save_string;
9659                 }
9660                 {
9661                         uint32_t _flags_save_string = ndr->flags;
9662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9663                         if (r->architecture) {
9664                                 uint32_t _relative_save_offset;
9665                                 _relative_save_offset = ndr->offset;
9666                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
9667                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9668                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9669                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
9670                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9671                                 ndr->offset = _relative_save_offset;
9672                         }
9673                         ndr->flags = _flags_save_string;
9674                 }
9675                 {
9676                         uint32_t _flags_save_string = ndr->flags;
9677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9678                         if (r->driver_path) {
9679                                 uint32_t _relative_save_offset;
9680                                 _relative_save_offset = ndr->offset;
9681                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
9682                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9683                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9684                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
9685                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9686                                 ndr->offset = _relative_save_offset;
9687                         }
9688                         ndr->flags = _flags_save_string;
9689                 }
9690                 {
9691                         uint32_t _flags_save_string = ndr->flags;
9692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9693                         if (r->data_file) {
9694                                 uint32_t _relative_save_offset;
9695                                 _relative_save_offset = ndr->offset;
9696                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
9697                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9698                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9699                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
9700                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9701                                 ndr->offset = _relative_save_offset;
9702                         }
9703                         ndr->flags = _flags_save_string;
9704                 }
9705                 {
9706                         uint32_t _flags_save_string = ndr->flags;
9707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9708                         if (r->config_file) {
9709                                 uint32_t _relative_save_offset;
9710                                 _relative_save_offset = ndr->offset;
9711                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
9712                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9713                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9714                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
9715                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9716                                 ndr->offset = _relative_save_offset;
9717                         }
9718                         ndr->flags = _flags_save_string;
9719                 }
9720                 {
9721                         uint32_t _flags_save_string = ndr->flags;
9722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9723                         if (r->help_file) {
9724                                 uint32_t _relative_save_offset;
9725                                 _relative_save_offset = ndr->offset;
9726                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
9727                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9728                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9729                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
9730                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9731                                 ndr->offset = _relative_save_offset;
9732                         }
9733                         ndr->flags = _flags_save_string;
9734                 }
9735                 {
9736                         uint32_t _flags_save_string_array = ndr->flags;
9737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9738                         if (r->dependent_files) {
9739                                 uint32_t _relative_save_offset;
9740                                 _relative_save_offset = ndr->offset;
9741                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
9742                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9743                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9744                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
9745                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9746                                 ndr->offset = _relative_save_offset;
9747                         }
9748                         ndr->flags = _flags_save_string_array;
9749                 }
9750                 {
9751                         uint32_t _flags_save_string = ndr->flags;
9752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9753                         if (r->monitor_name) {
9754                                 uint32_t _relative_save_offset;
9755                                 _relative_save_offset = ndr->offset;
9756                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
9757                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9758                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9759                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
9760                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9761                                 ndr->offset = _relative_save_offset;
9762                         }
9763                         ndr->flags = _flags_save_string;
9764                 }
9765                 {
9766                         uint32_t _flags_save_string = ndr->flags;
9767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9768                         if (r->default_datatype) {
9769                                 uint32_t _relative_save_offset;
9770                                 _relative_save_offset = ndr->offset;
9771                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
9772                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9773                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9774                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
9775                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9776                                 ndr->offset = _relative_save_offset;
9777                         }
9778                         ndr->flags = _flags_save_string;
9779                 }
9780                 {
9781                         uint32_t _flags_save_string_array = ndr->flags;
9782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9783                         if (r->previous_names) {
9784                                 uint32_t _relative_save_offset;
9785                                 _relative_save_offset = ndr->offset;
9786                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
9787                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9788                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9789                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
9790                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9791                                 ndr->offset = _relative_save_offset;
9792                         }
9793                         ndr->flags = _flags_save_string_array;
9794                 }
9795         }
9796         return NDR_ERR_SUCCESS;
9797 }
9798
9799 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
9800 {
9801         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
9802         ndr->depth++;
9803         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9804         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9805         ndr->depth++;
9806         if (r->driver_name) {
9807                 ndr_print_string(ndr, "driver_name", r->driver_name);
9808         }
9809         ndr->depth--;
9810         ndr_print_ptr(ndr, "architecture", r->architecture);
9811         ndr->depth++;
9812         if (r->architecture) {
9813                 ndr_print_string(ndr, "architecture", r->architecture);
9814         }
9815         ndr->depth--;
9816         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9817         ndr->depth++;
9818         if (r->driver_path) {
9819                 ndr_print_string(ndr, "driver_path", r->driver_path);
9820         }
9821         ndr->depth--;
9822         ndr_print_ptr(ndr, "data_file", r->data_file);
9823         ndr->depth++;
9824         if (r->data_file) {
9825                 ndr_print_string(ndr, "data_file", r->data_file);
9826         }
9827         ndr->depth--;
9828         ndr_print_ptr(ndr, "config_file", r->config_file);
9829         ndr->depth++;
9830         if (r->config_file) {
9831                 ndr_print_string(ndr, "config_file", r->config_file);
9832         }
9833         ndr->depth--;
9834         ndr_print_ptr(ndr, "help_file", r->help_file);
9835         ndr->depth++;
9836         if (r->help_file) {
9837                 ndr_print_string(ndr, "help_file", r->help_file);
9838         }
9839         ndr->depth--;
9840         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9841         ndr->depth++;
9842         if (r->dependent_files) {
9843                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
9844         }
9845         ndr->depth--;
9846         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9847         ndr->depth++;
9848         if (r->monitor_name) {
9849                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9850         }
9851         ndr->depth--;
9852         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9853         ndr->depth++;
9854         if (r->default_datatype) {
9855                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9856         }
9857         ndr->depth--;
9858         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9859         ndr->depth++;
9860         if (r->previous_names) {
9861                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
9862         }
9863         ndr->depth--;
9864         ndr->depth--;
9865 }
9866
9867 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
9868 {
9869         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
9870 }
9871
9872 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
9873 {
9874         if (ndr_flags & NDR_SCALARS) {
9875                 NDR_CHECK(ndr_push_align(ndr, 4));
9876                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9877                 {
9878                         uint32_t _flags_save_string = ndr->flags;
9879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9880                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9881                         ndr->flags = _flags_save_string;
9882                 }
9883                 {
9884                         uint32_t _flags_save_string = ndr->flags;
9885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9886                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9887                         ndr->flags = _flags_save_string;
9888                 }
9889                 {
9890                         uint32_t _flags_save_string = ndr->flags;
9891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9892                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9893                         ndr->flags = _flags_save_string;
9894                 }
9895                 {
9896                         uint32_t _flags_save_string = ndr->flags;
9897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9898                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9899                         ndr->flags = _flags_save_string;
9900                 }
9901                 {
9902                         uint32_t _flags_save_string = ndr->flags;
9903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9904                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9905                         ndr->flags = _flags_save_string;
9906                 }
9907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
9908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
9909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
9910         }
9911         if (ndr_flags & NDR_BUFFERS) {
9912                 {
9913                         uint32_t _flags_save_string = ndr->flags;
9914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9915                         if (r->driver_name) {
9916                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9917                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9918                         }
9919                         ndr->flags = _flags_save_string;
9920                 }
9921                 {
9922                         uint32_t _flags_save_string = ndr->flags;
9923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9924                         if (r->architecture) {
9925                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9926                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9927                         }
9928                         ndr->flags = _flags_save_string;
9929                 }
9930                 {
9931                         uint32_t _flags_save_string = ndr->flags;
9932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9933                         if (r->driver_path) {
9934                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9935                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9936                         }
9937                         ndr->flags = _flags_save_string;
9938                 }
9939                 {
9940                         uint32_t _flags_save_string = ndr->flags;
9941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9942                         if (r->data_file) {
9943                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9944                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9945                         }
9946                         ndr->flags = _flags_save_string;
9947                 }
9948                 {
9949                         uint32_t _flags_save_string = ndr->flags;
9950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9951                         if (r->config_file) {
9952                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9953                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9954                         }
9955                         ndr->flags = _flags_save_string;
9956                 }
9957         }
9958         return NDR_ERR_SUCCESS;
9959 }
9960
9961 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
9962 {
9963         uint32_t _ptr_driver_name;
9964         TALLOC_CTX *_mem_save_driver_name_0;
9965         uint32_t _ptr_architecture;
9966         TALLOC_CTX *_mem_save_architecture_0;
9967         uint32_t _ptr_driver_path;
9968         TALLOC_CTX *_mem_save_driver_path_0;
9969         uint32_t _ptr_data_file;
9970         TALLOC_CTX *_mem_save_data_file_0;
9971         uint32_t _ptr_config_file;
9972         TALLOC_CTX *_mem_save_config_file_0;
9973         if (ndr_flags & NDR_SCALARS) {
9974                 NDR_CHECK(ndr_pull_align(ndr, 4));
9975                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
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_driver_name));
9980                         if (_ptr_driver_name) {
9981                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9982                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9983                         } else {
9984                                 r->driver_name = NULL;
9985                         }
9986                         ndr->flags = _flags_save_string;
9987                 }
9988                 {
9989                         uint32_t _flags_save_string = ndr->flags;
9990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9991                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9992                         if (_ptr_architecture) {
9993                                 NDR_PULL_ALLOC(ndr, r->architecture);
9994                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9995                         } else {
9996                                 r->architecture = NULL;
9997                         }
9998                         ndr->flags = _flags_save_string;
9999                 }
10000                 {
10001                         uint32_t _flags_save_string = ndr->flags;
10002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10003                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10004                         if (_ptr_driver_path) {
10005                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10006                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10007                         } else {
10008                                 r->driver_path = NULL;
10009                         }
10010                         ndr->flags = _flags_save_string;
10011                 }
10012                 {
10013                         uint32_t _flags_save_string = ndr->flags;
10014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10015                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10016                         if (_ptr_data_file) {
10017                                 NDR_PULL_ALLOC(ndr, r->data_file);
10018                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10019                         } else {
10020                                 r->data_file = NULL;
10021                         }
10022                         ndr->flags = _flags_save_string;
10023                 }
10024                 {
10025                         uint32_t _flags_save_string = ndr->flags;
10026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10027                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10028                         if (_ptr_config_file) {
10029                                 NDR_PULL_ALLOC(ndr, r->config_file);
10030                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10031                         } else {
10032                                 r->config_file = NULL;
10033                         }
10034                         ndr->flags = _flags_save_string;
10035                 }
10036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
10037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
10038                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
10039         }
10040         if (ndr_flags & NDR_BUFFERS) {
10041                 {
10042                         uint32_t _flags_save_string = ndr->flags;
10043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10044                         if (r->driver_name) {
10045                                 uint32_t _relative_save_offset;
10046                                 _relative_save_offset = ndr->offset;
10047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10048                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10049                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10052                                 ndr->offset = _relative_save_offset;
10053                         }
10054                         ndr->flags = _flags_save_string;
10055                 }
10056                 {
10057                         uint32_t _flags_save_string = ndr->flags;
10058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10059                         if (r->architecture) {
10060                                 uint32_t _relative_save_offset;
10061                                 _relative_save_offset = ndr->offset;
10062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10063                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10064                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10067                                 ndr->offset = _relative_save_offset;
10068                         }
10069                         ndr->flags = _flags_save_string;
10070                 }
10071                 {
10072                         uint32_t _flags_save_string = ndr->flags;
10073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10074                         if (r->driver_path) {
10075                                 uint32_t _relative_save_offset;
10076                                 _relative_save_offset = ndr->offset;
10077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10078                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10079                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10082                                 ndr->offset = _relative_save_offset;
10083                         }
10084                         ndr->flags = _flags_save_string;
10085                 }
10086                 {
10087                         uint32_t _flags_save_string = ndr->flags;
10088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10089                         if (r->data_file) {
10090                                 uint32_t _relative_save_offset;
10091                                 _relative_save_offset = ndr->offset;
10092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10093                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10094                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10095                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10097                                 ndr->offset = _relative_save_offset;
10098                         }
10099                         ndr->flags = _flags_save_string;
10100                 }
10101                 {
10102                         uint32_t _flags_save_string = ndr->flags;
10103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10104                         if (r->config_file) {
10105                                 uint32_t _relative_save_offset;
10106                                 _relative_save_offset = ndr->offset;
10107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10108                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10109                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10112                                 ndr->offset = _relative_save_offset;
10113                         }
10114                         ndr->flags = _flags_save_string;
10115                 }
10116         }
10117         return NDR_ERR_SUCCESS;
10118 }
10119
10120 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
10121 {
10122         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
10123         ndr->depth++;
10124         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10125         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10126         ndr->depth++;
10127         if (r->driver_name) {
10128                 ndr_print_string(ndr, "driver_name", r->driver_name);
10129         }
10130         ndr->depth--;
10131         ndr_print_ptr(ndr, "architecture", r->architecture);
10132         ndr->depth++;
10133         if (r->architecture) {
10134                 ndr_print_string(ndr, "architecture", r->architecture);
10135         }
10136         ndr->depth--;
10137         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10138         ndr->depth++;
10139         if (r->driver_path) {
10140                 ndr_print_string(ndr, "driver_path", r->driver_path);
10141         }
10142         ndr->depth--;
10143         ndr_print_ptr(ndr, "data_file", r->data_file);
10144         ndr->depth++;
10145         if (r->data_file) {
10146                 ndr_print_string(ndr, "data_file", r->data_file);
10147         }
10148         ndr->depth--;
10149         ndr_print_ptr(ndr, "config_file", r->config_file);
10150         ndr->depth++;
10151         if (r->config_file) {
10152                 ndr_print_string(ndr, "config_file", r->config_file);
10153         }
10154         ndr->depth--;
10155         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
10156         ndr_print_uint32(ndr, "config_version", r->config_version);
10157         ndr_print_uint32(ndr, "driver_version", r->driver_version);
10158         ndr->depth--;
10159 }
10160
10161 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
10162 {
10163         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
10164 }
10165
10166 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
10167 {
10168         if (ndr_flags & NDR_SCALARS) {
10169                 NDR_CHECK(ndr_push_align(ndr, 8));
10170                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10171                 {
10172                         uint32_t _flags_save_string = ndr->flags;
10173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10174                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10175                         ndr->flags = _flags_save_string;
10176                 }
10177                 {
10178                         uint32_t _flags_save_string = ndr->flags;
10179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10180                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10181                         ndr->flags = _flags_save_string;
10182                 }
10183                 {
10184                         uint32_t _flags_save_string = ndr->flags;
10185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10186                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10187                         ndr->flags = _flags_save_string;
10188                 }
10189                 {
10190                         uint32_t _flags_save_string = ndr->flags;
10191                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10192                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10193                         ndr->flags = _flags_save_string;
10194                 }
10195                 {
10196                         uint32_t _flags_save_string = ndr->flags;
10197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10198                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10199                         ndr->flags = _flags_save_string;
10200                 }
10201                 {
10202                         uint32_t _flags_save_string = ndr->flags;
10203                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10204                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10205                         ndr->flags = _flags_save_string;
10206                 }
10207                 {
10208                         uint32_t _flags_save_string_array = ndr->flags;
10209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10210                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10211                         ndr->flags = _flags_save_string_array;
10212                 }
10213                 {
10214                         uint32_t _flags_save_string = ndr->flags;
10215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10216                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10217                         ndr->flags = _flags_save_string;
10218                 }
10219                 {
10220                         uint32_t _flags_save_string = ndr->flags;
10221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10222                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10223                         ndr->flags = _flags_save_string;
10224                 }
10225                 {
10226                         uint32_t _flags_save_string_array = ndr->flags;
10227                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10228                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10229                         ndr->flags = _flags_save_string_array;
10230                 }
10231                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
10232                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
10233                 {
10234                         uint32_t _flags_save_string = ndr->flags;
10235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10236                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
10237                         ndr->flags = _flags_save_string;
10238                 }
10239                 {
10240                         uint32_t _flags_save_string = ndr->flags;
10241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
10243                         ndr->flags = _flags_save_string;
10244                 }
10245                 {
10246                         uint32_t _flags_save_string = ndr->flags;
10247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
10249                         ndr->flags = _flags_save_string;
10250                 }
10251                 {
10252                         uint32_t _flags_save_string = ndr->flags;
10253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
10255                         ndr->flags = _flags_save_string;
10256                 }
10257         }
10258         if (ndr_flags & NDR_BUFFERS) {
10259                 {
10260                         uint32_t _flags_save_string = ndr->flags;
10261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10262                         if (r->driver_name) {
10263                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10264                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10265                         }
10266                         ndr->flags = _flags_save_string;
10267                 }
10268                 {
10269                         uint32_t _flags_save_string = ndr->flags;
10270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10271                         if (r->architecture) {
10272                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10273                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10274                         }
10275                         ndr->flags = _flags_save_string;
10276                 }
10277                 {
10278                         uint32_t _flags_save_string = ndr->flags;
10279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10280                         if (r->driver_path) {
10281                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10282                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10283                         }
10284                         ndr->flags = _flags_save_string;
10285                 }
10286                 {
10287                         uint32_t _flags_save_string = ndr->flags;
10288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10289                         if (r->data_file) {
10290                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10291                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10292                         }
10293                         ndr->flags = _flags_save_string;
10294                 }
10295                 {
10296                         uint32_t _flags_save_string = ndr->flags;
10297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10298                         if (r->config_file) {
10299                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10300                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10301                         }
10302                         ndr->flags = _flags_save_string;
10303                 }
10304                 {
10305                         uint32_t _flags_save_string = ndr->flags;
10306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10307                         if (r->help_file) {
10308                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10309                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10310                         }
10311                         ndr->flags = _flags_save_string;
10312                 }
10313                 {
10314                         uint32_t _flags_save_string_array = ndr->flags;
10315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10316                         if (r->dependent_files) {
10317                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10318                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10319                         }
10320                         ndr->flags = _flags_save_string_array;
10321                 }
10322                 {
10323                         uint32_t _flags_save_string = ndr->flags;
10324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10325                         if (r->monitor_name) {
10326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10328                         }
10329                         ndr->flags = _flags_save_string;
10330                 }
10331                 {
10332                         uint32_t _flags_save_string = ndr->flags;
10333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10334                         if (r->default_datatype) {
10335                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10336                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10337                         }
10338                         ndr->flags = _flags_save_string;
10339                 }
10340                 {
10341                         uint32_t _flags_save_string_array = ndr->flags;
10342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10343                         if (r->previous_names) {
10344                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10345                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10346                         }
10347                         ndr->flags = _flags_save_string_array;
10348                 }
10349                 {
10350                         uint32_t _flags_save_string = ndr->flags;
10351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10352                         if (r->manufacturer_name) {
10353                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
10354                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
10355                         }
10356                         ndr->flags = _flags_save_string;
10357                 }
10358                 {
10359                         uint32_t _flags_save_string = ndr->flags;
10360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10361                         if (r->manufacturer_url) {
10362                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
10363                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
10364                         }
10365                         ndr->flags = _flags_save_string;
10366                 }
10367                 {
10368                         uint32_t _flags_save_string = ndr->flags;
10369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10370                         if (r->hardware_id) {
10371                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
10372                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
10373                         }
10374                         ndr->flags = _flags_save_string;
10375                 }
10376                 {
10377                         uint32_t _flags_save_string = ndr->flags;
10378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10379                         if (r->provider) {
10380                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
10381                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
10382                         }
10383                         ndr->flags = _flags_save_string;
10384                 }
10385         }
10386         return NDR_ERR_SUCCESS;
10387 }
10388
10389 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
10390 {
10391         uint32_t _ptr_driver_name;
10392         TALLOC_CTX *_mem_save_driver_name_0;
10393         uint32_t _ptr_architecture;
10394         TALLOC_CTX *_mem_save_architecture_0;
10395         uint32_t _ptr_driver_path;
10396         TALLOC_CTX *_mem_save_driver_path_0;
10397         uint32_t _ptr_data_file;
10398         TALLOC_CTX *_mem_save_data_file_0;
10399         uint32_t _ptr_config_file;
10400         TALLOC_CTX *_mem_save_config_file_0;
10401         uint32_t _ptr_help_file;
10402         TALLOC_CTX *_mem_save_help_file_0;
10403         uint32_t _ptr_dependent_files;
10404         TALLOC_CTX *_mem_save_dependent_files_0;
10405         uint32_t _ptr_monitor_name;
10406         TALLOC_CTX *_mem_save_monitor_name_0;
10407         uint32_t _ptr_default_datatype;
10408         TALLOC_CTX *_mem_save_default_datatype_0;
10409         uint32_t _ptr_previous_names;
10410         TALLOC_CTX *_mem_save_previous_names_0;
10411         uint32_t _ptr_manufacturer_name;
10412         TALLOC_CTX *_mem_save_manufacturer_name_0;
10413         uint32_t _ptr_manufacturer_url;
10414         TALLOC_CTX *_mem_save_manufacturer_url_0;
10415         uint32_t _ptr_hardware_id;
10416         TALLOC_CTX *_mem_save_hardware_id_0;
10417         uint32_t _ptr_provider;
10418         TALLOC_CTX *_mem_save_provider_0;
10419         if (ndr_flags & NDR_SCALARS) {
10420                 NDR_CHECK(ndr_pull_align(ndr, 8));
10421                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10422                 {
10423                         uint32_t _flags_save_string = ndr->flags;
10424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10425                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10426                         if (_ptr_driver_name) {
10427                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10428                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10429                         } else {
10430                                 r->driver_name = NULL;
10431                         }
10432                         ndr->flags = _flags_save_string;
10433                 }
10434                 {
10435                         uint32_t _flags_save_string = ndr->flags;
10436                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10437                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10438                         if (_ptr_architecture) {
10439                                 NDR_PULL_ALLOC(ndr, r->architecture);
10440                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10441                         } else {
10442                                 r->architecture = NULL;
10443                         }
10444                         ndr->flags = _flags_save_string;
10445                 }
10446                 {
10447                         uint32_t _flags_save_string = ndr->flags;
10448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10449                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10450                         if (_ptr_driver_path) {
10451                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10452                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10453                         } else {
10454                                 r->driver_path = NULL;
10455                         }
10456                         ndr->flags = _flags_save_string;
10457                 }
10458                 {
10459                         uint32_t _flags_save_string = ndr->flags;
10460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10461                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10462                         if (_ptr_data_file) {
10463                                 NDR_PULL_ALLOC(ndr, r->data_file);
10464                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10465                         } else {
10466                                 r->data_file = NULL;
10467                         }
10468                         ndr->flags = _flags_save_string;
10469                 }
10470                 {
10471                         uint32_t _flags_save_string = ndr->flags;
10472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10473                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10474                         if (_ptr_config_file) {
10475                                 NDR_PULL_ALLOC(ndr, r->config_file);
10476                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10477                         } else {
10478                                 r->config_file = NULL;
10479                         }
10480                         ndr->flags = _flags_save_string;
10481                 }
10482                 {
10483                         uint32_t _flags_save_string = ndr->flags;
10484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10485                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10486                         if (_ptr_help_file) {
10487                                 NDR_PULL_ALLOC(ndr, r->help_file);
10488                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10489                         } else {
10490                                 r->help_file = NULL;
10491                         }
10492                         ndr->flags = _flags_save_string;
10493                 }
10494                 {
10495                         uint32_t _flags_save_string_array = ndr->flags;
10496                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10497                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10498                         if (_ptr_dependent_files) {
10499                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10500                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10501                         } else {
10502                                 r->dependent_files = NULL;
10503                         }
10504                         ndr->flags = _flags_save_string_array;
10505                 }
10506                 {
10507                         uint32_t _flags_save_string = ndr->flags;
10508                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10509                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10510                         if (_ptr_monitor_name) {
10511                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10512                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10513                         } else {
10514                                 r->monitor_name = NULL;
10515                         }
10516                         ndr->flags = _flags_save_string;
10517                 }
10518                 {
10519                         uint32_t _flags_save_string = ndr->flags;
10520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10521                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10522                         if (_ptr_default_datatype) {
10523                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10524                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10525                         } else {
10526                                 r->default_datatype = NULL;
10527                         }
10528                         ndr->flags = _flags_save_string;
10529                 }
10530                 {
10531                         uint32_t _flags_save_string_array = ndr->flags;
10532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10533                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10534                         if (_ptr_previous_names) {
10535                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10536                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10537                         } else {
10538                                 r->previous_names = NULL;
10539                         }
10540                         ndr->flags = _flags_save_string_array;
10541                 }
10542                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
10543                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
10544                 {
10545                         uint32_t _flags_save_string = ndr->flags;
10546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10547                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
10548                         if (_ptr_manufacturer_name) {
10549                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
10550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
10551                         } else {
10552                                 r->manufacturer_name = NULL;
10553                         }
10554                         ndr->flags = _flags_save_string;
10555                 }
10556                 {
10557                         uint32_t _flags_save_string = ndr->flags;
10558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
10560                         if (_ptr_manufacturer_url) {
10561                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
10562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
10563                         } else {
10564                                 r->manufacturer_url = NULL;
10565                         }
10566                         ndr->flags = _flags_save_string;
10567                 }
10568                 {
10569                         uint32_t _flags_save_string = ndr->flags;
10570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
10572                         if (_ptr_hardware_id) {
10573                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
10574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
10575                         } else {
10576                                 r->hardware_id = NULL;
10577                         }
10578                         ndr->flags = _flags_save_string;
10579                 }
10580                 {
10581                         uint32_t _flags_save_string = ndr->flags;
10582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10583                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
10584                         if (_ptr_provider) {
10585                                 NDR_PULL_ALLOC(ndr, r->provider);
10586                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
10587                         } else {
10588                                 r->provider = NULL;
10589                         }
10590                         ndr->flags = _flags_save_string;
10591                 }
10592         }
10593         if (ndr_flags & NDR_BUFFERS) {
10594                 {
10595                         uint32_t _flags_save_string = ndr->flags;
10596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10597                         if (r->driver_name) {
10598                                 uint32_t _relative_save_offset;
10599                                 _relative_save_offset = ndr->offset;
10600                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10601                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10602                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10603                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10604                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10605                                 ndr->offset = _relative_save_offset;
10606                         }
10607                         ndr->flags = _flags_save_string;
10608                 }
10609                 {
10610                         uint32_t _flags_save_string = ndr->flags;
10611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10612                         if (r->architecture) {
10613                                 uint32_t _relative_save_offset;
10614                                 _relative_save_offset = ndr->offset;
10615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10616                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10617                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10620                                 ndr->offset = _relative_save_offset;
10621                         }
10622                         ndr->flags = _flags_save_string;
10623                 }
10624                 {
10625                         uint32_t _flags_save_string = ndr->flags;
10626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10627                         if (r->driver_path) {
10628                                 uint32_t _relative_save_offset;
10629                                 _relative_save_offset = ndr->offset;
10630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10631                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10632                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10635                                 ndr->offset = _relative_save_offset;
10636                         }
10637                         ndr->flags = _flags_save_string;
10638                 }
10639                 {
10640                         uint32_t _flags_save_string = ndr->flags;
10641                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10642                         if (r->data_file) {
10643                                 uint32_t _relative_save_offset;
10644                                 _relative_save_offset = ndr->offset;
10645                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10646                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10647                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10648                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10649                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10650                                 ndr->offset = _relative_save_offset;
10651                         }
10652                         ndr->flags = _flags_save_string;
10653                 }
10654                 {
10655                         uint32_t _flags_save_string = ndr->flags;
10656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10657                         if (r->config_file) {
10658                                 uint32_t _relative_save_offset;
10659                                 _relative_save_offset = ndr->offset;
10660                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10661                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10662                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10663                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10664                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10665                                 ndr->offset = _relative_save_offset;
10666                         }
10667                         ndr->flags = _flags_save_string;
10668                 }
10669                 {
10670                         uint32_t _flags_save_string = ndr->flags;
10671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10672                         if (r->help_file) {
10673                                 uint32_t _relative_save_offset;
10674                                 _relative_save_offset = ndr->offset;
10675                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10676                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10677                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10678                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10679                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10680                                 ndr->offset = _relative_save_offset;
10681                         }
10682                         ndr->flags = _flags_save_string;
10683                 }
10684                 {
10685                         uint32_t _flags_save_string_array = ndr->flags;
10686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10687                         if (r->dependent_files) {
10688                                 uint32_t _relative_save_offset;
10689                                 _relative_save_offset = ndr->offset;
10690                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10691                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10692                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10693                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10694                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10695                                 ndr->offset = _relative_save_offset;
10696                         }
10697                         ndr->flags = _flags_save_string_array;
10698                 }
10699                 {
10700                         uint32_t _flags_save_string = ndr->flags;
10701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10702                         if (r->monitor_name) {
10703                                 uint32_t _relative_save_offset;
10704                                 _relative_save_offset = ndr->offset;
10705                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10706                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10707                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10708                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10709                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10710                                 ndr->offset = _relative_save_offset;
10711                         }
10712                         ndr->flags = _flags_save_string;
10713                 }
10714                 {
10715                         uint32_t _flags_save_string = ndr->flags;
10716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10717                         if (r->default_datatype) {
10718                                 uint32_t _relative_save_offset;
10719                                 _relative_save_offset = ndr->offset;
10720                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10721                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10722                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10723                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10724                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10725                                 ndr->offset = _relative_save_offset;
10726                         }
10727                         ndr->flags = _flags_save_string;
10728                 }
10729                 {
10730                         uint32_t _flags_save_string_array = ndr->flags;
10731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10732                         if (r->previous_names) {
10733                                 uint32_t _relative_save_offset;
10734                                 _relative_save_offset = ndr->offset;
10735                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
10736                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
10737                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
10738                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
10739                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
10740                                 ndr->offset = _relative_save_offset;
10741                         }
10742                         ndr->flags = _flags_save_string_array;
10743                 }
10744                 {
10745                         uint32_t _flags_save_string = ndr->flags;
10746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10747                         if (r->manufacturer_name) {
10748                                 uint32_t _relative_save_offset;
10749                                 _relative_save_offset = ndr->offset;
10750                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
10751                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10752                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
10753                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
10754                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
10755                                 ndr->offset = _relative_save_offset;
10756                         }
10757                         ndr->flags = _flags_save_string;
10758                 }
10759                 {
10760                         uint32_t _flags_save_string = ndr->flags;
10761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10762                         if (r->manufacturer_url) {
10763                                 uint32_t _relative_save_offset;
10764                                 _relative_save_offset = ndr->offset;
10765                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
10766                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
10767                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
10768                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
10769                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
10770                                 ndr->offset = _relative_save_offset;
10771                         }
10772                         ndr->flags = _flags_save_string;
10773                 }
10774                 {
10775                         uint32_t _flags_save_string = ndr->flags;
10776                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10777                         if (r->hardware_id) {
10778                                 uint32_t _relative_save_offset;
10779                                 _relative_save_offset = ndr->offset;
10780                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
10781                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
10782                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
10783                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
10784                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
10785                                 ndr->offset = _relative_save_offset;
10786                         }
10787                         ndr->flags = _flags_save_string;
10788                 }
10789                 {
10790                         uint32_t _flags_save_string = ndr->flags;
10791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10792                         if (r->provider) {
10793                                 uint32_t _relative_save_offset;
10794                                 _relative_save_offset = ndr->offset;
10795                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
10796                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
10797                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
10798                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
10799                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
10800                                 ndr->offset = _relative_save_offset;
10801                         }
10802                         ndr->flags = _flags_save_string;
10803                 }
10804         }
10805         return NDR_ERR_SUCCESS;
10806 }
10807
10808 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
10809 {
10810         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
10811         ndr->depth++;
10812         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10813         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10814         ndr->depth++;
10815         if (r->driver_name) {
10816                 ndr_print_string(ndr, "driver_name", r->driver_name);
10817         }
10818         ndr->depth--;
10819         ndr_print_ptr(ndr, "architecture", r->architecture);
10820         ndr->depth++;
10821         if (r->architecture) {
10822                 ndr_print_string(ndr, "architecture", r->architecture);
10823         }
10824         ndr->depth--;
10825         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10826         ndr->depth++;
10827         if (r->driver_path) {
10828                 ndr_print_string(ndr, "driver_path", r->driver_path);
10829         }
10830         ndr->depth--;
10831         ndr_print_ptr(ndr, "data_file", r->data_file);
10832         ndr->depth++;
10833         if (r->data_file) {
10834                 ndr_print_string(ndr, "data_file", r->data_file);
10835         }
10836         ndr->depth--;
10837         ndr_print_ptr(ndr, "config_file", r->config_file);
10838         ndr->depth++;
10839         if (r->config_file) {
10840                 ndr_print_string(ndr, "config_file", r->config_file);
10841         }
10842         ndr->depth--;
10843         ndr_print_ptr(ndr, "help_file", r->help_file);
10844         ndr->depth++;
10845         if (r->help_file) {
10846                 ndr_print_string(ndr, "help_file", r->help_file);
10847         }
10848         ndr->depth--;
10849         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10850         ndr->depth++;
10851         if (r->dependent_files) {
10852                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10853         }
10854         ndr->depth--;
10855         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10856         ndr->depth++;
10857         if (r->monitor_name) {
10858                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10859         }
10860         ndr->depth--;
10861         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10862         ndr->depth++;
10863         if (r->default_datatype) {
10864                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10865         }
10866         ndr->depth--;
10867         ndr_print_ptr(ndr, "previous_names", r->previous_names);
10868         ndr->depth++;
10869         if (r->previous_names) {
10870                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
10871         }
10872         ndr->depth--;
10873         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
10874         ndr_print_hyper(ndr, "driver_version", r->driver_version);
10875         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
10876         ndr->depth++;
10877         if (r->manufacturer_name) {
10878                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
10879         }
10880         ndr->depth--;
10881         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
10882         ndr->depth++;
10883         if (r->manufacturer_url) {
10884                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
10885         }
10886         ndr->depth--;
10887         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
10888         ndr->depth++;
10889         if (r->hardware_id) {
10890                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
10891         }
10892         ndr->depth--;
10893         ndr_print_ptr(ndr, "provider", r->provider);
10894         ndr->depth++;
10895         if (r->provider) {
10896                 ndr_print_string(ndr, "provider", r->provider);
10897         }
10898         ndr->depth--;
10899         ndr->depth--;
10900 }
10901
10902 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
10903 {
10904         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
10905 }
10906
10907 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
10908 {
10909         if (ndr_flags & NDR_SCALARS) {
10910                 NDR_CHECK(ndr_push_align(ndr, 8));
10911                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10912                 {
10913                         uint32_t _flags_save_string = ndr->flags;
10914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10915                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10916                         ndr->flags = _flags_save_string;
10917                 }
10918                 {
10919                         uint32_t _flags_save_string = ndr->flags;
10920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10921                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10922                         ndr->flags = _flags_save_string;
10923                 }
10924                 {
10925                         uint32_t _flags_save_string = ndr->flags;
10926                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10927                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10928                         ndr->flags = _flags_save_string;
10929                 }
10930                 {
10931                         uint32_t _flags_save_string = ndr->flags;
10932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10933                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10934                         ndr->flags = _flags_save_string;
10935                 }
10936                 {
10937                         uint32_t _flags_save_string = ndr->flags;
10938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10939                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10940                         ndr->flags = _flags_save_string;
10941                 }
10942                 {
10943                         uint32_t _flags_save_string = ndr->flags;
10944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10945                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10946                         ndr->flags = _flags_save_string;
10947                 }
10948                 {
10949                         uint32_t _flags_save_string = ndr->flags;
10950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10951                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10952                         ndr->flags = _flags_save_string;
10953                 }
10954                 {
10955                         uint32_t _flags_save_string = ndr->flags;
10956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10958                         ndr->flags = _flags_save_string;
10959                 }
10960                 {
10961                         uint32_t _flags_save_string_array = ndr->flags;
10962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10964                         ndr->flags = _flags_save_string_array;
10965                 }
10966                 {
10967                         uint32_t _flags_save_string_array = ndr->flags;
10968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10970                         ndr->flags = _flags_save_string_array;
10971                 }
10972                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
10973                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
10974                 {
10975                         uint32_t _flags_save_string = ndr->flags;
10976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10977                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
10978                         ndr->flags = _flags_save_string;
10979                 }
10980                 {
10981                         uint32_t _flags_save_string = ndr->flags;
10982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10983                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
10984                         ndr->flags = _flags_save_string;
10985                 }
10986                 {
10987                         uint32_t _flags_save_string = ndr->flags;
10988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10989                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
10990                         ndr->flags = _flags_save_string;
10991                 }
10992                 {
10993                         uint32_t _flags_save_string = ndr->flags;
10994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
10996                         ndr->flags = _flags_save_string;
10997                 }
10998                 {
10999                         uint32_t _flags_save_string = ndr->flags;
11000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
11002                         ndr->flags = _flags_save_string;
11003                 }
11004                 {
11005                         uint32_t _flags_save_string = ndr->flags;
11006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
11008                         ndr->flags = _flags_save_string;
11009                 }
11010                 {
11011                         uint32_t _flags_save_string_array = ndr->flags;
11012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
11014                         ndr->flags = _flags_save_string_array;
11015                 }
11016                 {
11017                         uint32_t _flags_save_string = ndr->flags;
11018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
11020                         ndr->flags = _flags_save_string;
11021                 }
11022                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
11023                 {
11024                         uint32_t _flags_save_string_array = ndr->flags;
11025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11026                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
11027                         ndr->flags = _flags_save_string_array;
11028                 }
11029                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
11030                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
11031         }
11032         if (ndr_flags & NDR_BUFFERS) {
11033                 {
11034                         uint32_t _flags_save_string = ndr->flags;
11035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11036                         if (r->driver_name) {
11037                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11038                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11039                         }
11040                         ndr->flags = _flags_save_string;
11041                 }
11042                 {
11043                         uint32_t _flags_save_string = ndr->flags;
11044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11045                         if (r->architecture) {
11046                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11047                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11048                         }
11049                         ndr->flags = _flags_save_string;
11050                 }
11051                 {
11052                         uint32_t _flags_save_string = ndr->flags;
11053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11054                         if (r->driver_path) {
11055                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11056                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11057                         }
11058                         ndr->flags = _flags_save_string;
11059                 }
11060                 {
11061                         uint32_t _flags_save_string = ndr->flags;
11062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11063                         if (r->data_file) {
11064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11066                         }
11067                         ndr->flags = _flags_save_string;
11068                 }
11069                 {
11070                         uint32_t _flags_save_string = ndr->flags;
11071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11072                         if (r->config_file) {
11073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11075                         }
11076                         ndr->flags = _flags_save_string;
11077                 }
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11081                         if (r->help_file) {
11082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11084                         }
11085                         ndr->flags = _flags_save_string;
11086                 }
11087                 {
11088                         uint32_t _flags_save_string = ndr->flags;
11089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11090                         if (r->monitor_name) {
11091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11093                         }
11094                         ndr->flags = _flags_save_string;
11095                 }
11096                 {
11097                         uint32_t _flags_save_string = ndr->flags;
11098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11099                         if (r->default_datatype) {
11100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11102                         }
11103                         ndr->flags = _flags_save_string;
11104                 }
11105                 {
11106                         uint32_t _flags_save_string_array = ndr->flags;
11107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11108                         if (r->dependent_files) {
11109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11110                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11111                         }
11112                         ndr->flags = _flags_save_string_array;
11113                 }
11114                 {
11115                         uint32_t _flags_save_string_array = ndr->flags;
11116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11117                         if (r->previous_names) {
11118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11119                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11120                         }
11121                         ndr->flags = _flags_save_string_array;
11122                 }
11123                 {
11124                         uint32_t _flags_save_string = ndr->flags;
11125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11126                         if (r->manufacturer_name) {
11127                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11128                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11129                         }
11130                         ndr->flags = _flags_save_string;
11131                 }
11132                 {
11133                         uint32_t _flags_save_string = ndr->flags;
11134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11135                         if (r->manufacturer_url) {
11136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11138                         }
11139                         ndr->flags = _flags_save_string;
11140                 }
11141                 {
11142                         uint32_t _flags_save_string = ndr->flags;
11143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11144                         if (r->hardware_id) {
11145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11147                         }
11148                         ndr->flags = _flags_save_string;
11149                 }
11150                 {
11151                         uint32_t _flags_save_string = ndr->flags;
11152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11153                         if (r->provider) {
11154                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11155                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11156                         }
11157                         ndr->flags = _flags_save_string;
11158                 }
11159                 {
11160                         uint32_t _flags_save_string = ndr->flags;
11161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11162                         if (r->print_processor) {
11163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
11164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
11165                         }
11166                         ndr->flags = _flags_save_string;
11167                 }
11168                 {
11169                         uint32_t _flags_save_string = ndr->flags;
11170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11171                         if (r->vendor_setup) {
11172                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
11173                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
11174                         }
11175                         ndr->flags = _flags_save_string;
11176                 }
11177                 {
11178                         uint32_t _flags_save_string_array = ndr->flags;
11179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11180                         if (r->color_profiles) {
11181                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
11182                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
11183                         }
11184                         ndr->flags = _flags_save_string_array;
11185                 }
11186                 {
11187                         uint32_t _flags_save_string = ndr->flags;
11188                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11189                         if (r->inf_path) {
11190                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
11191                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
11192                         }
11193                         ndr->flags = _flags_save_string;
11194                 }
11195                 {
11196                         uint32_t _flags_save_string_array = ndr->flags;
11197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11198                         if (r->core_driver_dependencies) {
11199                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
11200                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
11201                         }
11202                         ndr->flags = _flags_save_string_array;
11203                 }
11204         }
11205         return NDR_ERR_SUCCESS;
11206 }
11207
11208 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
11209 {
11210         uint32_t _ptr_driver_name;
11211         TALLOC_CTX *_mem_save_driver_name_0;
11212         uint32_t _ptr_architecture;
11213         TALLOC_CTX *_mem_save_architecture_0;
11214         uint32_t _ptr_driver_path;
11215         TALLOC_CTX *_mem_save_driver_path_0;
11216         uint32_t _ptr_data_file;
11217         TALLOC_CTX *_mem_save_data_file_0;
11218         uint32_t _ptr_config_file;
11219         TALLOC_CTX *_mem_save_config_file_0;
11220         uint32_t _ptr_help_file;
11221         TALLOC_CTX *_mem_save_help_file_0;
11222         uint32_t _ptr_monitor_name;
11223         TALLOC_CTX *_mem_save_monitor_name_0;
11224         uint32_t _ptr_default_datatype;
11225         TALLOC_CTX *_mem_save_default_datatype_0;
11226         uint32_t _ptr_dependent_files;
11227         TALLOC_CTX *_mem_save_dependent_files_0;
11228         uint32_t _ptr_previous_names;
11229         TALLOC_CTX *_mem_save_previous_names_0;
11230         uint32_t _ptr_manufacturer_name;
11231         TALLOC_CTX *_mem_save_manufacturer_name_0;
11232         uint32_t _ptr_manufacturer_url;
11233         TALLOC_CTX *_mem_save_manufacturer_url_0;
11234         uint32_t _ptr_hardware_id;
11235         TALLOC_CTX *_mem_save_hardware_id_0;
11236         uint32_t _ptr_provider;
11237         TALLOC_CTX *_mem_save_provider_0;
11238         uint32_t _ptr_print_processor;
11239         TALLOC_CTX *_mem_save_print_processor_0;
11240         uint32_t _ptr_vendor_setup;
11241         TALLOC_CTX *_mem_save_vendor_setup_0;
11242         uint32_t _ptr_color_profiles;
11243         TALLOC_CTX *_mem_save_color_profiles_0;
11244         uint32_t _ptr_inf_path;
11245         TALLOC_CTX *_mem_save_inf_path_0;
11246         uint32_t _ptr_core_driver_dependencies;
11247         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
11248         if (ndr_flags & NDR_SCALARS) {
11249                 NDR_CHECK(ndr_pull_align(ndr, 8));
11250                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11251                 {
11252                         uint32_t _flags_save_string = ndr->flags;
11253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11254                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11255                         if (_ptr_driver_name) {
11256                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11257                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11258                         } else {
11259                                 r->driver_name = NULL;
11260                         }
11261                         ndr->flags = _flags_save_string;
11262                 }
11263                 {
11264                         uint32_t _flags_save_string = ndr->flags;
11265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11266                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11267                         if (_ptr_architecture) {
11268                                 NDR_PULL_ALLOC(ndr, r->architecture);
11269                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11270                         } else {
11271                                 r->architecture = NULL;
11272                         }
11273                         ndr->flags = _flags_save_string;
11274                 }
11275                 {
11276                         uint32_t _flags_save_string = ndr->flags;
11277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11278                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11279                         if (_ptr_driver_path) {
11280                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11281                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11282                         } else {
11283                                 r->driver_path = NULL;
11284                         }
11285                         ndr->flags = _flags_save_string;
11286                 }
11287                 {
11288                         uint32_t _flags_save_string = ndr->flags;
11289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11290                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11291                         if (_ptr_data_file) {
11292                                 NDR_PULL_ALLOC(ndr, r->data_file);
11293                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11294                         } else {
11295                                 r->data_file = NULL;
11296                         }
11297                         ndr->flags = _flags_save_string;
11298                 }
11299                 {
11300                         uint32_t _flags_save_string = ndr->flags;
11301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11302                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11303                         if (_ptr_config_file) {
11304                                 NDR_PULL_ALLOC(ndr, r->config_file);
11305                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11306                         } else {
11307                                 r->config_file = NULL;
11308                         }
11309                         ndr->flags = _flags_save_string;
11310                 }
11311                 {
11312                         uint32_t _flags_save_string = ndr->flags;
11313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11314                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11315                         if (_ptr_help_file) {
11316                                 NDR_PULL_ALLOC(ndr, r->help_file);
11317                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11318                         } else {
11319                                 r->help_file = NULL;
11320                         }
11321                         ndr->flags = _flags_save_string;
11322                 }
11323                 {
11324                         uint32_t _flags_save_string = ndr->flags;
11325                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11326                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11327                         if (_ptr_monitor_name) {
11328                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11329                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11330                         } else {
11331                                 r->monitor_name = NULL;
11332                         }
11333                         ndr->flags = _flags_save_string;
11334                 }
11335                 {
11336                         uint32_t _flags_save_string = ndr->flags;
11337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11338                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11339                         if (_ptr_default_datatype) {
11340                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11341                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11342                         } else {
11343                                 r->default_datatype = NULL;
11344                         }
11345                         ndr->flags = _flags_save_string;
11346                 }
11347                 {
11348                         uint32_t _flags_save_string_array = ndr->flags;
11349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11350                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11351                         if (_ptr_dependent_files) {
11352                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11353                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11354                         } else {
11355                                 r->dependent_files = NULL;
11356                         }
11357                         ndr->flags = _flags_save_string_array;
11358                 }
11359                 {
11360                         uint32_t _flags_save_string_array = ndr->flags;
11361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11362                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11363                         if (_ptr_previous_names) {
11364                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11365                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11366                         } else {
11367                                 r->previous_names = NULL;
11368                         }
11369                         ndr->flags = _flags_save_string_array;
11370                 }
11371                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11372                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11373                 {
11374                         uint32_t _flags_save_string = ndr->flags;
11375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11376                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11377                         if (_ptr_manufacturer_name) {
11378                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11379                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11380                         } else {
11381                                 r->manufacturer_name = NULL;
11382                         }
11383                         ndr->flags = _flags_save_string;
11384                 }
11385                 {
11386                         uint32_t _flags_save_string = ndr->flags;
11387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11388                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11389                         if (_ptr_manufacturer_url) {
11390                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11391                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11392                         } else {
11393                                 r->manufacturer_url = NULL;
11394                         }
11395                         ndr->flags = _flags_save_string;
11396                 }
11397                 {
11398                         uint32_t _flags_save_string = ndr->flags;
11399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11400                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11401                         if (_ptr_hardware_id) {
11402                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11403                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11404                         } else {
11405                                 r->hardware_id = NULL;
11406                         }
11407                         ndr->flags = _flags_save_string;
11408                 }
11409                 {
11410                         uint32_t _flags_save_string = ndr->flags;
11411                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11412                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11413                         if (_ptr_provider) {
11414                                 NDR_PULL_ALLOC(ndr, r->provider);
11415                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11416                         } else {
11417                                 r->provider = NULL;
11418                         }
11419                         ndr->flags = _flags_save_string;
11420                 }
11421                 {
11422                         uint32_t _flags_save_string = ndr->flags;
11423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11424                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
11425                         if (_ptr_print_processor) {
11426                                 NDR_PULL_ALLOC(ndr, r->print_processor);
11427                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
11428                         } else {
11429                                 r->print_processor = NULL;
11430                         }
11431                         ndr->flags = _flags_save_string;
11432                 }
11433                 {
11434                         uint32_t _flags_save_string = ndr->flags;
11435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11436                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
11437                         if (_ptr_vendor_setup) {
11438                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
11439                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
11440                         } else {
11441                                 r->vendor_setup = NULL;
11442                         }
11443                         ndr->flags = _flags_save_string;
11444                 }
11445                 {
11446                         uint32_t _flags_save_string_array = ndr->flags;
11447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11448                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
11449                         if (_ptr_color_profiles) {
11450                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
11451                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
11452                         } else {
11453                                 r->color_profiles = NULL;
11454                         }
11455                         ndr->flags = _flags_save_string_array;
11456                 }
11457                 {
11458                         uint32_t _flags_save_string = ndr->flags;
11459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11460                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
11461                         if (_ptr_inf_path) {
11462                                 NDR_PULL_ALLOC(ndr, r->inf_path);
11463                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
11464                         } else {
11465                                 r->inf_path = NULL;
11466                         }
11467                         ndr->flags = _flags_save_string;
11468                 }
11469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
11470                 {
11471                         uint32_t _flags_save_string_array = ndr->flags;
11472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11473                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
11474                         if (_ptr_core_driver_dependencies) {
11475                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
11476                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
11477                         } else {
11478                                 r->core_driver_dependencies = NULL;
11479                         }
11480                         ndr->flags = _flags_save_string_array;
11481                 }
11482                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
11483                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
11484         }
11485         if (ndr_flags & NDR_BUFFERS) {
11486                 {
11487                         uint32_t _flags_save_string = ndr->flags;
11488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11489                         if (r->driver_name) {
11490                                 uint32_t _relative_save_offset;
11491                                 _relative_save_offset = ndr->offset;
11492                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11493                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11494                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11495                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11496                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11497                                 ndr->offset = _relative_save_offset;
11498                         }
11499                         ndr->flags = _flags_save_string;
11500                 }
11501                 {
11502                         uint32_t _flags_save_string = ndr->flags;
11503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11504                         if (r->architecture) {
11505                                 uint32_t _relative_save_offset;
11506                                 _relative_save_offset = ndr->offset;
11507                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11508                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11509                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11510                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11511                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11512                                 ndr->offset = _relative_save_offset;
11513                         }
11514                         ndr->flags = _flags_save_string;
11515                 }
11516                 {
11517                         uint32_t _flags_save_string = ndr->flags;
11518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11519                         if (r->driver_path) {
11520                                 uint32_t _relative_save_offset;
11521                                 _relative_save_offset = ndr->offset;
11522                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11523                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11524                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11525                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11526                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11527                                 ndr->offset = _relative_save_offset;
11528                         }
11529                         ndr->flags = _flags_save_string;
11530                 }
11531                 {
11532                         uint32_t _flags_save_string = ndr->flags;
11533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11534                         if (r->data_file) {
11535                                 uint32_t _relative_save_offset;
11536                                 _relative_save_offset = ndr->offset;
11537                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11538                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11539                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11540                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11541                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11542                                 ndr->offset = _relative_save_offset;
11543                         }
11544                         ndr->flags = _flags_save_string;
11545                 }
11546                 {
11547                         uint32_t _flags_save_string = ndr->flags;
11548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11549                         if (r->config_file) {
11550                                 uint32_t _relative_save_offset;
11551                                 _relative_save_offset = ndr->offset;
11552                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11553                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11554                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11555                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11556                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11557                                 ndr->offset = _relative_save_offset;
11558                         }
11559                         ndr->flags = _flags_save_string;
11560                 }
11561                 {
11562                         uint32_t _flags_save_string = ndr->flags;
11563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11564                         if (r->help_file) {
11565                                 uint32_t _relative_save_offset;
11566                                 _relative_save_offset = ndr->offset;
11567                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11568                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11569                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11570                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11571                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11572                                 ndr->offset = _relative_save_offset;
11573                         }
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         if (r->monitor_name) {
11580                                 uint32_t _relative_save_offset;
11581                                 _relative_save_offset = ndr->offset;
11582                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11583                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11584                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11585                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11586                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11587                                 ndr->offset = _relative_save_offset;
11588                         }
11589                         ndr->flags = _flags_save_string;
11590                 }
11591                 {
11592                         uint32_t _flags_save_string = ndr->flags;
11593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11594                         if (r->default_datatype) {
11595                                 uint32_t _relative_save_offset;
11596                                 _relative_save_offset = ndr->offset;
11597                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11598                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11599                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11600                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11601                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11602                                 ndr->offset = _relative_save_offset;
11603                         }
11604                         ndr->flags = _flags_save_string;
11605                 }
11606                 {
11607                         uint32_t _flags_save_string_array = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         if (r->dependent_files) {
11610                                 uint32_t _relative_save_offset;
11611                                 _relative_save_offset = ndr->offset;
11612                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11613                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11614                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11615                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11616                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11617                                 ndr->offset = _relative_save_offset;
11618                         }
11619                         ndr->flags = _flags_save_string_array;
11620                 }
11621                 {
11622                         uint32_t _flags_save_string_array = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         if (r->previous_names) {
11625                                 uint32_t _relative_save_offset;
11626                                 _relative_save_offset = ndr->offset;
11627                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11628                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11629                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11630                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11631                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11632                                 ndr->offset = _relative_save_offset;
11633                         }
11634                         ndr->flags = _flags_save_string_array;
11635                 }
11636                 {
11637                         uint32_t _flags_save_string = ndr->flags;
11638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11639                         if (r->manufacturer_name) {
11640                                 uint32_t _relative_save_offset;
11641                                 _relative_save_offset = ndr->offset;
11642                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
11643                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11644                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
11645                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
11646                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
11647                                 ndr->offset = _relative_save_offset;
11648                         }
11649                         ndr->flags = _flags_save_string;
11650                 }
11651                 {
11652                         uint32_t _flags_save_string = ndr->flags;
11653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11654                         if (r->manufacturer_url) {
11655                                 uint32_t _relative_save_offset;
11656                                 _relative_save_offset = ndr->offset;
11657                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
11658                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
11659                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
11660                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
11661                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
11662                                 ndr->offset = _relative_save_offset;
11663                         }
11664                         ndr->flags = _flags_save_string;
11665                 }
11666                 {
11667                         uint32_t _flags_save_string = ndr->flags;
11668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11669                         if (r->hardware_id) {
11670                                 uint32_t _relative_save_offset;
11671                                 _relative_save_offset = ndr->offset;
11672                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
11673                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
11674                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
11675                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
11676                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
11677                                 ndr->offset = _relative_save_offset;
11678                         }
11679                         ndr->flags = _flags_save_string;
11680                 }
11681                 {
11682                         uint32_t _flags_save_string = ndr->flags;
11683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11684                         if (r->provider) {
11685                                 uint32_t _relative_save_offset;
11686                                 _relative_save_offset = ndr->offset;
11687                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
11688                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
11689                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
11690                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
11691                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
11692                                 ndr->offset = _relative_save_offset;
11693                         }
11694                         ndr->flags = _flags_save_string;
11695                 }
11696                 {
11697                         uint32_t _flags_save_string = ndr->flags;
11698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11699                         if (r->print_processor) {
11700                                 uint32_t _relative_save_offset;
11701                                 _relative_save_offset = ndr->offset;
11702                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
11703                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
11704                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
11705                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
11706                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
11707                                 ndr->offset = _relative_save_offset;
11708                         }
11709                         ndr->flags = _flags_save_string;
11710                 }
11711                 {
11712                         uint32_t _flags_save_string = ndr->flags;
11713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11714                         if (r->vendor_setup) {
11715                                 uint32_t _relative_save_offset;
11716                                 _relative_save_offset = ndr->offset;
11717                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
11718                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
11719                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
11720                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
11721                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
11722                                 ndr->offset = _relative_save_offset;
11723                         }
11724                         ndr->flags = _flags_save_string;
11725                 }
11726                 {
11727                         uint32_t _flags_save_string_array = ndr->flags;
11728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11729                         if (r->color_profiles) {
11730                                 uint32_t _relative_save_offset;
11731                                 _relative_save_offset = ndr->offset;
11732                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
11733                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
11734                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
11735                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
11736                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
11737                                 ndr->offset = _relative_save_offset;
11738                         }
11739                         ndr->flags = _flags_save_string_array;
11740                 }
11741                 {
11742                         uint32_t _flags_save_string = ndr->flags;
11743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11744                         if (r->inf_path) {
11745                                 uint32_t _relative_save_offset;
11746                                 _relative_save_offset = ndr->offset;
11747                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
11748                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11749                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
11750                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
11751                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
11752                                 ndr->offset = _relative_save_offset;
11753                         }
11754                         ndr->flags = _flags_save_string;
11755                 }
11756                 {
11757                         uint32_t _flags_save_string_array = ndr->flags;
11758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11759                         if (r->core_driver_dependencies) {
11760                                 uint32_t _relative_save_offset;
11761                                 _relative_save_offset = ndr->offset;
11762                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
11763                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
11764                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
11765                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
11766                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
11767                                 ndr->offset = _relative_save_offset;
11768                         }
11769                         ndr->flags = _flags_save_string_array;
11770                 }
11771         }
11772         return NDR_ERR_SUCCESS;
11773 }
11774
11775 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
11776 {
11777         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
11778         ndr->depth++;
11779         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11780         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11781         ndr->depth++;
11782         if (r->driver_name) {
11783                 ndr_print_string(ndr, "driver_name", r->driver_name);
11784         }
11785         ndr->depth--;
11786         ndr_print_ptr(ndr, "architecture", r->architecture);
11787         ndr->depth++;
11788         if (r->architecture) {
11789                 ndr_print_string(ndr, "architecture", r->architecture);
11790         }
11791         ndr->depth--;
11792         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11793         ndr->depth++;
11794         if (r->driver_path) {
11795                 ndr_print_string(ndr, "driver_path", r->driver_path);
11796         }
11797         ndr->depth--;
11798         ndr_print_ptr(ndr, "data_file", r->data_file);
11799         ndr->depth++;
11800         if (r->data_file) {
11801                 ndr_print_string(ndr, "data_file", r->data_file);
11802         }
11803         ndr->depth--;
11804         ndr_print_ptr(ndr, "config_file", r->config_file);
11805         ndr->depth++;
11806         if (r->config_file) {
11807                 ndr_print_string(ndr, "config_file", r->config_file);
11808         }
11809         ndr->depth--;
11810         ndr_print_ptr(ndr, "help_file", r->help_file);
11811         ndr->depth++;
11812         if (r->help_file) {
11813                 ndr_print_string(ndr, "help_file", r->help_file);
11814         }
11815         ndr->depth--;
11816         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11817         ndr->depth++;
11818         if (r->monitor_name) {
11819                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11820         }
11821         ndr->depth--;
11822         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11823         ndr->depth++;
11824         if (r->default_datatype) {
11825                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11826         }
11827         ndr->depth--;
11828         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11829         ndr->depth++;
11830         if (r->dependent_files) {
11831                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11832         }
11833         ndr->depth--;
11834         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11835         ndr->depth++;
11836         if (r->previous_names) {
11837                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11838         }
11839         ndr->depth--;
11840         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
11841         ndr_print_hyper(ndr, "driver_version", r->driver_version);
11842         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
11843         ndr->depth++;
11844         if (r->manufacturer_name) {
11845                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
11846         }
11847         ndr->depth--;
11848         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
11849         ndr->depth++;
11850         if (r->manufacturer_url) {
11851                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
11852         }
11853         ndr->depth--;
11854         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
11855         ndr->depth++;
11856         if (r->hardware_id) {
11857                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
11858         }
11859         ndr->depth--;
11860         ndr_print_ptr(ndr, "provider", r->provider);
11861         ndr->depth++;
11862         if (r->provider) {
11863                 ndr_print_string(ndr, "provider", r->provider);
11864         }
11865         ndr->depth--;
11866         ndr_print_ptr(ndr, "print_processor", r->print_processor);
11867         ndr->depth++;
11868         if (r->print_processor) {
11869                 ndr_print_string(ndr, "print_processor", r->print_processor);
11870         }
11871         ndr->depth--;
11872         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
11873         ndr->depth++;
11874         if (r->vendor_setup) {
11875                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
11876         }
11877         ndr->depth--;
11878         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
11879         ndr->depth++;
11880         if (r->color_profiles) {
11881                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
11882         }
11883         ndr->depth--;
11884         ndr_print_ptr(ndr, "inf_path", r->inf_path);
11885         ndr->depth++;
11886         if (r->inf_path) {
11887                 ndr_print_string(ndr, "inf_path", r->inf_path);
11888         }
11889         ndr->depth--;
11890         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
11891         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
11892         ndr->depth++;
11893         if (r->core_driver_dependencies) {
11894                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
11895         }
11896         ndr->depth--;
11897         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
11898         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
11899         ndr->depth--;
11900 }
11901
11902 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
11903 {
11904         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
11905 }
11906
11907 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
11908 {
11909         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
11910         return NDR_ERR_SUCCESS;
11911 }
11912
11913 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
11914 {
11915         uint32_t v;
11916         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
11917         *r = v;
11918         return NDR_ERR_SUCCESS;
11919 }
11920
11921 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
11922 {
11923         const char *val = NULL;
11924
11925         switch (r) {
11926                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
11927                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
11928                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
11929                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
11930                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
11931         }
11932         ndr_print_enum(ndr, name, "ENUM", val, r);
11933 }
11934
11935 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
11936 {
11937         if (ndr_flags & NDR_SCALARS) {
11938                 NDR_CHECK(ndr_push_align(ndr, 4));
11939                 {
11940                         uint32_t _flags_save_string = ndr->flags;
11941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11942                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
11943                         ndr->flags = _flags_save_string;
11944                 }
11945                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
11946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
11947         }
11948         if (ndr_flags & NDR_BUFFERS) {
11949                 {
11950                         uint32_t _flags_save_string = ndr->flags;
11951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11952                         if (r->file_name) {
11953                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
11954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
11955                         }
11956                         ndr->flags = _flags_save_string;
11957                 }
11958         }
11959         return NDR_ERR_SUCCESS;
11960 }
11961
11962 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
11963 {
11964         uint32_t _ptr_file_name;
11965         TALLOC_CTX *_mem_save_file_name_0;
11966         if (ndr_flags & NDR_SCALARS) {
11967                 NDR_CHECK(ndr_pull_align(ndr, 4));
11968                 {
11969                         uint32_t _flags_save_string = ndr->flags;
11970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11971                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
11972                         if (_ptr_file_name) {
11973                                 NDR_PULL_ALLOC(ndr, r->file_name);
11974                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
11975                         } else {
11976                                 r->file_name = NULL;
11977                         }
11978                         ndr->flags = _flags_save_string;
11979                 }
11980                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
11981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
11982         }
11983         if (ndr_flags & NDR_BUFFERS) {
11984                 {
11985                         uint32_t _flags_save_string = ndr->flags;
11986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11987                         if (r->file_name) {
11988                                 uint32_t _relative_save_offset;
11989                                 _relative_save_offset = ndr->offset;
11990                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
11991                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11992                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
11993                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
11994                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
11995                                 ndr->offset = _relative_save_offset;
11996                         }
11997                         ndr->flags = _flags_save_string;
11998                 }
11999         }
12000         return NDR_ERR_SUCCESS;
12001 }
12002
12003 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
12004 {
12005         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
12006         ndr->depth++;
12007         ndr_print_ptr(ndr, "file_name", r->file_name);
12008         ndr->depth++;
12009         if (r->file_name) {
12010                 ndr_print_string(ndr, "file_name", r->file_name);
12011         }
12012         ndr->depth--;
12013         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
12014         ndr_print_uint32(ndr, "file_version", r->file_version);
12015         ndr->depth--;
12016 }
12017
12018 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
12019 {
12020         uint32_t cntr_file_info_1;
12021         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
12022         ndr->depth++;
12023         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12024         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12025         ndr->depth++;
12026         if (r->driver_name) {
12027                 ndr_print_string(ndr, "driver_name", r->driver_name);
12028         }
12029         ndr->depth--;
12030         ndr_print_ptr(ndr, "architecture", r->architecture);
12031         ndr->depth++;
12032         if (r->architecture) {
12033                 ndr_print_string(ndr, "architecture", r->architecture);
12034         }
12035         ndr->depth--;
12036         ndr_print_ptr(ndr, "file_info", r->file_info);
12037         ndr->depth++;
12038         if (r->file_info) {
12039                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
12040                 ndr->depth++;
12041                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
12042                         char *idx_1=NULL;
12043                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
12044                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
12045                                 free(idx_1);
12046                         }
12047                 }
12048                 ndr->depth--;
12049         }
12050         ndr->depth--;
12051         ndr_print_uint32(ndr, "file_count", r->file_count);
12052         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12053         ndr->depth++;
12054         if (r->monitor_name) {
12055                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12056         }
12057         ndr->depth--;
12058         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12059         ndr->depth++;
12060         if (r->default_datatype) {
12061                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12062         }
12063         ndr->depth--;
12064         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12065         ndr->depth++;
12066         if (r->previous_names) {
12067                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12068         }
12069         ndr->depth--;
12070         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12071         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12072         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12073         ndr->depth++;
12074         if (r->manufacturer_name) {
12075                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12076         }
12077         ndr->depth--;
12078         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12079         ndr->depth++;
12080         if (r->manufacturer_url) {
12081                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12082         }
12083         ndr->depth--;
12084         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12085         ndr->depth++;
12086         if (r->hardware_id) {
12087                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12088         }
12089         ndr->depth--;
12090         ndr_print_ptr(ndr, "provider", r->provider);
12091         ndr->depth++;
12092         if (r->provider) {
12093                 ndr_print_string(ndr, "provider", r->provider);
12094         }
12095         ndr->depth--;
12096         ndr->depth--;
12097 }
12098
12099 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
12100 {
12101         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
12102 }
12103
12104 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
12105 {
12106         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12107         if (ndr_flags & NDR_SCALARS) {
12108                 int level = ndr_push_get_switch_value(ndr, r);
12109                 switch (level) {
12110                         case 1: {
12111                                 NDR_CHECK(ndr_push_align(ndr, 4));
12112                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12113                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
12114                         break; }
12115
12116                         case 2: {
12117                                 NDR_CHECK(ndr_push_align(ndr, 4));
12118                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12119                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
12120                         break; }
12121
12122                         case 3: {
12123                                 NDR_CHECK(ndr_push_align(ndr, 4));
12124                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12125                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
12126                         break; }
12127
12128                         case 4: {
12129                                 NDR_CHECK(ndr_push_align(ndr, 4));
12130                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12131                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
12132                         break; }
12133
12134                         case 5: {
12135                                 NDR_CHECK(ndr_push_align(ndr, 4));
12136                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12137                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
12138                         break; }
12139
12140                         case 6: {
12141                                 NDR_CHECK(ndr_push_align(ndr, 8));
12142                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12143                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
12144                         break; }
12145
12146                         case 8: {
12147                                 NDR_CHECK(ndr_push_align(ndr, 8));
12148                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12149                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
12150                         break; }
12151
12152                         case 101: {
12153                                 NDR_CHECK(ndr_push_align(ndr, 8));
12154                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12155                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
12156                         break; }
12157
12158                         default: {
12159                         break; }
12160
12161                 }
12162         }
12163         if (ndr_flags & NDR_BUFFERS) {
12164                 int level = ndr_push_get_switch_value(ndr, r);
12165                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12166                 switch (level) {
12167                         case 1:
12168                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
12169                         break;
12170
12171                         case 2:
12172                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
12173                         break;
12174
12175                         case 3:
12176                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
12177                         break;
12178
12179                         case 4:
12180                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
12181                         break;
12182
12183                         case 5:
12184                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
12185                         break;
12186
12187                         case 6:
12188                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
12189                         break;
12190
12191                         case 8:
12192                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
12193                         break;
12194
12195                         case 101:
12196                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
12197                         break;
12198
12199                         default:
12200                         break;
12201
12202                 }
12203         }
12204         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12205         return NDR_ERR_SUCCESS;
12206 }
12207
12208 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
12209 {
12210         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12211         int level;
12212         level = ndr_pull_get_switch_value(ndr, r);
12213         if (ndr_flags & NDR_SCALARS) {
12214                 switch (level) {
12215                         case 1: {
12216                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12217                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12218                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
12219                         break; }
12220
12221                         case 2: {
12222                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12223                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12224                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
12225                         break; }
12226
12227                         case 3: {
12228                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12229                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12230                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
12231                         break; }
12232
12233                         case 4: {
12234                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12235                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12236                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
12237                         break; }
12238
12239                         case 5: {
12240                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12241                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12242                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
12243                         break; }
12244
12245                         case 6: {
12246                                 NDR_CHECK(ndr_pull_align(ndr, 8));
12247                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12248                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
12249                         break; }
12250
12251                         case 8: {
12252                                 NDR_CHECK(ndr_pull_align(ndr, 8));
12253                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12254                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
12255                         break; }
12256
12257                         case 101: {
12258                                 NDR_CHECK(ndr_pull_align(ndr, 8));
12259                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12260                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
12261                         break; }
12262
12263                         default: {
12264                         break; }
12265
12266                 }
12267         }
12268         if (ndr_flags & NDR_BUFFERS) {
12269                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12270                 switch (level) {
12271                         case 1:
12272                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
12273                         break;
12274
12275                         case 2:
12276                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
12277                         break;
12278
12279                         case 3:
12280                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
12281                         break;
12282
12283                         case 4:
12284                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
12285                         break;
12286
12287                         case 5:
12288                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
12289                         break;
12290
12291                         case 6:
12292                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
12293                         break;
12294
12295                         case 8:
12296                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
12297                         break;
12298
12299                         case 101:
12300                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
12301                         break;
12302
12303                         default:
12304                         break;
12305
12306                 }
12307         }
12308         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12309         return NDR_ERR_SUCCESS;
12310 }
12311
12312 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
12313 {
12314         int level;
12315         level = ndr_print_get_switch_value(ndr, r);
12316         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
12317         switch (level) {
12318                 case 1:
12319                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
12320                 break;
12321
12322                 case 2:
12323                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
12324                 break;
12325
12326                 case 3:
12327                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
12328                 break;
12329
12330                 case 4:
12331                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
12332                 break;
12333
12334                 case 5:
12335                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
12336                 break;
12337
12338                 case 6:
12339                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
12340                 break;
12341
12342                 case 8:
12343                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
12344                 break;
12345
12346                 case 101:
12347                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
12348                 break;
12349
12350                 default:
12351                 break;
12352
12353         }
12354 }
12355
12356 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
12357 {
12358         if (ndr_flags & NDR_SCALARS) {
12359                 NDR_CHECK(ndr_push_align(ndr, 4));
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
12364                         ndr->flags = _flags_save_string;
12365                 }
12366         }
12367         if (ndr_flags & NDR_BUFFERS) {
12368         }
12369         return NDR_ERR_SUCCESS;
12370 }
12371
12372 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
12373 {
12374         if (ndr_flags & NDR_SCALARS) {
12375                 NDR_CHECK(ndr_pull_align(ndr, 4));
12376                 {
12377                         uint32_t _flags_save_string = ndr->flags;
12378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12379                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
12380                         ndr->flags = _flags_save_string;
12381                 }
12382         }
12383         if (ndr_flags & NDR_BUFFERS) {
12384         }
12385         return NDR_ERR_SUCCESS;
12386 }
12387
12388 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
12389 {
12390         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
12391         ndr->depth++;
12392         ndr_print_string(ndr, "directory_name", r->directory_name);
12393         ndr->depth--;
12394 }
12395
12396 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
12397 {
12398         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
12399 }
12400
12401 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
12402 {
12403         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12404         if (ndr_flags & NDR_SCALARS) {
12405                 int level = ndr_push_get_switch_value(ndr, r);
12406                 switch (level) {
12407                         case 1: {
12408                                 NDR_CHECK(ndr_push_align(ndr, 4));
12409                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12410                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12411                         break; }
12412
12413                         default: {
12414                                 NDR_CHECK(ndr_push_align(ndr, 4));
12415                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12416                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12417                         break; }
12418
12419                 }
12420         }
12421         if (ndr_flags & NDR_BUFFERS) {
12422                 int level = ndr_push_get_switch_value(ndr, r);
12423                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12424                 switch (level) {
12425                         case 1:
12426                         break;
12427
12428                         default:
12429                         break;
12430
12431                 }
12432         }
12433         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12434         return NDR_ERR_SUCCESS;
12435 }
12436
12437 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
12438 {
12439         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12440         int level;
12441         level = ndr_pull_get_switch_value(ndr, r);
12442         if (ndr_flags & NDR_SCALARS) {
12443                 switch (level) {
12444                         case 1: {
12445                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12446                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12447                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12448                         break; }
12449
12450                         default: {
12451                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12452                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12453                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12454                         break; }
12455
12456                 }
12457         }
12458         if (ndr_flags & NDR_BUFFERS) {
12459                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12460                 switch (level) {
12461                         case 1:
12462                         break;
12463
12464                         default:
12465                         break;
12466
12467                 }
12468         }
12469         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12470         return NDR_ERR_SUCCESS;
12471 }
12472
12473 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
12474 {
12475         int level;
12476         level = ndr_print_get_switch_value(ndr, r);
12477         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
12478         switch (level) {
12479                 case 1:
12480                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
12481                 break;
12482
12483                 default:
12484                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
12485                 break;
12486
12487         }
12488 }
12489
12490 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12491 {
12492         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
12493 }
12494
12495 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
12496 {
12497         if (ndr_flags & NDR_SCALARS) {
12498                 NDR_CHECK(ndr_push_align(ndr, 4));
12499                 {
12500                         uint32_t _flags_save_string = ndr->flags;
12501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12502                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
12503                         ndr->flags = _flags_save_string;
12504                 }
12505         }
12506         if (ndr_flags & NDR_BUFFERS) {
12507                 {
12508                         uint32_t _flags_save_string = ndr->flags;
12509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12510                         if (r->print_processor_name) {
12511                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
12512                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
12513                         }
12514                         ndr->flags = _flags_save_string;
12515                 }
12516         }
12517         return NDR_ERR_SUCCESS;
12518 }
12519
12520 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
12521 {
12522         uint32_t _ptr_print_processor_name;
12523         TALLOC_CTX *_mem_save_print_processor_name_0;
12524         if (ndr_flags & NDR_SCALARS) {
12525                 NDR_CHECK(ndr_pull_align(ndr, 4));
12526                 {
12527                         uint32_t _flags_save_string = ndr->flags;
12528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12529                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
12530                         if (_ptr_print_processor_name) {
12531                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
12532                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
12533                         } else {
12534                                 r->print_processor_name = NULL;
12535                         }
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->print_processor_name) {
12544                                 uint32_t _relative_save_offset;
12545                                 _relative_save_offset = ndr->offset;
12546                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
12547                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12548                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
12549                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
12550                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
12551                                 ndr->offset = _relative_save_offset;
12552                         }
12553                         ndr->flags = _flags_save_string;
12554                 }
12555         }
12556         return NDR_ERR_SUCCESS;
12557 }
12558
12559 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
12560 {
12561         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
12562         ndr->depth++;
12563         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
12564         ndr->depth++;
12565         if (r->print_processor_name) {
12566                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
12567         }
12568         ndr->depth--;
12569         ndr->depth--;
12570 }
12571
12572 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
12573 {
12574         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12575         if (ndr_flags & NDR_SCALARS) {
12576                 int level = ndr_push_get_switch_value(ndr, r);
12577                 switch (level) {
12578                         case 1: {
12579                                 NDR_CHECK(ndr_push_align(ndr, 4));
12580                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12581                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
12582                         break; }
12583
12584                         default: {
12585                         break; }
12586
12587                 }
12588         }
12589         if (ndr_flags & NDR_BUFFERS) {
12590                 int level = ndr_push_get_switch_value(ndr, r);
12591                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12592                 switch (level) {
12593                         case 1:
12594                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
12595                         break;
12596
12597                         default:
12598                         break;
12599
12600                 }
12601         }
12602         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12603         return NDR_ERR_SUCCESS;
12604 }
12605
12606 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
12607 {
12608         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12609         int level;
12610         level = ndr_pull_get_switch_value(ndr, r);
12611         if (ndr_flags & NDR_SCALARS) {
12612                 switch (level) {
12613                         case 1: {
12614                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12615                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12616                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
12617                         break; }
12618
12619                         default: {
12620                         break; }
12621
12622                 }
12623         }
12624         if (ndr_flags & NDR_BUFFERS) {
12625                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12626                 switch (level) {
12627                         case 1:
12628                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
12629                         break;
12630
12631                         default:
12632                         break;
12633
12634                 }
12635         }
12636         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12637         return NDR_ERR_SUCCESS;
12638 }
12639
12640 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
12641 {
12642         int level;
12643         level = ndr_print_get_switch_value(ndr, r);
12644         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
12645         switch (level) {
12646                 case 1:
12647                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
12648                 break;
12649
12650                 default:
12651                 break;
12652
12653         }
12654 }
12655
12656 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
12657 {
12658         if (ndr_flags & NDR_SCALARS) {
12659                 NDR_CHECK(ndr_push_align(ndr, 4));
12660                 {
12661                         uint32_t _flags_save_string = ndr->flags;
12662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12663                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
12664                         ndr->flags = _flags_save_string;
12665                 }
12666         }
12667         if (ndr_flags & NDR_BUFFERS) {
12668         }
12669         return NDR_ERR_SUCCESS;
12670 }
12671
12672 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
12673 {
12674         if (ndr_flags & NDR_SCALARS) {
12675                 NDR_CHECK(ndr_pull_align(ndr, 4));
12676                 {
12677                         uint32_t _flags_save_string = ndr->flags;
12678                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12679                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
12680                         ndr->flags = _flags_save_string;
12681                 }
12682         }
12683         if (ndr_flags & NDR_BUFFERS) {
12684         }
12685         return NDR_ERR_SUCCESS;
12686 }
12687
12688 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
12689 {
12690         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
12691         ndr->depth++;
12692         ndr_print_string(ndr, "directory_name", r->directory_name);
12693         ndr->depth--;
12694 }
12695
12696 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
12697 {
12698         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
12699 }
12700
12701 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
12702 {
12703         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
12704         if (ndr_flags & NDR_SCALARS) {
12705                 int level = ndr_push_get_switch_value(ndr, r);
12706                 switch (level) {
12707                         case 1: {
12708                                 NDR_CHECK(ndr_push_align(ndr, 4));
12709                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12710                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12711                         break; }
12712
12713                         default: {
12714                                 NDR_CHECK(ndr_push_align(ndr, 4));
12715                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
12716                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12717                         break; }
12718
12719                 }
12720         }
12721         if (ndr_flags & NDR_BUFFERS) {
12722                 int level = ndr_push_get_switch_value(ndr, r);
12723                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
12724                 switch (level) {
12725                         case 1:
12726                         break;
12727
12728                         default:
12729                         break;
12730
12731                 }
12732         }
12733         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
12734         return NDR_ERR_SUCCESS;
12735 }
12736
12737 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
12738 {
12739         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
12740         int level;
12741         level = ndr_pull_get_switch_value(ndr, r);
12742         if (ndr_flags & NDR_SCALARS) {
12743                 switch (level) {
12744                         case 1: {
12745                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12746                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12747                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12748                         break; }
12749
12750                         default: {
12751                                 NDR_CHECK(ndr_pull_align(ndr, 4));
12752                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
12753                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
12754                         break; }
12755
12756                 }
12757         }
12758         if (ndr_flags & NDR_BUFFERS) {
12759                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
12760                 switch (level) {
12761                         case 1:
12762                         break;
12763
12764                         default:
12765                         break;
12766
12767                 }
12768         }
12769         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
12770         return NDR_ERR_SUCCESS;
12771 }
12772
12773 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
12774 {
12775         int level;
12776         level = ndr_print_get_switch_value(ndr, r);
12777         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
12778         switch (level) {
12779                 case 1:
12780                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
12781                 break;
12782
12783                 default:
12784                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
12785                 break;
12786
12787         }
12788 }
12789
12790 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
12791 {
12792         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
12793 }
12794
12795 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
12796 {
12797         if (ndr_flags & NDR_SCALARS) {
12798                 NDR_CHECK(ndr_push_align(ndr, 4));
12799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
12800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
12801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
12802         }
12803         if (ndr_flags & NDR_BUFFERS) {
12804                 if (r->document_name) {
12805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
12806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12807                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
12808                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12809                 }
12810                 if (r->output_file) {
12811                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
12812                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12813                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
12814                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12815                 }
12816                 if (r->datatype) {
12817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
12818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12819                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
12820                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12821                 }
12822         }
12823         return NDR_ERR_SUCCESS;
12824 }
12825
12826 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
12827 {
12828         uint32_t _ptr_document_name;
12829         TALLOC_CTX *_mem_save_document_name_0;
12830         uint32_t _ptr_output_file;
12831         TALLOC_CTX *_mem_save_output_file_0;
12832         uint32_t _ptr_datatype;
12833         TALLOC_CTX *_mem_save_datatype_0;
12834         if (ndr_flags & NDR_SCALARS) {
12835                 NDR_CHECK(ndr_pull_align(ndr, 4));
12836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
12837                 if (_ptr_document_name) {
12838                         NDR_PULL_ALLOC(ndr, r->document_name);
12839                 } else {
12840                         r->document_name = NULL;
12841                 }
12842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
12843                 if (_ptr_output_file) {
12844                         NDR_PULL_ALLOC(ndr, r->output_file);
12845                 } else {
12846                         r->output_file = NULL;
12847                 }
12848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
12849                 if (_ptr_datatype) {
12850                         NDR_PULL_ALLOC(ndr, r->datatype);
12851                 } else {
12852                         r->datatype = NULL;
12853                 }
12854         }
12855         if (ndr_flags & NDR_BUFFERS) {
12856                 if (r->document_name) {
12857                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12858                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
12859                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
12860                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
12861                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
12862                                 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));
12863                         }
12864                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
12865                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
12866                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
12867                 }
12868                 if (r->output_file) {
12869                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12870                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
12871                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
12872                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
12873                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
12874                                 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));
12875                         }
12876                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
12877                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
12878                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
12879                 }
12880                 if (r->datatype) {
12881                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12882                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
12883                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
12884                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
12885                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
12886                                 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));
12887                         }
12888                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
12889                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
12890                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
12891                 }
12892         }
12893         return NDR_ERR_SUCCESS;
12894 }
12895
12896 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
12897 {
12898         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
12899         ndr->depth++;
12900         ndr_print_ptr(ndr, "document_name", r->document_name);
12901         ndr->depth++;
12902         if (r->document_name) {
12903                 ndr_print_string(ndr, "document_name", r->document_name);
12904         }
12905         ndr->depth--;
12906         ndr_print_ptr(ndr, "output_file", r->output_file);
12907         ndr->depth++;
12908         if (r->output_file) {
12909                 ndr_print_string(ndr, "output_file", r->output_file);
12910         }
12911         ndr->depth--;
12912         ndr_print_ptr(ndr, "datatype", r->datatype);
12913         ndr->depth++;
12914         if (r->datatype) {
12915                 ndr_print_string(ndr, "datatype", r->datatype);
12916         }
12917         ndr->depth--;
12918         ndr->depth--;
12919 }
12920
12921 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
12922 {
12923         if (ndr_flags & NDR_SCALARS) {
12924                 int level = ndr_push_get_switch_value(ndr, r);
12925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
12926                 switch (level) {
12927                         case 1: {
12928                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
12929                         break; }
12930
12931                         case 2: {
12932                         break; }
12933
12934                         case 3: {
12935                         break; }
12936
12937                         default: {
12938                         break; }
12939
12940                 }
12941         }
12942         if (ndr_flags & NDR_BUFFERS) {
12943                 int level = ndr_push_get_switch_value(ndr, r);
12944                 switch (level) {
12945                         case 1:
12946                                 if (r->info1) {
12947                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
12948                                 }
12949                         break;
12950
12951                         case 2:
12952                         break;
12953
12954                         case 3:
12955                         break;
12956
12957                         default:
12958                         break;
12959
12960                 }
12961         }
12962         return NDR_ERR_SUCCESS;
12963 }
12964
12965 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
12966 {
12967         int level;
12968         uint32_t _level;
12969         TALLOC_CTX *_mem_save_info1_0;
12970         level = ndr_pull_get_switch_value(ndr, r);
12971         if (ndr_flags & NDR_SCALARS) {
12972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
12973                 if (_level != level) {
12974                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
12975                 }
12976                 switch (level) {
12977                         case 1: {
12978                                 uint32_t _ptr_info1;
12979                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
12980                                 if (_ptr_info1) {
12981                                         NDR_PULL_ALLOC(ndr, r->info1);
12982                                 } else {
12983                                         r->info1 = NULL;
12984                                 }
12985                         break; }
12986
12987                         case 2: {
12988                         break; }
12989
12990                         case 3: {
12991                         break; }
12992
12993                         default: {
12994                         break; }
12995
12996                 }
12997         }
12998         if (ndr_flags & NDR_BUFFERS) {
12999                 switch (level) {
13000                         case 1:
13001                                 if (r->info1) {
13002                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
13003                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
13004                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
13005                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
13006                                 }
13007                         break;
13008
13009                         case 2:
13010                         break;
13011
13012                         case 3:
13013                         break;
13014
13015                         default:
13016                         break;
13017
13018                 }
13019         }
13020         return NDR_ERR_SUCCESS;
13021 }
13022
13023 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
13024 {
13025         int level;
13026         level = ndr_print_get_switch_value(ndr, r);
13027         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
13028         switch (level) {
13029                 case 1:
13030                         ndr_print_ptr(ndr, "info1", r->info1);
13031                         ndr->depth++;
13032                         if (r->info1) {
13033                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
13034                         }
13035                         ndr->depth--;
13036                 break;
13037
13038                 case 2:
13039                 break;
13040
13041                 case 3:
13042                 break;
13043
13044                 default:
13045                 break;
13046
13047         }
13048 }
13049
13050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
13051 {
13052         if (ndr_flags & NDR_SCALARS) {
13053                 NDR_CHECK(ndr_push_align(ndr, 4));
13054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
13055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
13056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
13057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13059                 {
13060                         uint32_t _flags_save_string = ndr->flags;
13061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13062                         {
13063                                 struct ndr_push *_ndr_extra_string;
13064                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
13065                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
13066                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
13067                         }
13068                         ndr->flags = _flags_save_string;
13069                 }
13070         }
13071         if (ndr_flags & NDR_BUFFERS) {
13072         }
13073         return NDR_ERR_SUCCESS;
13074 }
13075
13076 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
13077 {
13078         if (ndr_flags & NDR_SCALARS) {
13079                 NDR_CHECK(ndr_pull_align(ndr, 4));
13080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
13081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
13082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
13083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
13085                 {
13086                         uint32_t _flags_save_string = ndr->flags;
13087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13088                         {
13089                                 struct ndr_pull *_ndr_extra_string;
13090                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
13091                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
13092                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
13093                         }
13094                         ndr->flags = _flags_save_string;
13095                 }
13096         }
13097         if (ndr_flags & NDR_BUFFERS) {
13098         }
13099         return NDR_ERR_SUCCESS;
13100 }
13101
13102 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
13103 {
13104         ndr_print_struct(ndr, name, "spoolss_OSVersion");
13105         ndr->depth++;
13106         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);
13107         ndr_print_uint32(ndr, "major", r->major);
13108         ndr_print_uint32(ndr, "minor", r->minor);
13109         ndr_print_uint32(ndr, "build", r->build);
13110         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
13111         ndr_print_string(ndr, "extra_string", r->extra_string);
13112         ndr->depth--;
13113 }
13114
13115 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
13116 {
13117         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
13118 }
13119
13120 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
13121 {
13122         if (ndr_flags & NDR_SCALARS) {
13123                 NDR_CHECK(ndr_push_align(ndr, 4));
13124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
13125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
13126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
13127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
13128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
13129                 {
13130                         uint32_t _flags_save_string = ndr->flags;
13131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13132                         {
13133                                 struct ndr_push *_ndr_extra_string;
13134                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
13135                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
13136                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
13137                         }
13138                         ndr->flags = _flags_save_string;
13139                 }
13140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
13141                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
13142         }
13143         if (ndr_flags & NDR_BUFFERS) {
13144         }
13145         return NDR_ERR_SUCCESS;
13146 }
13147
13148 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
13149 {
13150         if (ndr_flags & NDR_SCALARS) {
13151                 NDR_CHECK(ndr_pull_align(ndr, 4));
13152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
13153                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
13154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
13155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
13156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
13157                 {
13158                         uint32_t _flags_save_string = ndr->flags;
13159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13160                         {
13161                                 struct ndr_pull *_ndr_extra_string;
13162                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
13163                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
13164                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
13165                         }
13166                         ndr->flags = _flags_save_string;
13167                 }
13168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
13169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
13170         }
13171         if (ndr_flags & NDR_BUFFERS) {
13172         }
13173         return NDR_ERR_SUCCESS;
13174 }
13175
13176 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
13177 {
13178         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
13179         ndr->depth++;
13180         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);
13181         ndr_print_uint32(ndr, "major", r->major);
13182         ndr_print_uint32(ndr, "minor", r->minor);
13183         ndr_print_uint32(ndr, "build", r->build);
13184         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
13185         ndr_print_string(ndr, "extra_string", r->extra_string);
13186         ndr_print_uint32(ndr, "unknown2", r->unknown2);
13187         ndr_print_uint32(ndr, "unknown3", r->unknown3);
13188         ndr->depth--;
13189 }
13190
13191 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
13192 {
13193         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
13194 }
13195
13196 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
13197 {
13198         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13199         return NDR_ERR_SUCCESS;
13200 }
13201
13202 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
13203 {
13204         uint32_t v;
13205         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13206         *r = v;
13207         return NDR_ERR_SUCCESS;
13208 }
13209
13210 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
13211 {
13212         const char *val = NULL;
13213
13214         switch (r) {
13215                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
13216                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
13217                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
13218                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
13219                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
13220         }
13221         ndr_print_enum(ndr, name, "ENUM", val, r);
13222 }
13223
13224 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
13225 {
13226         if (ndr_flags & NDR_SCALARS) {
13227                 int level = ndr_push_get_switch_value(ndr, r);
13228                 switch (level) {
13229                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
13230                         break; }
13231
13232                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
13233                                 {
13234                                         uint32_t _flags_save_string = ndr->flags;
13235                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13236                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
13237                                         ndr->flags = _flags_save_string;
13238                                 }
13239                         break; }
13240
13241                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
13242                                 {
13243                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
13244                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
13245                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
13246                                         ndr->flags = _flags_save_DATA_BLOB;
13247                                 }
13248                         break; }
13249
13250                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
13251                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
13252                         break; }
13253
13254                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
13255                                 {
13256                                         uint32_t _flags_save_string_array = ndr->flags;
13257                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13258                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
13259                                         ndr->flags = _flags_save_string_array;
13260                                 }
13261                         break; }
13262
13263                         default: {
13264                                 {
13265                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
13266                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
13267                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
13268                                         ndr->flags = _flags_save_DATA_BLOB;
13269                                 }
13270                         break; }
13271
13272                 }
13273         }
13274         if (ndr_flags & NDR_BUFFERS) {
13275                 int level = ndr_push_get_switch_value(ndr, r);
13276                 switch (level) {
13277                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
13278                         break;
13279
13280                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
13281                         break;
13282
13283                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
13284                         break;
13285
13286                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
13287                         break;
13288
13289                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
13290                         break;
13291
13292                         default:
13293                         break;
13294
13295                 }
13296         }
13297         return NDR_ERR_SUCCESS;
13298 }
13299
13300 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
13301 {
13302         int level;
13303         level = ndr_pull_get_switch_value(ndr, r);
13304         if (ndr_flags & NDR_SCALARS) {
13305                 switch (level) {
13306                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
13307                         break; }
13308
13309                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
13310                                 {
13311                                         uint32_t _flags_save_string = ndr->flags;
13312                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13313                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
13314                                         ndr->flags = _flags_save_string;
13315                                 }
13316                         break; }
13317
13318                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
13319                                 {
13320                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
13321                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
13322                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
13323                                         ndr->flags = _flags_save_DATA_BLOB;
13324                                 }
13325                         break; }
13326
13327                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
13328                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
13329                         break; }
13330
13331                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
13332                                 {
13333                                         uint32_t _flags_save_string_array = ndr->flags;
13334                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13335                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
13336                                         ndr->flags = _flags_save_string_array;
13337                                 }
13338                         break; }
13339
13340                         default: {
13341                                 {
13342                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
13343                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
13344                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
13345                                         ndr->flags = _flags_save_DATA_BLOB;
13346                                 }
13347                         break; }
13348
13349                 }
13350         }
13351         if (ndr_flags & NDR_BUFFERS) {
13352                 switch (level) {
13353                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
13354                         break;
13355
13356                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
13357                         break;
13358
13359                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
13360                         break;
13361
13362                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
13363                         break;
13364
13365                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
13366                         break;
13367
13368                         default:
13369                         break;
13370
13371                 }
13372         }
13373         return NDR_ERR_SUCCESS;
13374 }
13375
13376 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
13377 {
13378         int level;
13379         level = ndr_print_get_switch_value(ndr, r);
13380         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
13381         switch (level) {
13382                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
13383                 break;
13384
13385                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
13386                         ndr_print_string(ndr, "string", r->string);
13387                 break;
13388
13389                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
13390                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
13391                 break;
13392
13393                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
13394                         ndr_print_uint32(ndr, "value", r->value);
13395                 break;
13396
13397                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
13398                         ndr_print_string_array(ndr, "string_array", r->string_array);
13399                 break;
13400
13401                 default:
13402                         ndr_print_DATA_BLOB(ndr, "data", r->data);
13403                 break;
13404
13405         }
13406 }
13407
13408 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13409 {
13410         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
13411 }
13412
13413 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
13414 {
13415         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13416         return NDR_ERR_SUCCESS;
13417 }
13418
13419 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
13420 {
13421         uint32_t v;
13422         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13423         *r = v;
13424         return NDR_ERR_SUCCESS;
13425 }
13426
13427 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
13428 {
13429         const char *val = NULL;
13430
13431         switch (r) {
13432                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
13433                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
13434                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
13435         }
13436         ndr_print_enum(ndr, name, "ENUM", val, r);
13437 }
13438
13439 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
13440 {
13441         if (ndr_flags & NDR_SCALARS) {
13442                 NDR_CHECK(ndr_push_align(ndr, 4));
13443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
13444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
13445         }
13446         if (ndr_flags & NDR_BUFFERS) {
13447         }
13448         return NDR_ERR_SUCCESS;
13449 }
13450
13451 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
13452 {
13453         if (ndr_flags & NDR_SCALARS) {
13454                 NDR_CHECK(ndr_pull_align(ndr, 4));
13455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
13456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
13457         }
13458         if (ndr_flags & NDR_BUFFERS) {
13459         }
13460         return NDR_ERR_SUCCESS;
13461 }
13462
13463 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
13464 {
13465         ndr_print_struct(ndr, name, "spoolss_FormSize");
13466         ndr->depth++;
13467         ndr_print_uint32(ndr, "width", r->width);
13468         ndr_print_uint32(ndr, "height", r->height);
13469         ndr->depth--;
13470 }
13471
13472 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
13473 {
13474         if (ndr_flags & NDR_SCALARS) {
13475                 NDR_CHECK(ndr_push_align(ndr, 4));
13476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
13477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
13478                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
13479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
13480         }
13481         if (ndr_flags & NDR_BUFFERS) {
13482         }
13483         return NDR_ERR_SUCCESS;
13484 }
13485
13486 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
13487 {
13488         if (ndr_flags & NDR_SCALARS) {
13489                 NDR_CHECK(ndr_pull_align(ndr, 4));
13490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
13491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
13492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
13493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
13494         }
13495         if (ndr_flags & NDR_BUFFERS) {
13496         }
13497         return NDR_ERR_SUCCESS;
13498 }
13499
13500 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
13501 {
13502         ndr_print_struct(ndr, name, "spoolss_FormArea");
13503         ndr->depth++;
13504         ndr_print_uint32(ndr, "left", r->left);
13505         ndr_print_uint32(ndr, "top", r->top);
13506         ndr_print_uint32(ndr, "right", r->right);
13507         ndr_print_uint32(ndr, "bottom", r->bottom);
13508         ndr->depth--;
13509 }
13510
13511 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
13512 {
13513         if (ndr_flags & NDR_SCALARS) {
13514                 NDR_CHECK(ndr_push_align(ndr, 4));
13515                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
13516                 {
13517                         uint32_t _flags_save_string = ndr->flags;
13518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
13520                         ndr->flags = _flags_save_string;
13521                 }
13522                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
13523                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
13524         }
13525         if (ndr_flags & NDR_BUFFERS) {
13526                 {
13527                         uint32_t _flags_save_string = ndr->flags;
13528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13529                         if (r->form_name) {
13530                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
13531                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
13532                         }
13533                         ndr->flags = _flags_save_string;
13534                 }
13535         }
13536         return NDR_ERR_SUCCESS;
13537 }
13538
13539 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
13540 {
13541         uint32_t _ptr_form_name;
13542         TALLOC_CTX *_mem_save_form_name_0;
13543         if (ndr_flags & NDR_SCALARS) {
13544                 NDR_CHECK(ndr_pull_align(ndr, 4));
13545                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
13546                 {
13547                         uint32_t _flags_save_string = ndr->flags;
13548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
13550                         if (_ptr_form_name) {
13551                                 NDR_PULL_ALLOC(ndr, r->form_name);
13552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
13553                         } else {
13554                                 r->form_name = NULL;
13555                         }
13556                         ndr->flags = _flags_save_string;
13557                 }
13558                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
13559                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
13560         }
13561         if (ndr_flags & NDR_BUFFERS) {
13562                 {
13563                         uint32_t _flags_save_string = ndr->flags;
13564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13565                         if (r->form_name) {
13566                                 uint32_t _relative_save_offset;
13567                                 _relative_save_offset = ndr->offset;
13568                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
13569                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13570                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
13571                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
13572                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
13573                                 ndr->offset = _relative_save_offset;
13574                         }
13575                         ndr->flags = _flags_save_string;
13576                 }
13577         }
13578         return NDR_ERR_SUCCESS;
13579 }
13580
13581 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
13582 {
13583         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
13584         ndr->depth++;
13585         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
13586         ndr_print_ptr(ndr, "form_name", r->form_name);
13587         ndr->depth++;
13588         if (r->form_name) {
13589                 ndr_print_string(ndr, "form_name", r->form_name);
13590         }
13591         ndr->depth--;
13592         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
13593         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
13594         ndr->depth--;
13595 }
13596
13597 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
13598 {
13599         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13600         return NDR_ERR_SUCCESS;
13601 }
13602
13603 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
13604 {
13605         uint32_t v;
13606         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13607         *r = v;
13608         return NDR_ERR_SUCCESS;
13609 }
13610
13611 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
13612 {
13613         ndr_print_uint32(ndr, name, r);
13614         ndr->depth++;
13615         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
13616         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
13617         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
13618         ndr->depth--;
13619 }
13620
13621 static enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
13622 {
13623         if (ndr_flags & NDR_SCALARS) {
13624                 NDR_CHECK(ndr_push_align(ndr, 4));
13625                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
13626                 {
13627                         uint32_t _flags_save_string = ndr->flags;
13628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13629                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
13630                         ndr->flags = _flags_save_string;
13631                 }
13632                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
13633                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
13634                 {
13635                         uint32_t _flags_save_string = ndr->flags;
13636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
13637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
13638                         ndr->flags = _flags_save_string;
13639                 }
13640                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
13641                 {
13642                         uint32_t _flags_save_string = ndr->flags;
13643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
13645                         ndr->flags = _flags_save_string;
13646                 }
13647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
13648                 {
13649                         uint32_t _flags_save_string = ndr->flags;
13650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
13652                         ndr->flags = _flags_save_string;
13653                 }
13654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
13655         }
13656         if (ndr_flags & NDR_BUFFERS) {
13657                 {
13658                         uint32_t _flags_save_string = ndr->flags;
13659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13660                         if (r->form_name) {
13661                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
13662                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
13663                         }
13664                         ndr->flags = _flags_save_string;
13665                 }
13666                 {
13667                         uint32_t _flags_save_string = ndr->flags;
13668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
13669                         if (r->keyword) {
13670                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
13671                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
13672                         }
13673                         ndr->flags = _flags_save_string;
13674                 }
13675                 {
13676                         uint32_t _flags_save_string = ndr->flags;
13677                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13678                         if (r->mui_dll) {
13679                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
13680                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
13681                         }
13682                         ndr->flags = _flags_save_string;
13683                 }
13684                 {
13685                         uint32_t _flags_save_string = ndr->flags;
13686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13687                         if (r->display_name) {
13688                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
13689                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
13690                         }
13691                         ndr->flags = _flags_save_string;
13692                 }
13693         }
13694         return NDR_ERR_SUCCESS;
13695 }
13696
13697 static enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
13698 {
13699         uint32_t _ptr_form_name;
13700         TALLOC_CTX *_mem_save_form_name_0;
13701         uint32_t _ptr_keyword;
13702         TALLOC_CTX *_mem_save_keyword_0;
13703         uint32_t _ptr_mui_dll;
13704         TALLOC_CTX *_mem_save_mui_dll_0;
13705         uint32_t _ptr_display_name;
13706         TALLOC_CTX *_mem_save_display_name_0;
13707         if (ndr_flags & NDR_SCALARS) {
13708                 NDR_CHECK(ndr_pull_align(ndr, 4));
13709                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
13710                 {
13711                         uint32_t _flags_save_string = ndr->flags;
13712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13713                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
13714                         if (_ptr_form_name) {
13715                                 NDR_PULL_ALLOC(ndr, r->form_name);
13716                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
13717                         } else {
13718                                 r->form_name = NULL;
13719                         }
13720                         ndr->flags = _flags_save_string;
13721                 }
13722                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
13723                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
13724                 {
13725                         uint32_t _flags_save_string = ndr->flags;
13726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
13727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
13728                         if (_ptr_keyword) {
13729                                 NDR_PULL_ALLOC(ndr, r->keyword);
13730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
13731                         } else {
13732                                 r->keyword = NULL;
13733                         }
13734                         ndr->flags = _flags_save_string;
13735                 }
13736                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
13737                 {
13738                         uint32_t _flags_save_string = ndr->flags;
13739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13740                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
13741                         if (_ptr_mui_dll) {
13742                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
13743                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
13744                         } else {
13745                                 r->mui_dll = NULL;
13746                         }
13747                         ndr->flags = _flags_save_string;
13748                 }
13749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
13750                 {
13751                         uint32_t _flags_save_string = ndr->flags;
13752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13753                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
13754                         if (_ptr_display_name) {
13755                                 NDR_PULL_ALLOC(ndr, r->display_name);
13756                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
13757                         } else {
13758                                 r->display_name = NULL;
13759                         }
13760                         ndr->flags = _flags_save_string;
13761                 }
13762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
13763         }
13764         if (ndr_flags & NDR_BUFFERS) {
13765                 {
13766                         uint32_t _flags_save_string = ndr->flags;
13767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13768                         if (r->form_name) {
13769                                 uint32_t _relative_save_offset;
13770                                 _relative_save_offset = ndr->offset;
13771                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
13772                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13773                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
13774                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
13775                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
13776                                 ndr->offset = _relative_save_offset;
13777                         }
13778                         ndr->flags = _flags_save_string;
13779                 }
13780                 {
13781                         uint32_t _flags_save_string = ndr->flags;
13782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
13783                         if (r->keyword) {
13784                                 uint32_t _relative_save_offset;
13785                                 _relative_save_offset = ndr->offset;
13786                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
13787                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
13788                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
13789                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
13790                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
13791                                 ndr->offset = _relative_save_offset;
13792                         }
13793                         ndr->flags = _flags_save_string;
13794                 }
13795                 {
13796                         uint32_t _flags_save_string = ndr->flags;
13797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13798                         if (r->mui_dll) {
13799                                 uint32_t _relative_save_offset;
13800                                 _relative_save_offset = ndr->offset;
13801                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
13802                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
13803                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
13804                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
13805                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
13806                                 ndr->offset = _relative_save_offset;
13807                         }
13808                         ndr->flags = _flags_save_string;
13809                 }
13810                 {
13811                         uint32_t _flags_save_string = ndr->flags;
13812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13813                         if (r->display_name) {
13814                                 uint32_t _relative_save_offset;
13815                                 _relative_save_offset = ndr->offset;
13816                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
13817                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13818                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
13819                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
13820                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
13821                                 ndr->offset = _relative_save_offset;
13822                         }
13823                         ndr->flags = _flags_save_string;
13824                 }
13825         }
13826         return NDR_ERR_SUCCESS;
13827 }
13828
13829 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
13830 {
13831         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
13832         ndr->depth++;
13833         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
13834         ndr_print_ptr(ndr, "form_name", r->form_name);
13835         ndr->depth++;
13836         if (r->form_name) {
13837                 ndr_print_string(ndr, "form_name", r->form_name);
13838         }
13839         ndr->depth--;
13840         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
13841         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
13842         ndr_print_ptr(ndr, "keyword", r->keyword);
13843         ndr->depth++;
13844         if (r->keyword) {
13845                 ndr_print_string(ndr, "keyword", r->keyword);
13846         }
13847         ndr->depth--;
13848         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
13849         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
13850         ndr->depth++;
13851         if (r->mui_dll) {
13852                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
13853         }
13854         ndr->depth--;
13855         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
13856         ndr_print_ptr(ndr, "display_name", r->display_name);
13857         ndr->depth++;
13858         if (r->display_name) {
13859                 ndr_print_string(ndr, "display_name", r->display_name);
13860         }
13861         ndr->depth--;
13862         ndr_print_uint32(ndr, "lang_id", r->lang_id);
13863         ndr->depth--;
13864 }
13865
13866 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
13867 {
13868         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13869         if (ndr_flags & NDR_SCALARS) {
13870                 int level = ndr_push_get_switch_value(ndr, r);
13871                 switch (level) {
13872                         case 1: {
13873                                 NDR_CHECK(ndr_push_align(ndr, 4));
13874                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13875                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
13876                         break; }
13877
13878                         case 2: {
13879                                 NDR_CHECK(ndr_push_align(ndr, 4));
13880                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13881                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
13882                         break; }
13883
13884                         default: {
13885                         break; }
13886
13887                 }
13888         }
13889         if (ndr_flags & NDR_BUFFERS) {
13890                 int level = ndr_push_get_switch_value(ndr, r);
13891                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13892                 switch (level) {
13893                         case 1:
13894                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
13895                         break;
13896
13897                         case 2:
13898                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
13899                         break;
13900
13901                         default:
13902                         break;
13903
13904                 }
13905         }
13906         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13907         return NDR_ERR_SUCCESS;
13908 }
13909
13910 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
13911 {
13912         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13913         int level;
13914         level = ndr_pull_get_switch_value(ndr, r);
13915         if (ndr_flags & NDR_SCALARS) {
13916                 switch (level) {
13917                         case 1: {
13918                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13919                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13920                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
13921                         break; }
13922
13923                         case 2: {
13924                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13925                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13926                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
13927                         break; }
13928
13929                         default: {
13930                         break; }
13931
13932                 }
13933         }
13934         if (ndr_flags & NDR_BUFFERS) {
13935                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13936                 switch (level) {
13937                         case 1:
13938                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
13939                         break;
13940
13941                         case 2:
13942                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
13943                         break;
13944
13945                         default:
13946                         break;
13947
13948                 }
13949         }
13950         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13951         return NDR_ERR_SUCCESS;
13952 }
13953
13954 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
13955 {
13956         int level;
13957         level = ndr_print_get_switch_value(ndr, r);
13958         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
13959         switch (level) {
13960                 case 1:
13961                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
13962                 break;
13963
13964                 case 2:
13965                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
13966                 break;
13967
13968                 default:
13969                 break;
13970
13971         }
13972 }
13973
13974 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13975 {
13976         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
13977 }
13978
13979 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
13980 {
13981         if (ndr_flags & NDR_SCALARS) {
13982                 NDR_CHECK(ndr_push_align(ndr, 4));
13983                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
13984                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
13985                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
13986                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
13987         }
13988         if (ndr_flags & NDR_BUFFERS) {
13989                 if (r->form_name) {
13990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
13991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
13993                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13994                 }
13995         }
13996         return NDR_ERR_SUCCESS;
13997 }
13998
13999 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
14000 {
14001         uint32_t _ptr_form_name;
14002         TALLOC_CTX *_mem_save_form_name_0;
14003         if (ndr_flags & NDR_SCALARS) {
14004                 NDR_CHECK(ndr_pull_align(ndr, 4));
14005                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14007                 if (_ptr_form_name) {
14008                         NDR_PULL_ALLOC(ndr, r->form_name);
14009                 } else {
14010                         r->form_name = NULL;
14011                 }
14012                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14013                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14014         }
14015         if (ndr_flags & NDR_BUFFERS) {
14016                 if (r->form_name) {
14017                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14018                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14019                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
14020                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
14021                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
14022                                 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));
14023                         }
14024                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
14025                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
14026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14027                 }
14028         }
14029         return NDR_ERR_SUCCESS;
14030 }
14031
14032 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
14033 {
14034         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
14035         ndr->depth++;
14036         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14037         ndr_print_ptr(ndr, "form_name", r->form_name);
14038         ndr->depth++;
14039         if (r->form_name) {
14040                 ndr_print_string(ndr, "form_name", r->form_name);
14041         }
14042         ndr->depth--;
14043         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14044         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14045         ndr->depth--;
14046 }
14047
14048 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
14049 {
14050         if (ndr_flags & NDR_SCALARS) {
14051                 NDR_CHECK(ndr_push_align(ndr, 4));
14052                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14053                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
14054                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14055                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14056                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
14057                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
14059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
14061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14062         }
14063         if (ndr_flags & NDR_BUFFERS) {
14064                 if (r->form_name) {
14065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
14066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
14068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14069                 }
14070                 if (r->keyword) {
14071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
14072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
14074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
14075                 }
14076                 if (r->mui_dll) {
14077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
14078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
14080                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14081                 }
14082                 if (r->display_name) {
14083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
14084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
14086                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14087                 }
14088         }
14089         return NDR_ERR_SUCCESS;
14090 }
14091
14092 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
14093 {
14094         uint32_t _ptr_form_name;
14095         TALLOC_CTX *_mem_save_form_name_0;
14096         uint32_t _ptr_keyword;
14097         TALLOC_CTX *_mem_save_keyword_0;
14098         uint32_t _ptr_mui_dll;
14099         TALLOC_CTX *_mem_save_mui_dll_0;
14100         uint32_t _ptr_display_name;
14101         TALLOC_CTX *_mem_save_display_name_0;
14102         if (ndr_flags & NDR_SCALARS) {
14103                 NDR_CHECK(ndr_pull_align(ndr, 4));
14104                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14106                 if (_ptr_form_name) {
14107                         NDR_PULL_ALLOC(ndr, r->form_name);
14108                 } else {
14109                         r->form_name = NULL;
14110                 }
14111                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14112                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14113                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
14114                 if (_ptr_keyword) {
14115                         NDR_PULL_ALLOC(ndr, r->keyword);
14116                 } else {
14117                         r->keyword = NULL;
14118                 }
14119                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
14120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
14121                 if (_ptr_mui_dll) {
14122                         NDR_PULL_ALLOC(ndr, r->mui_dll);
14123                 } else {
14124                         r->mui_dll = NULL;
14125                 }
14126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
14127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
14128                 if (_ptr_display_name) {
14129                         NDR_PULL_ALLOC(ndr, r->display_name);
14130                 } else {
14131                         r->display_name = NULL;
14132                 }
14133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
14134         }
14135         if (ndr_flags & NDR_BUFFERS) {
14136                 if (r->form_name) {
14137                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14138                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
14140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
14141                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
14142                                 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));
14143                         }
14144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
14145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
14146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14147                 }
14148                 if (r->keyword) {
14149                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
14150                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
14151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
14152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
14153                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
14154                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->keyword), ndr_get_array_length(ndr, &r->keyword));
14155                         }
14156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
14157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
14158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
14159                 }
14160                 if (r->mui_dll) {
14161                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
14162                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
14163                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
14164                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
14165                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
14166                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->mui_dll), ndr_get_array_length(ndr, &r->mui_dll));
14167                         }
14168                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
14169                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
14170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
14171                 }
14172                 if (r->display_name) {
14173                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14174                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
14175                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
14176                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
14177                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
14178                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->display_name), ndr_get_array_length(ndr, &r->display_name));
14179                         }
14180                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
14181                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
14182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
14183                 }
14184         }
14185         return NDR_ERR_SUCCESS;
14186 }
14187
14188 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
14189 {
14190         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
14191         ndr->depth++;
14192         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14193         ndr_print_ptr(ndr, "form_name", r->form_name);
14194         ndr->depth++;
14195         if (r->form_name) {
14196                 ndr_print_string(ndr, "form_name", r->form_name);
14197         }
14198         ndr->depth--;
14199         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14200         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14201         ndr_print_ptr(ndr, "keyword", r->keyword);
14202         ndr->depth++;
14203         if (r->keyword) {
14204                 ndr_print_string(ndr, "keyword", r->keyword);
14205         }
14206         ndr->depth--;
14207         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
14208         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
14209         ndr->depth++;
14210         if (r->mui_dll) {
14211                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
14212         }
14213         ndr->depth--;
14214         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
14215         ndr_print_ptr(ndr, "display_name", r->display_name);
14216         ndr->depth++;
14217         if (r->display_name) {
14218                 ndr_print_string(ndr, "display_name", r->display_name);
14219         }
14220         ndr->depth--;
14221         ndr_print_uint32(ndr, "lang_id", r->lang_id);
14222         ndr->depth--;
14223 }
14224
14225 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
14226 {
14227         if (ndr_flags & NDR_SCALARS) {
14228                 int level = ndr_push_get_switch_value(ndr, r);
14229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14230                 switch (level) {
14231                         case 1: {
14232                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14233                         break; }
14234
14235                         case 2: {
14236                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
14237                         break; }
14238
14239                         default:
14240                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14241                 }
14242         }
14243         if (ndr_flags & NDR_BUFFERS) {
14244                 int level = ndr_push_get_switch_value(ndr, r);
14245                 switch (level) {
14246                         case 1:
14247                                 if (r->info1) {
14248                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14249                                 }
14250                         break;
14251
14252                         case 2:
14253                                 if (r->info2) {
14254                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
14255                                 }
14256                         break;
14257
14258                         default:
14259                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14260                 }
14261         }
14262         return NDR_ERR_SUCCESS;
14263 }
14264
14265 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
14266 {
14267         int level;
14268         uint32_t _level;
14269         TALLOC_CTX *_mem_save_info1_0;
14270         TALLOC_CTX *_mem_save_info2_0;
14271         level = ndr_pull_get_switch_value(ndr, r);
14272         if (ndr_flags & NDR_SCALARS) {
14273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14274                 if (_level != level) {
14275                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14276                 }
14277                 switch (level) {
14278                         case 1: {
14279                                 uint32_t _ptr_info1;
14280                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14281                                 if (_ptr_info1) {
14282                                         NDR_PULL_ALLOC(ndr, r->info1);
14283                                 } else {
14284                                         r->info1 = NULL;
14285                                 }
14286                         break; }
14287
14288                         case 2: {
14289                                 uint32_t _ptr_info2;
14290                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
14291                                 if (_ptr_info2) {
14292                                         NDR_PULL_ALLOC(ndr, r->info2);
14293                                 } else {
14294                                         r->info2 = NULL;
14295                                 }
14296                         break; }
14297
14298                         default:
14299                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14300                 }
14301         }
14302         if (ndr_flags & NDR_BUFFERS) {
14303                 switch (level) {
14304                         case 1:
14305                                 if (r->info1) {
14306                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14307                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14308                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14309                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14310                                 }
14311                         break;
14312
14313                         case 2:
14314                                 if (r->info2) {
14315                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
14316                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
14317                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
14318                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
14319                                 }
14320                         break;
14321
14322                         default:
14323                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
14324                 }
14325         }
14326         return NDR_ERR_SUCCESS;
14327 }
14328
14329 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
14330 {
14331         int level;
14332         level = ndr_print_get_switch_value(ndr, r);
14333         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
14334         switch (level) {
14335                 case 1:
14336                         ndr_print_ptr(ndr, "info1", r->info1);
14337                         ndr->depth++;
14338                         if (r->info1) {
14339                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
14340                         }
14341                         ndr->depth--;
14342                 break;
14343
14344                 case 2:
14345                         ndr_print_ptr(ndr, "info2", r->info2);
14346                         ndr->depth++;
14347                         if (r->info2) {
14348                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
14349                         }
14350                         ndr->depth--;
14351                 break;
14352
14353                 default:
14354                         ndr_print_bad_level(ndr, name, level);
14355         }
14356 }
14357
14358 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
14359 {
14360         if (ndr_flags & NDR_SCALARS) {
14361                 NDR_CHECK(ndr_push_align(ndr, 4));
14362                 {
14363                         uint32_t _flags_save_string = ndr->flags;
14364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14365                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
14366                         ndr->flags = _flags_save_string;
14367                 }
14368         }
14369         if (ndr_flags & NDR_BUFFERS) {
14370                 {
14371                         uint32_t _flags_save_string = ndr->flags;
14372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14373                         if (r->port_name) {
14374                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
14375                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
14376                         }
14377                         ndr->flags = _flags_save_string;
14378                 }
14379         }
14380         return NDR_ERR_SUCCESS;
14381 }
14382
14383 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
14384 {
14385         uint32_t _ptr_port_name;
14386         TALLOC_CTX *_mem_save_port_name_0;
14387         if (ndr_flags & NDR_SCALARS) {
14388                 NDR_CHECK(ndr_pull_align(ndr, 4));
14389                 {
14390                         uint32_t _flags_save_string = ndr->flags;
14391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
14393                         if (_ptr_port_name) {
14394                                 NDR_PULL_ALLOC(ndr, r->port_name);
14395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
14396                         } else {
14397                                 r->port_name = NULL;
14398                         }
14399                         ndr->flags = _flags_save_string;
14400                 }
14401         }
14402         if (ndr_flags & NDR_BUFFERS) {
14403                 {
14404                         uint32_t _flags_save_string = ndr->flags;
14405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14406                         if (r->port_name) {
14407                                 uint32_t _relative_save_offset;
14408                                 _relative_save_offset = ndr->offset;
14409                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
14410                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14411                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
14412                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
14413                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
14414                                 ndr->offset = _relative_save_offset;
14415                         }
14416                         ndr->flags = _flags_save_string;
14417                 }
14418         }
14419         return NDR_ERR_SUCCESS;
14420 }
14421
14422 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
14423 {
14424         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
14425         ndr->depth++;
14426         ndr_print_ptr(ndr, "port_name", r->port_name);
14427         ndr->depth++;
14428         if (r->port_name) {
14429                 ndr_print_string(ndr, "port_name", r->port_name);
14430         }
14431         ndr->depth--;
14432         ndr->depth--;
14433 }
14434
14435 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14436 {
14437         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14438         return NDR_ERR_SUCCESS;
14439 }
14440
14441 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14442 {
14443         uint32_t v;
14444         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14445         *r = v;
14446         return NDR_ERR_SUCCESS;
14447 }
14448
14449 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
14450 {
14451         ndr_print_uint32(ndr, name, r);
14452         ndr->depth++;
14453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
14454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
14455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
14456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
14457         ndr->depth--;
14458 }
14459
14460 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
14461 {
14462         if (ndr_flags & NDR_SCALARS) {
14463                 NDR_CHECK(ndr_push_align(ndr, 4));
14464                 {
14465                         uint32_t _flags_save_string = ndr->flags;
14466                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14467                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
14468                         ndr->flags = _flags_save_string;
14469                 }
14470                 {
14471                         uint32_t _flags_save_string = ndr->flags;
14472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
14474                         ndr->flags = _flags_save_string;
14475                 }
14476                 {
14477                         uint32_t _flags_save_string = ndr->flags;
14478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
14480                         ndr->flags = _flags_save_string;
14481                 }
14482                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
14483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
14484         }
14485         if (ndr_flags & NDR_BUFFERS) {
14486                 {
14487                         uint32_t _flags_save_string = ndr->flags;
14488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14489                         if (r->port_name) {
14490                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
14491                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
14492                         }
14493                         ndr->flags = _flags_save_string;
14494                 }
14495                 {
14496                         uint32_t _flags_save_string = ndr->flags;
14497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14498                         if (r->monitor_name) {
14499                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
14500                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
14501                         }
14502                         ndr->flags = _flags_save_string;
14503                 }
14504                 {
14505                         uint32_t _flags_save_string = ndr->flags;
14506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14507                         if (r->description) {
14508                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
14509                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
14510                         }
14511                         ndr->flags = _flags_save_string;
14512                 }
14513         }
14514         return NDR_ERR_SUCCESS;
14515 }
14516
14517 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
14518 {
14519         uint32_t _ptr_port_name;
14520         TALLOC_CTX *_mem_save_port_name_0;
14521         uint32_t _ptr_monitor_name;
14522         TALLOC_CTX *_mem_save_monitor_name_0;
14523         uint32_t _ptr_description;
14524         TALLOC_CTX *_mem_save_description_0;
14525         if (ndr_flags & NDR_SCALARS) {
14526                 NDR_CHECK(ndr_pull_align(ndr, 4));
14527                 {
14528                         uint32_t _flags_save_string = ndr->flags;
14529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14530                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
14531                         if (_ptr_port_name) {
14532                                 NDR_PULL_ALLOC(ndr, r->port_name);
14533                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
14534                         } else {
14535                                 r->port_name = NULL;
14536                         }
14537                         ndr->flags = _flags_save_string;
14538                 }
14539                 {
14540                         uint32_t _flags_save_string = ndr->flags;
14541                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14542                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
14543                         if (_ptr_monitor_name) {
14544                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
14545                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
14546                         } else {
14547                                 r->monitor_name = NULL;
14548                         }
14549                         ndr->flags = _flags_save_string;
14550                 }
14551                 {
14552                         uint32_t _flags_save_string = ndr->flags;
14553                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14554                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
14555                         if (_ptr_description) {
14556                                 NDR_PULL_ALLOC(ndr, r->description);
14557                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
14558                         } else {
14559                                 r->description = NULL;
14560                         }
14561                         ndr->flags = _flags_save_string;
14562                 }
14563                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
14564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
14565         }
14566         if (ndr_flags & NDR_BUFFERS) {
14567                 {
14568                         uint32_t _flags_save_string = ndr->flags;
14569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14570                         if (r->port_name) {
14571                                 uint32_t _relative_save_offset;
14572                                 _relative_save_offset = ndr->offset;
14573                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
14574                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14575                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
14576                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
14577                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
14578                                 ndr->offset = _relative_save_offset;
14579                         }
14580                         ndr->flags = _flags_save_string;
14581                 }
14582                 {
14583                         uint32_t _flags_save_string = ndr->flags;
14584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14585                         if (r->monitor_name) {
14586                                 uint32_t _relative_save_offset;
14587                                 _relative_save_offset = ndr->offset;
14588                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14589                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14590                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14591                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14592                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14593                                 ndr->offset = _relative_save_offset;
14594                         }
14595                         ndr->flags = _flags_save_string;
14596                 }
14597                 {
14598                         uint32_t _flags_save_string = ndr->flags;
14599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14600                         if (r->description) {
14601                                 uint32_t _relative_save_offset;
14602                                 _relative_save_offset = ndr->offset;
14603                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
14604                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
14605                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
14606                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
14607                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
14608                                 ndr->offset = _relative_save_offset;
14609                         }
14610                         ndr->flags = _flags_save_string;
14611                 }
14612         }
14613         return NDR_ERR_SUCCESS;
14614 }
14615
14616 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
14617 {
14618         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
14619         ndr->depth++;
14620         ndr_print_ptr(ndr, "port_name", r->port_name);
14621         ndr->depth++;
14622         if (r->port_name) {
14623                 ndr_print_string(ndr, "port_name", r->port_name);
14624         }
14625         ndr->depth--;
14626         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14627         ndr->depth++;
14628         if (r->monitor_name) {
14629                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14630         }
14631         ndr->depth--;
14632         ndr_print_ptr(ndr, "description", r->description);
14633         ndr->depth++;
14634         if (r->description) {
14635                 ndr_print_string(ndr, "description", r->description);
14636         }
14637         ndr->depth--;
14638         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
14639         ndr_print_uint32(ndr, "reserved", r->reserved);
14640         ndr->depth--;
14641 }
14642
14643 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
14644 {
14645         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14646         if (ndr_flags & NDR_SCALARS) {
14647                 int level = ndr_push_get_switch_value(ndr, r);
14648                 switch (level) {
14649                         case 1: {
14650                                 NDR_CHECK(ndr_push_align(ndr, 4));
14651                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14652                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
14653                         break; }
14654
14655                         case 2: {
14656                                 NDR_CHECK(ndr_push_align(ndr, 4));
14657                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14658                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
14659                         break; }
14660
14661                         case 3: {
14662                         break; }
14663
14664                         default: {
14665                         break; }
14666
14667                 }
14668         }
14669         if (ndr_flags & NDR_BUFFERS) {
14670                 int level = ndr_push_get_switch_value(ndr, r);
14671                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14672                 switch (level) {
14673                         case 1:
14674                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
14675                         break;
14676
14677                         case 2:
14678                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
14679                         break;
14680
14681                         case 3:
14682                         break;
14683
14684                         default:
14685                         break;
14686
14687                 }
14688         }
14689         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14690         return NDR_ERR_SUCCESS;
14691 }
14692
14693 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
14694 {
14695         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14696         int level;
14697         level = ndr_pull_get_switch_value(ndr, r);
14698         if (ndr_flags & NDR_SCALARS) {
14699                 switch (level) {
14700                         case 1: {
14701                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14702                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14703                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
14704                         break; }
14705
14706                         case 2: {
14707                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14708                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14709                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
14710                         break; }
14711
14712                         case 3: {
14713                         break; }
14714
14715                         default: {
14716                         break; }
14717
14718                 }
14719         }
14720         if (ndr_flags & NDR_BUFFERS) {
14721                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14722                 switch (level) {
14723                         case 1:
14724                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
14725                         break;
14726
14727                         case 2:
14728                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
14729                         break;
14730
14731                         case 3:
14732                         break;
14733
14734                         default:
14735                         break;
14736
14737                 }
14738         }
14739         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14740         return NDR_ERR_SUCCESS;
14741 }
14742
14743 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
14744 {
14745         int level;
14746         level = ndr_print_get_switch_value(ndr, r);
14747         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
14748         switch (level) {
14749                 case 1:
14750                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
14751                 break;
14752
14753                 case 2:
14754                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
14755                 break;
14756
14757                 case 3:
14758                 break;
14759
14760                 default:
14761                 break;
14762
14763         }
14764 }
14765
14766 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
14767 {
14768         if (ndr_flags & NDR_SCALARS) {
14769                 NDR_CHECK(ndr_push_align(ndr, 4));
14770                 {
14771                         uint32_t _flags_save_string = ndr->flags;
14772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14773                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
14774                         ndr->flags = _flags_save_string;
14775                 }
14776         }
14777         if (ndr_flags & NDR_BUFFERS) {
14778                 {
14779                         uint32_t _flags_save_string = ndr->flags;
14780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14781                         if (r->monitor_name) {
14782                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
14783                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
14784                         }
14785                         ndr->flags = _flags_save_string;
14786                 }
14787         }
14788         return NDR_ERR_SUCCESS;
14789 }
14790
14791 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
14792 {
14793         uint32_t _ptr_monitor_name;
14794         TALLOC_CTX *_mem_save_monitor_name_0;
14795         if (ndr_flags & NDR_SCALARS) {
14796                 NDR_CHECK(ndr_pull_align(ndr, 4));
14797                 {
14798                         uint32_t _flags_save_string = ndr->flags;
14799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
14801                         if (_ptr_monitor_name) {
14802                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
14803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
14804                         } else {
14805                                 r->monitor_name = NULL;
14806                         }
14807                         ndr->flags = _flags_save_string;
14808                 }
14809         }
14810         if (ndr_flags & NDR_BUFFERS) {
14811                 {
14812                         uint32_t _flags_save_string = ndr->flags;
14813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14814                         if (r->monitor_name) {
14815                                 uint32_t _relative_save_offset;
14816                                 _relative_save_offset = ndr->offset;
14817                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14818                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14819                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14820                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14821                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14822                                 ndr->offset = _relative_save_offset;
14823                         }
14824                         ndr->flags = _flags_save_string;
14825                 }
14826         }
14827         return NDR_ERR_SUCCESS;
14828 }
14829
14830 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
14831 {
14832         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
14833         ndr->depth++;
14834         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
14835         ndr->depth++;
14836         if (r->monitor_name) {
14837                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
14838         }
14839         ndr->depth--;
14840         ndr->depth--;
14841 }
14842
14843 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
14844 {
14845         if (ndr_flags & NDR_SCALARS) {
14846                 NDR_CHECK(ndr_push_align(ndr, 4));
14847                 {
14848                         uint32_t _flags_save_string = ndr->flags;
14849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14850                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
14851                         ndr->flags = _flags_save_string;
14852                 }
14853                 {
14854                         uint32_t _flags_save_string = ndr->flags;
14855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14856                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
14857                         ndr->flags = _flags_save_string;
14858                 }
14859                 {
14860                         uint32_t _flags_save_string = ndr->flags;
14861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14862                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
14863                         ndr->flags = _flags_save_string;
14864                 }
14865         }
14866         if (ndr_flags & NDR_BUFFERS) {
14867                 {
14868                         uint32_t _flags_save_string = ndr->flags;
14869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14870                         if (r->monitor_name) {
14871                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
14872                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
14873                         }
14874                         ndr->flags = _flags_save_string;
14875                 }
14876                 {
14877                         uint32_t _flags_save_string = ndr->flags;
14878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14879                         if (r->environment) {
14880                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
14881                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
14882                         }
14883                         ndr->flags = _flags_save_string;
14884                 }
14885                 {
14886                         uint32_t _flags_save_string = ndr->flags;
14887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14888                         if (r->dll_name) {
14889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
14890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
14891                         }
14892                         ndr->flags = _flags_save_string;
14893                 }
14894         }
14895         return NDR_ERR_SUCCESS;
14896 }
14897
14898 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
14899 {
14900         uint32_t _ptr_monitor_name;
14901         TALLOC_CTX *_mem_save_monitor_name_0;
14902         uint32_t _ptr_environment;
14903         TALLOC_CTX *_mem_save_environment_0;
14904         uint32_t _ptr_dll_name;
14905         TALLOC_CTX *_mem_save_dll_name_0;
14906         if (ndr_flags & NDR_SCALARS) {
14907                 NDR_CHECK(ndr_pull_align(ndr, 4));
14908                 {
14909                         uint32_t _flags_save_string = ndr->flags;
14910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14911                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
14912                         if (_ptr_monitor_name) {
14913                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
14914                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
14915                         } else {
14916                                 r->monitor_name = NULL;
14917                         }
14918                         ndr->flags = _flags_save_string;
14919                 }
14920                 {
14921                         uint32_t _flags_save_string = ndr->flags;
14922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14923                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
14924                         if (_ptr_environment) {
14925                                 NDR_PULL_ALLOC(ndr, r->environment);
14926                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
14927                         } else {
14928                                 r->environment = NULL;
14929                         }
14930                         ndr->flags = _flags_save_string;
14931                 }
14932                 {
14933                         uint32_t _flags_save_string = ndr->flags;
14934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
14936                         if (_ptr_dll_name) {
14937                                 NDR_PULL_ALLOC(ndr, r->dll_name);
14938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
14939                         } else {
14940                                 r->dll_name = NULL;
14941                         }
14942                         ndr->flags = _flags_save_string;
14943                 }
14944         }
14945         if (ndr_flags & NDR_BUFFERS) {
14946                 {
14947                         uint32_t _flags_save_string = ndr->flags;
14948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14949                         if (r->monitor_name) {
14950                                 uint32_t _relative_save_offset;
14951                                 _relative_save_offset = ndr->offset;
14952                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
14953                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14954                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
14955                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
14956                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
14957                                 ndr->offset = _relative_save_offset;
14958                         }
14959                         ndr->flags = _flags_save_string;
14960                 }
14961                 {
14962                         uint32_t _flags_save_string = ndr->flags;
14963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14964                         if (r->environment) {
14965                                 uint32_t _relative_save_offset;
14966                                 _relative_save_offset = ndr->offset;
14967                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
14968                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
14969                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
14970                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
14971                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
14972                                 ndr->offset = _relative_save_offset;
14973                         }
14974                         ndr->flags = _flags_save_string;
14975                 }
14976                 {
14977                         uint32_t _flags_save_string = ndr->flags;
14978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14979                         if (r->dll_name) {
14980                                 uint32_t _relative_save_offset;
14981                                 _relative_save_offset = ndr->offset;
14982                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
14983                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14984                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
14985                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
14986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
14987                                 ndr->offset = _relative_save_offset;
14988                         }
14989                         ndr->flags = _flags_save_string;
14990                 }
14991         }
14992         return NDR_ERR_SUCCESS;
14993 }
14994
14995 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
14996 {
14997         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
14998         ndr->depth++;
14999         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15000         ndr->depth++;
15001         if (r->monitor_name) {
15002                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15003         }
15004         ndr->depth--;
15005         ndr_print_ptr(ndr, "environment", r->environment);
15006         ndr->depth++;
15007         if (r->environment) {
15008                 ndr_print_string(ndr, "environment", r->environment);
15009         }
15010         ndr->depth--;
15011         ndr_print_ptr(ndr, "dll_name", r->dll_name);
15012         ndr->depth++;
15013         if (r->dll_name) {
15014                 ndr_print_string(ndr, "dll_name", r->dll_name);
15015         }
15016         ndr->depth--;
15017         ndr->depth--;
15018 }
15019
15020 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
15021 {
15022         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15023         if (ndr_flags & NDR_SCALARS) {
15024                 int level = ndr_push_get_switch_value(ndr, r);
15025                 switch (level) {
15026                         case 1: {
15027                                 NDR_CHECK(ndr_push_align(ndr, 4));
15028                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15029                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
15030                         break; }
15031
15032                         case 2: {
15033                                 NDR_CHECK(ndr_push_align(ndr, 4));
15034                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15035                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
15036                         break; }
15037
15038                         default: {
15039                         break; }
15040
15041                 }
15042         }
15043         if (ndr_flags & NDR_BUFFERS) {
15044                 int level = ndr_push_get_switch_value(ndr, r);
15045                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15046                 switch (level) {
15047                         case 1:
15048                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
15049                         break;
15050
15051                         case 2:
15052                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
15053                         break;
15054
15055                         default:
15056                         break;
15057
15058                 }
15059         }
15060         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15061         return NDR_ERR_SUCCESS;
15062 }
15063
15064 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
15065 {
15066         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15067         int level;
15068         level = ndr_pull_get_switch_value(ndr, r);
15069         if (ndr_flags & NDR_SCALARS) {
15070                 switch (level) {
15071                         case 1: {
15072                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15073                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15074                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
15075                         break; }
15076
15077                         case 2: {
15078                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15079                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15080                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
15081                         break; }
15082
15083                         default: {
15084                         break; }
15085
15086                 }
15087         }
15088         if (ndr_flags & NDR_BUFFERS) {
15089                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15090                 switch (level) {
15091                         case 1:
15092                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
15093                         break;
15094
15095                         case 2:
15096                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
15097                         break;
15098
15099                         default:
15100                         break;
15101
15102                 }
15103         }
15104         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15105         return NDR_ERR_SUCCESS;
15106 }
15107
15108 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
15109 {
15110         int level;
15111         level = ndr_print_get_switch_value(ndr, r);
15112         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
15113         switch (level) {
15114                 case 1:
15115                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
15116                 break;
15117
15118                 case 2:
15119                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
15120                 break;
15121
15122                 default:
15123                 break;
15124
15125         }
15126 }
15127
15128 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15129 {
15130         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15131         return NDR_ERR_SUCCESS;
15132 }
15133
15134 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15135 {
15136         uint32_t v;
15137         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15138         *r = v;
15139         return NDR_ERR_SUCCESS;
15140 }
15141
15142 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
15143 {
15144         ndr_print_uint32(ndr, name, r);
15145         ndr->depth++;
15146         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
15147         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
15148         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
15149         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
15150         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
15151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
15152         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
15153         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
15154         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
15155         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
15156         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
15157         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
15158         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
15159         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
15160         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
15161         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
15162         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
15163         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
15164         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
15165         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
15166         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
15167         ndr->depth--;
15168 }
15169
15170 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
15171 {
15172         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
15173         return NDR_ERR_SUCCESS;
15174 }
15175
15176 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
15177 {
15178         uint16_t v;
15179         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
15180         *r = v;
15181         return NDR_ERR_SUCCESS;
15182 }
15183
15184 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
15185 {
15186         const char *val = NULL;
15187
15188         switch (r) {
15189                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
15190                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
15191                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
15192                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
15193                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
15194                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
15195                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
15196                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
15197                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
15198                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
15199                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
15200                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
15201                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
15202                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
15203                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
15204                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
15205                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
15206                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
15207                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
15208                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
15209                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
15210                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
15211                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
15212                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
15213                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
15214                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
15215         }
15216         ndr_print_enum(ndr, name, "ENUM", val, r);
15217 }
15218
15219 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
15220 {
15221         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
15222         return NDR_ERR_SUCCESS;
15223 }
15224
15225 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
15226 {
15227         uint16_t v;
15228         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
15229         *r = v;
15230         return NDR_ERR_SUCCESS;
15231 }
15232
15233 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
15234 {
15235         const char *val = NULL;
15236
15237         switch (r) {
15238                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
15239                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
15240         }
15241         ndr_print_enum(ndr, name, "ENUM", val, r);
15242 }
15243
15244 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
15245 {
15246         uint32_t cntr_fields_1;
15247         if (ndr_flags & NDR_SCALARS) {
15248                 NDR_CHECK(ndr_push_align(ndr, 4));
15249                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
15250                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
15251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
15252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
15253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
15254                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
15255         }
15256         if (ndr_flags & NDR_BUFFERS) {
15257                 if (r->fields) {
15258                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
15259                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
15260                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
15261                         }
15262                 }
15263         }
15264         return NDR_ERR_SUCCESS;
15265 }
15266
15267 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
15268 {
15269         uint32_t _ptr_fields;
15270         uint32_t cntr_fields_1;
15271         TALLOC_CTX *_mem_save_fields_0;
15272         TALLOC_CTX *_mem_save_fields_1;
15273         if (ndr_flags & NDR_SCALARS) {
15274                 NDR_CHECK(ndr_pull_align(ndr, 4));
15275                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
15276                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
15277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
15278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
15279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
15280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
15281                 if (_ptr_fields) {
15282                         NDR_PULL_ALLOC(ndr, r->fields);
15283                 } else {
15284                         r->fields = NULL;
15285                 }
15286         }
15287         if (ndr_flags & NDR_BUFFERS) {
15288                 if (r->fields) {
15289                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
15290                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
15291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
15292                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
15293                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
15294                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
15295                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
15296                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
15297                         }
15298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
15299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
15300                 }
15301                 if (r->fields) {
15302                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
15303                 }
15304         }
15305         return NDR_ERR_SUCCESS;
15306 }
15307
15308 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
15309 {
15310         uint32_t cntr_fields_1;
15311         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
15312         ndr->depth++;
15313         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
15314         ndr_print_uint16(ndr, "u1", r->u1);
15315         ndr_print_uint32(ndr, "u2", r->u2);
15316         ndr_print_uint32(ndr, "u3", r->u3);
15317         ndr_print_uint32(ndr, "count", r->count);
15318         ndr_print_ptr(ndr, "fields", r->fields);
15319         ndr->depth++;
15320         if (r->fields) {
15321                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
15322                 ndr->depth++;
15323                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
15324                         char *idx_1=NULL;
15325                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
15326                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
15327                                 free(idx_1);
15328                         }
15329                 }
15330                 ndr->depth--;
15331         }
15332         ndr->depth--;
15333         ndr->depth--;
15334 }
15335
15336 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15337 {
15338         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15339         return NDR_ERR_SUCCESS;
15340 }
15341
15342 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15343 {
15344         uint32_t v;
15345         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15346         *r = v;
15347         return NDR_ERR_SUCCESS;
15348 }
15349
15350 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
15351 {
15352         ndr_print_uint32(ndr, name, r);
15353         ndr->depth++;
15354         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
15355         ndr->depth--;
15356 }
15357
15358 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
15359 {
15360         uint32_t cntr_types_1;
15361         if (ndr_flags & NDR_SCALARS) {
15362                 NDR_CHECK(ndr_push_align(ndr, 4));
15363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15364                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
15365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
15366                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
15367         }
15368         if (ndr_flags & NDR_BUFFERS) {
15369                 if (r->types) {
15370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
15371                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
15372                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
15373                         }
15374                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
15375                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
15376                         }
15377                 }
15378         }
15379         return NDR_ERR_SUCCESS;
15380 }
15381
15382 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
15383 {
15384         uint32_t _ptr_types;
15385         uint32_t cntr_types_1;
15386         TALLOC_CTX *_mem_save_types_0;
15387         TALLOC_CTX *_mem_save_types_1;
15388         if (ndr_flags & NDR_SCALARS) {
15389                 NDR_CHECK(ndr_pull_align(ndr, 4));
15390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
15391                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
15392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
15393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
15394                 if (_ptr_types) {
15395                         NDR_PULL_ALLOC(ndr, r->types);
15396                 } else {
15397                         r->types = NULL;
15398                 }
15399         }
15400         if (ndr_flags & NDR_BUFFERS) {
15401                 if (r->types) {
15402                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
15403                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
15404                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
15405                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
15406                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
15407                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
15408                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
15409                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
15410                         }
15411                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
15412                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
15413                         }
15414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
15415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
15416                 }
15417                 if (r->types) {
15418                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
15419                 }
15420         }
15421         return NDR_ERR_SUCCESS;
15422 }
15423
15424 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
15425 {
15426         uint32_t cntr_types_1;
15427         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
15428         ndr->depth++;
15429         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
15430         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
15431         ndr_print_uint32(ndr, "count", r->count);
15432         ndr_print_ptr(ndr, "types", r->types);
15433         ndr->depth++;
15434         if (r->types) {
15435                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
15436                 ndr->depth++;
15437                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
15438                         char *idx_1=NULL;
15439                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
15440                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
15441                                 free(idx_1);
15442                         }
15443                 }
15444                 ndr->depth--;
15445         }
15446         ndr->depth--;
15447         ndr->depth--;
15448 }
15449
15450 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
15451 {
15452         if (ndr_flags & NDR_SCALARS) {
15453                 NDR_CHECK(ndr_push_align(ndr, 4));
15454                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
15455                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
15456         }
15457         if (ndr_flags & NDR_BUFFERS) {
15458                 if (r->string) {
15459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
15460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
15461                 }
15462         }
15463         return NDR_ERR_SUCCESS;
15464 }
15465
15466 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
15467 {
15468         uint32_t _ptr_string;
15469         TALLOC_CTX *_mem_save_string_0;
15470         if (ndr_flags & NDR_SCALARS) {
15471                 NDR_CHECK(ndr_pull_align(ndr, 4));
15472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
15473                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
15474                 if (_ptr_string) {
15475                         NDR_PULL_ALLOC(ndr, r->string);
15476                 } else {
15477                         r->string = NULL;
15478                 }
15479         }
15480         if (ndr_flags & NDR_BUFFERS) {
15481                 if (r->string) {
15482                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
15483                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
15484                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
15485                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
15486                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
15487                 }
15488                 if (r->string) {
15489                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
15490                 }
15491         }
15492         return NDR_ERR_SUCCESS;
15493 }
15494
15495 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
15496 {
15497         ndr_print_struct(ndr, name, "spoolss_NotifyString");
15498         ndr->depth++;
15499         ndr_print_uint32(ndr, "size", r->size);
15500         ndr_print_ptr(ndr, "string", r->string);
15501         ndr->depth++;
15502         if (r->string) {
15503                 ndr_print_string(ndr, "string", r->string);
15504         }
15505         ndr->depth--;
15506         ndr->depth--;
15507 }
15508
15509 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
15510 {
15511         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15512         return NDR_ERR_SUCCESS;
15513 }
15514
15515 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
15516 {
15517         uint32_t v;
15518         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15519         *r = v;
15520         return NDR_ERR_SUCCESS;
15521 }
15522
15523 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
15524 {
15525         const char *val = NULL;
15526
15527         switch (r) {
15528                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
15529                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
15530                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
15531                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
15532                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
15533         }
15534         ndr_print_enum(ndr, name, "ENUM", val, r);
15535 }
15536
15537 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
15538 {
15539         if (ndr_flags & NDR_SCALARS) {
15540                 int level = ndr_push_get_switch_value(ndr, r);
15541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15542                 switch (level) {
15543                         case 1: {
15544                                 uint32_t cntr_integer_0;
15545                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
15546                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
15547                                 }
15548                         break; }
15549
15550                         case 2: {
15551                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
15552                         break; }
15553
15554                         case 3: {
15555                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
15556                         break; }
15557
15558                         case 4: {
15559                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
15560                         break; }
15561
15562                         case 5: {
15563                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
15564                         break; }
15565
15566                         default:
15567                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15568                 }
15569         }
15570         if (ndr_flags & NDR_BUFFERS) {
15571                 int level = ndr_push_get_switch_value(ndr, r);
15572                 switch (level) {
15573                         case 1:
15574                         break;
15575
15576                         case 2:
15577                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
15578                         break;
15579
15580                         case 3:
15581                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
15582                         break;
15583
15584                         case 4:
15585                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
15586                         break;
15587
15588                         case 5:
15589                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
15590                         break;
15591
15592                         default:
15593                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15594                 }
15595         }
15596         return NDR_ERR_SUCCESS;
15597 }
15598
15599 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
15600 {
15601         int level;
15602         uint32_t _level;
15603         level = ndr_pull_get_switch_value(ndr, r);
15604         if (ndr_flags & NDR_SCALARS) {
15605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15606                 if (_level != level) {
15607                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15608                 }
15609                 switch (level) {
15610                         case 1: {
15611                                 uint32_t cntr_integer_0;
15612                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
15613                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
15614                                 }
15615                         break; }
15616
15617                         case 2: {
15618                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
15619                         break; }
15620
15621                         case 3: {
15622                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
15623                         break; }
15624
15625                         case 4: {
15626                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
15627                         break; }
15628
15629                         case 5: {
15630                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
15631                         break; }
15632
15633                         default:
15634                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15635                 }
15636         }
15637         if (ndr_flags & NDR_BUFFERS) {
15638                 switch (level) {
15639                         case 1:
15640                         break;
15641
15642                         case 2:
15643                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
15644                         break;
15645
15646                         case 3:
15647                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
15648                         break;
15649
15650                         case 4:
15651                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
15652                         break;
15653
15654                         case 5:
15655                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
15656                         break;
15657
15658                         default:
15659                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15660                 }
15661         }
15662         return NDR_ERR_SUCCESS;
15663 }
15664
15665 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
15666 {
15667         int level;
15668         uint32_t cntr_integer_0;
15669         level = ndr_print_get_switch_value(ndr, r);
15670         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
15671         switch (level) {
15672                 case 1:
15673                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
15674                         ndr->depth++;
15675                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
15676                                 char *idx_0=NULL;
15677                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
15678                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
15679                                         free(idx_0);
15680                                 }
15681                         }
15682                         ndr->depth--;
15683                 break;
15684
15685                 case 2:
15686                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
15687                 break;
15688
15689                 case 3:
15690                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
15691                 break;
15692
15693                 case 4:
15694                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
15695                 break;
15696
15697                 case 5:
15698                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
15699                 break;
15700
15701                 default:
15702                         ndr_print_bad_level(ndr, name, level);
15703         }
15704 }
15705
15706 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
15707 {
15708         if (ndr_flags & NDR_SCALARS) {
15709                 NDR_CHECK(ndr_push_align(ndr, 4));
15710                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
15711                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
15712                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
15713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
15714                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
15715                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
15716         }
15717         if (ndr_flags & NDR_BUFFERS) {
15718                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
15719         }
15720         return NDR_ERR_SUCCESS;
15721 }
15722
15723 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
15724 {
15725         if (ndr_flags & NDR_SCALARS) {
15726                 NDR_CHECK(ndr_pull_align(ndr, 4));
15727                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
15728                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
15729                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
15730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
15731                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
15732                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
15733         }
15734         if (ndr_flags & NDR_BUFFERS) {
15735                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
15736         }
15737         return NDR_ERR_SUCCESS;
15738 }
15739
15740 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
15741 {
15742         ndr_print_struct(ndr, name, "spoolss_Notify");
15743         ndr->depth++;
15744         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
15745         ndr_print_spoolss_Field(ndr, "field", r->field);
15746         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
15747         ndr_print_uint32(ndr, "job_id", r->job_id);
15748         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
15749         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
15750         ndr->depth--;
15751 }
15752
15753 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
15754 {
15755         uint32_t cntr_notifies_0;
15756         if (ndr_flags & NDR_SCALARS) {
15757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
15758                 NDR_CHECK(ndr_push_align(ndr, 4));
15759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
15760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
15761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
15762                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
15763                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
15764                 }
15765         }
15766         if (ndr_flags & NDR_BUFFERS) {
15767                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
15768                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
15769                 }
15770         }
15771         return NDR_ERR_SUCCESS;
15772 }
15773
15774 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
15775 {
15776         uint32_t cntr_notifies_0;
15777         TALLOC_CTX *_mem_save_notifies_0;
15778         if (ndr_flags & NDR_SCALARS) {
15779                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
15780                 NDR_CHECK(ndr_pull_align(ndr, 4));
15781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
15782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
15783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
15784                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
15785                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
15786                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
15787                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
15788                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
15789                 }
15790                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
15791                 if (r->notifies) {
15792                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
15793                 }
15794         }
15795         if (ndr_flags & NDR_BUFFERS) {
15796                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
15797                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
15798                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
15799                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
15800                 }
15801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
15802         }
15803         return NDR_ERR_SUCCESS;
15804 }
15805
15806 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
15807 {
15808         uint32_t cntr_notifies_0;
15809         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
15810         ndr->depth++;
15811         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
15812         ndr_print_uint32(ndr, "flags", r->flags);
15813         ndr_print_uint32(ndr, "count", r->count);
15814         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
15815         ndr->depth++;
15816         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
15817                 char *idx_0=NULL;
15818                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
15819                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
15820                         free(idx_0);
15821                 }
15822         }
15823         ndr->depth--;
15824         ndr->depth--;
15825 }
15826
15827 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
15828 {
15829         if (ndr_flags & NDR_SCALARS) {
15830                 int level = ndr_push_get_switch_value(ndr, r);
15831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15832                 switch (level) {
15833                         case 0: {
15834                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
15835                         break; }
15836
15837                         default:
15838                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15839                 }
15840         }
15841         if (ndr_flags & NDR_BUFFERS) {
15842                 int level = ndr_push_get_switch_value(ndr, r);
15843                 switch (level) {
15844                         case 0:
15845                                 if (r->info0) {
15846                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
15847                                 }
15848                         break;
15849
15850                         default:
15851                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15852                 }
15853         }
15854         return NDR_ERR_SUCCESS;
15855 }
15856
15857 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
15858 {
15859         int level;
15860         uint32_t _level;
15861         TALLOC_CTX *_mem_save_info0_0;
15862         level = ndr_pull_get_switch_value(ndr, r);
15863         if (ndr_flags & NDR_SCALARS) {
15864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15865                 if (_level != level) {
15866                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15867                 }
15868                 switch (level) {
15869                         case 0: {
15870                                 uint32_t _ptr_info0;
15871                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
15872                                 if (_ptr_info0) {
15873                                         NDR_PULL_ALLOC(ndr, r->info0);
15874                                 } else {
15875                                         r->info0 = NULL;
15876                                 }
15877                         break; }
15878
15879                         default:
15880                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15881                 }
15882         }
15883         if (ndr_flags & NDR_BUFFERS) {
15884                 switch (level) {
15885                         case 0:
15886                                 if (r->info0) {
15887                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
15888                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
15889                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
15890                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
15891                                 }
15892                         break;
15893
15894                         default:
15895                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15896                 }
15897         }
15898         return NDR_ERR_SUCCESS;
15899 }
15900
15901 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
15902 {
15903         int level;
15904         level = ndr_print_get_switch_value(ndr, r);
15905         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
15906         switch (level) {
15907                 case 0:
15908                         ndr_print_ptr(ndr, "info0", r->info0);
15909                         ndr->depth++;
15910                         if (r->info0) {
15911                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
15912                         }
15913                         ndr->depth--;
15914                 break;
15915
15916                 default:
15917                         ndr_print_bad_level(ndr, name, level);
15918         }
15919 }
15920
15921 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15922 {
15923         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15924         return NDR_ERR_SUCCESS;
15925 }
15926
15927 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15928 {
15929         uint32_t v;
15930         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15931         *r = v;
15932         return NDR_ERR_SUCCESS;
15933 }
15934
15935 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
15936 {
15937         ndr_print_uint32(ndr, name, r);
15938         ndr->depth++;
15939         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
15940         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
15941         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
15942         ndr->depth--;
15943 }
15944
15945 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
15946 {
15947         if (ndr_flags & NDR_SCALARS) {
15948                 NDR_CHECK(ndr_push_align(ndr, 4));
15949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
15950                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
15951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
15952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
15953                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
15954                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
15955                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
15956         }
15957         if (ndr_flags & NDR_BUFFERS) {
15958                 if (r->client) {
15959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
15960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
15962                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15963                 }
15964                 if (r->user) {
15965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
15966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15967                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
15968                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15969                 }
15970         }
15971         return NDR_ERR_SUCCESS;
15972 }
15973
15974 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
15975 {
15976         uint32_t _ptr_client;
15977         TALLOC_CTX *_mem_save_client_0;
15978         uint32_t _ptr_user;
15979         TALLOC_CTX *_mem_save_user_0;
15980         if (ndr_flags & NDR_SCALARS) {
15981                 NDR_CHECK(ndr_pull_align(ndr, 4));
15982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
15983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
15984                 if (_ptr_client) {
15985                         NDR_PULL_ALLOC(ndr, r->client);
15986                 } else {
15987                         r->client = NULL;
15988                 }
15989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
15990                 if (_ptr_user) {
15991                         NDR_PULL_ALLOC(ndr, r->user);
15992                 } else {
15993                         r->user = NULL;
15994                 }
15995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
15996                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
15997                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
15998                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
15999         }
16000         if (ndr_flags & NDR_BUFFERS) {
16001                 if (r->client) {
16002                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
16003                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
16004                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
16005                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
16006                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
16007                                 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));
16008                         }
16009                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
16010                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
16011                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
16012                 }
16013                 if (r->user) {
16014                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
16015                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
16016                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
16017                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
16018                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
16019                                 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));
16020                         }
16021                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
16022                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
16023                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
16024                 }
16025         }
16026         return NDR_ERR_SUCCESS;
16027 }
16028
16029 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
16030 {
16031         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
16032         ndr->depth++;
16033         ndr_print_uint32(ndr, "size", r->size);
16034         ndr_print_ptr(ndr, "client", r->client);
16035         ndr->depth++;
16036         if (r->client) {
16037                 ndr_print_string(ndr, "client", r->client);
16038         }
16039         ndr->depth--;
16040         ndr_print_ptr(ndr, "user", r->user);
16041         ndr->depth++;
16042         if (r->user) {
16043                 ndr_print_string(ndr, "user", r->user);
16044         }
16045         ndr->depth--;
16046         ndr_print_uint32(ndr, "build", r->build);
16047         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
16048         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
16049         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
16050         ndr->depth--;
16051 }
16052
16053 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
16054 {
16055         if (ndr_flags & NDR_SCALARS) {
16056                 NDR_CHECK(ndr_push_align(ndr, 4));
16057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
16058         }
16059         if (ndr_flags & NDR_BUFFERS) {
16060         }
16061         return NDR_ERR_SUCCESS;
16062 }
16063
16064 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
16065 {
16066         if (ndr_flags & NDR_SCALARS) {
16067                 NDR_CHECK(ndr_pull_align(ndr, 4));
16068                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
16069         }
16070         if (ndr_flags & NDR_BUFFERS) {
16071         }
16072         return NDR_ERR_SUCCESS;
16073 }
16074
16075 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
16076 {
16077         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
16078         ndr->depth++;
16079         ndr_print_uint32(ndr, "not_used", r->not_used);
16080         ndr->depth--;
16081 }
16082
16083 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
16084 {
16085         if (ndr_flags & NDR_SCALARS) {
16086                 NDR_CHECK(ndr_push_align(ndr, 4));
16087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
16088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
16089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
16090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
16091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
16092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
16093                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
16094                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
16095                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
16096                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
16097         }
16098         if (ndr_flags & NDR_BUFFERS) {
16099                 if (r->client) {
16100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
16101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
16103                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16104                 }
16105                 if (r->user) {
16106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
16107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
16109                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16110                 }
16111         }
16112         return NDR_ERR_SUCCESS;
16113 }
16114
16115 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
16116 {
16117         uint32_t _ptr_client;
16118         TALLOC_CTX *_mem_save_client_0;
16119         uint32_t _ptr_user;
16120         TALLOC_CTX *_mem_save_user_0;
16121         if (ndr_flags & NDR_SCALARS) {
16122                 NDR_CHECK(ndr_pull_align(ndr, 4));
16123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
16124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
16125                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
16126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
16127                 if (_ptr_client) {
16128                         NDR_PULL_ALLOC(ndr, r->client);
16129                 } else {
16130                         r->client = NULL;
16131                 }
16132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
16133                 if (_ptr_user) {
16134                         NDR_PULL_ALLOC(ndr, r->user);
16135                 } else {
16136                         r->user = NULL;
16137                 }
16138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
16139                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
16140                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
16141                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
16142                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
16143         }
16144         if (ndr_flags & NDR_BUFFERS) {
16145                 if (r->client) {
16146                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
16147                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
16148                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
16149                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
16150                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
16151                                 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));
16152                         }
16153                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
16154                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
16155                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
16156                 }
16157                 if (r->user) {
16158                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
16159                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
16160                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
16161                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
16162                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
16163                                 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));
16164                         }
16165                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
16166                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
16167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
16168                 }
16169         }
16170         return NDR_ERR_SUCCESS;
16171 }
16172
16173 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
16174 {
16175         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
16176         ndr->depth++;
16177         ndr_print_uint32(ndr, "size", r->size);
16178         ndr_print_uint32(ndr, "flags", r->flags);
16179         ndr_print_uint32(ndr, "size2", r->size2);
16180         ndr_print_ptr(ndr, "client", r->client);
16181         ndr->depth++;
16182         if (r->client) {
16183                 ndr_print_string(ndr, "client", r->client);
16184         }
16185         ndr->depth--;
16186         ndr_print_ptr(ndr, "user", r->user);
16187         ndr->depth++;
16188         if (r->user) {
16189                 ndr_print_string(ndr, "user", r->user);
16190         }
16191         ndr->depth--;
16192         ndr_print_uint32(ndr, "build", r->build);
16193         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
16194         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
16195         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
16196         ndr_print_udlong(ndr, "reserved", r->reserved);
16197         ndr->depth--;
16198 }
16199
16200 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
16201 {
16202         if (ndr_flags & NDR_SCALARS) {
16203                 int level = ndr_push_get_switch_value(ndr, r);
16204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
16205                 switch (level) {
16206                         case 1: {
16207                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
16208                         break; }
16209
16210                         case 2: {
16211                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
16212                         break; }
16213
16214                         case 3: {
16215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
16216                         break; }
16217
16218                         default:
16219                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16220                 }
16221         }
16222         if (ndr_flags & NDR_BUFFERS) {
16223                 int level = ndr_push_get_switch_value(ndr, r);
16224                 switch (level) {
16225                         case 1:
16226                                 if (r->level1) {
16227                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
16228                                 }
16229                         break;
16230
16231                         case 2:
16232                                 if (r->level2) {
16233                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
16234                                 }
16235                         break;
16236
16237                         case 3:
16238                                 if (r->level3) {
16239                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
16240                                 }
16241                         break;
16242
16243                         default:
16244                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16245                 }
16246         }
16247         return NDR_ERR_SUCCESS;
16248 }
16249
16250 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
16251 {
16252         int level;
16253         uint32_t _level;
16254         TALLOC_CTX *_mem_save_level1_0;
16255         TALLOC_CTX *_mem_save_level2_0;
16256         TALLOC_CTX *_mem_save_level3_0;
16257         level = ndr_pull_get_switch_value(ndr, r);
16258         if (ndr_flags & NDR_SCALARS) {
16259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
16260                 if (_level != level) {
16261                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
16262                 }
16263                 switch (level) {
16264                         case 1: {
16265                                 uint32_t _ptr_level1;
16266                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
16267                                 if (_ptr_level1) {
16268                                         NDR_PULL_ALLOC(ndr, r->level1);
16269                                 } else {
16270                                         r->level1 = NULL;
16271                                 }
16272                         break; }
16273
16274                         case 2: {
16275                                 uint32_t _ptr_level2;
16276                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
16277                                 if (_ptr_level2) {
16278                                         NDR_PULL_ALLOC(ndr, r->level2);
16279                                 } else {
16280                                         r->level2 = NULL;
16281                                 }
16282                         break; }
16283
16284                         case 3: {
16285                                 uint32_t _ptr_level3;
16286                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
16287                                 if (_ptr_level3) {
16288                                         NDR_PULL_ALLOC(ndr, r->level3);
16289                                 } else {
16290                                         r->level3 = NULL;
16291                                 }
16292                         break; }
16293
16294                         default:
16295                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16296                 }
16297         }
16298         if (ndr_flags & NDR_BUFFERS) {
16299                 switch (level) {
16300                         case 1:
16301                                 if (r->level1) {
16302                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
16303                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
16304                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
16305                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
16306                                 }
16307                         break;
16308
16309                         case 2:
16310                                 if (r->level2) {
16311                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
16312                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
16313                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
16314                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
16315                                 }
16316                         break;
16317
16318                         case 3:
16319                                 if (r->level3) {
16320                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
16321                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
16322                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
16323                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
16324                                 }
16325                         break;
16326
16327                         default:
16328                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
16329                 }
16330         }
16331         return NDR_ERR_SUCCESS;
16332 }
16333
16334 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
16335 {
16336         int level;
16337         level = ndr_print_get_switch_value(ndr, r);
16338         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
16339         switch (level) {
16340                 case 1:
16341                         ndr_print_ptr(ndr, "level1", r->level1);
16342                         ndr->depth++;
16343                         if (r->level1) {
16344                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
16345                         }
16346                         ndr->depth--;
16347                 break;
16348
16349                 case 2:
16350                         ndr_print_ptr(ndr, "level2", r->level2);
16351                         ndr->depth++;
16352                         if (r->level2) {
16353                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
16354                         }
16355                         ndr->depth--;
16356                 break;
16357
16358                 case 3:
16359                         ndr_print_ptr(ndr, "level3", r->level3);
16360                         ndr->depth++;
16361                         if (r->level3) {
16362                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
16363                         }
16364                         ndr->depth--;
16365                 break;
16366
16367                 default:
16368                         ndr_print_bad_level(ndr, name, level);
16369         }
16370 }
16371
16372 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
16373 {
16374         if (ndr_flags & NDR_SCALARS) {
16375                 NDR_CHECK(ndr_push_align(ndr, 4));
16376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
16377                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
16378                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
16379         }
16380         if (ndr_flags & NDR_BUFFERS) {
16381                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
16382         }
16383         return NDR_ERR_SUCCESS;
16384 }
16385
16386 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
16387 {
16388         if (ndr_flags & NDR_SCALARS) {
16389                 NDR_CHECK(ndr_pull_align(ndr, 4));
16390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
16391                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
16392                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
16393         }
16394         if (ndr_flags & NDR_BUFFERS) {
16395                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
16396         }
16397         return NDR_ERR_SUCCESS;
16398 }
16399
16400 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
16401 {
16402         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
16403         ndr->depth++;
16404         ndr_print_uint32(ndr, "level", r->level);
16405         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
16406         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
16407         ndr->depth--;
16408 }
16409
16410 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16411 {
16412         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16413         return NDR_ERR_SUCCESS;
16414 }
16415
16416 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16417 {
16418         uint32_t v;
16419         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16420         *r = v;
16421         return NDR_ERR_SUCCESS;
16422 }
16423
16424 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
16425 {
16426         ndr_print_uint32(ndr, name, r);
16427         ndr->depth++;
16428         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
16429         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
16430         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
16431         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
16432         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
16433         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
16434         ndr->depth--;
16435 }
16436
16437 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16438 {
16439         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16440         return NDR_ERR_SUCCESS;
16441 }
16442
16443 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16444 {
16445         uint32_t v;
16446         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16447         *r = v;
16448         return NDR_ERR_SUCCESS;
16449 }
16450
16451 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16452 {
16453         ndr_print_uint32(ndr, name, r);
16454         ndr->depth++;
16455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
16456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
16457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
16458         ndr->depth--;
16459 }
16460
16461 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
16462 {
16463         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16464         return NDR_ERR_SUCCESS;
16465 }
16466
16467 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
16468 {
16469         uint32_t v;
16470         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16471         *r = v;
16472         return NDR_ERR_SUCCESS;
16473 }
16474
16475 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
16476 {
16477         const char *val = NULL;
16478
16479         switch (r) {
16480                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
16481                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
16482         }
16483         ndr_print_enum(ndr, name, "ENUM", val, r);
16484 }
16485
16486 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
16487 {
16488         if (ndr_flags & NDR_SCALARS) {
16489                 NDR_CHECK(ndr_push_align(ndr, 4));
16490                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
16491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
16492                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
16493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
16494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16495                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
16496                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
16497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
16498                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
16499                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
16500                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
16501                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
16502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
16503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
16504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
16505         }
16506         if (ndr_flags & NDR_BUFFERS) {
16507         }
16508         return NDR_ERR_SUCCESS;
16509 }
16510
16511 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
16512 {
16513         if (ndr_flags & NDR_SCALARS) {
16514                 NDR_CHECK(ndr_pull_align(ndr, 4));
16515                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
16516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
16517                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
16518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
16519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16520                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
16521                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
16522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
16523                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
16524                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
16525                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
16526                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
16527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
16528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
16529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
16530         }
16531         if (ndr_flags & NDR_BUFFERS) {
16532         }
16533         return NDR_ERR_SUCCESS;
16534 }
16535
16536 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
16537 {
16538         ndr_print_struct(ndr, name, "spoolss_PortData1");
16539         ndr->depth++;
16540         ndr_print_string(ndr, "portname", r->portname);
16541         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
16542         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
16543         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
16544         ndr_print_uint32(ndr, "reserved", r->reserved);
16545         ndr_print_string(ndr, "hostaddress", r->hostaddress);
16546         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
16547         ndr_print_uint32(ndr, "dblspool", r->dblspool);
16548         ndr_print_string(ndr, "queue", r->queue);
16549         ndr_print_string(ndr, "ip_address", r->ip_address);
16550         ndr_print_string(ndr, "hardware_address", r->hardware_address);
16551         ndr_print_string(ndr, "device_type", r->device_type);
16552         ndr_print_uint32(ndr, "port_number", r->port_number);
16553         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
16554         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
16555         ndr->depth--;
16556 }
16557
16558 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
16559 {
16560         if (ndr_flags & NDR_SCALARS) {
16561                 NDR_CHECK(ndr_push_align(ndr, 4));
16562                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
16563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
16564                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
16565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
16566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
16567                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
16568                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
16569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
16570                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
16571                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
16572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
16573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
16574                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
16575                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
16576         }
16577         if (ndr_flags & NDR_BUFFERS) {
16578         }
16579         return NDR_ERR_SUCCESS;
16580 }
16581
16582 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
16583 {
16584         if (ndr_flags & NDR_SCALARS) {
16585                 NDR_CHECK(ndr_pull_align(ndr, 4));
16586                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
16587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
16588                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
16589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
16590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
16591                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
16592                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
16593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
16594                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
16595                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
16596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
16597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
16598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
16599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
16600         }
16601         if (ndr_flags & NDR_BUFFERS) {
16602         }
16603         return NDR_ERR_SUCCESS;
16604 }
16605
16606 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
16607 {
16608         ndr_print_struct(ndr, name, "spoolss_PortData2");
16609         ndr->depth++;
16610         ndr_print_string(ndr, "portname", r->portname);
16611         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
16612         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
16613         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
16614         ndr_print_uint32(ndr, "reserved", r->reserved);
16615         ndr_print_string(ndr, "hostaddress", r->hostaddress);
16616         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
16617         ndr_print_uint32(ndr, "dblspool", r->dblspool);
16618         ndr_print_string(ndr, "queue", r->queue);
16619         ndr_print_string(ndr, "device_type", r->device_type);
16620         ndr_print_uint32(ndr, "port_number", r->port_number);
16621         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
16622         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
16623         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
16624         ndr->depth--;
16625 }
16626
16627 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
16628 {
16629         if (ndr_flags & NDR_SCALARS) {
16630                 NDR_CHECK(ndr_push_align(ndr, 4));
16631                 {
16632                         uint32_t _flags_save_string = ndr->flags;
16633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16634                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16635                         ndr->flags = _flags_save_string;
16636                 }
16637         }
16638         if (ndr_flags & NDR_BUFFERS) {
16639         }
16640         return NDR_ERR_SUCCESS;
16641 }
16642
16643 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
16644 {
16645         if (ndr_flags & NDR_SCALARS) {
16646                 NDR_CHECK(ndr_pull_align(ndr, 4));
16647                 {
16648                         uint32_t _flags_save_string = ndr->flags;
16649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16650                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16651                         ndr->flags = _flags_save_string;
16652                 }
16653         }
16654         if (ndr_flags & NDR_BUFFERS) {
16655         }
16656         return NDR_ERR_SUCCESS;
16657 }
16658
16659 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
16660 {
16661         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
16662         ndr->depth++;
16663         ndr_print_string(ndr, "dll_name", r->dll_name);
16664         ndr->depth--;
16665 }
16666
16667 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16668 {
16669         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16670         return NDR_ERR_SUCCESS;
16671 }
16672
16673 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16674 {
16675         uint32_t v;
16676         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16677         *r = v;
16678         return NDR_ERR_SUCCESS;
16679 }
16680
16681 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16682 {
16683         ndr_print_uint32(ndr, name, r);
16684         ndr->depth++;
16685         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
16686         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
16687         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
16688         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
16689         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
16690         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
16691         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
16692         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
16693         ndr->depth--;
16694 }
16695
16696 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
16697 {
16698         if (flags & NDR_IN) {
16699                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
16700                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16701                 if (r->in.server) {
16702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16704                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16705                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16706                 }
16707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16708                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
16709                 if (r->in.buffer) {
16710                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
16711                 }
16712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
16713         }
16714         if (flags & NDR_OUT) {
16715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
16716                 if (r->out.info) {
16717                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
16718                 }
16719                 if (r->out.needed == NULL) {
16720                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16721                 }
16722                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16723                 if (r->out.count == NULL) {
16724                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16725                 }
16726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
16727                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16728         }
16729         return NDR_ERR_SUCCESS;
16730 }
16731
16732 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
16733 {
16734         uint32_t _ptr_server;
16735         uint32_t _ptr_buffer;
16736         uint32_t _ptr_info;
16737         TALLOC_CTX *_mem_save_server_0;
16738         TALLOC_CTX *_mem_save_buffer_0;
16739         TALLOC_CTX *_mem_save_info_0;
16740         TALLOC_CTX *_mem_save_needed_0;
16741         TALLOC_CTX *_mem_save_count_0;
16742         if (flags & NDR_IN) {
16743                 ZERO_STRUCT(r->out);
16744
16745                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
16746                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16747                 if (_ptr_server) {
16748                         NDR_PULL_ALLOC(ndr, r->in.server);
16749                 } else {
16750                         r->in.server = NULL;
16751                 }
16752                 if (r->in.server) {
16753                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16754                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16757                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16758                                 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));
16759                         }
16760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16763                 }
16764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16765                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
16766                 if (_ptr_buffer) {
16767                         NDR_PULL_ALLOC(ndr, r->in.buffer);
16768                 } else {
16769                         r->in.buffer = NULL;
16770                 }
16771                 if (r->in.buffer) {
16772                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
16773                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
16774                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
16775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
16776                 }
16777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
16778                 NDR_PULL_ALLOC(ndr, r->out.needed);
16779                 ZERO_STRUCTP(r->out.needed);
16780                 NDR_PULL_ALLOC(ndr, r->out.count);
16781                 ZERO_STRUCTP(r->out.count);
16782         }
16783         if (flags & NDR_OUT) {
16784                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
16785                 if (_ptr_info) {
16786                         NDR_PULL_ALLOC(ndr, r->out.info);
16787                 } else {
16788                         r->out.info = NULL;
16789                 }
16790                 if (r->out.info) {
16791                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16792                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16793                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
16794                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16795                 }
16796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16797                         NDR_PULL_ALLOC(ndr, r->out.needed);
16798                 }
16799                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16800                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16804                         NDR_PULL_ALLOC(ndr, r->out.count);
16805                 }
16806                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16811         }
16812         return NDR_ERR_SUCCESS;
16813 }
16814
16815 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
16816 {
16817         uint32_t cntr_info_0;
16818         if (flags & NDR_IN) {
16819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
16820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
16821         }
16822         if (flags & NDR_OUT) {
16823                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16824                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16825                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16826                 }
16827                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16828                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16829                 }
16830         }
16831         return NDR_ERR_SUCCESS;
16832 }
16833
16834 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
16835 {
16836         uint32_t cntr_info_0;
16837         TALLOC_CTX *_mem_save_info_0;
16838         if (flags & NDR_IN) {
16839                 ZERO_STRUCT(r->out);
16840
16841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
16842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
16843         }
16844         if (flags & NDR_OUT) {
16845                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
16846                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
16847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
16848                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16849                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
16850                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
16851                 }
16852                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
16853                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
16854                 }
16855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
16856         }
16857         return NDR_ERR_SUCCESS;
16858 }
16859
16860 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
16861 {
16862         uint32_t cntr_info_1;
16863         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
16864         ndr->depth++;
16865         if (flags & NDR_SET_VALUES) {
16866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16867         }
16868         if (flags & NDR_IN) {
16869                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
16870                 ndr->depth++;
16871                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
16872                 ndr_print_ptr(ndr, "server", r->in.server);
16873                 ndr->depth++;
16874                 if (r->in.server) {
16875                         ndr_print_string(ndr, "server", r->in.server);
16876                 }
16877                 ndr->depth--;
16878                 ndr_print_uint32(ndr, "level", r->in.level);
16879                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
16880                 ndr->depth++;
16881                 if (r->in.buffer) {
16882                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
16883                 }
16884                 ndr->depth--;
16885                 ndr_print_uint32(ndr, "offered", r->in.offered);
16886                 ndr->depth--;
16887         }
16888         if (flags & NDR_OUT) {
16889                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
16890                 ndr->depth++;
16891                 ndr_print_ptr(ndr, "count", r->out.count);
16892                 ndr->depth++;
16893                 ndr_print_uint32(ndr, "count", *r->out.count);
16894                 ndr->depth--;
16895                 ndr_print_ptr(ndr, "info", r->out.info);
16896                 ndr->depth++;
16897                 if (r->out.info) {
16898                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
16899                         ndr->depth++;
16900                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
16901                                 char *idx_1=NULL;
16902                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
16903                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
16904                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
16905                                         free(idx_1);
16906                                 }
16907                         }
16908                         ndr->depth--;
16909                 }
16910                 ndr->depth--;
16911                 ndr_print_ptr(ndr, "needed", r->out.needed);
16912                 ndr->depth++;
16913                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16914                 ndr->depth--;
16915                 ndr_print_WERROR(ndr, "result", r->out.result);
16916                 ndr->depth--;
16917         }
16918         ndr->depth--;
16919 }
16920
16921 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
16922 {
16923         if (flags & NDR_IN) {
16924                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
16925                 if (r->in.printername) {
16926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
16927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
16929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16930                 }
16931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
16932                 if (r->in.datatype) {
16933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
16934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
16936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16937                 }
16938                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
16939                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
16940         }
16941         if (flags & NDR_OUT) {
16942                 if (r->out.handle == NULL) {
16943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16944                 }
16945                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
16946                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16947         }
16948         return NDR_ERR_SUCCESS;
16949 }
16950
16951 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
16952 {
16953         uint32_t _ptr_printername;
16954         uint32_t _ptr_datatype;
16955         TALLOC_CTX *_mem_save_printername_0;
16956         TALLOC_CTX *_mem_save_datatype_0;
16957         TALLOC_CTX *_mem_save_handle_0;
16958         if (flags & NDR_IN) {
16959                 ZERO_STRUCT(r->out);
16960
16961                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
16962                 if (_ptr_printername) {
16963                         NDR_PULL_ALLOC(ndr, r->in.printername);
16964                 } else {
16965                         r->in.printername = NULL;
16966                 }
16967                 if (r->in.printername) {
16968                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
16969                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
16970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
16971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
16972                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
16973                                 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));
16974                         }
16975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
16976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
16977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
16978                 }
16979                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
16980                 if (_ptr_datatype) {
16981                         NDR_PULL_ALLOC(ndr, r->in.datatype);
16982                 } else {
16983                         r->in.datatype = NULL;
16984                 }
16985                 if (r->in.datatype) {
16986                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
16987                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
16988                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
16989                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
16990                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
16991                                 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));
16992                         }
16993                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
16994                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
16995                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
16996                 }
16997                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
16998                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
16999                 NDR_PULL_ALLOC(ndr, r->out.handle);
17000                 ZERO_STRUCTP(r->out.handle);
17001         }
17002         if (flags & NDR_OUT) {
17003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17004                         NDR_PULL_ALLOC(ndr, r->out.handle);
17005                 }
17006                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
17008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
17009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17011         }
17012         return NDR_ERR_SUCCESS;
17013 }
17014
17015 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
17016 {
17017         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
17018         ndr->depth++;
17019         if (flags & NDR_SET_VALUES) {
17020                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17021         }
17022         if (flags & NDR_IN) {
17023                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
17024                 ndr->depth++;
17025                 ndr_print_ptr(ndr, "printername", r->in.printername);
17026                 ndr->depth++;
17027                 if (r->in.printername) {
17028                         ndr_print_string(ndr, "printername", r->in.printername);
17029                 }
17030                 ndr->depth--;
17031                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
17032                 ndr->depth++;
17033                 if (r->in.datatype) {
17034                         ndr_print_string(ndr, "datatype", r->in.datatype);
17035                 }
17036                 ndr->depth--;
17037                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
17038                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
17039                 ndr->depth--;
17040         }
17041         if (flags & NDR_OUT) {
17042                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
17043                 ndr->depth++;
17044                 ndr_print_ptr(ndr, "handle", r->out.handle);
17045                 ndr->depth++;
17046                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
17047                 ndr->depth--;
17048                 ndr_print_WERROR(ndr, "result", r->out.result);
17049                 ndr->depth--;
17050         }
17051         ndr->depth--;
17052 }
17053
17054 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
17055 {
17056         if (flags & NDR_IN) {
17057                 if (r->in.handle == NULL) {
17058                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17059                 }
17060                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
17062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
17063                 if (r->in.ctr) {
17064                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
17065                 }
17066                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
17067         }
17068         if (flags & NDR_OUT) {
17069                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17070         }
17071         return NDR_ERR_SUCCESS;
17072 }
17073
17074 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
17075 {
17076         uint32_t _ptr_ctr;
17077         TALLOC_CTX *_mem_save_handle_0;
17078         TALLOC_CTX *_mem_save_ctr_0;
17079         if (flags & NDR_IN) {
17080                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17081                         NDR_PULL_ALLOC(ndr, r->in.handle);
17082                 }
17083                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17084                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17085                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17086                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
17088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
17089                 if (_ptr_ctr) {
17090                         NDR_PULL_ALLOC(ndr, r->in.ctr);
17091                 } else {
17092                         r->in.ctr = NULL;
17093                 }
17094                 if (r->in.ctr) {
17095                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17096                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
17097                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
17098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
17099                 }
17100                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
17101         }
17102         if (flags & NDR_OUT) {
17103                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17104         }
17105         return NDR_ERR_SUCCESS;
17106 }
17107
17108 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
17109 {
17110         ndr_print_struct(ndr, name, "spoolss_SetJob");
17111         ndr->depth++;
17112         if (flags & NDR_SET_VALUES) {
17113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17114         }
17115         if (flags & NDR_IN) {
17116                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
17117                 ndr->depth++;
17118                 ndr_print_ptr(ndr, "handle", r->in.handle);
17119                 ndr->depth++;
17120                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17121                 ndr->depth--;
17122                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
17123                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
17124                 ndr->depth++;
17125                 if (r->in.ctr) {
17126                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
17127                 }
17128                 ndr->depth--;
17129                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
17130                 ndr->depth--;
17131         }
17132         if (flags & NDR_OUT) {
17133                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
17134                 ndr->depth++;
17135                 ndr_print_WERROR(ndr, "result", r->out.result);
17136                 ndr->depth--;
17137         }
17138         ndr->depth--;
17139 }
17140
17141 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
17142 {
17143         if (flags & NDR_IN) {
17144                 if (r->in.handle == NULL) {
17145                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17146                 }
17147                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
17149                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17150                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17151                 if (r->in.buffer) {
17152                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17153                 }
17154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17155         }
17156         if (flags & NDR_OUT) {
17157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17158                 if (r->out.info) {
17159                         {
17160                                 struct ndr_push *_ndr_info;
17161                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17162                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
17163                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17164                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17165                         }
17166                 }
17167                 if (r->out.needed == NULL) {
17168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17169                 }
17170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17171                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17172         }
17173         return NDR_ERR_SUCCESS;
17174 }
17175
17176 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
17177 {
17178         uint32_t _ptr_buffer;
17179         uint32_t _ptr_info;
17180         TALLOC_CTX *_mem_save_handle_0;
17181         TALLOC_CTX *_mem_save_buffer_0;
17182         TALLOC_CTX *_mem_save_info_0;
17183         TALLOC_CTX *_mem_save_needed_0;
17184         if (flags & NDR_IN) {
17185                 ZERO_STRUCT(r->out);
17186
17187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17188                         NDR_PULL_ALLOC(ndr, r->in.handle);
17189                 }
17190                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17192                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
17195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17197                 if (_ptr_buffer) {
17198                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17199                 } else {
17200                         r->in.buffer = NULL;
17201                 }
17202                 if (r->in.buffer) {
17203                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17204                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17205                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17207                 }
17208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17209                 NDR_PULL_ALLOC(ndr, r->out.needed);
17210                 ZERO_STRUCTP(r->out.needed);
17211         }
17212         if (flags & NDR_OUT) {
17213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17214                 if (_ptr_info) {
17215                         NDR_PULL_ALLOC(ndr, r->out.info);
17216                 } else {
17217                         r->out.info = NULL;
17218                 }
17219                 if (r->out.info) {
17220                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17221                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17222                         {
17223                                 struct ndr_pull *_ndr_info;
17224                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17225                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
17226                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17227                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17228                         }
17229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17230                 }
17231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17232                         NDR_PULL_ALLOC(ndr, r->out.needed);
17233                 }
17234                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17235                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17238                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17239         }
17240         return NDR_ERR_SUCCESS;
17241 }
17242
17243 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
17244 {
17245         ndr_print_struct(ndr, name, "spoolss_GetJob");
17246         ndr->depth++;
17247         if (flags & NDR_SET_VALUES) {
17248                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17249         }
17250         if (flags & NDR_IN) {
17251                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
17252                 ndr->depth++;
17253                 ndr_print_ptr(ndr, "handle", r->in.handle);
17254                 ndr->depth++;
17255                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17256                 ndr->depth--;
17257                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
17258                 ndr_print_uint32(ndr, "level", r->in.level);
17259                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17260                 ndr->depth++;
17261                 if (r->in.buffer) {
17262                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17263                 }
17264                 ndr->depth--;
17265                 ndr_print_uint32(ndr, "offered", r->in.offered);
17266                 ndr->depth--;
17267         }
17268         if (flags & NDR_OUT) {
17269                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
17270                 ndr->depth++;
17271                 ndr_print_ptr(ndr, "info", r->out.info);
17272                 ndr->depth++;
17273                 if (r->out.info) {
17274                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
17275                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
17276                 }
17277                 ndr->depth--;
17278                 ndr_print_ptr(ndr, "needed", r->out.needed);
17279                 ndr->depth++;
17280                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17281                 ndr->depth--;
17282                 ndr_print_WERROR(ndr, "result", r->out.result);
17283                 ndr->depth--;
17284         }
17285         ndr->depth--;
17286 }
17287
17288 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
17289 {
17290         if (flags & NDR_IN) {
17291                 if (r->in.handle == NULL) {
17292                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17293                 }
17294                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
17296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
17297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17298                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17299                 if (r->in.buffer) {
17300                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17301                 }
17302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17303         }
17304         if (flags & NDR_OUT) {
17305                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17306                 if (r->out.info) {
17307                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
17308                 }
17309                 if (r->out.needed == NULL) {
17310                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17311                 }
17312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17313                 if (r->out.count == NULL) {
17314                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17315                 }
17316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
17317                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17318         }
17319         return NDR_ERR_SUCCESS;
17320 }
17321
17322 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
17323 {
17324         uint32_t _ptr_buffer;
17325         uint32_t _ptr_info;
17326         TALLOC_CTX *_mem_save_handle_0;
17327         TALLOC_CTX *_mem_save_buffer_0;
17328         TALLOC_CTX *_mem_save_info_0;
17329         TALLOC_CTX *_mem_save_needed_0;
17330         TALLOC_CTX *_mem_save_count_0;
17331         if (flags & NDR_IN) {
17332                 ZERO_STRUCT(r->out);
17333
17334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17335                         NDR_PULL_ALLOC(ndr, r->in.handle);
17336                 }
17337                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17338                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17339                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
17342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
17343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17344                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17345                 if (_ptr_buffer) {
17346                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17347                 } else {
17348                         r->in.buffer = NULL;
17349                 }
17350                 if (r->in.buffer) {
17351                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17352                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17353                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17355                 }
17356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17357                 NDR_PULL_ALLOC(ndr, r->out.needed);
17358                 ZERO_STRUCTP(r->out.needed);
17359                 NDR_PULL_ALLOC(ndr, r->out.count);
17360                 ZERO_STRUCTP(r->out.count);
17361         }
17362         if (flags & NDR_OUT) {
17363                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17364                 if (_ptr_info) {
17365                         NDR_PULL_ALLOC(ndr, r->out.info);
17366                 } else {
17367                         r->out.info = NULL;
17368                 }
17369                 if (r->out.info) {
17370                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17371                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17372                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
17373                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17374                 }
17375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17376                         NDR_PULL_ALLOC(ndr, r->out.needed);
17377                 }
17378                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17379                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17383                         NDR_PULL_ALLOC(ndr, r->out.count);
17384                 }
17385                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
17386                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
17387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
17388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
17389                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17390         }
17391         return NDR_ERR_SUCCESS;
17392 }
17393
17394 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
17395 {
17396         uint32_t cntr_info_0;
17397         if (flags & NDR_IN) {
17398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
17400         }
17401         if (flags & NDR_OUT) {
17402                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17403                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
17404                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
17405                 }
17406                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17407                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
17408                 }
17409         }
17410         return NDR_ERR_SUCCESS;
17411 }
17412
17413 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
17414 {
17415         uint32_t cntr_info_0;
17416         TALLOC_CTX *_mem_save_info_0;
17417         if (flags & NDR_IN) {
17418                 ZERO_STRUCT(r->out);
17419
17420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17421                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
17422         }
17423         if (flags & NDR_OUT) {
17424                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
17425                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17426                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17427                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17428                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
17429                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
17430                 }
17431                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
17432                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
17433                 }
17434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17435         }
17436         return NDR_ERR_SUCCESS;
17437 }
17438
17439 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
17440 {
17441         uint32_t cntr_info_1;
17442         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
17443         ndr->depth++;
17444         if (flags & NDR_SET_VALUES) {
17445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17446         }
17447         if (flags & NDR_IN) {
17448                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
17449                 ndr->depth++;
17450                 ndr_print_ptr(ndr, "handle", r->in.handle);
17451                 ndr->depth++;
17452                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17453                 ndr->depth--;
17454                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
17455                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
17456                 ndr_print_uint32(ndr, "level", r->in.level);
17457                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17458                 ndr->depth++;
17459                 if (r->in.buffer) {
17460                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17461                 }
17462                 ndr->depth--;
17463                 ndr_print_uint32(ndr, "offered", r->in.offered);
17464                 ndr->depth--;
17465         }
17466         if (flags & NDR_OUT) {
17467                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
17468                 ndr->depth++;
17469                 ndr_print_ptr(ndr, "count", r->out.count);
17470                 ndr->depth++;
17471                 ndr_print_uint32(ndr, "count", *r->out.count);
17472                 ndr->depth--;
17473                 ndr_print_ptr(ndr, "info", r->out.info);
17474                 ndr->depth++;
17475                 if (r->out.info) {
17476                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
17477                         ndr->depth++;
17478                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
17479                                 char *idx_1=NULL;
17480                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
17481                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
17482                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
17483                                         free(idx_1);
17484                                 }
17485                         }
17486                         ndr->depth--;
17487                 }
17488                 ndr->depth--;
17489                 ndr_print_ptr(ndr, "needed", r->out.needed);
17490                 ndr->depth++;
17491                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17492                 ndr->depth--;
17493                 ndr_print_WERROR(ndr, "result", r->out.result);
17494                 ndr->depth--;
17495         }
17496         ndr->depth--;
17497 }
17498
17499 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
17500 {
17501         if (flags & NDR_IN) {
17502         }
17503         if (flags & NDR_OUT) {
17504                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17505         }
17506         return NDR_ERR_SUCCESS;
17507 }
17508
17509 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
17510 {
17511         if (flags & NDR_IN) {
17512         }
17513         if (flags & NDR_OUT) {
17514                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17515         }
17516         return NDR_ERR_SUCCESS;
17517 }
17518
17519 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
17520 {
17521         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
17522         ndr->depth++;
17523         if (flags & NDR_SET_VALUES) {
17524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17525         }
17526         if (flags & NDR_IN) {
17527                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
17528                 ndr->depth++;
17529                 ndr->depth--;
17530         }
17531         if (flags & NDR_OUT) {
17532                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
17533                 ndr->depth++;
17534                 ndr_print_WERROR(ndr, "result", r->out.result);
17535                 ndr->depth--;
17536         }
17537         ndr->depth--;
17538 }
17539
17540 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
17541 {
17542         if (flags & NDR_IN) {
17543                 if (r->in.handle == NULL) {
17544                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17545                 }
17546                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17547         }
17548         if (flags & NDR_OUT) {
17549                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17550         }
17551         return NDR_ERR_SUCCESS;
17552 }
17553
17554 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
17555 {
17556         TALLOC_CTX *_mem_save_handle_0;
17557         if (flags & NDR_IN) {
17558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17559                         NDR_PULL_ALLOC(ndr, r->in.handle);
17560                 }
17561                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17563                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17565         }
17566         if (flags & NDR_OUT) {
17567                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17568         }
17569         return NDR_ERR_SUCCESS;
17570 }
17571
17572 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
17573 {
17574         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
17575         ndr->depth++;
17576         if (flags & NDR_SET_VALUES) {
17577                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17578         }
17579         if (flags & NDR_IN) {
17580                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
17581                 ndr->depth++;
17582                 ndr_print_ptr(ndr, "handle", r->in.handle);
17583                 ndr->depth++;
17584                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17585                 ndr->depth--;
17586                 ndr->depth--;
17587         }
17588         if (flags & NDR_OUT) {
17589                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
17590                 ndr->depth++;
17591                 ndr_print_WERROR(ndr, "result", r->out.result);
17592                 ndr->depth--;
17593         }
17594         ndr->depth--;
17595 }
17596
17597 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
17598 {
17599         if (flags & NDR_IN) {
17600                 if (r->in.handle == NULL) {
17601                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17602                 }
17603                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17604                 if (r->in.info_ctr == NULL) {
17605                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17606                 }
17607                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17608                 if (r->in.devmode_ctr == NULL) {
17609                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17610                 }
17611                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
17612                 if (r->in.secdesc_ctr == NULL) {
17613                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17614                 }
17615                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
17616                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
17617         }
17618         if (flags & NDR_OUT) {
17619                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17620         }
17621         return NDR_ERR_SUCCESS;
17622 }
17623
17624 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
17625 {
17626         TALLOC_CTX *_mem_save_handle_0;
17627         TALLOC_CTX *_mem_save_info_ctr_0;
17628         TALLOC_CTX *_mem_save_devmode_ctr_0;
17629         TALLOC_CTX *_mem_save_secdesc_ctr_0;
17630         if (flags & NDR_IN) {
17631                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17632                         NDR_PULL_ALLOC(ndr, r->in.handle);
17633                 }
17634                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17635                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17636                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17637                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17638                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17639                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
17640                 }
17641                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17642                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
17643                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17644                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17645                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17646                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
17647                 }
17648                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17649                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
17650                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
17651                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17653                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
17654                 }
17655                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17656                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
17657                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
17658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17659                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
17660         }
17661         if (flags & NDR_OUT) {
17662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17663         }
17664         return NDR_ERR_SUCCESS;
17665 }
17666
17667 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
17668 {
17669         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
17670         ndr->depth++;
17671         if (flags & NDR_SET_VALUES) {
17672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17673         }
17674         if (flags & NDR_IN) {
17675                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
17676                 ndr->depth++;
17677                 ndr_print_ptr(ndr, "handle", r->in.handle);
17678                 ndr->depth++;
17679                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17680                 ndr->depth--;
17681                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
17682                 ndr->depth++;
17683                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
17684                 ndr->depth--;
17685                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
17686                 ndr->depth++;
17687                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
17688                 ndr->depth--;
17689                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
17690                 ndr->depth++;
17691                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
17692                 ndr->depth--;
17693                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
17694                 ndr->depth--;
17695         }
17696         if (flags & NDR_OUT) {
17697                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
17698                 ndr->depth++;
17699                 ndr_print_WERROR(ndr, "result", r->out.result);
17700                 ndr->depth--;
17701         }
17702         ndr->depth--;
17703 }
17704
17705 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
17706 {
17707         if (flags & NDR_IN) {
17708                 if (r->in.handle == NULL) {
17709                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17710                 }
17711                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17714                 if (r->in.buffer) {
17715                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17716                 }
17717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17718         }
17719         if (flags & NDR_OUT) {
17720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17721                 if (r->out.info) {
17722                         {
17723                                 struct ndr_push *_ndr_info;
17724                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17725                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
17726                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17727                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17728                         }
17729                 }
17730                 if (r->out.needed == NULL) {
17731                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17732                 }
17733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17734                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17735         }
17736         return NDR_ERR_SUCCESS;
17737 }
17738
17739 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
17740 {
17741         uint32_t _ptr_buffer;
17742         uint32_t _ptr_info;
17743         TALLOC_CTX *_mem_save_handle_0;
17744         TALLOC_CTX *_mem_save_buffer_0;
17745         TALLOC_CTX *_mem_save_info_0;
17746         TALLOC_CTX *_mem_save_needed_0;
17747         if (flags & NDR_IN) {
17748                 ZERO_STRUCT(r->out);
17749
17750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17751                         NDR_PULL_ALLOC(ndr, r->in.handle);
17752                 }
17753                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
17754                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
17755                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
17756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
17757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
17758                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
17759                 if (_ptr_buffer) {
17760                         NDR_PULL_ALLOC(ndr, r->in.buffer);
17761                 } else {
17762                         r->in.buffer = NULL;
17763                 }
17764                 if (r->in.buffer) {
17765                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
17766                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
17767                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
17768                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
17769                 }
17770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
17771                 NDR_PULL_ALLOC(ndr, r->out.needed);
17772                 ZERO_STRUCTP(r->out.needed);
17773         }
17774         if (flags & NDR_OUT) {
17775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
17776                 if (_ptr_info) {
17777                         NDR_PULL_ALLOC(ndr, r->out.info);
17778                 } else {
17779                         r->out.info = NULL;
17780                 }
17781                 if (r->out.info) {
17782                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
17783                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
17784                         {
17785                                 struct ndr_pull *_ndr_info;
17786                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
17787                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
17788                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
17789                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
17790                         }
17791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
17792                 }
17793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17794                         NDR_PULL_ALLOC(ndr, r->out.needed);
17795                 }
17796                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
17797                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
17798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
17799                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
17800                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17801         }
17802         return NDR_ERR_SUCCESS;
17803 }
17804
17805 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
17806 {
17807         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
17808         ndr->depth++;
17809         if (flags & NDR_SET_VALUES) {
17810                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17811         }
17812         if (flags & NDR_IN) {
17813                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
17814                 ndr->depth++;
17815                 ndr_print_ptr(ndr, "handle", r->in.handle);
17816                 ndr->depth++;
17817                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
17818                 ndr->depth--;
17819                 ndr_print_uint32(ndr, "level", r->in.level);
17820                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
17821                 ndr->depth++;
17822                 if (r->in.buffer) {
17823                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
17824                 }
17825                 ndr->depth--;
17826                 ndr_print_uint32(ndr, "offered", r->in.offered);
17827                 ndr->depth--;
17828         }
17829         if (flags & NDR_OUT) {
17830                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
17831                 ndr->depth++;
17832                 ndr_print_ptr(ndr, "info", r->out.info);
17833                 ndr->depth++;
17834                 if (r->out.info) {
17835                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
17836                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
17837                 }
17838                 ndr->depth--;
17839                 ndr_print_ptr(ndr, "needed", r->out.needed);
17840                 ndr->depth++;
17841                 ndr_print_uint32(ndr, "needed", *r->out.needed);
17842                 ndr->depth--;
17843                 ndr_print_WERROR(ndr, "result", r->out.result);
17844                 ndr->depth--;
17845         }
17846         ndr->depth--;
17847 }
17848
17849 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
17850 {
17851         if (flags & NDR_IN) {
17852                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
17853                 if (r->in.servername) {
17854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
17855                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17856                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
17857                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17858                 }
17859                 if (r->in.info_ctr == NULL) {
17860                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17861                 }
17862                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17863         }
17864         if (flags & NDR_OUT) {
17865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17866         }
17867         return NDR_ERR_SUCCESS;
17868 }
17869
17870 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
17871 {
17872         uint32_t _ptr_servername;
17873         TALLOC_CTX *_mem_save_servername_0;
17874         TALLOC_CTX *_mem_save_info_ctr_0;
17875         if (flags & NDR_IN) {
17876                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
17877                 if (_ptr_servername) {
17878                         NDR_PULL_ALLOC(ndr, r->in.servername);
17879                 } else {
17880                         r->in.servername = NULL;
17881                 }
17882                 if (r->in.servername) {
17883                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
17884                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
17885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
17886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
17887                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
17888                                 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));
17889                         }
17890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
17891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
17892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
17893                 }
17894                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
17895                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
17896                 }
17897                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
17898                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
17899                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
17900                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
17901         }
17902         if (flags & NDR_OUT) {
17903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17904         }
17905         return NDR_ERR_SUCCESS;
17906 }
17907
17908 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
17909 {
17910         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
17911         ndr->depth++;
17912         if (flags & NDR_SET_VALUES) {
17913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17914         }
17915         if (flags & NDR_IN) {
17916                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
17917                 ndr->depth++;
17918                 ndr_print_ptr(ndr, "servername", r->in.servername);
17919                 ndr->depth++;
17920                 if (r->in.servername) {
17921                         ndr_print_string(ndr, "servername", r->in.servername);
17922                 }
17923                 ndr->depth--;
17924                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
17925                 ndr->depth++;
17926                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
17927                 ndr->depth--;
17928                 ndr->depth--;
17929         }
17930         if (flags & NDR_OUT) {
17931                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
17932                 ndr->depth++;
17933                 ndr_print_WERROR(ndr, "result", r->out.result);
17934                 ndr->depth--;
17935         }
17936         ndr->depth--;
17937 }
17938
17939 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
17940 {
17941         if (flags & NDR_IN) {
17942                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
17943                 if (r->in.server) {
17944                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
17947                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17948                 }
17949                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
17950                 if (r->in.environment) {
17951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
17954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17955                 }
17956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
17957                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
17958                 if (r->in.buffer) {
17959                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
17960                 }
17961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
17962         }
17963         if (flags & NDR_OUT) {
17964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
17965                 if (r->out.info) {
17966                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
17967                 }
17968                 if (r->out.needed == NULL) {
17969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17970                 }
17971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
17972                 if (r->out.count == NULL) {
17973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
17974                 }
17975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
17976                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17977         }
17978         return NDR_ERR_SUCCESS;
17979 }
17980
17981 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
17982 {
17983         uint32_t _ptr_server;
17984         uint32_t _ptr_environment;
17985         uint32_t _ptr_buffer;
17986         uint32_t _ptr_info;
17987         TALLOC_CTX *_mem_save_server_0;
17988         TALLOC_CTX *_mem_save_environment_0;
17989         TALLOC_CTX *_mem_save_buffer_0;
17990         TALLOC_CTX *_mem_save_info_0;
17991         TALLOC_CTX *_mem_save_needed_0;
17992         TALLOC_CTX *_mem_save_count_0;
17993         if (flags & NDR_IN) {
17994                 ZERO_STRUCT(r->out);
17995
17996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
17997                 if (_ptr_server) {
17998                         NDR_PULL_ALLOC(ndr, r->in.server);
17999                 } else {
18000                         r->in.server = NULL;
18001                 }
18002                 if (r->in.server) {
18003                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18004                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18005                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18006                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18007                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18008                                 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));
18009                         }
18010                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18011                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18012                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18013                 }
18014                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18015                 if (_ptr_environment) {
18016                         NDR_PULL_ALLOC(ndr, r->in.environment);
18017                 } else {
18018                         r->in.environment = NULL;
18019                 }
18020                 if (r->in.environment) {
18021                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18022                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
18023                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
18024                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
18025                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
18026                                 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));
18027                         }
18028                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
18029                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
18030                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18031                 }
18032                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18034                 if (_ptr_buffer) {
18035                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18036                 } else {
18037                         r->in.buffer = NULL;
18038                 }
18039                 if (r->in.buffer) {
18040                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18041                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18042                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18044                 }
18045                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18046                 NDR_PULL_ALLOC(ndr, r->out.needed);
18047                 ZERO_STRUCTP(r->out.needed);
18048                 NDR_PULL_ALLOC(ndr, r->out.count);
18049                 ZERO_STRUCTP(r->out.count);
18050         }
18051         if (flags & NDR_OUT) {
18052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18053                 if (_ptr_info) {
18054                         NDR_PULL_ALLOC(ndr, r->out.info);
18055                 } else {
18056                         r->out.info = NULL;
18057                 }
18058                 if (r->out.info) {
18059                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18060                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18061                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18063                 }
18064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18065                         NDR_PULL_ALLOC(ndr, r->out.needed);
18066                 }
18067                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18068                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18071                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18072                         NDR_PULL_ALLOC(ndr, r->out.count);
18073                 }
18074                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18075                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18077                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18078                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18079         }
18080         return NDR_ERR_SUCCESS;
18081 }
18082
18083 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
18084 {
18085         uint32_t cntr_info_0;
18086         if (flags & NDR_IN) {
18087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18089         }
18090         if (flags & NDR_OUT) {
18091                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18092                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18093                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18094                 }
18095                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18096                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18097                 }
18098         }
18099         return NDR_ERR_SUCCESS;
18100 }
18101
18102 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
18103 {
18104         uint32_t cntr_info_0;
18105         TALLOC_CTX *_mem_save_info_0;
18106         if (flags & NDR_IN) {
18107                 ZERO_STRUCT(r->out);
18108
18109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18111         }
18112         if (flags & NDR_OUT) {
18113                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18114                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18115                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18116                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18117                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18118                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18119                 }
18120                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18121                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18122                 }
18123                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18124         }
18125         return NDR_ERR_SUCCESS;
18126 }
18127
18128 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
18129 {
18130         uint32_t cntr_info_1;
18131         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
18132         ndr->depth++;
18133         if (flags & NDR_SET_VALUES) {
18134                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18135         }
18136         if (flags & NDR_IN) {
18137                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
18138                 ndr->depth++;
18139                 ndr_print_ptr(ndr, "server", r->in.server);
18140                 ndr->depth++;
18141                 if (r->in.server) {
18142                         ndr_print_string(ndr, "server", r->in.server);
18143                 }
18144                 ndr->depth--;
18145                 ndr_print_ptr(ndr, "environment", r->in.environment);
18146                 ndr->depth++;
18147                 if (r->in.environment) {
18148                         ndr_print_string(ndr, "environment", r->in.environment);
18149                 }
18150                 ndr->depth--;
18151                 ndr_print_uint32(ndr, "level", r->in.level);
18152                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18153                 ndr->depth++;
18154                 if (r->in.buffer) {
18155                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18156                 }
18157                 ndr->depth--;
18158                 ndr_print_uint32(ndr, "offered", r->in.offered);
18159                 ndr->depth--;
18160         }
18161         if (flags & NDR_OUT) {
18162                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
18163                 ndr->depth++;
18164                 ndr_print_ptr(ndr, "count", r->out.count);
18165                 ndr->depth++;
18166                 ndr_print_uint32(ndr, "count", *r->out.count);
18167                 ndr->depth--;
18168                 ndr_print_ptr(ndr, "info", r->out.info);
18169                 ndr->depth++;
18170                 if (r->out.info) {
18171                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18172                         ndr->depth++;
18173                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18174                                 char *idx_1=NULL;
18175                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18176                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18177                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
18178                                         free(idx_1);
18179                                 }
18180                         }
18181                         ndr->depth--;
18182                 }
18183                 ndr->depth--;
18184                 ndr_print_ptr(ndr, "needed", r->out.needed);
18185                 ndr->depth++;
18186                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18187                 ndr->depth--;
18188                 ndr_print_WERROR(ndr, "result", r->out.result);
18189                 ndr->depth--;
18190         }
18191         ndr->depth--;
18192 }
18193
18194 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
18195 {
18196         if (flags & NDR_IN) {
18197         }
18198         if (flags & NDR_OUT) {
18199                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18200         }
18201         return NDR_ERR_SUCCESS;
18202 }
18203
18204 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
18205 {
18206         if (flags & NDR_IN) {
18207         }
18208         if (flags & NDR_OUT) {
18209                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18210         }
18211         return NDR_ERR_SUCCESS;
18212 }
18213
18214 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
18215 {
18216         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
18217         ndr->depth++;
18218         if (flags & NDR_SET_VALUES) {
18219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18220         }
18221         if (flags & NDR_IN) {
18222                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
18223                 ndr->depth++;
18224                 ndr->depth--;
18225         }
18226         if (flags & NDR_OUT) {
18227                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
18228                 ndr->depth++;
18229                 ndr_print_WERROR(ndr, "result", r->out.result);
18230                 ndr->depth--;
18231         }
18232         ndr->depth--;
18233 }
18234
18235 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
18236 {
18237         if (flags & NDR_IN) {
18238                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18239                 if (r->in.server) {
18240                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18243                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18244                 }
18245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
18246                 if (r->in.environment) {
18247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
18248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
18250                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18251                 }
18252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18254                 if (r->in.buffer) {
18255                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18256                 }
18257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18258         }
18259         if (flags & NDR_OUT) {
18260                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18261                 if (r->out.info) {
18262                         {
18263                                 struct ndr_push *_ndr_info;
18264                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18265                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18266                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
18267                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18268                         }
18269                 }
18270                 if (r->out.needed == NULL) {
18271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18272                 }
18273                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18274                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18275         }
18276         return NDR_ERR_SUCCESS;
18277 }
18278
18279 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
18280 {
18281         uint32_t _ptr_server;
18282         uint32_t _ptr_environment;
18283         uint32_t _ptr_buffer;
18284         uint32_t _ptr_info;
18285         TALLOC_CTX *_mem_save_server_0;
18286         TALLOC_CTX *_mem_save_environment_0;
18287         TALLOC_CTX *_mem_save_buffer_0;
18288         TALLOC_CTX *_mem_save_info_0;
18289         TALLOC_CTX *_mem_save_needed_0;
18290         if (flags & NDR_IN) {
18291                 ZERO_STRUCT(r->out);
18292
18293                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18294                 if (_ptr_server) {
18295                         NDR_PULL_ALLOC(ndr, r->in.server);
18296                 } else {
18297                         r->in.server = NULL;
18298                 }
18299                 if (r->in.server) {
18300                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18301                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18302                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18303                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18304                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18305                                 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));
18306                         }
18307                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18308                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18310                 }
18311                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18312                 if (_ptr_environment) {
18313                         NDR_PULL_ALLOC(ndr, r->in.environment);
18314                 } else {
18315                         r->in.environment = NULL;
18316                 }
18317                 if (r->in.environment) {
18318                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18319                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
18320                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
18321                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
18322                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
18323                                 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));
18324                         }
18325                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
18326                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
18327                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18328                 }
18329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18330                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18331                 if (_ptr_buffer) {
18332                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18333                 } else {
18334                         r->in.buffer = NULL;
18335                 }
18336                 if (r->in.buffer) {
18337                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18338                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18339                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18341                 }
18342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18343                 NDR_PULL_ALLOC(ndr, r->out.needed);
18344                 ZERO_STRUCTP(r->out.needed);
18345         }
18346         if (flags & NDR_OUT) {
18347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18348                 if (_ptr_info) {
18349                         NDR_PULL_ALLOC(ndr, r->out.info);
18350                 } else {
18351                         r->out.info = NULL;
18352                 }
18353                 if (r->out.info) {
18354                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18355                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18356                         {
18357                                 struct ndr_pull *_ndr_info;
18358                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18359                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18360                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
18361                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18362                         }
18363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18364                 }
18365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18366                         NDR_PULL_ALLOC(ndr, r->out.needed);
18367                 }
18368                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18369                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18372                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18373         }
18374         return NDR_ERR_SUCCESS;
18375 }
18376
18377 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
18378 {
18379         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
18380         ndr->depth++;
18381         if (flags & NDR_SET_VALUES) {
18382                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18383         }
18384         if (flags & NDR_IN) {
18385                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
18386                 ndr->depth++;
18387                 ndr_print_ptr(ndr, "server", r->in.server);
18388                 ndr->depth++;
18389                 if (r->in.server) {
18390                         ndr_print_string(ndr, "server", r->in.server);
18391                 }
18392                 ndr->depth--;
18393                 ndr_print_ptr(ndr, "environment", r->in.environment);
18394                 ndr->depth++;
18395                 if (r->in.environment) {
18396                         ndr_print_string(ndr, "environment", r->in.environment);
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_GetPrinterDriverDirectory");
18411                 ndr->depth++;
18412                 ndr_print_ptr(ndr, "info", r->out.info);
18413                 ndr->depth++;
18414                 if (r->out.info) {
18415                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
18416                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
18417                 }
18418                 ndr->depth--;
18419                 ndr_print_ptr(ndr, "needed", r->out.needed);
18420                 ndr->depth++;
18421                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18422                 ndr->depth--;
18423                 ndr_print_WERROR(ndr, "result", r->out.result);
18424                 ndr->depth--;
18425         }
18426         ndr->depth--;
18427 }
18428
18429 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
18430 {
18431         if (flags & NDR_IN) {
18432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18433                 if (r->in.server) {
18434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18438                 }
18439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
18440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
18442                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
18444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
18446                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18447         }
18448         if (flags & NDR_OUT) {
18449                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18450         }
18451         return NDR_ERR_SUCCESS;
18452 }
18453
18454 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
18455 {
18456         uint32_t _ptr_server;
18457         TALLOC_CTX *_mem_save_server_0;
18458         if (flags & NDR_IN) {
18459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18460                 if (_ptr_server) {
18461                         NDR_PULL_ALLOC(ndr, r->in.server);
18462                 } else {
18463                         r->in.server = NULL;
18464                 }
18465                 if (r->in.server) {
18466                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18467                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18470                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18471                                 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));
18472                         }
18473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18474                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18476                 }
18477                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
18478                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
18479                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
18480                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.architecture), ndr_get_array_length(ndr, &r->in.architecture));
18481                 }
18482                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
18483                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
18484                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
18485                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
18486                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
18487                         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));
18488                 }
18489                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
18490                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
18491         }
18492         if (flags & NDR_OUT) {
18493                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18494         }
18495         return NDR_ERR_SUCCESS;
18496 }
18497
18498 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
18499 {
18500         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
18501         ndr->depth++;
18502         if (flags & NDR_SET_VALUES) {
18503                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18504         }
18505         if (flags & NDR_IN) {
18506                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
18507                 ndr->depth++;
18508                 ndr_print_ptr(ndr, "server", r->in.server);
18509                 ndr->depth++;
18510                 if (r->in.server) {
18511                         ndr_print_string(ndr, "server", r->in.server);
18512                 }
18513                 ndr->depth--;
18514                 ndr_print_string(ndr, "architecture", r->in.architecture);
18515                 ndr_print_string(ndr, "driver", r->in.driver);
18516                 ndr->depth--;
18517         }
18518         if (flags & NDR_OUT) {
18519                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
18520                 ndr->depth++;
18521                 ndr_print_WERROR(ndr, "result", r->out.result);
18522                 ndr->depth--;
18523         }
18524         ndr->depth--;
18525 }
18526
18527 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
18528 {
18529         if (flags & NDR_IN) {
18530                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18531                 if (r->in.server) {
18532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18535                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18536                 }
18537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
18538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
18540                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
18542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
18544                 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));
18545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
18546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
18548                 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));
18549         }
18550         if (flags & NDR_OUT) {
18551                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18552         }
18553         return NDR_ERR_SUCCESS;
18554 }
18555
18556 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
18557 {
18558         uint32_t _ptr_server;
18559         TALLOC_CTX *_mem_save_server_0;
18560         if (flags & NDR_IN) {
18561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18562                 if (_ptr_server) {
18563                         NDR_PULL_ALLOC(ndr, r->in.server);
18564                 } else {
18565                         r->in.server = NULL;
18566                 }
18567                 if (r->in.server) {
18568                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18569                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18572                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18573                                 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));
18574                         }
18575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18578                 }
18579                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
18580                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
18581                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
18582                         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));
18583                 }
18584                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
18585                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
18586                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
18587                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
18588                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
18589                         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));
18590                 }
18591                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
18592                 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));
18593                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
18594                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
18595                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
18596                         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));
18597                 }
18598                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
18599                 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));
18600         }
18601         if (flags & NDR_OUT) {
18602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18603         }
18604         return NDR_ERR_SUCCESS;
18605 }
18606
18607 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
18608 {
18609         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
18610         ndr->depth++;
18611         if (flags & NDR_SET_VALUES) {
18612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18613         }
18614         if (flags & NDR_IN) {
18615                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
18616                 ndr->depth++;
18617                 ndr_print_ptr(ndr, "server", r->in.server);
18618                 ndr->depth++;
18619                 if (r->in.server) {
18620                         ndr_print_string(ndr, "server", r->in.server);
18621                 }
18622                 ndr->depth--;
18623                 ndr_print_string(ndr, "architecture", r->in.architecture);
18624                 ndr_print_string(ndr, "path_name", r->in.path_name);
18625                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
18626                 ndr->depth--;
18627         }
18628         if (flags & NDR_OUT) {
18629                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
18630                 ndr->depth++;
18631                 ndr_print_WERROR(ndr, "result", r->out.result);
18632                 ndr->depth--;
18633         }
18634         ndr->depth--;
18635 }
18636
18637 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
18638 {
18639         if (flags & NDR_IN) {
18640                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
18641                 if (r->in.servername) {
18642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18644                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
18645                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18646                 }
18647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
18648                 if (r->in.environment) {
18649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
18650                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
18652                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18653                 }
18654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18656                 if (r->in.buffer) {
18657                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18658                 }
18659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18660         }
18661         if (flags & NDR_OUT) {
18662                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18663                 if (r->out.info) {
18664                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18665                 }
18666                 if (r->out.needed == NULL) {
18667                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18668                 }
18669                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18670                 if (r->out.count == NULL) {
18671                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18672                 }
18673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18674                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18675         }
18676         return NDR_ERR_SUCCESS;
18677 }
18678
18679 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
18680 {
18681         uint32_t _ptr_servername;
18682         uint32_t _ptr_environment;
18683         uint32_t _ptr_buffer;
18684         uint32_t _ptr_info;
18685         TALLOC_CTX *_mem_save_servername_0;
18686         TALLOC_CTX *_mem_save_environment_0;
18687         TALLOC_CTX *_mem_save_buffer_0;
18688         TALLOC_CTX *_mem_save_info_0;
18689         TALLOC_CTX *_mem_save_needed_0;
18690         TALLOC_CTX *_mem_save_count_0;
18691         if (flags & NDR_IN) {
18692                 ZERO_STRUCT(r->out);
18693
18694                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
18695                 if (_ptr_servername) {
18696                         NDR_PULL_ALLOC(ndr, r->in.servername);
18697                 } else {
18698                         r->in.servername = NULL;
18699                 }
18700                 if (r->in.servername) {
18701                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18702                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
18703                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
18704                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
18705                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
18706                                 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));
18707                         }
18708                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
18709                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
18710                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
18711                 }
18712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18713                 if (_ptr_environment) {
18714                         NDR_PULL_ALLOC(ndr, r->in.environment);
18715                 } else {
18716                         r->in.environment = NULL;
18717                 }
18718                 if (r->in.environment) {
18719                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18720                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
18721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
18722                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
18723                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
18724                                 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));
18725                         }
18726                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
18727                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
18728                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18729                 }
18730                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18732                 if (_ptr_buffer) {
18733                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18734                 } else {
18735                         r->in.buffer = NULL;
18736                 }
18737                 if (r->in.buffer) {
18738                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18739                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18740                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18742                 }
18743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18744                 NDR_PULL_ALLOC(ndr, r->out.needed);
18745                 ZERO_STRUCTP(r->out.needed);
18746                 NDR_PULL_ALLOC(ndr, r->out.count);
18747                 ZERO_STRUCTP(r->out.count);
18748         }
18749         if (flags & NDR_OUT) {
18750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18751                 if (_ptr_info) {
18752                         NDR_PULL_ALLOC(ndr, r->out.info);
18753                 } else {
18754                         r->out.info = NULL;
18755                 }
18756                 if (r->out.info) {
18757                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18758                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18759                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18761                 }
18762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18763                         NDR_PULL_ALLOC(ndr, r->out.needed);
18764                 }
18765                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18766                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18769                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18770                         NDR_PULL_ALLOC(ndr, r->out.count);
18771                 }
18772                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18773                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18775                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18776                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18777         }
18778         return NDR_ERR_SUCCESS;
18779 }
18780
18781 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
18782 {
18783         uint32_t cntr_info_0;
18784         if (flags & NDR_IN) {
18785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18787         }
18788         if (flags & NDR_OUT) {
18789                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18790                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18791                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18792                 }
18793                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18794                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18795                 }
18796         }
18797         return NDR_ERR_SUCCESS;
18798 }
18799
18800 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
18801 {
18802         uint32_t cntr_info_0;
18803         TALLOC_CTX *_mem_save_info_0;
18804         if (flags & NDR_IN) {
18805                 ZERO_STRUCT(r->out);
18806
18807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18809         }
18810         if (flags & NDR_OUT) {
18811                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18812                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18813                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18814                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18815                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18816                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18817                 }
18818                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18819                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18820                 }
18821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18822         }
18823         return NDR_ERR_SUCCESS;
18824 }
18825
18826 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
18827 {
18828         uint32_t cntr_info_1;
18829         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
18830         ndr->depth++;
18831         if (flags & NDR_SET_VALUES) {
18832                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18833         }
18834         if (flags & NDR_IN) {
18835                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
18836                 ndr->depth++;
18837                 ndr_print_ptr(ndr, "servername", r->in.servername);
18838                 ndr->depth++;
18839                 if (r->in.servername) {
18840                         ndr_print_string(ndr, "servername", r->in.servername);
18841                 }
18842                 ndr->depth--;
18843                 ndr_print_ptr(ndr, "environment", r->in.environment);
18844                 ndr->depth++;
18845                 if (r->in.environment) {
18846                         ndr_print_string(ndr, "environment", r->in.environment);
18847                 }
18848                 ndr->depth--;
18849                 ndr_print_uint32(ndr, "level", r->in.level);
18850                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18851                 ndr->depth++;
18852                 if (r->in.buffer) {
18853                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18854                 }
18855                 ndr->depth--;
18856                 ndr_print_uint32(ndr, "offered", r->in.offered);
18857                 ndr->depth--;
18858         }
18859         if (flags & NDR_OUT) {
18860                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
18861                 ndr->depth++;
18862                 ndr_print_ptr(ndr, "count", r->out.count);
18863                 ndr->depth++;
18864                 ndr_print_uint32(ndr, "count", *r->out.count);
18865                 ndr->depth--;
18866                 ndr_print_ptr(ndr, "info", r->out.info);
18867                 ndr->depth++;
18868                 if (r->out.info) {
18869                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18870                         ndr->depth++;
18871                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
18872                                 char *idx_1=NULL;
18873                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
18874                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
18875                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
18876                                         free(idx_1);
18877                                 }
18878                         }
18879                         ndr->depth--;
18880                 }
18881                 ndr->depth--;
18882                 ndr_print_ptr(ndr, "needed", r->out.needed);
18883                 ndr->depth++;
18884                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18885                 ndr->depth--;
18886                 ndr_print_WERROR(ndr, "result", r->out.result);
18887                 ndr->depth--;
18888         }
18889         ndr->depth--;
18890 }
18891
18892 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
18893 {
18894         if (flags & NDR_IN) {
18895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18896                 if (r->in.server) {
18897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18901                 }
18902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
18903                 if (r->in.environment) {
18904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
18905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
18907                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18908                 }
18909                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18911                 if (r->in.buffer) {
18912                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18913                 }
18914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18915         }
18916         if (flags & NDR_OUT) {
18917                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18918                 if (r->out.info) {
18919                         {
18920                                 struct ndr_push *_ndr_info;
18921                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18922                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18923                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
18924                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18925                         }
18926                 }
18927                 if (r->out.needed == NULL) {
18928                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18929                 }
18930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18931                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18932         }
18933         return NDR_ERR_SUCCESS;
18934 }
18935
18936 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
18937 {
18938         uint32_t _ptr_server;
18939         uint32_t _ptr_environment;
18940         uint32_t _ptr_buffer;
18941         uint32_t _ptr_info;
18942         TALLOC_CTX *_mem_save_server_0;
18943         TALLOC_CTX *_mem_save_environment_0;
18944         TALLOC_CTX *_mem_save_buffer_0;
18945         TALLOC_CTX *_mem_save_info_0;
18946         TALLOC_CTX *_mem_save_needed_0;
18947         if (flags & NDR_IN) {
18948                 ZERO_STRUCT(r->out);
18949
18950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18951                 if (_ptr_server) {
18952                         NDR_PULL_ALLOC(ndr, r->in.server);
18953                 } else {
18954                         r->in.server = NULL;
18955                 }
18956                 if (r->in.server) {
18957                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18958                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18961                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18962                                 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));
18963                         }
18964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18967                 }
18968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
18969                 if (_ptr_environment) {
18970                         NDR_PULL_ALLOC(ndr, r->in.environment);
18971                 } else {
18972                         r->in.environment = NULL;
18973                 }
18974                 if (r->in.environment) {
18975                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
18976                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
18977                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
18978                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
18979                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
18980                                 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));
18981                         }
18982                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
18983                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
18984                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
18985                 }
18986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18987                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18988                 if (_ptr_buffer) {
18989                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18990                 } else {
18991                         r->in.buffer = NULL;
18992                 }
18993                 if (r->in.buffer) {
18994                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18995                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18996                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18998                 }
18999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19000                 NDR_PULL_ALLOC(ndr, r->out.needed);
19001                 ZERO_STRUCTP(r->out.needed);
19002         }
19003         if (flags & NDR_OUT) {
19004                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19005                 if (_ptr_info) {
19006                         NDR_PULL_ALLOC(ndr, r->out.info);
19007                 } else {
19008                         r->out.info = NULL;
19009                 }
19010                 if (r->out.info) {
19011                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19012                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19013                         {
19014                                 struct ndr_pull *_ndr_info;
19015                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19016                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19017                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
19018                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19019                         }
19020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19021                 }
19022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19023                         NDR_PULL_ALLOC(ndr, r->out.needed);
19024                 }
19025                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19029                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19030         }
19031         return NDR_ERR_SUCCESS;
19032 }
19033
19034 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
19035 {
19036         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
19037         ndr->depth++;
19038         if (flags & NDR_SET_VALUES) {
19039                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19040         }
19041         if (flags & NDR_IN) {
19042                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
19043                 ndr->depth++;
19044                 ndr_print_ptr(ndr, "server", r->in.server);
19045                 ndr->depth++;
19046                 if (r->in.server) {
19047                         ndr_print_string(ndr, "server", r->in.server);
19048                 }
19049                 ndr->depth--;
19050                 ndr_print_ptr(ndr, "environment", r->in.environment);
19051                 ndr->depth++;
19052                 if (r->in.environment) {
19053                         ndr_print_string(ndr, "environment", r->in.environment);
19054                 }
19055                 ndr->depth--;
19056                 ndr_print_uint32(ndr, "level", r->in.level);
19057                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19058                 ndr->depth++;
19059                 if (r->in.buffer) {
19060                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19061                 }
19062                 ndr->depth--;
19063                 ndr_print_uint32(ndr, "offered", r->in.offered);
19064                 ndr->depth--;
19065         }
19066         if (flags & NDR_OUT) {
19067                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
19068                 ndr->depth++;
19069                 ndr_print_ptr(ndr, "info", r->out.info);
19070                 ndr->depth++;
19071                 if (r->out.info) {
19072                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19073                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
19074                 }
19075                 ndr->depth--;
19076                 ndr_print_ptr(ndr, "needed", r->out.needed);
19077                 ndr->depth++;
19078                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19079                 ndr->depth--;
19080                 ndr_print_WERROR(ndr, "result", r->out.result);
19081                 ndr->depth--;
19082         }
19083         ndr->depth--;
19084 }
19085
19086 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
19087 {
19088         if (flags & NDR_IN) {
19089                 if (r->in.handle == NULL) {
19090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19091                 }
19092                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19094                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
19095                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
19096         }
19097         if (flags & NDR_OUT) {
19098                 if (r->out.job_id == NULL) {
19099                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19100                 }
19101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
19102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19103         }
19104         return NDR_ERR_SUCCESS;
19105 }
19106
19107 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
19108 {
19109         TALLOC_CTX *_mem_save_handle_0;
19110         TALLOC_CTX *_mem_save_job_id_0;
19111         if (flags & NDR_IN) {
19112                 ZERO_STRUCT(r->out);
19113
19114                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19115                         NDR_PULL_ALLOC(ndr, r->in.handle);
19116                 }
19117                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19118                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19119                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19120                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19122                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
19123                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
19124                 NDR_PULL_ALLOC(ndr, r->out.job_id);
19125                 ZERO_STRUCTP(r->out.job_id);
19126         }
19127         if (flags & NDR_OUT) {
19128                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19129                         NDR_PULL_ALLOC(ndr, r->out.job_id);
19130                 }
19131                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
19132                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
19133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
19134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
19135                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19136         }
19137         return NDR_ERR_SUCCESS;
19138 }
19139
19140 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
19141 {
19142         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
19143         ndr->depth++;
19144         if (flags & NDR_SET_VALUES) {
19145                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19146         }
19147         if (flags & NDR_IN) {
19148                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
19149                 ndr->depth++;
19150                 ndr_print_ptr(ndr, "handle", r->in.handle);
19151                 ndr->depth++;
19152                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19153                 ndr->depth--;
19154                 ndr_print_uint32(ndr, "level", r->in.level);
19155                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
19156                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
19157                 ndr->depth--;
19158         }
19159         if (flags & NDR_OUT) {
19160                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
19161                 ndr->depth++;
19162                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
19163                 ndr->depth++;
19164                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
19165                 ndr->depth--;
19166                 ndr_print_WERROR(ndr, "result", r->out.result);
19167                 ndr->depth--;
19168         }
19169         ndr->depth--;
19170 }
19171
19172 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
19173 {
19174         if (flags & NDR_IN) {
19175                 if (r->in.handle == NULL) {
19176                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19177                 }
19178                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19179         }
19180         if (flags & NDR_OUT) {
19181                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19182         }
19183         return NDR_ERR_SUCCESS;
19184 }
19185
19186 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
19187 {
19188         TALLOC_CTX *_mem_save_handle_0;
19189         if (flags & NDR_IN) {
19190                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19191                         NDR_PULL_ALLOC(ndr, r->in.handle);
19192                 }
19193                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19194                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19195                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19196                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19197         }
19198         if (flags & NDR_OUT) {
19199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19200         }
19201         return NDR_ERR_SUCCESS;
19202 }
19203
19204 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
19205 {
19206         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
19207         ndr->depth++;
19208         if (flags & NDR_SET_VALUES) {
19209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19210         }
19211         if (flags & NDR_IN) {
19212                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
19213                 ndr->depth++;
19214                 ndr_print_ptr(ndr, "handle", r->in.handle);
19215                 ndr->depth++;
19216                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19217                 ndr->depth--;
19218                 ndr->depth--;
19219         }
19220         if (flags & NDR_OUT) {
19221                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
19222                 ndr->depth++;
19223                 ndr_print_WERROR(ndr, "result", r->out.result);
19224                 ndr->depth--;
19225         }
19226         ndr->depth--;
19227 }
19228
19229 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
19230 {
19231         if (flags & NDR_IN) {
19232                 if (r->in.handle == NULL) {
19233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19234                 }
19235                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19236                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
19237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
19238         }
19239         if (flags & NDR_OUT) {
19240                 if (r->out.num_written == NULL) {
19241                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19242                 }
19243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
19244                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19245         }
19246         return NDR_ERR_SUCCESS;
19247 }
19248
19249 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
19250 {
19251         TALLOC_CTX *_mem_save_handle_0;
19252         TALLOC_CTX *_mem_save_num_written_0;
19253         if (flags & NDR_IN) {
19254                 ZERO_STRUCT(r->out);
19255
19256                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19257                         NDR_PULL_ALLOC(ndr, r->in.handle);
19258                 }
19259                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19260                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19261                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19262                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19263                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
19264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
19265                 NDR_PULL_ALLOC(ndr, r->out.num_written);
19266                 ZERO_STRUCTP(r->out.num_written);
19267         }
19268         if (flags & NDR_OUT) {
19269                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19270                         NDR_PULL_ALLOC(ndr, r->out.num_written);
19271                 }
19272                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
19273                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
19274                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
19275                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
19276                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19277         }
19278         return NDR_ERR_SUCCESS;
19279 }
19280
19281 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
19282 {
19283         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
19284         ndr->depth++;
19285         if (flags & NDR_SET_VALUES) {
19286                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19287         }
19288         if (flags & NDR_IN) {
19289                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
19290                 ndr->depth++;
19291                 ndr_print_ptr(ndr, "handle", r->in.handle);
19292                 ndr->depth++;
19293                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19294                 ndr->depth--;
19295                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
19296                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
19297                 ndr->depth--;
19298         }
19299         if (flags & NDR_OUT) {
19300                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
19301                 ndr->depth++;
19302                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
19303                 ndr->depth++;
19304                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
19305                 ndr->depth--;
19306                 ndr_print_WERROR(ndr, "result", r->out.result);
19307                 ndr->depth--;
19308         }
19309         ndr->depth--;
19310 }
19311
19312 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
19313 {
19314         if (flags & NDR_IN) {
19315                 if (r->in.handle == NULL) {
19316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19317                 }
19318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19319         }
19320         if (flags & NDR_OUT) {
19321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19322         }
19323         return NDR_ERR_SUCCESS;
19324 }
19325
19326 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
19327 {
19328         TALLOC_CTX *_mem_save_handle_0;
19329         if (flags & NDR_IN) {
19330                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19331                         NDR_PULL_ALLOC(ndr, r->in.handle);
19332                 }
19333                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19334                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19335                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19336                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19337         }
19338         if (flags & NDR_OUT) {
19339                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19340         }
19341         return NDR_ERR_SUCCESS;
19342 }
19343
19344 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
19345 {
19346         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
19347         ndr->depth++;
19348         if (flags & NDR_SET_VALUES) {
19349                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19350         }
19351         if (flags & NDR_IN) {
19352                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
19353                 ndr->depth++;
19354                 ndr_print_ptr(ndr, "handle", r->in.handle);
19355                 ndr->depth++;
19356                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19357                 ndr->depth--;
19358                 ndr->depth--;
19359         }
19360         if (flags & NDR_OUT) {
19361                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
19362                 ndr->depth++;
19363                 ndr_print_WERROR(ndr, "result", r->out.result);
19364                 ndr->depth--;
19365         }
19366         ndr->depth--;
19367 }
19368
19369 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
19370 {
19371         if (flags & NDR_IN) {
19372                 if (r->in.handle == NULL) {
19373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19374                 }
19375                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19376         }
19377         if (flags & NDR_OUT) {
19378                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19379         }
19380         return NDR_ERR_SUCCESS;
19381 }
19382
19383 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
19384 {
19385         TALLOC_CTX *_mem_save_handle_0;
19386         if (flags & NDR_IN) {
19387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19388                         NDR_PULL_ALLOC(ndr, r->in.handle);
19389                 }
19390                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19391                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19392                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19394         }
19395         if (flags & NDR_OUT) {
19396                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19397         }
19398         return NDR_ERR_SUCCESS;
19399 }
19400
19401 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
19402 {
19403         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
19404         ndr->depth++;
19405         if (flags & NDR_SET_VALUES) {
19406                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19407         }
19408         if (flags & NDR_IN) {
19409                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
19410                 ndr->depth++;
19411                 ndr_print_ptr(ndr, "handle", r->in.handle);
19412                 ndr->depth++;
19413                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19414                 ndr->depth--;
19415                 ndr->depth--;
19416         }
19417         if (flags & NDR_OUT) {
19418                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
19419                 ndr->depth++;
19420                 ndr_print_WERROR(ndr, "result", r->out.result);
19421                 ndr->depth--;
19422         }
19423         ndr->depth--;
19424 }
19425
19426 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
19427 {
19428         if (flags & NDR_IN) {
19429                 if (r->in.handle == NULL) {
19430                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19431                 }
19432                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
19434         }
19435         if (flags & NDR_OUT) {
19436                 if (r->out.data == NULL) {
19437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19438                 }
19439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
19440                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
19441                 if (r->out._data_size == NULL) {
19442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19443                 }
19444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
19445                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19446         }
19447         return NDR_ERR_SUCCESS;
19448 }
19449
19450 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
19451 {
19452         TALLOC_CTX *_mem_save_handle_0;
19453         TALLOC_CTX *_mem_save__data_size_0;
19454         if (flags & NDR_IN) {
19455                 ZERO_STRUCT(r->out);
19456
19457                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19458                         NDR_PULL_ALLOC(ndr, r->in.handle);
19459                 }
19460                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19461                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19462                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
19465                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
19466                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
19467                 NDR_PULL_ALLOC(ndr, r->out._data_size);
19468                 ZERO_STRUCTP(r->out._data_size);
19469         }
19470         if (flags & NDR_OUT) {
19471                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
19472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19473                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
19474                 }
19475                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
19476                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19477                         NDR_PULL_ALLOC(ndr, r->out._data_size);
19478                 }
19479                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
19480                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
19481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
19482                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
19483                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19484                 if (r->out.data) {
19485                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
19486                 }
19487         }
19488         return NDR_ERR_SUCCESS;
19489 }
19490
19491 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
19492 {
19493         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
19494         ndr->depth++;
19495         if (flags & NDR_SET_VALUES) {
19496                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19497         }
19498         if (flags & NDR_IN) {
19499                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
19500                 ndr->depth++;
19501                 ndr_print_ptr(ndr, "handle", r->in.handle);
19502                 ndr->depth++;
19503                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19504                 ndr->depth--;
19505                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
19506                 ndr->depth--;
19507         }
19508         if (flags & NDR_OUT) {
19509                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
19510                 ndr->depth++;
19511                 ndr_print_ptr(ndr, "data", r->out.data);
19512                 ndr->depth++;
19513                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
19514                 ndr->depth--;
19515                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
19516                 ndr->depth++;
19517                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
19518                 ndr->depth--;
19519                 ndr_print_WERROR(ndr, "result", r->out.result);
19520                 ndr->depth--;
19521         }
19522         ndr->depth--;
19523 }
19524
19525 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
19526 {
19527         if (flags & NDR_IN) {
19528                 if (r->in.handle == NULL) {
19529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19530                 }
19531                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19532         }
19533         if (flags & NDR_OUT) {
19534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19535         }
19536         return NDR_ERR_SUCCESS;
19537 }
19538
19539 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
19540 {
19541         TALLOC_CTX *_mem_save_handle_0;
19542         if (flags & NDR_IN) {
19543                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19544                         NDR_PULL_ALLOC(ndr, r->in.handle);
19545                 }
19546                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19547                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19548                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19549                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19550         }
19551         if (flags & NDR_OUT) {
19552                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19553         }
19554         return NDR_ERR_SUCCESS;
19555 }
19556
19557 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
19558 {
19559         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
19560         ndr->depth++;
19561         if (flags & NDR_SET_VALUES) {
19562                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19563         }
19564         if (flags & NDR_IN) {
19565                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
19566                 ndr->depth++;
19567                 ndr_print_ptr(ndr, "handle", r->in.handle);
19568                 ndr->depth++;
19569                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19570                 ndr->depth--;
19571                 ndr->depth--;
19572         }
19573         if (flags & NDR_OUT) {
19574                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
19575                 ndr->depth++;
19576                 ndr_print_WERROR(ndr, "result", r->out.result);
19577                 ndr->depth--;
19578         }
19579         ndr->depth--;
19580 }
19581
19582 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
19583 {
19584         if (flags & NDR_IN) {
19585                 if (r->in.handle == NULL) {
19586                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19587                 }
19588                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19590                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19591                 if (r->in.buffer) {
19592                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19593                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
19594                 }
19595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19596         }
19597         if (flags & NDR_OUT) {
19598                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
19599                 if (r->out.buffer) {
19600                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19601                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
19602                 }
19603                 if (r->out.needed == NULL) {
19604                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19605                 }
19606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19607                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19608         }
19609         return NDR_ERR_SUCCESS;
19610 }
19611
19612 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
19613 {
19614         uint32_t _ptr_buffer;
19615         TALLOC_CTX *_mem_save_handle_0;
19616         TALLOC_CTX *_mem_save_buffer_0;
19617         TALLOC_CTX *_mem_save_needed_0;
19618         if (flags & NDR_IN) {
19619                 ZERO_STRUCT(r->out);
19620
19621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19622                         NDR_PULL_ALLOC(ndr, r->in.handle);
19623                 }
19624                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19625                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19626                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19629                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19630                 if (_ptr_buffer) {
19631                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19632                 } else {
19633                         r->in.buffer = NULL;
19634                 }
19635                 if (r->in.buffer) {
19636                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19637                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19638                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
19639                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
19640                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
19641                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19642                 }
19643                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19644                 NDR_PULL_ALLOC(ndr, r->out.needed);
19645                 ZERO_STRUCTP(r->out.needed);
19646                 if (r->in.buffer) {
19647                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
19648                 }
19649         }
19650         if (flags & NDR_OUT) {
19651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19652                 if (_ptr_buffer) {
19653                         NDR_PULL_ALLOC(ndr, r->out.buffer);
19654                 } else {
19655                         r->out.buffer = NULL;
19656                 }
19657                 if (r->out.buffer) {
19658                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19659                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
19660                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
19661                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
19662                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
19663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19664                 }
19665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19666                         NDR_PULL_ALLOC(ndr, r->out.needed);
19667                 }
19668                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19669                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19672                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19673                 if (r->out.buffer) {
19674                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
19675                 }
19676         }
19677         return NDR_ERR_SUCCESS;
19678 }
19679
19680 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
19681 {
19682         ndr_print_struct(ndr, name, "spoolss_AddJob");
19683         ndr->depth++;
19684         if (flags & NDR_SET_VALUES) {
19685                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19686         }
19687         if (flags & NDR_IN) {
19688                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
19689                 ndr->depth++;
19690                 ndr_print_ptr(ndr, "handle", r->in.handle);
19691                 ndr->depth++;
19692                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19693                 ndr->depth--;
19694                 ndr_print_uint32(ndr, "level", r->in.level);
19695                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19696                 ndr->depth++;
19697                 if (r->in.buffer) {
19698                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
19699                 }
19700                 ndr->depth--;
19701                 ndr_print_uint32(ndr, "offered", r->in.offered);
19702                 ndr->depth--;
19703         }
19704         if (flags & NDR_OUT) {
19705                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
19706                 ndr->depth++;
19707                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
19708                 ndr->depth++;
19709                 if (r->out.buffer) {
19710                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
19711                 }
19712                 ndr->depth--;
19713                 ndr_print_ptr(ndr, "needed", r->out.needed);
19714                 ndr->depth++;
19715                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19716                 ndr->depth--;
19717                 ndr_print_WERROR(ndr, "result", r->out.result);
19718                 ndr->depth--;
19719         }
19720         ndr->depth--;
19721 }
19722
19723 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
19724 {
19725         if (flags & NDR_IN) {
19726                 if (r->in.handle == NULL) {
19727                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19728                 }
19729                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
19731         }
19732         if (flags & NDR_OUT) {
19733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19734         }
19735         return NDR_ERR_SUCCESS;
19736 }
19737
19738 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
19739 {
19740         TALLOC_CTX *_mem_save_handle_0;
19741         if (flags & NDR_IN) {
19742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19743                         NDR_PULL_ALLOC(ndr, r->in.handle);
19744                 }
19745                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19746                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
19750         }
19751         if (flags & NDR_OUT) {
19752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19753         }
19754         return NDR_ERR_SUCCESS;
19755 }
19756
19757 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
19758 {
19759         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
19760         ndr->depth++;
19761         if (flags & NDR_SET_VALUES) {
19762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19763         }
19764         if (flags & NDR_IN) {
19765                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
19766                 ndr->depth++;
19767                 ndr_print_ptr(ndr, "handle", r->in.handle);
19768                 ndr->depth++;
19769                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19770                 ndr->depth--;
19771                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
19772                 ndr->depth--;
19773         }
19774         if (flags & NDR_OUT) {
19775                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
19776                 ndr->depth++;
19777                 ndr_print_WERROR(ndr, "result", r->out.result);
19778                 ndr->depth--;
19779         }
19780         ndr->depth--;
19781 }
19782
19783 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
19784 {
19785         if (flags & NDR_IN) {
19786                 if (r->in.handle == NULL) {
19787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19788                 }
19789                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19793                 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));
19794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19795         }
19796         if (flags & NDR_OUT) {
19797                 if (r->out.type == NULL) {
19798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19799                 }
19800                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
19801                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
19802                 if (r->out.needed == NULL) {
19803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19804                 }
19805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19807         }
19808         return NDR_ERR_SUCCESS;
19809 }
19810
19811 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
19812 {
19813         TALLOC_CTX *_mem_save_handle_0;
19814         TALLOC_CTX *_mem_save_type_0;
19815         TALLOC_CTX *_mem_save_needed_0;
19816         if (flags & NDR_IN) {
19817                 ZERO_STRUCT(r->out);
19818
19819                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19820                         NDR_PULL_ALLOC(ndr, r->in.handle);
19821                 }
19822                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19823                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19824                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19825                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19826                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
19827                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
19828                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
19829                         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));
19830                 }
19831                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
19832                 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));
19833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19834                 NDR_PULL_ALLOC(ndr, r->out.type);
19835                 ZERO_STRUCTP(r->out.type);
19836                 NDR_PULL_ALLOC(ndr, r->out.needed);
19837                 ZERO_STRUCTP(r->out.needed);
19838         }
19839         if (flags & NDR_OUT) {
19840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19841                         NDR_PULL_ALLOC(ndr, r->out.type);
19842                 }
19843                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
19844                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
19845                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
19846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
19847                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
19848                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19849                         NDR_PULL_ALLOC(ndr, r->out.needed);
19850                 }
19851                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19852                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19853                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19855                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19856         }
19857         return NDR_ERR_SUCCESS;
19858 }
19859
19860 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
19861 {
19862         if (flags & NDR_IN) {
19863                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
19864         }
19865         if (flags & NDR_OUT) {
19866                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
19867                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
19868         }
19869         return NDR_ERR_SUCCESS;
19870 }
19871
19872 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
19873 {
19874         if (flags & NDR_IN) {
19875                 ZERO_STRUCT(r->out);
19876
19877                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
19878         }
19879         if (flags & NDR_OUT) {
19880                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
19881                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
19882         }
19883         return NDR_ERR_SUCCESS;
19884 }
19885
19886 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
19887 {
19888         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
19889         ndr->depth++;
19890         if (flags & NDR_SET_VALUES) {
19891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19892         }
19893         if (flags & NDR_IN) {
19894                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
19895                 ndr->depth++;
19896                 ndr_print_ptr(ndr, "handle", r->in.handle);
19897                 ndr->depth++;
19898                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19899                 ndr->depth--;
19900                 ndr_print_string(ndr, "value_name", r->in.value_name);
19901                 ndr_print_uint32(ndr, "offered", r->in.offered);
19902                 ndr->depth--;
19903         }
19904         if (flags & NDR_OUT) {
19905                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
19906                 ndr->depth++;
19907                 ndr_print_ptr(ndr, "type", r->out.type);
19908                 ndr->depth++;
19909                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
19910                 ndr->depth--;
19911                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
19912                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
19913                 ndr_print_ptr(ndr, "needed", r->out.needed);
19914                 ndr->depth++;
19915                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19916                 ndr->depth--;
19917                 ndr_print_WERROR(ndr, "result", r->out.result);
19918                 ndr->depth--;
19919         }
19920         ndr->depth--;
19921 }
19922
19923 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
19924 {
19925         if (flags & NDR_IN) {
19926                 if (r->in.handle == NULL) {
19927                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19928                 }
19929                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
19933                 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));
19934                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
19935                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
19936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
19937         }
19938         if (flags & NDR_OUT) {
19939                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19940         }
19941         return NDR_ERR_SUCCESS;
19942 }
19943
19944 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
19945 {
19946         if (flags & NDR_IN) {
19947                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
19948         }
19949         if (flags & NDR_OUT) {
19950                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
19951                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
19952         }
19953         return NDR_ERR_SUCCESS;
19954 }
19955
19956 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
19957 {
19958         TALLOC_CTX *_mem_save_handle_0;
19959         if (flags & NDR_IN) {
19960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19961                         NDR_PULL_ALLOC(ndr, r->in.handle);
19962                 }
19963                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19964                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19965                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19967                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
19968                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
19969                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
19970                         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));
19971                 }
19972                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
19973                 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));
19974                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
19975                 {
19976                         struct ndr_pull *_ndr_data;
19977                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
19978                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
19979                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
19980                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
19981                 }
19982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
19983         }
19984         if (flags & NDR_OUT) {
19985                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19986         }
19987         return NDR_ERR_SUCCESS;
19988 }
19989
19990 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
19991 {
19992         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
19993         ndr->depth++;
19994         if (flags & NDR_SET_VALUES) {
19995                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19996         }
19997         if (flags & NDR_IN) {
19998                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
19999                 ndr->depth++;
20000                 ndr_print_ptr(ndr, "handle", r->in.handle);
20001                 ndr->depth++;
20002                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20003                 ndr->depth--;
20004                 ndr_print_string(ndr, "value_name", r->in.value_name);
20005                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
20006                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
20007                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
20008                 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);
20009                 ndr->depth--;
20010         }
20011         if (flags & NDR_OUT) {
20012                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
20013                 ndr->depth++;
20014                 ndr_print_WERROR(ndr, "result", r->out.result);
20015                 ndr->depth--;
20016         }
20017         ndr->depth--;
20018 }
20019
20020 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
20021 {
20022         if (flags & NDR_IN) {
20023         }
20024         if (flags & NDR_OUT) {
20025                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20026         }
20027         return NDR_ERR_SUCCESS;
20028 }
20029
20030 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
20031 {
20032         if (flags & NDR_IN) {
20033         }
20034         if (flags & NDR_OUT) {
20035                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20036         }
20037         return NDR_ERR_SUCCESS;
20038 }
20039
20040 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
20041 {
20042         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
20043         ndr->depth++;
20044         if (flags & NDR_SET_VALUES) {
20045                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20046         }
20047         if (flags & NDR_IN) {
20048                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
20049                 ndr->depth++;
20050                 ndr->depth--;
20051         }
20052         if (flags & NDR_OUT) {
20053                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
20054                 ndr->depth++;
20055                 ndr_print_WERROR(ndr, "result", r->out.result);
20056                 ndr->depth--;
20057         }
20058         ndr->depth--;
20059 }
20060
20061 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
20062 {
20063         if (flags & NDR_IN) {
20064                 if (r->in.handle == NULL) {
20065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20066                 }
20067                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20068         }
20069         if (flags & NDR_OUT) {
20070                 if (r->out.handle == NULL) {
20071                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20072                 }
20073                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20074                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20075         }
20076         return NDR_ERR_SUCCESS;
20077 }
20078
20079 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
20080 {
20081         TALLOC_CTX *_mem_save_handle_0;
20082         if (flags & NDR_IN) {
20083                 ZERO_STRUCT(r->out);
20084
20085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20086                         NDR_PULL_ALLOC(ndr, r->in.handle);
20087                 }
20088                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20089                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20090                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20092                 NDR_PULL_ALLOC(ndr, r->out.handle);
20093                 *r->out.handle = *r->in.handle;
20094         }
20095         if (flags & NDR_OUT) {
20096                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20097                         NDR_PULL_ALLOC(ndr, r->out.handle);
20098                 }
20099                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20100                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
20101                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
20102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20103                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20104         }
20105         return NDR_ERR_SUCCESS;
20106 }
20107
20108 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
20109 {
20110         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
20111         ndr->depth++;
20112         if (flags & NDR_SET_VALUES) {
20113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20114         }
20115         if (flags & NDR_IN) {
20116                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
20117                 ndr->depth++;
20118                 ndr_print_ptr(ndr, "handle", r->in.handle);
20119                 ndr->depth++;
20120                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20121                 ndr->depth--;
20122                 ndr->depth--;
20123         }
20124         if (flags & NDR_OUT) {
20125                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
20126                 ndr->depth++;
20127                 ndr_print_ptr(ndr, "handle", r->out.handle);
20128                 ndr->depth++;
20129                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
20130                 ndr->depth--;
20131                 ndr_print_WERROR(ndr, "result", r->out.result);
20132                 ndr->depth--;
20133         }
20134         ndr->depth--;
20135 }
20136
20137 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
20138 {
20139         if (flags & NDR_IN) {
20140                 if (r->in.handle == NULL) {
20141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20142                 }
20143                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20144                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20145                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20146                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20147         }
20148         if (flags & NDR_OUT) {
20149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20150         }
20151         return NDR_ERR_SUCCESS;
20152 }
20153
20154 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
20155 {
20156         TALLOC_CTX *_mem_save_handle_0;
20157         if (flags & NDR_IN) {
20158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20159                         NDR_PULL_ALLOC(ndr, r->in.handle);
20160                 }
20161                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20162                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20163                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20166                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20167                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20168         }
20169         if (flags & NDR_OUT) {
20170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20171         }
20172         return NDR_ERR_SUCCESS;
20173 }
20174
20175 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
20176 {
20177         ndr_print_struct(ndr, name, "spoolss_AddForm");
20178         ndr->depth++;
20179         if (flags & NDR_SET_VALUES) {
20180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20181         }
20182         if (flags & NDR_IN) {
20183                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
20184                 ndr->depth++;
20185                 ndr_print_ptr(ndr, "handle", r->in.handle);
20186                 ndr->depth++;
20187                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20188                 ndr->depth--;
20189                 ndr_print_uint32(ndr, "level", r->in.level);
20190                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20191                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
20192                 ndr->depth--;
20193         }
20194         if (flags & NDR_OUT) {
20195                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
20196                 ndr->depth++;
20197                 ndr_print_WERROR(ndr, "result", r->out.result);
20198                 ndr->depth--;
20199         }
20200         ndr->depth--;
20201 }
20202
20203 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
20204 {
20205         if (flags & NDR_IN) {
20206                 if (r->in.handle == NULL) {
20207                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20208                 }
20209                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
20211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
20213                 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));
20214         }
20215         if (flags & NDR_OUT) {
20216                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20217         }
20218         return NDR_ERR_SUCCESS;
20219 }
20220
20221 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
20222 {
20223         TALLOC_CTX *_mem_save_handle_0;
20224         if (flags & NDR_IN) {
20225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20226                         NDR_PULL_ALLOC(ndr, r->in.handle);
20227                 }
20228                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20229                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20230                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20231                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20232                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
20233                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
20234                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
20235                         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));
20236                 }
20237                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
20238                 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));
20239         }
20240         if (flags & NDR_OUT) {
20241                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20242         }
20243         return NDR_ERR_SUCCESS;
20244 }
20245
20246 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
20247 {
20248         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
20249         ndr->depth++;
20250         if (flags & NDR_SET_VALUES) {
20251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20252         }
20253         if (flags & NDR_IN) {
20254                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
20255                 ndr->depth++;
20256                 ndr_print_ptr(ndr, "handle", r->in.handle);
20257                 ndr->depth++;
20258                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20259                 ndr->depth--;
20260                 ndr_print_string(ndr, "form_name", r->in.form_name);
20261                 ndr->depth--;
20262         }
20263         if (flags & NDR_OUT) {
20264                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
20265                 ndr->depth++;
20266                 ndr_print_WERROR(ndr, "result", r->out.result);
20267                 ndr->depth--;
20268         }
20269         ndr->depth--;
20270 }
20271
20272 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
20273 {
20274         if (flags & NDR_IN) {
20275                 if (r->in.handle == NULL) {
20276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20277                 }
20278                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
20280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
20282                 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));
20283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20284                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20285                 if (r->in.buffer) {
20286                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20287                 }
20288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20289         }
20290         if (flags & NDR_OUT) {
20291                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20292                 if (r->out.info) {
20293                         {
20294                                 struct ndr_push *_ndr_info;
20295                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20296                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20297                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20298                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20299                         }
20300                 }
20301                 if (r->out.needed == NULL) {
20302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20303                 }
20304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20305                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20306         }
20307         return NDR_ERR_SUCCESS;
20308 }
20309
20310 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
20311 {
20312         uint32_t _ptr_buffer;
20313         uint32_t _ptr_info;
20314         TALLOC_CTX *_mem_save_handle_0;
20315         TALLOC_CTX *_mem_save_buffer_0;
20316         TALLOC_CTX *_mem_save_info_0;
20317         TALLOC_CTX *_mem_save_needed_0;
20318         if (flags & NDR_IN) {
20319                 ZERO_STRUCT(r->out);
20320
20321                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20322                         NDR_PULL_ALLOC(ndr, r->in.handle);
20323                 }
20324                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20325                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20326                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20328                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
20329                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
20330                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
20331                         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));
20332                 }
20333                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
20334                 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));
20335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20337                 if (_ptr_buffer) {
20338                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20339                 } else {
20340                         r->in.buffer = NULL;
20341                 }
20342                 if (r->in.buffer) {
20343                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20344                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20345                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20347                 }
20348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20349                 NDR_PULL_ALLOC(ndr, r->out.needed);
20350                 ZERO_STRUCTP(r->out.needed);
20351         }
20352         if (flags & NDR_OUT) {
20353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20354                 if (_ptr_info) {
20355                         NDR_PULL_ALLOC(ndr, r->out.info);
20356                 } else {
20357                         r->out.info = NULL;
20358                 }
20359                 if (r->out.info) {
20360                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20361                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20362                         {
20363                                 struct ndr_pull *_ndr_info;
20364                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20365                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20366                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
20367                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20368                         }
20369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20370                 }
20371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20372                         NDR_PULL_ALLOC(ndr, r->out.needed);
20373                 }
20374                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20375                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20378                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20379         }
20380         return NDR_ERR_SUCCESS;
20381 }
20382
20383 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
20384 {
20385         ndr_print_struct(ndr, name, "spoolss_GetForm");
20386         ndr->depth++;
20387         if (flags & NDR_SET_VALUES) {
20388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20389         }
20390         if (flags & NDR_IN) {
20391                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
20392                 ndr->depth++;
20393                 ndr_print_ptr(ndr, "handle", r->in.handle);
20394                 ndr->depth++;
20395                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20396                 ndr->depth--;
20397                 ndr_print_string(ndr, "form_name", r->in.form_name);
20398                 ndr_print_uint32(ndr, "level", r->in.level);
20399                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20400                 ndr->depth++;
20401                 if (r->in.buffer) {
20402                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20403                 }
20404                 ndr->depth--;
20405                 ndr_print_uint32(ndr, "offered", r->in.offered);
20406                 ndr->depth--;
20407         }
20408         if (flags & NDR_OUT) {
20409                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
20410                 ndr->depth++;
20411                 ndr_print_ptr(ndr, "info", r->out.info);
20412                 ndr->depth++;
20413                 if (r->out.info) {
20414                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20415                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
20416                 }
20417                 ndr->depth--;
20418                 ndr_print_ptr(ndr, "needed", r->out.needed);
20419                 ndr->depth++;
20420                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20421                 ndr->depth--;
20422                 ndr_print_WERROR(ndr, "result", r->out.result);
20423                 ndr->depth--;
20424         }
20425         ndr->depth--;
20426 }
20427
20428 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
20429 {
20430         if (flags & NDR_IN) {
20431                 if (r->in.handle == NULL) {
20432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20433                 }
20434                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
20436                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
20438                 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));
20439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20440                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20441                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20442         }
20443         if (flags & NDR_OUT) {
20444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20445         }
20446         return NDR_ERR_SUCCESS;
20447 }
20448
20449 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
20450 {
20451         TALLOC_CTX *_mem_save_handle_0;
20452         if (flags & NDR_IN) {
20453                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20454                         NDR_PULL_ALLOC(ndr, r->in.handle);
20455                 }
20456                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20457                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20458                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20459                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20460                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
20461                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
20462                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
20463                         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));
20464                 }
20465                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
20466                 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));
20467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20468                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20469                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20470         }
20471         if (flags & NDR_OUT) {
20472                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20473         }
20474         return NDR_ERR_SUCCESS;
20475 }
20476
20477 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
20478 {
20479         ndr_print_struct(ndr, name, "spoolss_SetForm");
20480         ndr->depth++;
20481         if (flags & NDR_SET_VALUES) {
20482                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20483         }
20484         if (flags & NDR_IN) {
20485                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
20486                 ndr->depth++;
20487                 ndr_print_ptr(ndr, "handle", r->in.handle);
20488                 ndr->depth++;
20489                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20490                 ndr->depth--;
20491                 ndr_print_string(ndr, "form_name", r->in.form_name);
20492                 ndr_print_uint32(ndr, "level", r->in.level);
20493                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20494                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
20495                 ndr->depth--;
20496         }
20497         if (flags & NDR_OUT) {
20498                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
20499                 ndr->depth++;
20500                 ndr_print_WERROR(ndr, "result", r->out.result);
20501                 ndr->depth--;
20502         }
20503         ndr->depth--;
20504 }
20505
20506 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
20507 {
20508         if (flags & NDR_IN) {
20509                 if (r->in.handle == NULL) {
20510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20511                 }
20512                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20515                 if (r->in.buffer) {
20516                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20517                 }
20518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20519         }
20520         if (flags & NDR_OUT) {
20521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20522                 if (r->out.info) {
20523                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20524                 }
20525                 if (r->out.needed == NULL) {
20526                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20527                 }
20528                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20529                 if (r->out.count == NULL) {
20530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20531                 }
20532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20534         }
20535         return NDR_ERR_SUCCESS;
20536 }
20537
20538 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
20539 {
20540         uint32_t _ptr_buffer;
20541         uint32_t _ptr_info;
20542         TALLOC_CTX *_mem_save_handle_0;
20543         TALLOC_CTX *_mem_save_buffer_0;
20544         TALLOC_CTX *_mem_save_info_0;
20545         TALLOC_CTX *_mem_save_needed_0;
20546         TALLOC_CTX *_mem_save_count_0;
20547         if (flags & NDR_IN) {
20548                 ZERO_STRUCT(r->out);
20549
20550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20551                         NDR_PULL_ALLOC(ndr, r->in.handle);
20552                 }
20553                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20554                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20555                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20559                 if (_ptr_buffer) {
20560                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20561                 } else {
20562                         r->in.buffer = NULL;
20563                 }
20564                 if (r->in.buffer) {
20565                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20566                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20567                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20568                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20569                 }
20570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20571                 NDR_PULL_ALLOC(ndr, r->out.needed);
20572                 ZERO_STRUCTP(r->out.needed);
20573                 NDR_PULL_ALLOC(ndr, r->out.count);
20574                 ZERO_STRUCTP(r->out.count);
20575         }
20576         if (flags & NDR_OUT) {
20577                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20578                 if (_ptr_info) {
20579                         NDR_PULL_ALLOC(ndr, r->out.info);
20580                 } else {
20581                         r->out.info = NULL;
20582                 }
20583                 if (r->out.info) {
20584                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20585                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20586                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20587                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20588                 }
20589                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20590                         NDR_PULL_ALLOC(ndr, r->out.needed);
20591                 }
20592                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20593                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20595                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20597                         NDR_PULL_ALLOC(ndr, r->out.count);
20598                 }
20599                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20600                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20603                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20604         }
20605         return NDR_ERR_SUCCESS;
20606 }
20607
20608 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
20609 {
20610         uint32_t cntr_info_0;
20611         if (flags & NDR_IN) {
20612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20614         }
20615         if (flags & NDR_OUT) {
20616                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20617                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20618                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20619                 }
20620                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20621                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20622                 }
20623         }
20624         return NDR_ERR_SUCCESS;
20625 }
20626
20627 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
20628 {
20629         uint32_t cntr_info_0;
20630         TALLOC_CTX *_mem_save_info_0;
20631         if (flags & NDR_IN) {
20632                 ZERO_STRUCT(r->out);
20633
20634                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20635                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20636         }
20637         if (flags & NDR_OUT) {
20638                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20639                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20640                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20641                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20642                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20643                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20644                 }
20645                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20646                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20647                 }
20648                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20649         }
20650         return NDR_ERR_SUCCESS;
20651 }
20652
20653 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
20654 {
20655         uint32_t cntr_info_1;
20656         ndr_print_struct(ndr, name, "spoolss_EnumForms");
20657         ndr->depth++;
20658         if (flags & NDR_SET_VALUES) {
20659                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20660         }
20661         if (flags & NDR_IN) {
20662                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
20663                 ndr->depth++;
20664                 ndr_print_ptr(ndr, "handle", r->in.handle);
20665                 ndr->depth++;
20666                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20667                 ndr->depth--;
20668                 ndr_print_uint32(ndr, "level", r->in.level);
20669                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20670                 ndr->depth++;
20671                 if (r->in.buffer) {
20672                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20673                 }
20674                 ndr->depth--;
20675                 ndr_print_uint32(ndr, "offered", r->in.offered);
20676                 ndr->depth--;
20677         }
20678         if (flags & NDR_OUT) {
20679                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
20680                 ndr->depth++;
20681                 ndr_print_ptr(ndr, "count", r->out.count);
20682                 ndr->depth++;
20683                 ndr_print_uint32(ndr, "count", *r->out.count);
20684                 ndr->depth--;
20685                 ndr_print_ptr(ndr, "info", r->out.info);
20686                 ndr->depth++;
20687                 if (r->out.info) {
20688                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20689                         ndr->depth++;
20690                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
20691                                 char *idx_1=NULL;
20692                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
20693                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
20694                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
20695                                         free(idx_1);
20696                                 }
20697                         }
20698                         ndr->depth--;
20699                 }
20700                 ndr->depth--;
20701                 ndr_print_ptr(ndr, "needed", r->out.needed);
20702                 ndr->depth++;
20703                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20704                 ndr->depth--;
20705                 ndr_print_WERROR(ndr, "result", r->out.result);
20706                 ndr->depth--;
20707         }
20708         ndr->depth--;
20709 }
20710
20711 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
20712 {
20713         if (flags & NDR_IN) {
20714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20715                 if (r->in.servername) {
20716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20720                 }
20721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20723                 if (r->in.buffer) {
20724                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20725                 }
20726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20727         }
20728         if (flags & NDR_OUT) {
20729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20730                 if (r->out.info) {
20731                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20732                 }
20733                 if (r->out.needed == NULL) {
20734                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20735                 }
20736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20737                 if (r->out.count == NULL) {
20738                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20739                 }
20740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20741                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20742         }
20743         return NDR_ERR_SUCCESS;
20744 }
20745
20746 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
20747 {
20748         uint32_t _ptr_servername;
20749         uint32_t _ptr_buffer;
20750         uint32_t _ptr_info;
20751         TALLOC_CTX *_mem_save_servername_0;
20752         TALLOC_CTX *_mem_save_buffer_0;
20753         TALLOC_CTX *_mem_save_info_0;
20754         TALLOC_CTX *_mem_save_needed_0;
20755         TALLOC_CTX *_mem_save_count_0;
20756         if (flags & NDR_IN) {
20757                 ZERO_STRUCT(r->out);
20758
20759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20760                 if (_ptr_servername) {
20761                         NDR_PULL_ALLOC(ndr, r->in.servername);
20762                 } else {
20763                         r->in.servername = NULL;
20764                 }
20765                 if (r->in.servername) {
20766                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20767                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20770                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20771                                 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));
20772                         }
20773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20774                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20776                 }
20777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20778                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20779                 if (_ptr_buffer) {
20780                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20781                 } else {
20782                         r->in.buffer = NULL;
20783                 }
20784                 if (r->in.buffer) {
20785                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20786                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20787                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20788                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20789                 }
20790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20791                 NDR_PULL_ALLOC(ndr, r->out.needed);
20792                 ZERO_STRUCTP(r->out.needed);
20793                 NDR_PULL_ALLOC(ndr, r->out.count);
20794                 ZERO_STRUCTP(r->out.count);
20795         }
20796         if (flags & NDR_OUT) {
20797                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20798                 if (_ptr_info) {
20799                         NDR_PULL_ALLOC(ndr, r->out.info);
20800                 } else {
20801                         r->out.info = NULL;
20802                 }
20803                 if (r->out.info) {
20804                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20805                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20806                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20808                 }
20809                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20810                         NDR_PULL_ALLOC(ndr, r->out.needed);
20811                 }
20812                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20813                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20815                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20817                         NDR_PULL_ALLOC(ndr, r->out.count);
20818                 }
20819                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20820                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20823                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20824         }
20825         return NDR_ERR_SUCCESS;
20826 }
20827
20828 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
20829 {
20830         uint32_t cntr_info_0;
20831         if (flags & NDR_IN) {
20832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20834         }
20835         if (flags & NDR_OUT) {
20836                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20837                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20838                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20839                 }
20840                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20841                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20842                 }
20843         }
20844         return NDR_ERR_SUCCESS;
20845 }
20846
20847 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
20848 {
20849         uint32_t cntr_info_0;
20850         TALLOC_CTX *_mem_save_info_0;
20851         if (flags & NDR_IN) {
20852                 ZERO_STRUCT(r->out);
20853
20854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20856         }
20857         if (flags & NDR_OUT) {
20858                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20859                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20860                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20861                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20862                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20863                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20864                 }
20865                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20866                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20867                 }
20868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20869         }
20870         return NDR_ERR_SUCCESS;
20871 }
20872
20873 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
20874 {
20875         uint32_t cntr_info_1;
20876         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
20877         ndr->depth++;
20878         if (flags & NDR_SET_VALUES) {
20879                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20880         }
20881         if (flags & NDR_IN) {
20882                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
20883                 ndr->depth++;
20884                 ndr_print_ptr(ndr, "servername", r->in.servername);
20885                 ndr->depth++;
20886                 if (r->in.servername) {
20887                         ndr_print_string(ndr, "servername", r->in.servername);
20888                 }
20889                 ndr->depth--;
20890                 ndr_print_uint32(ndr, "level", r->in.level);
20891                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20892                 ndr->depth++;
20893                 if (r->in.buffer) {
20894                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20895                 }
20896                 ndr->depth--;
20897                 ndr_print_uint32(ndr, "offered", r->in.offered);
20898                 ndr->depth--;
20899         }
20900         if (flags & NDR_OUT) {
20901                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
20902                 ndr->depth++;
20903                 ndr_print_ptr(ndr, "count", r->out.count);
20904                 ndr->depth++;
20905                 ndr_print_uint32(ndr, "count", *r->out.count);
20906                 ndr->depth--;
20907                 ndr_print_ptr(ndr, "info", r->out.info);
20908                 ndr->depth++;
20909                 if (r->out.info) {
20910                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20911                         ndr->depth++;
20912                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
20913                                 char *idx_1=NULL;
20914                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
20915                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
20916                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
20917                                         free(idx_1);
20918                                 }
20919                         }
20920                         ndr->depth--;
20921                 }
20922                 ndr->depth--;
20923                 ndr_print_ptr(ndr, "needed", r->out.needed);
20924                 ndr->depth++;
20925                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20926                 ndr->depth--;
20927                 ndr_print_WERROR(ndr, "result", r->out.result);
20928                 ndr->depth--;
20929         }
20930         ndr->depth--;
20931 }
20932
20933 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
20934 {
20935         if (flags & NDR_IN) {
20936                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20937                 if (r->in.servername) {
20938                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20941                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20942                 }
20943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20945                 if (r->in.buffer) {
20946                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20947                 }
20948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20949         }
20950         if (flags & NDR_OUT) {
20951                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20952                 if (r->out.info) {
20953                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20954                 }
20955                 if (r->out.needed == NULL) {
20956                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20957                 }
20958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20959                 if (r->out.count == NULL) {
20960                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20961                 }
20962                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20963                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20964         }
20965         return NDR_ERR_SUCCESS;
20966 }
20967
20968 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
20969 {
20970         uint32_t _ptr_servername;
20971         uint32_t _ptr_buffer;
20972         uint32_t _ptr_info;
20973         TALLOC_CTX *_mem_save_servername_0;
20974         TALLOC_CTX *_mem_save_buffer_0;
20975         TALLOC_CTX *_mem_save_info_0;
20976         TALLOC_CTX *_mem_save_needed_0;
20977         TALLOC_CTX *_mem_save_count_0;
20978         if (flags & NDR_IN) {
20979                 ZERO_STRUCT(r->out);
20980
20981                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20982                 if (_ptr_servername) {
20983                         NDR_PULL_ALLOC(ndr, r->in.servername);
20984                 } else {
20985                         r->in.servername = NULL;
20986                 }
20987                 if (r->in.servername) {
20988                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20989                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20990                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20991                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20992                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20993                                 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));
20994                         }
20995                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20996                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20997                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20998                 }
20999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21001                 if (_ptr_buffer) {
21002                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21003                 } else {
21004                         r->in.buffer = NULL;
21005                 }
21006                 if (r->in.buffer) {
21007                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21008                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21009                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21010                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21011                 }
21012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21013                 NDR_PULL_ALLOC(ndr, r->out.needed);
21014                 ZERO_STRUCTP(r->out.needed);
21015                 NDR_PULL_ALLOC(ndr, r->out.count);
21016                 ZERO_STRUCTP(r->out.count);
21017         }
21018         if (flags & NDR_OUT) {
21019                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21020                 if (_ptr_info) {
21021                         NDR_PULL_ALLOC(ndr, r->out.info);
21022                 } else {
21023                         r->out.info = NULL;
21024                 }
21025                 if (r->out.info) {
21026                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21027                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21028                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
21029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21030                 }
21031                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21032                         NDR_PULL_ALLOC(ndr, r->out.needed);
21033                 }
21034                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21035                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21037                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21038                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21039                         NDR_PULL_ALLOC(ndr, r->out.count);
21040                 }
21041                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
21042                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
21043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
21044                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
21045                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21046         }
21047         return NDR_ERR_SUCCESS;
21048 }
21049
21050 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
21051 {
21052         uint32_t cntr_info_0;
21053         if (flags & NDR_IN) {
21054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
21056         }
21057         if (flags & NDR_OUT) {
21058                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21059                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21060                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21061                 }
21062                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21063                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21064                 }
21065         }
21066         return NDR_ERR_SUCCESS;
21067 }
21068
21069 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
21070 {
21071         uint32_t cntr_info_0;
21072         TALLOC_CTX *_mem_save_info_0;
21073         if (flags & NDR_IN) {
21074                 ZERO_STRUCT(r->out);
21075
21076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21078         }
21079         if (flags & NDR_OUT) {
21080                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21081                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21082                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21083                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21084                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21085                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21086                 }
21087                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21088                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21089                 }
21090                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21091         }
21092         return NDR_ERR_SUCCESS;
21093 }
21094
21095 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
21096 {
21097         uint32_t cntr_info_1;
21098         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
21099         ndr->depth++;
21100         if (flags & NDR_SET_VALUES) {
21101                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21102         }
21103         if (flags & NDR_IN) {
21104                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
21105                 ndr->depth++;
21106                 ndr_print_ptr(ndr, "servername", r->in.servername);
21107                 ndr->depth++;
21108                 if (r->in.servername) {
21109                         ndr_print_string(ndr, "servername", r->in.servername);
21110                 }
21111                 ndr->depth--;
21112                 ndr_print_uint32(ndr, "level", r->in.level);
21113                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21114                 ndr->depth++;
21115                 if (r->in.buffer) {
21116                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21117                 }
21118                 ndr->depth--;
21119                 ndr_print_uint32(ndr, "offered", r->in.offered);
21120                 ndr->depth--;
21121         }
21122         if (flags & NDR_OUT) {
21123                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
21124                 ndr->depth++;
21125                 ndr_print_ptr(ndr, "count", r->out.count);
21126                 ndr->depth++;
21127                 ndr_print_uint32(ndr, "count", *r->out.count);
21128                 ndr->depth--;
21129                 ndr_print_ptr(ndr, "info", r->out.info);
21130                 ndr->depth++;
21131                 if (r->out.info) {
21132                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21133                         ndr->depth++;
21134                         for (cntr_info_1=0;cntr_info_1<*r->out.count;cntr_info_1++) {
21135                                 char *idx_1=NULL;
21136                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
21137                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
21138                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
21139                                         free(idx_1);
21140                                 }
21141                         }
21142                         ndr->depth--;
21143                 }
21144                 ndr->depth--;
21145                 ndr_print_ptr(ndr, "needed", r->out.needed);
21146                 ndr->depth++;
21147                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21148                 ndr->depth--;
21149                 ndr_print_WERROR(ndr, "result", r->out.result);
21150                 ndr->depth--;
21151         }
21152         ndr->depth--;
21153 }
21154
21155 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
21156 {
21157         if (flags & NDR_IN) {
21158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
21159                 if (r->in.server_name) {
21160                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
21161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
21163                         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));
21164                 }
21165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
21166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
21167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
21169                 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));
21170         }
21171         if (flags & NDR_OUT) {
21172                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21173         }
21174         return NDR_ERR_SUCCESS;
21175 }
21176
21177 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
21178 {
21179         uint32_t _ptr_server_name;
21180         TALLOC_CTX *_mem_save_server_name_0;
21181         if (flags & NDR_IN) {
21182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
21183                 if (_ptr_server_name) {
21184                         NDR_PULL_ALLOC(ndr, r->in.server_name);
21185                 } else {
21186                         r->in.server_name = NULL;
21187                 }
21188                 if (r->in.server_name) {
21189                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
21190                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
21191                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
21192                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
21193                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
21194                                 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));
21195                         }
21196                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
21197                         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));
21198                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
21199                 }
21200                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
21201                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
21202                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
21203                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
21204                         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));
21205                 }
21206                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
21207                 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));
21208         }
21209         if (flags & NDR_OUT) {
21210                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21211         }
21212         return NDR_ERR_SUCCESS;
21213 }
21214
21215 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
21216 {
21217         ndr_print_struct(ndr, name, "spoolss_AddPort");
21218         ndr->depth++;
21219         if (flags & NDR_SET_VALUES) {
21220                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21221         }
21222         if (flags & NDR_IN) {
21223                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
21224                 ndr->depth++;
21225                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
21226                 ndr->depth++;
21227                 if (r->in.server_name) {
21228                         ndr_print_string(ndr, "server_name", r->in.server_name);
21229                 }
21230                 ndr->depth--;
21231                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
21232                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
21233                 ndr->depth--;
21234         }
21235         if (flags & NDR_OUT) {
21236                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
21237                 ndr->depth++;
21238                 ndr_print_WERROR(ndr, "result", r->out.result);
21239                 ndr->depth--;
21240         }
21241         ndr->depth--;
21242 }
21243
21244 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
21245 {
21246         if (flags & NDR_IN) {
21247         }
21248         if (flags & NDR_OUT) {
21249                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21250         }
21251         return NDR_ERR_SUCCESS;
21252 }
21253
21254 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
21255 {
21256         if (flags & NDR_IN) {
21257         }
21258         if (flags & NDR_OUT) {
21259                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21260         }
21261         return NDR_ERR_SUCCESS;
21262 }
21263
21264 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
21265 {
21266         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
21267         ndr->depth++;
21268         if (flags & NDR_SET_VALUES) {
21269                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21270         }
21271         if (flags & NDR_IN) {
21272                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
21273                 ndr->depth++;
21274                 ndr->depth--;
21275         }
21276         if (flags & NDR_OUT) {
21277                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
21278                 ndr->depth++;
21279                 ndr_print_WERROR(ndr, "result", r->out.result);
21280                 ndr->depth--;
21281         }
21282         ndr->depth--;
21283 }
21284
21285 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
21286 {
21287         if (flags & NDR_IN) {
21288         }
21289         if (flags & NDR_OUT) {
21290                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21291         }
21292         return NDR_ERR_SUCCESS;
21293 }
21294
21295 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
21296 {
21297         if (flags & NDR_IN) {
21298         }
21299         if (flags & NDR_OUT) {
21300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21301         }
21302         return NDR_ERR_SUCCESS;
21303 }
21304
21305 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
21306 {
21307         ndr_print_struct(ndr, name, "spoolss_DeletePort");
21308         ndr->depth++;
21309         if (flags & NDR_SET_VALUES) {
21310                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21311         }
21312         if (flags & NDR_IN) {
21313                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
21314                 ndr->depth++;
21315                 ndr->depth--;
21316         }
21317         if (flags & NDR_OUT) {
21318                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
21319                 ndr->depth++;
21320                 ndr_print_WERROR(ndr, "result", r->out.result);
21321                 ndr->depth--;
21322         }
21323         ndr->depth--;
21324 }
21325
21326 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
21327 {
21328         if (flags & NDR_IN) {
21329         }
21330         if (flags & NDR_OUT) {
21331                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21332         }
21333         return NDR_ERR_SUCCESS;
21334 }
21335
21336 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
21337 {
21338         if (flags & NDR_IN) {
21339         }
21340         if (flags & NDR_OUT) {
21341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21342         }
21343         return NDR_ERR_SUCCESS;
21344 }
21345
21346 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
21347 {
21348         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
21349         ndr->depth++;
21350         if (flags & NDR_SET_VALUES) {
21351                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21352         }
21353         if (flags & NDR_IN) {
21354                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
21355                 ndr->depth++;
21356                 ndr->depth--;
21357         }
21358         if (flags & NDR_OUT) {
21359                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
21360                 ndr->depth++;
21361                 ndr_print_WERROR(ndr, "result", r->out.result);
21362                 ndr->depth--;
21363         }
21364         ndr->depth--;
21365 }
21366
21367 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
21368 {
21369         if (flags & NDR_IN) {
21370         }
21371         if (flags & NDR_OUT) {
21372                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21373         }
21374         return NDR_ERR_SUCCESS;
21375 }
21376
21377 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
21378 {
21379         if (flags & NDR_IN) {
21380         }
21381         if (flags & NDR_OUT) {
21382                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21383         }
21384         return NDR_ERR_SUCCESS;
21385 }
21386
21387 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
21388 {
21389         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
21390         ndr->depth++;
21391         if (flags & NDR_SET_VALUES) {
21392                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21393         }
21394         if (flags & NDR_IN) {
21395                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
21396                 ndr->depth++;
21397                 ndr->depth--;
21398         }
21399         if (flags & NDR_OUT) {
21400                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
21401                 ndr->depth++;
21402                 ndr_print_WERROR(ndr, "result", r->out.result);
21403                 ndr->depth--;
21404         }
21405         ndr->depth--;
21406 }
21407
21408 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
21409 {
21410         if (flags & NDR_IN) {
21411         }
21412         if (flags & NDR_OUT) {
21413                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21414         }
21415         return NDR_ERR_SUCCESS;
21416 }
21417
21418 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
21419 {
21420         if (flags & NDR_IN) {
21421         }
21422         if (flags & NDR_OUT) {
21423                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21424         }
21425         return NDR_ERR_SUCCESS;
21426 }
21427
21428 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
21429 {
21430         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
21431         ndr->depth++;
21432         if (flags & NDR_SET_VALUES) {
21433                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21434         }
21435         if (flags & NDR_IN) {
21436                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
21437                 ndr->depth++;
21438                 ndr->depth--;
21439         }
21440         if (flags & NDR_OUT) {
21441                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
21442                 ndr->depth++;
21443                 ndr_print_WERROR(ndr, "result", r->out.result);
21444                 ndr->depth--;
21445         }
21446         ndr->depth--;
21447 }
21448
21449 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
21450 {
21451         if (flags & NDR_IN) {
21452         }
21453         if (flags & NDR_OUT) {
21454                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21455         }
21456         return NDR_ERR_SUCCESS;
21457 }
21458
21459 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
21460 {
21461         if (flags & NDR_IN) {
21462         }
21463         if (flags & NDR_OUT) {
21464                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21465         }
21466         return NDR_ERR_SUCCESS;
21467 }
21468
21469 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
21470 {
21471         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
21472         ndr->depth++;
21473         if (flags & NDR_SET_VALUES) {
21474                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21475         }
21476         if (flags & NDR_IN) {
21477                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
21478                 ndr->depth++;
21479                 ndr->depth--;
21480         }
21481         if (flags & NDR_OUT) {
21482                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
21483                 ndr->depth++;
21484                 ndr_print_WERROR(ndr, "result", r->out.result);
21485                 ndr->depth--;
21486         }
21487         ndr->depth--;
21488 }
21489
21490 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
21491 {
21492         if (flags & NDR_IN) {
21493         }
21494         if (flags & NDR_OUT) {
21495                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21496         }
21497         return NDR_ERR_SUCCESS;
21498 }
21499
21500 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
21501 {
21502         if (flags & NDR_IN) {
21503         }
21504         if (flags & NDR_OUT) {
21505                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21506         }
21507         return NDR_ERR_SUCCESS;
21508 }
21509
21510 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
21511 {
21512         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
21513         ndr->depth++;
21514         if (flags & NDR_SET_VALUES) {
21515                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21516         }
21517         if (flags & NDR_IN) {
21518                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
21519                 ndr->depth++;
21520                 ndr->depth--;
21521         }
21522         if (flags & NDR_OUT) {
21523                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
21524                 ndr->depth++;
21525                 ndr_print_WERROR(ndr, "result", r->out.result);
21526                 ndr->depth--;
21527         }
21528         ndr->depth--;
21529 }
21530
21531 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
21532 {
21533         if (flags & NDR_IN) {
21534         }
21535         if (flags & NDR_OUT) {
21536                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21537         }
21538         return NDR_ERR_SUCCESS;
21539 }
21540
21541 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
21542 {
21543         if (flags & NDR_IN) {
21544         }
21545         if (flags & NDR_OUT) {
21546                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21547         }
21548         return NDR_ERR_SUCCESS;
21549 }
21550
21551 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
21552 {
21553         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
21554         ndr->depth++;
21555         if (flags & NDR_SET_VALUES) {
21556                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21557         }
21558         if (flags & NDR_IN) {
21559                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
21560                 ndr->depth++;
21561                 ndr->depth--;
21562         }
21563         if (flags & NDR_OUT) {
21564                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
21565                 ndr->depth++;
21566                 ndr_print_WERROR(ndr, "result", r->out.result);
21567                 ndr->depth--;
21568         }
21569         ndr->depth--;
21570 }
21571
21572 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
21573 {
21574         if (flags & NDR_IN) {
21575         }
21576         if (flags & NDR_OUT) {
21577                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21578         }
21579         return NDR_ERR_SUCCESS;
21580 }
21581
21582 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
21583 {
21584         if (flags & NDR_IN) {
21585         }
21586         if (flags & NDR_OUT) {
21587                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21588         }
21589         return NDR_ERR_SUCCESS;
21590 }
21591
21592 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
21593 {
21594         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
21595         ndr->depth++;
21596         if (flags & NDR_SET_VALUES) {
21597                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21598         }
21599         if (flags & NDR_IN) {
21600                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
21601                 ndr->depth++;
21602                 ndr->depth--;
21603         }
21604         if (flags & NDR_OUT) {
21605                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
21606                 ndr->depth++;
21607                 ndr_print_WERROR(ndr, "result", r->out.result);
21608                 ndr->depth--;
21609         }
21610         ndr->depth--;
21611 }
21612
21613 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
21614 {
21615         if (flags & NDR_IN) {
21616         }
21617         if (flags & NDR_OUT) {
21618                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21619         }
21620         return NDR_ERR_SUCCESS;
21621 }
21622
21623 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
21624 {
21625         if (flags & NDR_IN) {
21626         }
21627         if (flags & NDR_OUT) {
21628                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21629         }
21630         return NDR_ERR_SUCCESS;
21631 }
21632
21633 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
21634 {
21635         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
21636         ndr->depth++;
21637         if (flags & NDR_SET_VALUES) {
21638                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21639         }
21640         if (flags & NDR_IN) {
21641                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
21642                 ndr->depth++;
21643                 ndr->depth--;
21644         }
21645         if (flags & NDR_OUT) {
21646                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
21647                 ndr->depth++;
21648                 ndr_print_WERROR(ndr, "result", r->out.result);
21649                 ndr->depth--;
21650         }
21651         ndr->depth--;
21652 }
21653
21654 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
21655 {
21656         if (flags & NDR_IN) {
21657         }
21658         if (flags & NDR_OUT) {
21659                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21660         }
21661         return NDR_ERR_SUCCESS;
21662 }
21663
21664 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
21665 {
21666         if (flags & NDR_IN) {
21667         }
21668         if (flags & NDR_OUT) {
21669                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21670         }
21671         return NDR_ERR_SUCCESS;
21672 }
21673
21674 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
21675 {
21676         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
21677         ndr->depth++;
21678         if (flags & NDR_SET_VALUES) {
21679                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21680         }
21681         if (flags & NDR_IN) {
21682                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
21683                 ndr->depth++;
21684                 ndr->depth--;
21685         }
21686         if (flags & NDR_OUT) {
21687                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
21688                 ndr->depth++;
21689                 ndr_print_WERROR(ndr, "result", r->out.result);
21690                 ndr->depth--;
21691         }
21692         ndr->depth--;
21693 }
21694
21695 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
21696 {
21697         if (flags & NDR_IN) {
21698         }
21699         if (flags & NDR_OUT) {
21700                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21701         }
21702         return NDR_ERR_SUCCESS;
21703 }
21704
21705 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
21706 {
21707         if (flags & NDR_IN) {
21708         }
21709         if (flags & NDR_OUT) {
21710                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21711         }
21712         return NDR_ERR_SUCCESS;
21713 }
21714
21715 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
21716 {
21717         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
21718         ndr->depth++;
21719         if (flags & NDR_SET_VALUES) {
21720                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21721         }
21722         if (flags & NDR_IN) {
21723                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
21724                 ndr->depth++;
21725                 ndr->depth--;
21726         }
21727         if (flags & NDR_OUT) {
21728                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
21729                 ndr->depth++;
21730                 ndr_print_WERROR(ndr, "result", r->out.result);
21731                 ndr->depth--;
21732         }
21733         ndr->depth--;
21734 }
21735
21736 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
21737 {
21738         if (flags & NDR_IN) {
21739         }
21740         if (flags & NDR_OUT) {
21741                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21742         }
21743         return NDR_ERR_SUCCESS;
21744 }
21745
21746 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
21747 {
21748         if (flags & NDR_IN) {
21749         }
21750         if (flags & NDR_OUT) {
21751                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21752         }
21753         return NDR_ERR_SUCCESS;
21754 }
21755
21756 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
21757 {
21758         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
21759         ndr->depth++;
21760         if (flags & NDR_SET_VALUES) {
21761                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21762         }
21763         if (flags & NDR_IN) {
21764                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
21765                 ndr->depth++;
21766                 ndr->depth--;
21767         }
21768         if (flags & NDR_OUT) {
21769                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
21770                 ndr->depth++;
21771                 ndr_print_WERROR(ndr, "result", r->out.result);
21772                 ndr->depth--;
21773         }
21774         ndr->depth--;
21775 }
21776
21777 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
21778 {
21779         if (flags & NDR_IN) {
21780         }
21781         if (flags & NDR_OUT) {
21782                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21783         }
21784         return NDR_ERR_SUCCESS;
21785 }
21786
21787 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
21788 {
21789         if (flags & NDR_IN) {
21790         }
21791         if (flags & NDR_OUT) {
21792                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21793         }
21794         return NDR_ERR_SUCCESS;
21795 }
21796
21797 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
21798 {
21799         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
21800         ndr->depth++;
21801         if (flags & NDR_SET_VALUES) {
21802                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21803         }
21804         if (flags & NDR_IN) {
21805                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
21806                 ndr->depth++;
21807                 ndr->depth--;
21808         }
21809         if (flags & NDR_OUT) {
21810                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
21811                 ndr->depth++;
21812                 ndr_print_WERROR(ndr, "result", r->out.result);
21813                 ndr->depth--;
21814         }
21815         ndr->depth--;
21816 }
21817
21818 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
21819 {
21820         if (flags & NDR_IN) {
21821                 if (r->in.handle == NULL) {
21822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21823                 }
21824                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
21826                 if (r->in.data_type) {
21827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
21828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
21830                         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));
21831                 }
21832                 if (r->in.devmode_ctr == NULL) {
21833                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21834                 }
21835                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21836         }
21837         if (flags & NDR_OUT) {
21838                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21839         }
21840         return NDR_ERR_SUCCESS;
21841 }
21842
21843 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
21844 {
21845         uint32_t _ptr_data_type;
21846         TALLOC_CTX *_mem_save_handle_0;
21847         TALLOC_CTX *_mem_save_data_type_0;
21848         TALLOC_CTX *_mem_save_devmode_ctr_0;
21849         if (flags & NDR_IN) {
21850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21851                         NDR_PULL_ALLOC(ndr, r->in.handle);
21852                 }
21853                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21854                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21855                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21857                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
21858                 if (_ptr_data_type) {
21859                         NDR_PULL_ALLOC(ndr, r->in.data_type);
21860                 } else {
21861                         r->in.data_type = NULL;
21862                 }
21863                 if (r->in.data_type) {
21864                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21865                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
21866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
21867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
21868                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
21869                                 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));
21870                         }
21871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
21872                         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));
21873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
21874                 }
21875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21876                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
21877                 }
21878                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
21879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
21880                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
21881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
21882         }
21883         if (flags & NDR_OUT) {
21884                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21885         }
21886         return NDR_ERR_SUCCESS;
21887 }
21888
21889 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
21890 {
21891         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
21892         ndr->depth++;
21893         if (flags & NDR_SET_VALUES) {
21894                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21895         }
21896         if (flags & NDR_IN) {
21897                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
21898                 ndr->depth++;
21899                 ndr_print_ptr(ndr, "handle", r->in.handle);
21900                 ndr->depth++;
21901                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21902                 ndr->depth--;
21903                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
21904                 ndr->depth++;
21905                 if (r->in.data_type) {
21906                         ndr_print_string(ndr, "data_type", r->in.data_type);
21907                 }
21908                 ndr->depth--;
21909                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
21910                 ndr->depth++;
21911                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
21912                 ndr->depth--;
21913                 ndr->depth--;
21914         }
21915         if (flags & NDR_OUT) {
21916                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
21917                 ndr->depth++;
21918                 ndr_print_WERROR(ndr, "result", r->out.result);
21919                 ndr->depth--;
21920         }
21921         ndr->depth--;
21922 }
21923
21924 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
21925 {
21926         if (flags & NDR_IN) {
21927                 if (r->in.handle == NULL) {
21928                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21929                 }
21930                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21931                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
21932                 if (r->in.architecture) {
21933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
21936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21937                 }
21938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21939                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21940                 if (r->in.buffer) {
21941                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21942                 }
21943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
21945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
21946         }
21947         if (flags & NDR_OUT) {
21948                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21949                 if (r->out.info) {
21950                         {
21951                                 struct ndr_push *_ndr_info;
21952                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21953                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21954                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
21955                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21956                         }
21957                 }
21958                 if (r->out.needed == NULL) {
21959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21960                 }
21961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21962                 if (r->out.server_major_version == NULL) {
21963                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21964                 }
21965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
21966                 if (r->out.server_minor_version == NULL) {
21967                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21968                 }
21969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
21970                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21971         }
21972         return NDR_ERR_SUCCESS;
21973 }
21974
21975 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
21976 {
21977         uint32_t _ptr_architecture;
21978         uint32_t _ptr_buffer;
21979         uint32_t _ptr_info;
21980         TALLOC_CTX *_mem_save_handle_0;
21981         TALLOC_CTX *_mem_save_architecture_0;
21982         TALLOC_CTX *_mem_save_buffer_0;
21983         TALLOC_CTX *_mem_save_info_0;
21984         TALLOC_CTX *_mem_save_needed_0;
21985         TALLOC_CTX *_mem_save_server_major_version_0;
21986         TALLOC_CTX *_mem_save_server_minor_version_0;
21987         if (flags & NDR_IN) {
21988                 ZERO_STRUCT(r->out);
21989
21990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21991                         NDR_PULL_ALLOC(ndr, r->in.handle);
21992                 }
21993                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21994                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21995                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
21998                 if (_ptr_architecture) {
21999                         NDR_PULL_ALLOC(ndr, r->in.architecture);
22000                 } else {
22001                         r->in.architecture = NULL;
22002                 }
22003                 if (r->in.architecture) {
22004                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
22005                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
22006                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
22007                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
22008                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
22009                                 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));
22010                         }
22011                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
22012                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
22013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
22014                 }
22015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22016                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22017                 if (_ptr_buffer) {
22018                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22019                 } else {
22020                         r->in.buffer = NULL;
22021                 }
22022                 if (r->in.buffer) {
22023                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22024                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22025                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22026                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22027                 }
22028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
22030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
22031                 NDR_PULL_ALLOC(ndr, r->out.needed);
22032                 ZERO_STRUCTP(r->out.needed);
22033                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
22034                 ZERO_STRUCTP(r->out.server_major_version);
22035                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
22036                 ZERO_STRUCTP(r->out.server_minor_version);
22037         }
22038         if (flags & NDR_OUT) {
22039                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22040                 if (_ptr_info) {
22041                         NDR_PULL_ALLOC(ndr, r->out.info);
22042                 } else {
22043                         r->out.info = NULL;
22044                 }
22045                 if (r->out.info) {
22046                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22047                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22048                         {
22049                                 struct ndr_pull *_ndr_info;
22050                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22051                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22052                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22053                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22054                         }
22055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22056                 }
22057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22058                         NDR_PULL_ALLOC(ndr, r->out.needed);
22059                 }
22060                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22065                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
22066                 }
22067                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
22068                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
22069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
22070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
22071                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22072                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
22073                 }
22074                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
22075                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
22076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
22077                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
22078                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22079         }
22080         return NDR_ERR_SUCCESS;
22081 }
22082
22083 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
22084 {
22085         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
22086         ndr->depth++;
22087         if (flags & NDR_SET_VALUES) {
22088                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22089         }
22090         if (flags & NDR_IN) {
22091                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
22092                 ndr->depth++;
22093                 ndr_print_ptr(ndr, "handle", r->in.handle);
22094                 ndr->depth++;
22095                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22096                 ndr->depth--;
22097                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
22098                 ndr->depth++;
22099                 if (r->in.architecture) {
22100                         ndr_print_string(ndr, "architecture", r->in.architecture);
22101                 }
22102                 ndr->depth--;
22103                 ndr_print_uint32(ndr, "level", r->in.level);
22104                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22105                 ndr->depth++;
22106                 if (r->in.buffer) {
22107                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22108                 }
22109                 ndr->depth--;
22110                 ndr_print_uint32(ndr, "offered", r->in.offered);
22111                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
22112                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
22113                 ndr->depth--;
22114         }
22115         if (flags & NDR_OUT) {
22116                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
22117                 ndr->depth++;
22118                 ndr_print_ptr(ndr, "info", r->out.info);
22119                 ndr->depth++;
22120                 if (r->out.info) {
22121                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22122                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
22123                 }
22124                 ndr->depth--;
22125                 ndr_print_ptr(ndr, "needed", r->out.needed);
22126                 ndr->depth++;
22127                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22128                 ndr->depth--;
22129                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
22130                 ndr->depth++;
22131                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
22132                 ndr->depth--;
22133                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
22134                 ndr->depth++;
22135                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
22136                 ndr->depth--;
22137                 ndr_print_WERROR(ndr, "result", r->out.result);
22138                 ndr->depth--;
22139         }
22140         ndr->depth--;
22141 }
22142
22143 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
22144 {
22145         if (flags & NDR_IN) {
22146         }
22147         if (flags & NDR_OUT) {
22148                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22149         }
22150         return NDR_ERR_SUCCESS;
22151 }
22152
22153 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
22154 {
22155         if (flags & NDR_IN) {
22156         }
22157         if (flags & NDR_OUT) {
22158                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22159         }
22160         return NDR_ERR_SUCCESS;
22161 }
22162
22163 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
22164 {
22165         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
22166         ndr->depth++;
22167         if (flags & NDR_SET_VALUES) {
22168                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22169         }
22170         if (flags & NDR_IN) {
22171                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
22172                 ndr->depth++;
22173                 ndr->depth--;
22174         }
22175         if (flags & NDR_OUT) {
22176                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
22177                 ndr->depth++;
22178                 ndr_print_WERROR(ndr, "result", r->out.result);
22179                 ndr->depth--;
22180         }
22181         ndr->depth--;
22182 }
22183
22184 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
22185 {
22186         if (flags & NDR_IN) {
22187         }
22188         if (flags & NDR_OUT) {
22189                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22190         }
22191         return NDR_ERR_SUCCESS;
22192 }
22193
22194 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
22195 {
22196         if (flags & NDR_IN) {
22197         }
22198         if (flags & NDR_OUT) {
22199                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22200         }
22201         return NDR_ERR_SUCCESS;
22202 }
22203
22204 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
22205 {
22206         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
22207         ndr->depth++;
22208         if (flags & NDR_SET_VALUES) {
22209                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22210         }
22211         if (flags & NDR_IN) {
22212                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
22213                 ndr->depth++;
22214                 ndr->depth--;
22215         }
22216         if (flags & NDR_OUT) {
22217                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
22218                 ndr->depth++;
22219                 ndr_print_WERROR(ndr, "result", r->out.result);
22220                 ndr->depth--;
22221         }
22222         ndr->depth--;
22223 }
22224
22225 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
22226 {
22227         if (flags & NDR_IN) {
22228                 if (r->in.handle == NULL) {
22229                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22230                 }
22231                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22232         }
22233         if (flags & NDR_OUT) {
22234                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22235         }
22236         return NDR_ERR_SUCCESS;
22237 }
22238
22239 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
22240 {
22241         TALLOC_CTX *_mem_save_handle_0;
22242         if (flags & NDR_IN) {
22243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22244                         NDR_PULL_ALLOC(ndr, r->in.handle);
22245                 }
22246                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22247                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22248                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22250         }
22251         if (flags & NDR_OUT) {
22252                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22253         }
22254         return NDR_ERR_SUCCESS;
22255 }
22256
22257 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
22258 {
22259         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
22260         ndr->depth++;
22261         if (flags & NDR_SET_VALUES) {
22262                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22263         }
22264         if (flags & NDR_IN) {
22265                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
22266                 ndr->depth++;
22267                 ndr_print_ptr(ndr, "handle", r->in.handle);
22268                 ndr->depth++;
22269                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22270                 ndr->depth--;
22271                 ndr->depth--;
22272         }
22273         if (flags & NDR_OUT) {
22274                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
22275                 ndr->depth++;
22276                 ndr_print_WERROR(ndr, "result", r->out.result);
22277                 ndr->depth--;
22278         }
22279         ndr->depth--;
22280 }
22281
22282 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
22283 {
22284         if (flags & NDR_IN) {
22285         }
22286         if (flags & NDR_OUT) {
22287                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22288         }
22289         return NDR_ERR_SUCCESS;
22290 }
22291
22292 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
22293 {
22294         if (flags & NDR_IN) {
22295         }
22296         if (flags & NDR_OUT) {
22297                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22298         }
22299         return NDR_ERR_SUCCESS;
22300 }
22301
22302 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
22303 {
22304         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
22305         ndr->depth++;
22306         if (flags & NDR_SET_VALUES) {
22307                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22308         }
22309         if (flags & NDR_IN) {
22310                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
22311                 ndr->depth++;
22312                 ndr->depth--;
22313         }
22314         if (flags & NDR_OUT) {
22315                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
22316                 ndr->depth++;
22317                 ndr_print_WERROR(ndr, "result", r->out.result);
22318                 ndr->depth--;
22319         }
22320         ndr->depth--;
22321 }
22322
22323 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
22324 {
22325         if (flags & NDR_IN) {
22326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22329                 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));
22330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
22331                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
22333                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22334                 if (r->in.buffer) {
22335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
22336                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
22337                 }
22338         }
22339         if (flags & NDR_OUT) {
22340                 if (r->out.handle == NULL) {
22341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22342                 }
22343                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22344                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22345         }
22346         return NDR_ERR_SUCCESS;
22347 }
22348
22349 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
22350 {
22351         uint32_t _ptr_buffer;
22352         TALLOC_CTX *_mem_save_buffer_0;
22353         TALLOC_CTX *_mem_save_handle_0;
22354         if (flags & NDR_IN) {
22355                 ZERO_STRUCT(r->out);
22356
22357                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
22358                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
22359                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
22360                         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));
22361                 }
22362                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
22363                 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));
22364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
22365                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22366                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
22367                 if (r->in.bufsize > 512) {
22368                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
22369                 }
22370                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22371                 if (_ptr_buffer) {
22372                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22373                 } else {
22374                         r->in.buffer = NULL;
22375                 }
22376                 if (r->in.buffer) {
22377                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22378                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22379                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22380                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22381                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22383                 }
22384                 NDR_PULL_ALLOC(ndr, r->out.handle);
22385                 ZERO_STRUCTP(r->out.handle);
22386                 if (r->in.buffer) {
22387                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
22388                 }
22389         }
22390         if (flags & NDR_OUT) {
22391                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22392                         NDR_PULL_ALLOC(ndr, r->out.handle);
22393                 }
22394                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22395                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22396                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22397                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22398                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22399         }
22400         return NDR_ERR_SUCCESS;
22401 }
22402
22403 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
22404 {
22405         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
22406         ndr->depth++;
22407         if (flags & NDR_SET_VALUES) {
22408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22409         }
22410         if (flags & NDR_IN) {
22411                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
22412                 ndr->depth++;
22413                 ndr_print_string(ndr, "server_name", r->in.server_name);
22414                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
22415                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22416                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
22417                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22418                 ndr->depth++;
22419                 if (r->in.buffer) {
22420                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
22421                 }
22422                 ndr->depth--;
22423                 ndr->depth--;
22424         }
22425         if (flags & NDR_OUT) {
22426                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
22427                 ndr->depth++;
22428                 ndr_print_ptr(ndr, "handle", r->out.handle);
22429                 ndr->depth++;
22430                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22431                 ndr->depth--;
22432                 ndr_print_WERROR(ndr, "result", r->out.result);
22433                 ndr->depth--;
22434         }
22435         ndr->depth--;
22436 }
22437
22438 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
22439 {
22440         if (flags & NDR_IN) {
22441                 if (r->in.handle == NULL) {
22442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22443                 }
22444                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22445                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
22446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
22447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22448                 if (r->in.buffer) {
22449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
22450                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
22451                 }
22452         }
22453         if (flags & NDR_OUT) {
22454                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22455         }
22456         return NDR_ERR_SUCCESS;
22457 }
22458
22459 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
22460 {
22461         uint32_t _ptr_buffer;
22462         TALLOC_CTX *_mem_save_handle_0;
22463         TALLOC_CTX *_mem_save_buffer_0;
22464         if (flags & NDR_IN) {
22465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22466                         NDR_PULL_ALLOC(ndr, r->in.handle);
22467                 }
22468                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22470                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22472                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
22473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
22474                 if (r->in.bufsize > 512) {
22475                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
22476                 }
22477                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22478                 if (_ptr_buffer) {
22479                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22480                 } else {
22481                         r->in.buffer = NULL;
22482                 }
22483                 if (r->in.buffer) {
22484                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22485                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
22487                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
22488                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
22489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22490                 }
22491                 if (r->in.buffer) {
22492                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
22493                 }
22494         }
22495         if (flags & NDR_OUT) {
22496                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22497         }
22498         return NDR_ERR_SUCCESS;
22499 }
22500
22501 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
22502 {
22503         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
22504         ndr->depth++;
22505         if (flags & NDR_SET_VALUES) {
22506                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22507         }
22508         if (flags & NDR_IN) {
22509                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
22510                 ndr->depth++;
22511                 ndr_print_ptr(ndr, "handle", r->in.handle);
22512                 ndr->depth++;
22513                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22514                 ndr->depth--;
22515                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
22516                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
22517                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22518                 ndr->depth++;
22519                 if (r->in.buffer) {
22520                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
22521                 }
22522                 ndr->depth--;
22523                 ndr->depth--;
22524         }
22525         if (flags & NDR_OUT) {
22526                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
22527                 ndr->depth++;
22528                 ndr_print_WERROR(ndr, "result", r->out.result);
22529                 ndr->depth--;
22530         }
22531         ndr->depth--;
22532 }
22533
22534 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
22535 {
22536         if (flags & NDR_IN) {
22537                 if (r->in.handle == NULL) {
22538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22539                 }
22540                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22541         }
22542         if (flags & NDR_OUT) {
22543                 if (r->out.handle == NULL) {
22544                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22545                 }
22546                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22547                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22548         }
22549         return NDR_ERR_SUCCESS;
22550 }
22551
22552 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
22553 {
22554         TALLOC_CTX *_mem_save_handle_0;
22555         if (flags & NDR_IN) {
22556                 ZERO_STRUCT(r->out);
22557
22558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22559                         NDR_PULL_ALLOC(ndr, r->in.handle);
22560                 }
22561                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22563                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22565                 NDR_PULL_ALLOC(ndr, r->out.handle);
22566                 *r->out.handle = *r->in.handle;
22567         }
22568         if (flags & NDR_OUT) {
22569                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22570                         NDR_PULL_ALLOC(ndr, r->out.handle);
22571                 }
22572                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22573                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22574                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22575                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22576                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22577         }
22578         return NDR_ERR_SUCCESS;
22579 }
22580
22581 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
22582 {
22583         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
22584         ndr->depth++;
22585         if (flags & NDR_SET_VALUES) {
22586                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22587         }
22588         if (flags & NDR_IN) {
22589                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
22590                 ndr->depth++;
22591                 ndr_print_ptr(ndr, "handle", r->in.handle);
22592                 ndr->depth++;
22593                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22594                 ndr->depth--;
22595                 ndr->depth--;
22596         }
22597         if (flags & NDR_OUT) {
22598                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
22599                 ndr->depth++;
22600                 ndr_print_ptr(ndr, "handle", r->out.handle);
22601                 ndr->depth++;
22602                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22603                 ndr->depth--;
22604                 ndr_print_WERROR(ndr, "result", r->out.result);
22605                 ndr->depth--;
22606         }
22607         ndr->depth--;
22608 }
22609
22610 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
22611 {
22612         if (flags & NDR_IN) {
22613         }
22614         if (flags & NDR_OUT) {
22615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22616         }
22617         return NDR_ERR_SUCCESS;
22618 }
22619
22620 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
22621 {
22622         if (flags & NDR_IN) {
22623         }
22624         if (flags & NDR_OUT) {
22625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22626         }
22627         return NDR_ERR_SUCCESS;
22628 }
22629
22630 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
22631 {
22632         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
22633         ndr->depth++;
22634         if (flags & NDR_SET_VALUES) {
22635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22636         }
22637         if (flags & NDR_IN) {
22638                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
22639                 ndr->depth++;
22640                 ndr->depth--;
22641         }
22642         if (flags & NDR_OUT) {
22643                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
22644                 ndr->depth++;
22645                 ndr_print_WERROR(ndr, "result", r->out.result);
22646                 ndr->depth--;
22647         }
22648         ndr->depth--;
22649 }
22650
22651 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
22652 {
22653         if (flags & NDR_IN) {
22654         }
22655         if (flags & NDR_OUT) {
22656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22657         }
22658         return NDR_ERR_SUCCESS;
22659 }
22660
22661 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
22662 {
22663         if (flags & NDR_IN) {
22664         }
22665         if (flags & NDR_OUT) {
22666                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22667         }
22668         return NDR_ERR_SUCCESS;
22669 }
22670
22671 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
22672 {
22673         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
22674         ndr->depth++;
22675         if (flags & NDR_SET_VALUES) {
22676                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22677         }
22678         if (flags & NDR_IN) {
22679                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
22680                 ndr->depth++;
22681                 ndr->depth--;
22682         }
22683         if (flags & NDR_OUT) {
22684                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
22685                 ndr->depth++;
22686                 ndr_print_WERROR(ndr, "result", r->out.result);
22687                 ndr->depth--;
22688         }
22689         ndr->depth--;
22690 }
22691
22692 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
22693 {
22694         if (flags & NDR_IN) {
22695         }
22696         if (flags & NDR_OUT) {
22697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22698         }
22699         return NDR_ERR_SUCCESS;
22700 }
22701
22702 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
22703 {
22704         if (flags & NDR_IN) {
22705         }
22706         if (flags & NDR_OUT) {
22707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22708         }
22709         return NDR_ERR_SUCCESS;
22710 }
22711
22712 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
22713 {
22714         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
22715         ndr->depth++;
22716         if (flags & NDR_SET_VALUES) {
22717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22718         }
22719         if (flags & NDR_IN) {
22720                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
22721                 ndr->depth++;
22722                 ndr->depth--;
22723         }
22724         if (flags & NDR_OUT) {
22725                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
22726                 ndr->depth++;
22727                 ndr_print_WERROR(ndr, "result", r->out.result);
22728                 ndr->depth--;
22729         }
22730         ndr->depth--;
22731 }
22732
22733 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
22734 {
22735         if (flags & NDR_IN) {
22736         }
22737         if (flags & NDR_OUT) {
22738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22739         }
22740         return NDR_ERR_SUCCESS;
22741 }
22742
22743 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
22744 {
22745         if (flags & NDR_IN) {
22746         }
22747         if (flags & NDR_OUT) {
22748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22749         }
22750         return NDR_ERR_SUCCESS;
22751 }
22752
22753 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
22754 {
22755         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
22756         ndr->depth++;
22757         if (flags & NDR_SET_VALUES) {
22758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22759         }
22760         if (flags & NDR_IN) {
22761                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
22762                 ndr->depth++;
22763                 ndr->depth--;
22764         }
22765         if (flags & NDR_OUT) {
22766                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
22767                 ndr->depth++;
22768                 ndr_print_WERROR(ndr, "result", r->out.result);
22769                 ndr->depth--;
22770         }
22771         ndr->depth--;
22772 }
22773
22774 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
22775 {
22776         if (flags & NDR_IN) {
22777                 if (r->in.handle == NULL) {
22778                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22779                 }
22780                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22781                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
22782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
22783                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
22784                 if (r->in.local_machine) {
22785                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
22786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
22788                         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));
22789                 }
22790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
22791                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
22792                 if (r->in.notify_options) {
22793                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
22794                 }
22795         }
22796         if (flags & NDR_OUT) {
22797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22798         }
22799         return NDR_ERR_SUCCESS;
22800 }
22801
22802 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
22803 {
22804         uint32_t _ptr_local_machine;
22805         uint32_t _ptr_notify_options;
22806         TALLOC_CTX *_mem_save_handle_0;
22807         TALLOC_CTX *_mem_save_local_machine_0;
22808         TALLOC_CTX *_mem_save_notify_options_0;
22809         if (flags & NDR_IN) {
22810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22811                         NDR_PULL_ALLOC(ndr, r->in.handle);
22812                 }
22813                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22814                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22815                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22816                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22817                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
22818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
22819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
22820                 if (_ptr_local_machine) {
22821                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
22822                 } else {
22823                         r->in.local_machine = NULL;
22824                 }
22825                 if (r->in.local_machine) {
22826                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
22827                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
22828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
22829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
22830                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
22831                                 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));
22832                         }
22833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
22834                         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));
22835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
22836                 }
22837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
22838                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
22839                 if (_ptr_notify_options) {
22840                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
22841                 } else {
22842                         r->in.notify_options = NULL;
22843                 }
22844                 if (r->in.notify_options) {
22845                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
22846                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
22847                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
22848                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
22849                 }
22850         }
22851         if (flags & NDR_OUT) {
22852                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22853         }
22854         return NDR_ERR_SUCCESS;
22855 }
22856
22857 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
22858 {
22859         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
22860         ndr->depth++;
22861         if (flags & NDR_SET_VALUES) {
22862                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22863         }
22864         if (flags & NDR_IN) {
22865                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
22866                 ndr->depth++;
22867                 ndr_print_ptr(ndr, "handle", r->in.handle);
22868                 ndr->depth++;
22869                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22870                 ndr->depth--;
22871                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
22872                 ndr_print_uint32(ndr, "options", r->in.options);
22873                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
22874                 ndr->depth++;
22875                 if (r->in.local_machine) {
22876                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
22877                 }
22878                 ndr->depth--;
22879                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
22880                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
22881                 ndr->depth++;
22882                 if (r->in.notify_options) {
22883                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
22884                 }
22885                 ndr->depth--;
22886                 ndr->depth--;
22887         }
22888         if (flags & NDR_OUT) {
22889                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
22890                 ndr->depth++;
22891                 ndr_print_WERROR(ndr, "result", r->out.result);
22892                 ndr->depth--;
22893         }
22894         ndr->depth--;
22895 }
22896
22897 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
22898 {
22899         if (flags & NDR_IN) {
22900                 if (r->in.handle == NULL) {
22901                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22902                 }
22903                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
22905                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
22906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
22907                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
22908                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22909         }
22910         if (flags & NDR_OUT) {
22911                 if (r->out.reply_result == NULL) {
22912                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22913                 }
22914                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
22915                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22916         }
22917         return NDR_ERR_SUCCESS;
22918 }
22919
22920 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
22921 {
22922         TALLOC_CTX *_mem_save_handle_0;
22923         TALLOC_CTX *_mem_save_reply_result_0;
22924         if (flags & NDR_IN) {
22925                 ZERO_STRUCT(r->out);
22926
22927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22928                         NDR_PULL_ALLOC(ndr, r->in.handle);
22929                 }
22930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22931                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
22935                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
22936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
22937                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
22938                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22939                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
22940                 ZERO_STRUCTP(r->out.reply_result);
22941         }
22942         if (flags & NDR_OUT) {
22943                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22944                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
22945                 }
22946                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
22947                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
22948                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
22949                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
22950                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22951         }
22952         return NDR_ERR_SUCCESS;
22953 }
22954
22955 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
22956 {
22957         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
22958         ndr->depth++;
22959         if (flags & NDR_SET_VALUES) {
22960                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22961         }
22962         if (flags & NDR_IN) {
22963                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
22964                 ndr->depth++;
22965                 ndr_print_ptr(ndr, "handle", r->in.handle);
22966                 ndr->depth++;
22967                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22968                 ndr->depth--;
22969                 ndr_print_uint32(ndr, "color", r->in.color);
22970                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
22971                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
22972                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
22973                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
22974                 ndr->depth--;
22975         }
22976         if (flags & NDR_OUT) {
22977                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
22978                 ndr->depth++;
22979                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
22980                 ndr->depth++;
22981                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
22982                 ndr->depth--;
22983                 ndr_print_WERROR(ndr, "result", r->out.result);
22984                 ndr->depth--;
22985         }
22986         ndr->depth--;
22987 }
22988
22989 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
22990 {
22991         if (flags & NDR_IN) {
22992                 if (r->in.handle == NULL) {
22993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22994                 }
22995                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
22997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
22998                 if (r->in.options) {
22999                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
23000                 }
23001         }
23002         if (flags & NDR_OUT) {
23003                 if (r->out.info == NULL) {
23004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23005                 }
23006                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
23007                 if (*r->out.info) {
23008                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
23009                 }
23010                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23011         }
23012         return NDR_ERR_SUCCESS;
23013 }
23014
23015 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
23016 {
23017         uint32_t _ptr_options;
23018         uint32_t _ptr_info;
23019         TALLOC_CTX *_mem_save_handle_0;
23020         TALLOC_CTX *_mem_save_options_0;
23021         TALLOC_CTX *_mem_save_info_0;
23022         TALLOC_CTX *_mem_save_info_1;
23023         if (flags & NDR_IN) {
23024                 ZERO_STRUCT(r->out);
23025
23026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23027                         NDR_PULL_ALLOC(ndr, r->in.handle);
23028                 }
23029                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23030                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23031                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23033                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
23034                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
23035                 if (_ptr_options) {
23036                         NDR_PULL_ALLOC(ndr, r->in.options);
23037                 } else {
23038                         r->in.options = NULL;
23039                 }
23040                 if (r->in.options) {
23041                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
23042                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
23043                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
23044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
23045                 }
23046                 NDR_PULL_ALLOC(ndr, r->out.info);
23047                 ZERO_STRUCTP(r->out.info);
23048         }
23049         if (flags & NDR_OUT) {
23050                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23051                         NDR_PULL_ALLOC(ndr, r->out.info);
23052                 }
23053                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23054                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
23055                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23056                 if (_ptr_info) {
23057                         NDR_PULL_ALLOC(ndr, *r->out.info);
23058                 } else {
23059                         *r->out.info = NULL;
23060                 }
23061                 if (*r->out.info) {
23062                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
23063                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
23064                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
23065                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
23066                 }
23067                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
23068                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23069         }
23070         return NDR_ERR_SUCCESS;
23071 }
23072
23073 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
23074 {
23075         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
23076         ndr->depth++;
23077         if (flags & NDR_SET_VALUES) {
23078                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23079         }
23080         if (flags & NDR_IN) {
23081                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
23082                 ndr->depth++;
23083                 ndr_print_ptr(ndr, "handle", r->in.handle);
23084                 ndr->depth++;
23085                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23086                 ndr->depth--;
23087                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
23088                 ndr_print_ptr(ndr, "options", r->in.options);
23089                 ndr->depth++;
23090                 if (r->in.options) {
23091                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
23092                 }
23093                 ndr->depth--;
23094                 ndr->depth--;
23095         }
23096         if (flags & NDR_OUT) {
23097                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
23098                 ndr->depth++;
23099                 ndr_print_ptr(ndr, "info", r->out.info);
23100                 ndr->depth++;
23101                 ndr_print_ptr(ndr, "info", *r->out.info);
23102                 ndr->depth++;
23103                 if (*r->out.info) {
23104                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
23105                 }
23106                 ndr->depth--;
23107                 ndr->depth--;
23108                 ndr_print_WERROR(ndr, "result", r->out.result);
23109                 ndr->depth--;
23110         }
23111         ndr->depth--;
23112 }
23113
23114 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
23115 {
23116         if (flags & NDR_IN) {
23117         }
23118         if (flags & NDR_OUT) {
23119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23120         }
23121         return NDR_ERR_SUCCESS;
23122 }
23123
23124 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
23125 {
23126         if (flags & NDR_IN) {
23127         }
23128         if (flags & NDR_OUT) {
23129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23130         }
23131         return NDR_ERR_SUCCESS;
23132 }
23133
23134 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
23135 {
23136         ndr_print_struct(ndr, name, "spoolss_44");
23137         ndr->depth++;
23138         if (flags & NDR_SET_VALUES) {
23139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23140         }
23141         if (flags & NDR_IN) {
23142                 ndr_print_struct(ndr, "in", "spoolss_44");
23143                 ndr->depth++;
23144                 ndr->depth--;
23145         }
23146         if (flags & NDR_OUT) {
23147                 ndr_print_struct(ndr, "out", "spoolss_44");
23148                 ndr->depth++;
23149                 ndr_print_WERROR(ndr, "result", r->out.result);
23150                 ndr->depth--;
23151         }
23152         ndr->depth--;
23153 }
23154
23155 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
23156 {
23157         if (flags & NDR_IN) {
23158                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
23159                 if (r->in.printername) {
23160                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
23161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
23163                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23164                 }
23165                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
23166                 if (r->in.datatype) {
23167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
23168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23169                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
23170                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23171                 }
23172                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
23173                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
23174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23175                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
23176                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
23177         }
23178         if (flags & NDR_OUT) {
23179                 if (r->out.handle == NULL) {
23180                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23181                 }
23182                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23183                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23184         }
23185         return NDR_ERR_SUCCESS;
23186 }
23187
23188 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
23189 {
23190         uint32_t _ptr_printername;
23191         uint32_t _ptr_datatype;
23192         TALLOC_CTX *_mem_save_printername_0;
23193         TALLOC_CTX *_mem_save_datatype_0;
23194         TALLOC_CTX *_mem_save_handle_0;
23195         if (flags & NDR_IN) {
23196                 ZERO_STRUCT(r->out);
23197
23198                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
23199                 if (_ptr_printername) {
23200                         NDR_PULL_ALLOC(ndr, r->in.printername);
23201                 } else {
23202                         r->in.printername = NULL;
23203                 }
23204                 if (r->in.printername) {
23205                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23206                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
23207                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
23208                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
23209                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
23210                                 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));
23211                         }
23212                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
23213                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
23214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
23215                 }
23216                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
23217                 if (_ptr_datatype) {
23218                         NDR_PULL_ALLOC(ndr, r->in.datatype);
23219                 } else {
23220                         r->in.datatype = NULL;
23221                 }
23222                 if (r->in.datatype) {
23223                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
23224                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
23225                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
23226                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
23227                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
23228                                 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));
23229                         }
23230                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
23231                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
23232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
23233                 }
23234                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
23235                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
23236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23237                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
23238                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
23239                 NDR_PULL_ALLOC(ndr, r->out.handle);
23240                 ZERO_STRUCTP(r->out.handle);
23241         }
23242         if (flags & NDR_OUT) {
23243                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23244                         NDR_PULL_ALLOC(ndr, r->out.handle);
23245                 }
23246                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23247                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23248                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23249                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23250                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23251         }
23252         return NDR_ERR_SUCCESS;
23253 }
23254
23255 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
23256 {
23257         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
23258         ndr->depth++;
23259         if (flags & NDR_SET_VALUES) {
23260                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23261         }
23262         if (flags & NDR_IN) {
23263                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
23264                 ndr->depth++;
23265                 ndr_print_ptr(ndr, "printername", r->in.printername);
23266                 ndr->depth++;
23267                 if (r->in.printername) {
23268                         ndr_print_string(ndr, "printername", r->in.printername);
23269                 }
23270                 ndr->depth--;
23271                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
23272                 ndr->depth++;
23273                 if (r->in.datatype) {
23274                         ndr_print_string(ndr, "datatype", r->in.datatype);
23275                 }
23276                 ndr->depth--;
23277                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
23278                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
23279                 ndr_print_uint32(ndr, "level", r->in.level);
23280                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
23281                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
23282                 ndr->depth--;
23283         }
23284         if (flags & NDR_OUT) {
23285                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
23286                 ndr->depth++;
23287                 ndr_print_ptr(ndr, "handle", r->out.handle);
23288                 ndr->depth++;
23289                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23290                 ndr->depth--;
23291                 ndr_print_WERROR(ndr, "result", r->out.result);
23292                 ndr->depth--;
23293         }
23294         ndr->depth--;
23295 }
23296
23297 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
23298 {
23299         if (flags & NDR_IN) {
23300                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
23301                 if (r->in.server) {
23302                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23303                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23304                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
23305                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23306                 }
23307                 if (r->in.info_ctr == NULL) {
23308                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23309                 }
23310                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
23311                 if (r->in.devmode_ctr == NULL) {
23312                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23313                 }
23314                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23315                 if (r->in.secdesc_ctr == NULL) {
23316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23317                 }
23318                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
23319                 if (r->in.userlevel_ctr == NULL) {
23320                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23321                 }
23322                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
23323         }
23324         if (flags & NDR_OUT) {
23325                 if (r->out.handle == NULL) {
23326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23327                 }
23328                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23329                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23330         }
23331         return NDR_ERR_SUCCESS;
23332 }
23333
23334 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
23335 {
23336         uint32_t _ptr_server;
23337         TALLOC_CTX *_mem_save_server_0;
23338         TALLOC_CTX *_mem_save_info_ctr_0;
23339         TALLOC_CTX *_mem_save_devmode_ctr_0;
23340         TALLOC_CTX *_mem_save_secdesc_ctr_0;
23341         TALLOC_CTX *_mem_save_userlevel_ctr_0;
23342         TALLOC_CTX *_mem_save_handle_0;
23343         if (flags & NDR_IN) {
23344                 ZERO_STRUCT(r->out);
23345
23346                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
23347                 if (_ptr_server) {
23348                         NDR_PULL_ALLOC(ndr, r->in.server);
23349                 } else {
23350                         r->in.server = NULL;
23351                 }
23352                 if (r->in.server) {
23353                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
23354                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
23355                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
23356                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
23357                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
23358                                 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));
23359                         }
23360                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
23361                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
23362                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
23363                 }
23364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23365                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
23366                 }
23367                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23368                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
23369                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
23370                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23372                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23373                 }
23374                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23375                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23376                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23378                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23379                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
23380                 }
23381                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23382                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
23383                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
23384                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23386                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
23387                 }
23388                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23389                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
23390                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
23391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23392                 NDR_PULL_ALLOC(ndr, r->out.handle);
23393                 ZERO_STRUCTP(r->out.handle);
23394         }
23395         if (flags & NDR_OUT) {
23396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23397                         NDR_PULL_ALLOC(ndr, r->out.handle);
23398                 }
23399                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23400                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
23401                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
23402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23403                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23404         }
23405         return NDR_ERR_SUCCESS;
23406 }
23407
23408 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
23409 {
23410         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
23411         ndr->depth++;
23412         if (flags & NDR_SET_VALUES) {
23413                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23414         }
23415         if (flags & NDR_IN) {
23416                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
23417                 ndr->depth++;
23418                 ndr_print_ptr(ndr, "server", r->in.server);
23419                 ndr->depth++;
23420                 if (r->in.server) {
23421                         ndr_print_string(ndr, "server", r->in.server);
23422                 }
23423                 ndr->depth--;
23424                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
23425                 ndr->depth++;
23426                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
23427                 ndr->depth--;
23428                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23429                 ndr->depth++;
23430                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23431                 ndr->depth--;
23432                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
23433                 ndr->depth++;
23434                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
23435                 ndr->depth--;
23436                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
23437                 ndr->depth++;
23438                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
23439                 ndr->depth--;
23440                 ndr->depth--;
23441         }
23442         if (flags & NDR_OUT) {
23443                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
23444                 ndr->depth++;
23445                 ndr_print_ptr(ndr, "handle", r->out.handle);
23446                 ndr->depth++;
23447                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
23448                 ndr->depth--;
23449                 ndr_print_WERROR(ndr, "result", r->out.result);
23450                 ndr->depth--;
23451         }
23452         ndr->depth--;
23453 }
23454
23455 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
23456 {
23457         if (flags & NDR_IN) {
23458         }
23459         if (flags & NDR_OUT) {
23460                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23461         }
23462         return NDR_ERR_SUCCESS;
23463 }
23464
23465 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
23466 {
23467         if (flags & NDR_IN) {
23468         }
23469         if (flags & NDR_OUT) {
23470                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23471         }
23472         return NDR_ERR_SUCCESS;
23473 }
23474
23475 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
23476 {
23477         ndr_print_struct(ndr, name, "spoolss_47");
23478         ndr->depth++;
23479         if (flags & NDR_SET_VALUES) {
23480                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23481         }
23482         if (flags & NDR_IN) {
23483                 ndr_print_struct(ndr, "in", "spoolss_47");
23484                 ndr->depth++;
23485                 ndr->depth--;
23486         }
23487         if (flags & NDR_OUT) {
23488                 ndr_print_struct(ndr, "out", "spoolss_47");
23489                 ndr->depth++;
23490                 ndr_print_WERROR(ndr, "result", r->out.result);
23491                 ndr->depth--;
23492         }
23493         ndr->depth--;
23494 }
23495
23496 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
23497 {
23498         if (flags & NDR_IN) {
23499                 if (r->in.handle == NULL) {
23500                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23501                 }
23502                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
23504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
23505                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
23506         }
23507         if (flags & NDR_OUT) {
23508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
23509                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
23510                 if (r->out.value_needed == NULL) {
23511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23512                 }
23513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
23514                 if (r->out.printerdata_type == NULL) {
23515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23516                 }
23517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
23518                 if (r->out.buffer == NULL) {
23519                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23520                 }
23521                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
23522                 if (r->out.data_needed == NULL) {
23523                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23524                 }
23525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
23526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23527         }
23528         return NDR_ERR_SUCCESS;
23529 }
23530
23531 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
23532 {
23533         TALLOC_CTX *_mem_save_handle_0;
23534         TALLOC_CTX *_mem_save_value_needed_0;
23535         TALLOC_CTX *_mem_save_printerdata_type_0;
23536         TALLOC_CTX *_mem_save_buffer_0;
23537         TALLOC_CTX *_mem_save_data_needed_0;
23538         if (flags & NDR_IN) {
23539                 ZERO_STRUCT(r->out);
23540
23541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23542                         NDR_PULL_ALLOC(ndr, r->in.handle);
23543                 }
23544                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23545                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23546                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
23549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
23550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
23551                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
23552                 ZERO_STRUCTP(r->out.value_needed);
23553                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
23554                 ZERO_STRUCTP(r->out.printerdata_type);
23555                 NDR_PULL_ALLOC(ndr, r->out.buffer);
23556                 ZERO_STRUCTP(r->out.buffer);
23557                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
23558                 ZERO_STRUCTP(r->out.data_needed);
23559         }
23560         if (flags & NDR_OUT) {
23561                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
23562                 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));
23563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23564                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
23565                 }
23566                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
23568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
23569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
23570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23571                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
23572                 }
23573                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23574                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
23575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
23576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
23577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23578                         NDR_PULL_ALLOC(ndr, r->out.buffer);
23579                 }
23580                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23581                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
23582                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
23583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
23584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23585                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
23586                 }
23587                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23588                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
23589                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
23590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
23591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23592                 if (r->out.value_name) {
23593                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
23594                 }
23595         }
23596         return NDR_ERR_SUCCESS;
23597 }
23598
23599 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
23600 {
23601         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
23602         ndr->depth++;
23603         if (flags & NDR_SET_VALUES) {
23604                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23605         }
23606         if (flags & NDR_IN) {
23607                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
23608                 ndr->depth++;
23609                 ndr_print_ptr(ndr, "handle", r->in.handle);
23610                 ndr->depth++;
23611                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23612                 ndr->depth--;
23613                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
23614                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
23615                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
23616                 ndr->depth--;
23617         }
23618         if (flags & NDR_OUT) {
23619                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
23620                 ndr->depth++;
23621                 ndr_print_string(ndr, "value_name", r->out.value_name);
23622                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
23623                 ndr->depth++;
23624                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
23625                 ndr->depth--;
23626                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
23627                 ndr->depth++;
23628                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
23629                 ndr->depth--;
23630                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
23631                 ndr->depth++;
23632                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
23633                 ndr->depth--;
23634                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
23635                 ndr->depth++;
23636                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
23637                 ndr->depth--;
23638                 ndr_print_WERROR(ndr, "result", r->out.result);
23639                 ndr->depth--;
23640         }
23641         ndr->depth--;
23642 }
23643
23644 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
23645 {
23646         if (flags & NDR_IN) {
23647                 if (r->in.handle == NULL) {
23648                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23649                 }
23650                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23654                 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));
23655         }
23656         if (flags & NDR_OUT) {
23657                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23658         }
23659         return NDR_ERR_SUCCESS;
23660 }
23661
23662 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
23663 {
23664         TALLOC_CTX *_mem_save_handle_0;
23665         if (flags & NDR_IN) {
23666                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23667                         NDR_PULL_ALLOC(ndr, r->in.handle);
23668                 }
23669                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23670                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23671                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23672                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23673                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23674                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23675                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23676                         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));
23677                 }
23678                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23679                 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));
23680         }
23681         if (flags & NDR_OUT) {
23682                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23683         }
23684         return NDR_ERR_SUCCESS;
23685 }
23686
23687 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
23688 {
23689         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
23690         ndr->depth++;
23691         if (flags & NDR_SET_VALUES) {
23692                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23693         }
23694         if (flags & NDR_IN) {
23695                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
23696                 ndr->depth++;
23697                 ndr_print_ptr(ndr, "handle", r->in.handle);
23698                 ndr->depth++;
23699                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23700                 ndr->depth--;
23701                 ndr_print_string(ndr, "value_name", r->in.value_name);
23702                 ndr->depth--;
23703         }
23704         if (flags & NDR_OUT) {
23705                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
23706                 ndr->depth++;
23707                 ndr_print_WERROR(ndr, "result", r->out.result);
23708                 ndr->depth--;
23709         }
23710         ndr->depth--;
23711 }
23712
23713 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
23714 {
23715         if (flags & NDR_IN) {
23716         }
23717         if (flags & NDR_OUT) {
23718                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23719         }
23720         return NDR_ERR_SUCCESS;
23721 }
23722
23723 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
23724 {
23725         if (flags & NDR_IN) {
23726         }
23727         if (flags & NDR_OUT) {
23728                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23729         }
23730         return NDR_ERR_SUCCESS;
23731 }
23732
23733 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
23734 {
23735         ndr_print_struct(ndr, name, "spoolss_4a");
23736         ndr->depth++;
23737         if (flags & NDR_SET_VALUES) {
23738                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23739         }
23740         if (flags & NDR_IN) {
23741                 ndr_print_struct(ndr, "in", "spoolss_4a");
23742                 ndr->depth++;
23743                 ndr->depth--;
23744         }
23745         if (flags & NDR_OUT) {
23746                 ndr_print_struct(ndr, "out", "spoolss_4a");
23747                 ndr->depth++;
23748                 ndr_print_WERROR(ndr, "result", r->out.result);
23749                 ndr->depth--;
23750         }
23751         ndr->depth--;
23752 }
23753
23754 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
23755 {
23756         if (flags & NDR_IN) {
23757         }
23758         if (flags & NDR_OUT) {
23759                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23760         }
23761         return NDR_ERR_SUCCESS;
23762 }
23763
23764 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
23765 {
23766         if (flags & NDR_IN) {
23767         }
23768         if (flags & NDR_OUT) {
23769                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23770         }
23771         return NDR_ERR_SUCCESS;
23772 }
23773
23774 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
23775 {
23776         ndr_print_struct(ndr, name, "spoolss_4b");
23777         ndr->depth++;
23778         if (flags & NDR_SET_VALUES) {
23779                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23780         }
23781         if (flags & NDR_IN) {
23782                 ndr_print_struct(ndr, "in", "spoolss_4b");
23783                 ndr->depth++;
23784                 ndr->depth--;
23785         }
23786         if (flags & NDR_OUT) {
23787                 ndr_print_struct(ndr, "out", "spoolss_4b");
23788                 ndr->depth++;
23789                 ndr_print_WERROR(ndr, "result", r->out.result);
23790                 ndr->depth--;
23791         }
23792         ndr->depth--;
23793 }
23794
23795 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
23796 {
23797         if (flags & NDR_IN) {
23798         }
23799         if (flags & NDR_OUT) {
23800                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23801         }
23802         return NDR_ERR_SUCCESS;
23803 }
23804
23805 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
23806 {
23807         if (flags & NDR_IN) {
23808         }
23809         if (flags & NDR_OUT) {
23810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23811         }
23812         return NDR_ERR_SUCCESS;
23813 }
23814
23815 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
23816 {
23817         ndr_print_struct(ndr, name, "spoolss_4c");
23818         ndr->depth++;
23819         if (flags & NDR_SET_VALUES) {
23820                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23821         }
23822         if (flags & NDR_IN) {
23823                 ndr_print_struct(ndr, "in", "spoolss_4c");
23824                 ndr->depth++;
23825                 ndr->depth--;
23826         }
23827         if (flags & NDR_OUT) {
23828                 ndr_print_struct(ndr, "out", "spoolss_4c");
23829                 ndr->depth++;
23830                 ndr_print_WERROR(ndr, "result", r->out.result);
23831                 ndr->depth--;
23832         }
23833         ndr->depth--;
23834 }
23835
23836 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
23837 {
23838         if (flags & NDR_IN) {
23839                 if (r->in.handle == NULL) {
23840                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23841                 }
23842                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
23844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
23846                 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));
23847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23850                 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));
23851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
23852                 if (r->in.buffer == NULL) {
23853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23854                 }
23855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23856                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
23857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23858         }
23859         if (flags & NDR_OUT) {
23860                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23861         }
23862         return NDR_ERR_SUCCESS;
23863 }
23864
23865 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
23866 {
23867         TALLOC_CTX *_mem_save_handle_0;
23868         if (flags & NDR_IN) {
23869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23870                         NDR_PULL_ALLOC(ndr, r->in.handle);
23871                 }
23872                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23873                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23874                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23876                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
23877                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
23878                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
23879                         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));
23880                 }
23881                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
23882                 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));
23883                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23884                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
23885                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
23886                         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));
23887                 }
23888                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
23889                 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));
23890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
23891                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
23892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23893                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
23894                 }
23895                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
23896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23897                 if (r->in.buffer) {
23898                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
23899                 }
23900         }
23901         if (flags & NDR_OUT) {
23902                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23903         }
23904         return NDR_ERR_SUCCESS;
23905 }
23906
23907 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
23908 {
23909         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
23910         ndr->depth++;
23911         if (flags & NDR_SET_VALUES) {
23912                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23913         }
23914         if (flags & NDR_IN) {
23915                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
23916                 ndr->depth++;
23917                 ndr_print_ptr(ndr, "handle", r->in.handle);
23918                 ndr->depth++;
23919                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23920                 ndr->depth--;
23921                 ndr_print_string(ndr, "key_name", r->in.key_name);
23922                 ndr_print_string(ndr, "value_name", r->in.value_name);
23923                 ndr_print_uint32(ndr, "type", r->in.type);
23924                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23925                 ndr->depth++;
23926                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
23927                 ndr->depth--;
23928                 ndr_print_uint32(ndr, "offered", r->in.offered);
23929                 ndr->depth--;
23930         }
23931         if (flags & NDR_OUT) {
23932                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
23933                 ndr->depth++;
23934                 ndr_print_WERROR(ndr, "result", r->out.result);
23935                 ndr->depth--;
23936         }
23937         ndr->depth--;
23938 }
23939
23940 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
23941 {
23942         if (flags & NDR_IN) {
23943                 if (r->in.handle == NULL) {
23944                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23945                 }
23946                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
23948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
23950                 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));
23951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
23954                 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));
23955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23956         }
23957         if (flags & NDR_OUT) {
23958                 if (r->out.type == NULL) {
23959                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23960                 }
23961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
23962                 if (r->out.buffer == NULL) {
23963                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23964                 }
23965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23966                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
23967                 if (r->out.needed == NULL) {
23968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23969                 }
23970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23972         }
23973         return NDR_ERR_SUCCESS;
23974 }
23975
23976 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
23977 {
23978         TALLOC_CTX *_mem_save_handle_0;
23979         TALLOC_CTX *_mem_save_type_0;
23980         TALLOC_CTX *_mem_save_needed_0;
23981         if (flags & NDR_IN) {
23982                 ZERO_STRUCT(r->out);
23983
23984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23985                         NDR_PULL_ALLOC(ndr, r->in.handle);
23986                 }
23987                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23988                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23989                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23991                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
23992                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
23993                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
23994                         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));
23995                 }
23996                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
23997                 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));
23998                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
23999                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24000                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24001                         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));
24002                 }
24003                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24004                 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));
24005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24006                 NDR_PULL_ALLOC(ndr, r->out.type);
24007                 ZERO_STRUCTP(r->out.type);
24008                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
24009                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
24010                 NDR_PULL_ALLOC(ndr, r->out.needed);
24011                 ZERO_STRUCTP(r->out.needed);
24012         }
24013         if (flags & NDR_OUT) {
24014                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24015                         NDR_PULL_ALLOC(ndr, r->out.type);
24016                 }
24017                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24018                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
24019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
24020                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
24021                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
24022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24023                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
24024                 }
24025                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
24026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24027                         NDR_PULL_ALLOC(ndr, r->out.needed);
24028                 }
24029                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24030                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24033                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24034                 if (r->out.buffer) {
24035                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
24036                 }
24037         }
24038         return NDR_ERR_SUCCESS;
24039 }
24040
24041 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
24042 {
24043         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
24044         ndr->depth++;
24045         if (flags & NDR_SET_VALUES) {
24046                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24047         }
24048         if (flags & NDR_IN) {
24049                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
24050                 ndr->depth++;
24051                 ndr_print_ptr(ndr, "handle", r->in.handle);
24052                 ndr->depth++;
24053                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24054                 ndr->depth--;
24055                 ndr_print_string(ndr, "key_name", r->in.key_name);
24056                 ndr_print_string(ndr, "value_name", r->in.value_name);
24057                 ndr_print_uint32(ndr, "offered", r->in.offered);
24058                 ndr->depth--;
24059         }
24060         if (flags & NDR_OUT) {
24061                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
24062                 ndr->depth++;
24063                 ndr_print_ptr(ndr, "type", r->out.type);
24064                 ndr->depth++;
24065                 ndr_print_uint32(ndr, "type", *r->out.type);
24066                 ndr->depth--;
24067                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
24068                 ndr->depth++;
24069                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
24070                 ndr->depth--;
24071                 ndr_print_ptr(ndr, "needed", r->out.needed);
24072                 ndr->depth++;
24073                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24074                 ndr->depth--;
24075                 ndr_print_WERROR(ndr, "result", r->out.result);
24076                 ndr->depth--;
24077         }
24078         ndr->depth--;
24079 }
24080
24081 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
24082 {
24083         if (flags & NDR_IN) {
24084                 if (r->in.handle == NULL) {
24085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24086                 }
24087                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24091                 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));
24092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24093         }
24094         if (flags & NDR_OUT) {
24095                 if (r->out.buffer == NULL) {
24096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24097                 }
24098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24099                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
24100                 if (r->out.needed == NULL) {
24101                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24102                 }
24103                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24104                 if (r->out.count == NULL) {
24105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24106                 }
24107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24109         }
24110         return NDR_ERR_SUCCESS;
24111 }
24112
24113 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
24114 {
24115         TALLOC_CTX *_mem_save_handle_0;
24116         TALLOC_CTX *_mem_save_needed_0;
24117         TALLOC_CTX *_mem_save_count_0;
24118         if (flags & NDR_IN) {
24119                 ZERO_STRUCT(r->out);
24120
24121                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24122                         NDR_PULL_ALLOC(ndr, r->in.handle);
24123                 }
24124                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24125                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24126                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24128                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
24129                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
24130                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
24131                         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));
24132                 }
24133                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
24134                 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));
24135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24136                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
24137                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
24138                 NDR_PULL_ALLOC(ndr, r->out.needed);
24139                 ZERO_STRUCTP(r->out.needed);
24140                 NDR_PULL_ALLOC(ndr, r->out.count);
24141                 ZERO_STRUCTP(r->out.count);
24142         }
24143         if (flags & NDR_OUT) {
24144                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
24145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24146                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
24147                 }
24148                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
24149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24150                         NDR_PULL_ALLOC(ndr, r->out.needed);
24151                 }
24152                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24153                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24156                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24157                         NDR_PULL_ALLOC(ndr, r->out.count);
24158                 }
24159                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24160                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24162                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24163                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24164                 if (r->out.buffer) {
24165                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
24166                 }
24167         }
24168         return NDR_ERR_SUCCESS;
24169 }
24170
24171 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
24172 {
24173         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
24174         ndr->depth++;
24175         if (flags & NDR_SET_VALUES) {
24176                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24177         }
24178         if (flags & NDR_IN) {
24179                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
24180                 ndr->depth++;
24181                 ndr_print_ptr(ndr, "handle", r->in.handle);
24182                 ndr->depth++;
24183                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24184                 ndr->depth--;
24185                 ndr_print_string(ndr, "key_name", r->in.key_name);
24186                 ndr_print_uint32(ndr, "offered", r->in.offered);
24187                 ndr->depth--;
24188         }
24189         if (flags & NDR_OUT) {
24190                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
24191                 ndr->depth++;
24192                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
24193                 ndr->depth++;
24194                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
24195                 ndr->depth--;
24196                 ndr_print_ptr(ndr, "needed", r->out.needed);
24197                 ndr->depth++;
24198                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24199                 ndr->depth--;
24200                 ndr_print_ptr(ndr, "count", r->out.count);
24201                 ndr->depth++;
24202                 ndr_print_uint32(ndr, "count", *r->out.count);
24203                 ndr->depth--;
24204                 ndr_print_WERROR(ndr, "result", r->out.result);
24205                 ndr->depth--;
24206         }
24207         ndr->depth--;
24208 }
24209
24210 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
24211 {
24212         uint32_t cntr_key_buffer_1;
24213         if (flags & NDR_IN) {
24214                 if (r->in.handle == NULL) {
24215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24216                 }
24217                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24219                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24221                 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));
24222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
24223         }
24224         if (flags & NDR_OUT) {
24225                 if (r->out.key_buffer == NULL) {
24226                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24227                 }
24228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
24229                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
24230                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
24231                 }
24232                 if (r->out.needed == NULL) {
24233                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24234                 }
24235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24236                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24237         }
24238         return NDR_ERR_SUCCESS;
24239 }
24240
24241 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
24242 {
24243         uint32_t cntr_key_buffer_1;
24244         TALLOC_CTX *_mem_save_handle_0;
24245         TALLOC_CTX *_mem_save_key_buffer_1;
24246         TALLOC_CTX *_mem_save_needed_0;
24247         if (flags & NDR_IN) {
24248                 ZERO_STRUCT(r->out);
24249
24250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24251                         NDR_PULL_ALLOC(ndr, r->in.handle);
24252                 }
24253                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24254                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24255                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24257                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
24258                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
24259                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
24260                         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));
24261                 }
24262                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
24263                 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));
24264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
24265                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
24266                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
24267                 NDR_PULL_ALLOC(ndr, r->out.needed);
24268                 ZERO_STRUCTP(r->out.needed);
24269         }
24270         if (flags & NDR_OUT) {
24271                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
24272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24273                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
24274                 }
24275                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
24276                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
24277                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
24278                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
24279                 }
24280                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
24281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24282                         NDR_PULL_ALLOC(ndr, r->out.needed);
24283                 }
24284                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24285                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24287                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24288                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24289                 if (r->out.key_buffer) {
24290                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
24291                 }
24292         }
24293         return NDR_ERR_SUCCESS;
24294 }
24295
24296 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
24297 {
24298         uint32_t cntr_key_buffer_1;
24299         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
24300         ndr->depth++;
24301         if (flags & NDR_SET_VALUES) {
24302                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24303         }
24304         if (flags & NDR_IN) {
24305                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
24306                 ndr->depth++;
24307                 ndr_print_ptr(ndr, "handle", r->in.handle);
24308                 ndr->depth++;
24309                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24310                 ndr->depth--;
24311                 ndr_print_string(ndr, "key_name", r->in.key_name);
24312                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
24313                 ndr->depth--;
24314         }
24315         if (flags & NDR_OUT) {
24316                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
24317                 ndr->depth++;
24318                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
24319                 ndr->depth++;
24320                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
24321                 ndr->depth++;
24322                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
24323                         char *idx_1=NULL;
24324                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
24325                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
24326                                 free(idx_1);
24327                         }
24328                 }
24329                 ndr->depth--;
24330                 ndr->depth--;
24331                 ndr_print_ptr(ndr, "needed", r->out.needed);
24332                 ndr->depth++;
24333                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24334                 ndr->depth--;
24335                 ndr_print_WERROR(ndr, "result", r->out.result);
24336                 ndr->depth--;
24337         }
24338         ndr->depth--;
24339 }
24340
24341 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
24342 {
24343         if (flags & NDR_IN) {
24344                 if (r->in.handle == NULL) {
24345                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24346                 }
24347                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24351                 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));
24352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
24355                 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));
24356         }
24357         if (flags & NDR_OUT) {
24358                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24359         }
24360         return NDR_ERR_SUCCESS;
24361 }
24362
24363 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
24364 {
24365         TALLOC_CTX *_mem_save_handle_0;
24366         if (flags & NDR_IN) {
24367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24368                         NDR_PULL_ALLOC(ndr, r->in.handle);
24369                 }
24370                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24371                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24372                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24374                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
24375                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
24376                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
24377                         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));
24378                 }
24379                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
24380                 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));
24381                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
24382                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
24383                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
24384                         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));
24385                 }
24386                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
24387                 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));
24388         }
24389         if (flags & NDR_OUT) {
24390                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24391         }
24392         return NDR_ERR_SUCCESS;
24393 }
24394
24395 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
24396 {
24397         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
24398         ndr->depth++;
24399         if (flags & NDR_SET_VALUES) {
24400                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24401         }
24402         if (flags & NDR_IN) {
24403                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
24404                 ndr->depth++;
24405                 ndr_print_ptr(ndr, "handle", r->in.handle);
24406                 ndr->depth++;
24407                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24408                 ndr->depth--;
24409                 ndr_print_string(ndr, "key_name", r->in.key_name);
24410                 ndr_print_string(ndr, "value_name", r->in.value_name);
24411                 ndr->depth--;
24412         }
24413         if (flags & NDR_OUT) {
24414                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
24415                 ndr->depth++;
24416                 ndr_print_WERROR(ndr, "result", r->out.result);
24417                 ndr->depth--;
24418         }
24419         ndr->depth--;
24420 }
24421
24422 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
24423 {
24424         if (flags & NDR_IN) {
24425                 if (r->in.handle == NULL) {
24426                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24427                 }
24428                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24430                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
24432                 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));
24433         }
24434         if (flags & NDR_OUT) {
24435                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24436         }
24437         return NDR_ERR_SUCCESS;
24438 }
24439
24440 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
24441 {
24442         TALLOC_CTX *_mem_save_handle_0;
24443         if (flags & NDR_IN) {
24444                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24445                         NDR_PULL_ALLOC(ndr, r->in.handle);
24446                 }
24447                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24448                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24449                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24451                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
24452                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
24453                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
24454                         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));
24455                 }
24456                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
24457                 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));
24458         }
24459         if (flags & NDR_OUT) {
24460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24461         }
24462         return NDR_ERR_SUCCESS;
24463 }
24464
24465 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
24466 {
24467         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
24468         ndr->depth++;
24469         if (flags & NDR_SET_VALUES) {
24470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24471         }
24472         if (flags & NDR_IN) {
24473                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
24474                 ndr->depth++;
24475                 ndr_print_ptr(ndr, "handle", r->in.handle);
24476                 ndr->depth++;
24477                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24478                 ndr->depth--;
24479                 ndr_print_string(ndr, "key_name", r->in.key_name);
24480                 ndr->depth--;
24481         }
24482         if (flags & NDR_OUT) {
24483                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
24484                 ndr->depth++;
24485                 ndr_print_WERROR(ndr, "result", r->out.result);
24486                 ndr->depth--;
24487         }
24488         ndr->depth--;
24489 }
24490
24491 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
24492 {
24493         if (flags & NDR_IN) {
24494         }
24495         if (flags & NDR_OUT) {
24496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24497         }
24498         return NDR_ERR_SUCCESS;
24499 }
24500
24501 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
24502 {
24503         if (flags & NDR_IN) {
24504         }
24505         if (flags & NDR_OUT) {
24506                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24507         }
24508         return NDR_ERR_SUCCESS;
24509 }
24510
24511 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
24512 {
24513         ndr_print_struct(ndr, name, "spoolss_53");
24514         ndr->depth++;
24515         if (flags & NDR_SET_VALUES) {
24516                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24517         }
24518         if (flags & NDR_IN) {
24519                 ndr_print_struct(ndr, "in", "spoolss_53");
24520                 ndr->depth++;
24521                 ndr->depth--;
24522         }
24523         if (flags & NDR_OUT) {
24524                 ndr_print_struct(ndr, "out", "spoolss_53");
24525                 ndr->depth++;
24526                 ndr_print_WERROR(ndr, "result", r->out.result);
24527                 ndr->depth--;
24528         }
24529         ndr->depth--;
24530 }
24531
24532 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
24533 {
24534         if (flags & NDR_IN) {
24535                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
24536                 if (r->in.server) {
24537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
24538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
24540                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24541                 }
24542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24545                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
24547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24548                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
24549                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24550                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
24551                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
24552         }
24553         if (flags & NDR_OUT) {
24554                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24555         }
24556         return NDR_ERR_SUCCESS;
24557 }
24558
24559 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
24560 {
24561         uint32_t _ptr_server;
24562         TALLOC_CTX *_mem_save_server_0;
24563         if (flags & NDR_IN) {
24564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
24565                 if (_ptr_server) {
24566                         NDR_PULL_ALLOC(ndr, r->in.server);
24567                 } else {
24568                         r->in.server = NULL;
24569                 }
24570                 if (r->in.server) {
24571                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
24572                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
24573                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
24574                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
24575                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
24576                                 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));
24577                         }
24578                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
24579                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
24580                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
24581                 }
24582                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24583                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24584                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24585                         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));
24586                 }
24587                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24588                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24589                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
24590                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
24591                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
24592                         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));
24593                 }
24594                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
24595                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
24596                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
24597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
24598         }
24599         if (flags & NDR_OUT) {
24600                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24601         }
24602         return NDR_ERR_SUCCESS;
24603 }
24604
24605 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
24606 {
24607         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
24608         ndr->depth++;
24609         if (flags & NDR_SET_VALUES) {
24610                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24611         }
24612         if (flags & NDR_IN) {
24613                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
24614                 ndr->depth++;
24615                 ndr_print_ptr(ndr, "server", r->in.server);
24616                 ndr->depth++;
24617                 if (r->in.server) {
24618                         ndr_print_string(ndr, "server", r->in.server);
24619                 }
24620                 ndr->depth--;
24621                 ndr_print_string(ndr, "architecture", r->in.architecture);
24622                 ndr_print_string(ndr, "driver", r->in.driver);
24623                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
24624                 ndr_print_uint32(ndr, "version", r->in.version);
24625                 ndr->depth--;
24626         }
24627         if (flags & NDR_OUT) {
24628                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
24629                 ndr->depth++;
24630                 ndr_print_WERROR(ndr, "result", r->out.result);
24631                 ndr->depth--;
24632         }
24633         ndr->depth--;
24634 }
24635
24636 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
24637 {
24638         if (flags & NDR_IN) {
24639         }
24640         if (flags & NDR_OUT) {
24641                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24642         }
24643         return NDR_ERR_SUCCESS;
24644 }
24645
24646 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
24647 {
24648         if (flags & NDR_IN) {
24649         }
24650         if (flags & NDR_OUT) {
24651                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24652         }
24653         return NDR_ERR_SUCCESS;
24654 }
24655
24656 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
24657 {
24658         ndr_print_struct(ndr, name, "spoolss_55");
24659         ndr->depth++;
24660         if (flags & NDR_SET_VALUES) {
24661                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24662         }
24663         if (flags & NDR_IN) {
24664                 ndr_print_struct(ndr, "in", "spoolss_55");
24665                 ndr->depth++;
24666                 ndr->depth--;
24667         }
24668         if (flags & NDR_OUT) {
24669                 ndr_print_struct(ndr, "out", "spoolss_55");
24670                 ndr->depth++;
24671                 ndr_print_WERROR(ndr, "result", r->out.result);
24672                 ndr->depth--;
24673         }
24674         ndr->depth--;
24675 }
24676
24677 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
24678 {
24679         if (flags & NDR_IN) {
24680         }
24681         if (flags & NDR_OUT) {
24682                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24683         }
24684         return NDR_ERR_SUCCESS;
24685 }
24686
24687 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
24688 {
24689         if (flags & NDR_IN) {
24690         }
24691         if (flags & NDR_OUT) {
24692                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24693         }
24694         return NDR_ERR_SUCCESS;
24695 }
24696
24697 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
24698 {
24699         ndr_print_struct(ndr, name, "spoolss_56");
24700         ndr->depth++;
24701         if (flags & NDR_SET_VALUES) {
24702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24703         }
24704         if (flags & NDR_IN) {
24705                 ndr_print_struct(ndr, "in", "spoolss_56");
24706                 ndr->depth++;
24707                 ndr->depth--;
24708         }
24709         if (flags & NDR_OUT) {
24710                 ndr_print_struct(ndr, "out", "spoolss_56");
24711                 ndr->depth++;
24712                 ndr_print_WERROR(ndr, "result", r->out.result);
24713                 ndr->depth--;
24714         }
24715         ndr->depth--;
24716 }
24717
24718 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
24719 {
24720         if (flags & NDR_IN) {
24721         }
24722         if (flags & NDR_OUT) {
24723                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24724         }
24725         return NDR_ERR_SUCCESS;
24726 }
24727
24728 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
24729 {
24730         if (flags & NDR_IN) {
24731         }
24732         if (flags & NDR_OUT) {
24733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24734         }
24735         return NDR_ERR_SUCCESS;
24736 }
24737
24738 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
24739 {
24740         ndr_print_struct(ndr, name, "spoolss_57");
24741         ndr->depth++;
24742         if (flags & NDR_SET_VALUES) {
24743                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24744         }
24745         if (flags & NDR_IN) {
24746                 ndr_print_struct(ndr, "in", "spoolss_57");
24747                 ndr->depth++;
24748                 ndr->depth--;
24749         }
24750         if (flags & NDR_OUT) {
24751                 ndr_print_struct(ndr, "out", "spoolss_57");
24752                 ndr->depth++;
24753                 ndr_print_WERROR(ndr, "result", r->out.result);
24754                 ndr->depth--;
24755         }
24756         ndr->depth--;
24757 }
24758
24759 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
24760 {
24761         if (flags & NDR_IN) {
24762                 if (r->in.handle == NULL) {
24763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24764                 }
24765                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
24767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
24769                 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));
24770                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
24771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
24772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
24773                 if (r->in.status_code == NULL) {
24774                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24775                 }
24776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
24777         }
24778         if (flags & NDR_OUT) {
24779                 if (r->out.out_data == NULL) {
24780                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24781                 }
24782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
24783                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
24784                 if (r->out.needed == NULL) {
24785                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24786                 }
24787                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24788                 if (r->out.status_code == NULL) {
24789                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24790                 }
24791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
24792                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24793         }
24794         return NDR_ERR_SUCCESS;
24795 }
24796
24797 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
24798 {
24799         TALLOC_CTX *_mem_save_handle_0;
24800         TALLOC_CTX *_mem_save_needed_0;
24801         TALLOC_CTX *_mem_save_status_code_0;
24802         if (flags & NDR_IN) {
24803                 ZERO_STRUCT(r->out);
24804
24805                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24806                         NDR_PULL_ALLOC(ndr, r->in.handle);
24807                 }
24808                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24809                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24810                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24812                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
24813                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
24814                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
24815                         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));
24816                 }
24817                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
24818                 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));
24819                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
24820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
24821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
24822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24823                         NDR_PULL_ALLOC(ndr, r->in.status_code);
24824                 }
24825                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
24826                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
24827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
24828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
24829                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
24830                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
24831                 NDR_PULL_ALLOC(ndr, r->out.needed);
24832                 ZERO_STRUCTP(r->out.needed);
24833                 NDR_PULL_ALLOC(ndr, r->out.status_code);
24834                 *r->out.status_code = *r->in.status_code;
24835         }
24836         if (flags & NDR_OUT) {
24837                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
24838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24839                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
24840                 }
24841                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
24842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24843                         NDR_PULL_ALLOC(ndr, r->out.needed);
24844                 }
24845                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24846                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24850                         NDR_PULL_ALLOC(ndr, r->out.status_code);
24851                 }
24852                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
24853                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
24854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
24855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
24856                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24857                 if (r->out.out_data) {
24858                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
24859                 }
24860         }
24861         return NDR_ERR_SUCCESS;
24862 }
24863
24864 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
24865 {
24866         ndr_print_struct(ndr, name, "spoolss_XcvData");
24867         ndr->depth++;
24868         if (flags & NDR_SET_VALUES) {
24869                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24870         }
24871         if (flags & NDR_IN) {
24872                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
24873                 ndr->depth++;
24874                 ndr_print_ptr(ndr, "handle", r->in.handle);
24875                 ndr->depth++;
24876                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24877                 ndr->depth--;
24878                 ndr_print_string(ndr, "function_name", r->in.function_name);
24879                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
24880                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
24881                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
24882                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
24883                 ndr->depth++;
24884                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
24885                 ndr->depth--;
24886                 ndr->depth--;
24887         }
24888         if (flags & NDR_OUT) {
24889                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
24890                 ndr->depth++;
24891                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
24892                 ndr->depth++;
24893                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
24894                 ndr->depth--;
24895                 ndr_print_ptr(ndr, "needed", r->out.needed);
24896                 ndr->depth++;
24897                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24898                 ndr->depth--;
24899                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
24900                 ndr->depth++;
24901                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
24902                 ndr->depth--;
24903                 ndr_print_WERROR(ndr, "result", r->out.result);
24904                 ndr->depth--;
24905         }
24906         ndr->depth--;
24907 }
24908
24909 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
24910 {
24911         if (flags & NDR_IN) {
24912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24913                 if (r->in.servername) {
24914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24917                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24918                 }
24919                 if (r->in.info_ctr == NULL) {
24920                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24921                 }
24922                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
24923                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
24924         }
24925         if (flags & NDR_OUT) {
24926                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24927         }
24928         return NDR_ERR_SUCCESS;
24929 }
24930
24931 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
24932 {
24933         uint32_t _ptr_servername;
24934         TALLOC_CTX *_mem_save_servername_0;
24935         TALLOC_CTX *_mem_save_info_ctr_0;
24936         if (flags & NDR_IN) {
24937                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24938                 if (_ptr_servername) {
24939                         NDR_PULL_ALLOC(ndr, r->in.servername);
24940                 } else {
24941                         r->in.servername = NULL;
24942                 }
24943                 if (r->in.servername) {
24944                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24945                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24946                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24947                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24948                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24949                                 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));
24950                         }
24951                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24952                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24953                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24954                 }
24955                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24956                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
24957                 }
24958                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24959                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
24960                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
24961                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24962                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
24963         }
24964         if (flags & NDR_OUT) {
24965                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24966         }
24967         return NDR_ERR_SUCCESS;
24968 }
24969
24970 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
24971 {
24972         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
24973         ndr->depth++;
24974         if (flags & NDR_SET_VALUES) {
24975                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24976         }
24977         if (flags & NDR_IN) {
24978                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
24979                 ndr->depth++;
24980                 ndr_print_ptr(ndr, "servername", r->in.servername);
24981                 ndr->depth++;
24982                 if (r->in.servername) {
24983                         ndr_print_string(ndr, "servername", r->in.servername);
24984                 }
24985                 ndr->depth--;
24986                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
24987                 ndr->depth++;
24988                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
24989                 ndr->depth--;
24990                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
24991                 ndr->depth--;
24992         }
24993         if (flags & NDR_OUT) {
24994                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
24995                 ndr->depth++;
24996                 ndr_print_WERROR(ndr, "result", r->out.result);
24997                 ndr->depth--;
24998         }
24999         ndr->depth--;
25000 }
25001
25002 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
25003 {
25004         if (flags & NDR_IN) {
25005         }
25006         if (flags & NDR_OUT) {
25007                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25008         }
25009         return NDR_ERR_SUCCESS;
25010 }
25011
25012 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
25013 {
25014         if (flags & NDR_IN) {
25015         }
25016         if (flags & NDR_OUT) {
25017                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25018         }
25019         return NDR_ERR_SUCCESS;
25020 }
25021
25022 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
25023 {
25024         ndr_print_struct(ndr, name, "spoolss_5a");
25025         ndr->depth++;
25026         if (flags & NDR_SET_VALUES) {
25027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25028         }
25029         if (flags & NDR_IN) {
25030                 ndr_print_struct(ndr, "in", "spoolss_5a");
25031                 ndr->depth++;
25032                 ndr->depth--;
25033         }
25034         if (flags & NDR_OUT) {
25035                 ndr_print_struct(ndr, "out", "spoolss_5a");
25036                 ndr->depth++;
25037                 ndr_print_WERROR(ndr, "result", r->out.result);
25038                 ndr->depth--;
25039         }
25040         ndr->depth--;
25041 }
25042
25043 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
25044 {
25045         if (flags & NDR_IN) {
25046         }
25047         if (flags & NDR_OUT) {
25048                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25049         }
25050         return NDR_ERR_SUCCESS;
25051 }
25052
25053 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
25054 {
25055         if (flags & NDR_IN) {
25056         }
25057         if (flags & NDR_OUT) {
25058                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25059         }
25060         return NDR_ERR_SUCCESS;
25061 }
25062
25063 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
25064 {
25065         ndr_print_struct(ndr, name, "spoolss_5b");
25066         ndr->depth++;
25067         if (flags & NDR_SET_VALUES) {
25068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25069         }
25070         if (flags & NDR_IN) {
25071                 ndr_print_struct(ndr, "in", "spoolss_5b");
25072                 ndr->depth++;
25073                 ndr->depth--;
25074         }
25075         if (flags & NDR_OUT) {
25076                 ndr_print_struct(ndr, "out", "spoolss_5b");
25077                 ndr->depth++;
25078                 ndr_print_WERROR(ndr, "result", r->out.result);
25079                 ndr->depth--;
25080         }
25081         ndr->depth--;
25082 }
25083
25084 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
25085 {
25086         if (flags & NDR_IN) {
25087         }
25088         if (flags & NDR_OUT) {
25089                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25090         }
25091         return NDR_ERR_SUCCESS;
25092 }
25093
25094 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
25095 {
25096         if (flags & NDR_IN) {
25097         }
25098         if (flags & NDR_OUT) {
25099                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25100         }
25101         return NDR_ERR_SUCCESS;
25102 }
25103
25104 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
25105 {
25106         ndr_print_struct(ndr, name, "spoolss_5c");
25107         ndr->depth++;
25108         if (flags & NDR_SET_VALUES) {
25109                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25110         }
25111         if (flags & NDR_IN) {
25112                 ndr_print_struct(ndr, "in", "spoolss_5c");
25113                 ndr->depth++;
25114                 ndr->depth--;
25115         }
25116         if (flags & NDR_OUT) {
25117                 ndr_print_struct(ndr, "out", "spoolss_5c");
25118                 ndr->depth++;
25119                 ndr_print_WERROR(ndr, "result", r->out.result);
25120                 ndr->depth--;
25121         }
25122         ndr->depth--;
25123 }
25124
25125 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
25126 {
25127         if (flags & NDR_IN) {
25128         }
25129         if (flags & NDR_OUT) {
25130                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25131         }
25132         return NDR_ERR_SUCCESS;
25133 }
25134
25135 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
25136 {
25137         if (flags & NDR_IN) {
25138         }
25139         if (flags & NDR_OUT) {
25140                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25141         }
25142         return NDR_ERR_SUCCESS;
25143 }
25144
25145 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
25146 {
25147         ndr_print_struct(ndr, name, "spoolss_5d");
25148         ndr->depth++;
25149         if (flags & NDR_SET_VALUES) {
25150                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25151         }
25152         if (flags & NDR_IN) {
25153                 ndr_print_struct(ndr, "in", "spoolss_5d");
25154                 ndr->depth++;
25155                 ndr->depth--;
25156         }
25157         if (flags & NDR_OUT) {
25158                 ndr_print_struct(ndr, "out", "spoolss_5d");
25159                 ndr->depth++;
25160                 ndr_print_WERROR(ndr, "result", r->out.result);
25161                 ndr->depth--;
25162         }
25163         ndr->depth--;
25164 }
25165
25166 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
25167 {
25168         if (flags & NDR_IN) {
25169         }
25170         if (flags & NDR_OUT) {
25171                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25172         }
25173         return NDR_ERR_SUCCESS;
25174 }
25175
25176 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
25177 {
25178         if (flags & NDR_IN) {
25179         }
25180         if (flags & NDR_OUT) {
25181                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25182         }
25183         return NDR_ERR_SUCCESS;
25184 }
25185
25186 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
25187 {
25188         ndr_print_struct(ndr, name, "spoolss_5e");
25189         ndr->depth++;
25190         if (flags & NDR_SET_VALUES) {
25191                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25192         }
25193         if (flags & NDR_IN) {
25194                 ndr_print_struct(ndr, "in", "spoolss_5e");
25195                 ndr->depth++;
25196                 ndr->depth--;
25197         }
25198         if (flags & NDR_OUT) {
25199                 ndr_print_struct(ndr, "out", "spoolss_5e");
25200                 ndr->depth++;
25201                 ndr_print_WERROR(ndr, "result", r->out.result);
25202                 ndr->depth--;
25203         }
25204         ndr->depth--;
25205 }
25206
25207 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
25208 {
25209         if (flags & NDR_IN) {
25210         }
25211         if (flags & NDR_OUT) {
25212                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25213         }
25214         return NDR_ERR_SUCCESS;
25215 }
25216
25217 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
25218 {
25219         if (flags & NDR_IN) {
25220         }
25221         if (flags & NDR_OUT) {
25222                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25223         }
25224         return NDR_ERR_SUCCESS;
25225 }
25226
25227 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
25228 {
25229         ndr_print_struct(ndr, name, "spoolss_5f");
25230         ndr->depth++;
25231         if (flags & NDR_SET_VALUES) {
25232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25233         }
25234         if (flags & NDR_IN) {
25235                 ndr_print_struct(ndr, "in", "spoolss_5f");
25236                 ndr->depth++;
25237                 ndr->depth--;
25238         }
25239         if (flags & NDR_OUT) {
25240                 ndr_print_struct(ndr, "out", "spoolss_5f");
25241                 ndr->depth++;
25242                 ndr_print_WERROR(ndr, "result", r->out.result);
25243                 ndr->depth--;
25244         }
25245         ndr->depth--;
25246 }
25247
25248 static const struct ndr_interface_call spoolss_calls[] = {
25249         {
25250                 "spoolss_EnumPrinters",
25251                 sizeof(struct spoolss_EnumPrinters),
25252                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
25253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
25254                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
25255                 false,
25256         },
25257         {
25258                 "spoolss_OpenPrinter",
25259                 sizeof(struct spoolss_OpenPrinter),
25260                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
25261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
25262                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
25263                 false,
25264         },
25265         {
25266                 "spoolss_SetJob",
25267                 sizeof(struct spoolss_SetJob),
25268                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
25269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
25270                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
25271                 false,
25272         },
25273         {
25274                 "spoolss_GetJob",
25275                 sizeof(struct spoolss_GetJob),
25276                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
25277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
25278                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
25279                 false,
25280         },
25281         {
25282                 "spoolss_EnumJobs",
25283                 sizeof(struct spoolss_EnumJobs),
25284                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
25285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
25286                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
25287                 false,
25288         },
25289         {
25290                 "spoolss_AddPrinter",
25291                 sizeof(struct spoolss_AddPrinter),
25292                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
25293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
25294                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
25295                 false,
25296         },
25297         {
25298                 "spoolss_DeletePrinter",
25299                 sizeof(struct spoolss_DeletePrinter),
25300                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
25301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
25302                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
25303                 false,
25304         },
25305         {
25306                 "spoolss_SetPrinter",
25307                 sizeof(struct spoolss_SetPrinter),
25308                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
25309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
25310                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
25311                 false,
25312         },
25313         {
25314                 "spoolss_GetPrinter",
25315                 sizeof(struct spoolss_GetPrinter),
25316                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
25317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
25318                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
25319                 false,
25320         },
25321         {
25322                 "spoolss_AddPrinterDriver",
25323                 sizeof(struct spoolss_AddPrinterDriver),
25324                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
25325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
25326                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
25327                 false,
25328         },
25329         {
25330                 "spoolss_EnumPrinterDrivers",
25331                 sizeof(struct spoolss_EnumPrinterDrivers),
25332                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
25333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
25334                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
25335                 false,
25336         },
25337         {
25338                 "spoolss_GetPrinterDriver",
25339                 sizeof(struct spoolss_GetPrinterDriver),
25340                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
25341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
25342                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
25343                 false,
25344         },
25345         {
25346                 "spoolss_GetPrinterDriverDirectory",
25347                 sizeof(struct spoolss_GetPrinterDriverDirectory),
25348                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
25349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
25350                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
25351                 false,
25352         },
25353         {
25354                 "spoolss_DeletePrinterDriver",
25355                 sizeof(struct spoolss_DeletePrinterDriver),
25356                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
25357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
25358                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
25359                 false,
25360         },
25361         {
25362                 "spoolss_AddPrintProcessor",
25363                 sizeof(struct spoolss_AddPrintProcessor),
25364                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
25365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
25366                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
25367                 false,
25368         },
25369         {
25370                 "spoolss_EnumPrintProcessors",
25371                 sizeof(struct spoolss_EnumPrintProcessors),
25372                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
25373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
25374                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
25375                 false,
25376         },
25377         {
25378                 "spoolss_GetPrintProcessorDirectory",
25379                 sizeof(struct spoolss_GetPrintProcessorDirectory),
25380                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
25381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
25382                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
25383                 false,
25384         },
25385         {
25386                 "spoolss_StartDocPrinter",
25387                 sizeof(struct spoolss_StartDocPrinter),
25388                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
25389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
25390                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
25391                 false,
25392         },
25393         {
25394                 "spoolss_StartPagePrinter",
25395                 sizeof(struct spoolss_StartPagePrinter),
25396                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
25397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
25398                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
25399                 false,
25400         },
25401         {
25402                 "spoolss_WritePrinter",
25403                 sizeof(struct spoolss_WritePrinter),
25404                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
25405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
25406                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
25407                 false,
25408         },
25409         {
25410                 "spoolss_EndPagePrinter",
25411                 sizeof(struct spoolss_EndPagePrinter),
25412                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
25413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
25414                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
25415                 false,
25416         },
25417         {
25418                 "spoolss_AbortPrinter",
25419                 sizeof(struct spoolss_AbortPrinter),
25420                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
25421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
25422                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
25423                 false,
25424         },
25425         {
25426                 "spoolss_ReadPrinter",
25427                 sizeof(struct spoolss_ReadPrinter),
25428                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
25429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
25430                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
25431                 false,
25432         },
25433         {
25434                 "spoolss_EndDocPrinter",
25435                 sizeof(struct spoolss_EndDocPrinter),
25436                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
25437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
25438                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
25439                 false,
25440         },
25441         {
25442                 "spoolss_AddJob",
25443                 sizeof(struct spoolss_AddJob),
25444                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
25445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
25446                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
25447                 false,
25448         },
25449         {
25450                 "spoolss_ScheduleJob",
25451                 sizeof(struct spoolss_ScheduleJob),
25452                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
25453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
25454                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
25455                 false,
25456         },
25457         {
25458                 "spoolss_GetPrinterData",
25459                 sizeof(struct spoolss_GetPrinterData),
25460                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
25461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
25462                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
25463                 false,
25464         },
25465         {
25466                 "spoolss_SetPrinterData",
25467                 sizeof(struct spoolss_SetPrinterData),
25468                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
25469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
25470                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
25471                 false,
25472         },
25473         {
25474                 "spoolss_WaitForPrinterChange",
25475                 sizeof(struct spoolss_WaitForPrinterChange),
25476                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
25477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
25478                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
25479                 false,
25480         },
25481         {
25482                 "spoolss_ClosePrinter",
25483                 sizeof(struct spoolss_ClosePrinter),
25484                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
25485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
25486                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
25487                 false,
25488         },
25489         {
25490                 "spoolss_AddForm",
25491                 sizeof(struct spoolss_AddForm),
25492                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
25493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
25494                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
25495                 false,
25496         },
25497         {
25498                 "spoolss_DeleteForm",
25499                 sizeof(struct spoolss_DeleteForm),
25500                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
25501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
25502                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
25503                 false,
25504         },
25505         {
25506                 "spoolss_GetForm",
25507                 sizeof(struct spoolss_GetForm),
25508                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
25509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
25510                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
25511                 false,
25512         },
25513         {
25514                 "spoolss_SetForm",
25515                 sizeof(struct spoolss_SetForm),
25516                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
25517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
25518                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
25519                 false,
25520         },
25521         {
25522                 "spoolss_EnumForms",
25523                 sizeof(struct spoolss_EnumForms),
25524                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
25525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
25526                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
25527                 false,
25528         },
25529         {
25530                 "spoolss_EnumPorts",
25531                 sizeof(struct spoolss_EnumPorts),
25532                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
25533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
25534                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
25535                 false,
25536         },
25537         {
25538                 "spoolss_EnumMonitors",
25539                 sizeof(struct spoolss_EnumMonitors),
25540                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
25541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
25542                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
25543                 false,
25544         },
25545         {
25546                 "spoolss_AddPort",
25547                 sizeof(struct spoolss_AddPort),
25548                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
25549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
25550                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
25551                 false,
25552         },
25553         {
25554                 "spoolss_ConfigurePort",
25555                 sizeof(struct spoolss_ConfigurePort),
25556                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
25557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
25558                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
25559                 false,
25560         },
25561         {
25562                 "spoolss_DeletePort",
25563                 sizeof(struct spoolss_DeletePort),
25564                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
25565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
25566                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
25567                 false,
25568         },
25569         {
25570                 "spoolss_CreatePrinterIC",
25571                 sizeof(struct spoolss_CreatePrinterIC),
25572                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
25573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
25574                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
25575                 false,
25576         },
25577         {
25578                 "spoolss_PlayGDIScriptOnPrinterIC",
25579                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
25580                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
25581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
25582                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
25583                 false,
25584         },
25585         {
25586                 "spoolss_DeletePrinterIC",
25587                 sizeof(struct spoolss_DeletePrinterIC),
25588                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
25589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
25590                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
25591                 false,
25592         },
25593         {
25594                 "spoolss_AddPrinterConnection",
25595                 sizeof(struct spoolss_AddPrinterConnection),
25596                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
25597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
25598                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
25599                 false,
25600         },
25601         {
25602                 "spoolss_DeletePrinterConnection",
25603                 sizeof(struct spoolss_DeletePrinterConnection),
25604                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
25605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
25606                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
25607                 false,
25608         },
25609         {
25610                 "spoolss_PrinterMessageBox",
25611                 sizeof(struct spoolss_PrinterMessageBox),
25612                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
25613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
25614                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
25615                 false,
25616         },
25617         {
25618                 "spoolss_AddMonitor",
25619                 sizeof(struct spoolss_AddMonitor),
25620                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
25621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
25622                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
25623                 false,
25624         },
25625         {
25626                 "spoolss_DeleteMonitor",
25627                 sizeof(struct spoolss_DeleteMonitor),
25628                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
25629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
25630                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
25631                 false,
25632         },
25633         {
25634                 "spoolss_DeletePrintProcessor",
25635                 sizeof(struct spoolss_DeletePrintProcessor),
25636                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
25637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
25638                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
25639                 false,
25640         },
25641         {
25642                 "spoolss_AddPrintProvidor",
25643                 sizeof(struct spoolss_AddPrintProvidor),
25644                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
25645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
25646                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
25647                 false,
25648         },
25649         {
25650                 "spoolss_DeletePrintProvidor",
25651                 sizeof(struct spoolss_DeletePrintProvidor),
25652                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
25653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
25654                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
25655                 false,
25656         },
25657         {
25658                 "spoolss_EnumPrintProcDataTypes",
25659                 sizeof(struct spoolss_EnumPrintProcDataTypes),
25660                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
25661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
25662                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
25663                 false,
25664         },
25665         {
25666                 "spoolss_ResetPrinter",
25667                 sizeof(struct spoolss_ResetPrinter),
25668                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
25669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
25670                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
25671                 false,
25672         },
25673         {
25674                 "spoolss_GetPrinterDriver2",
25675                 sizeof(struct spoolss_GetPrinterDriver2),
25676                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
25677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
25678                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
25679                 false,
25680         },
25681         {
25682                 "spoolss_FindFirstPrinterChangeNotification",
25683                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
25684                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
25685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
25686                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
25687                 false,
25688         },
25689         {
25690                 "spoolss_FindNextPrinterChangeNotification",
25691                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
25692                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
25693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
25694                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
25695                 false,
25696         },
25697         {
25698                 "spoolss_FindClosePrinterNotify",
25699                 sizeof(struct spoolss_FindClosePrinterNotify),
25700                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
25701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
25702                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
25703                 false,
25704         },
25705         {
25706                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
25707                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
25708                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
25709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
25710                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
25711                 false,
25712         },
25713         {
25714                 "spoolss_ReplyOpenPrinter",
25715                 sizeof(struct spoolss_ReplyOpenPrinter),
25716                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
25717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
25718                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
25719                 false,
25720         },
25721         {
25722                 "spoolss_RouterReplyPrinter",
25723                 sizeof(struct spoolss_RouterReplyPrinter),
25724                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
25725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
25726                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
25727                 false,
25728         },
25729         {
25730                 "spoolss_ReplyClosePrinter",
25731                 sizeof(struct spoolss_ReplyClosePrinter),
25732                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
25733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
25734                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
25735                 false,
25736         },
25737         {
25738                 "spoolss_AddPortEx",
25739                 sizeof(struct spoolss_AddPortEx),
25740                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
25741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
25742                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
25743                 false,
25744         },
25745         {
25746                 "spoolss_RouterFindFirstPrinterChangeNotification",
25747                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
25748                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
25749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
25750                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
25751                 false,
25752         },
25753         {
25754                 "spoolss_SpoolerInit",
25755                 sizeof(struct spoolss_SpoolerInit),
25756                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
25757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
25758                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
25759                 false,
25760         },
25761         {
25762                 "spoolss_ResetPrinterEx",
25763                 sizeof(struct spoolss_ResetPrinterEx),
25764                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
25765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
25766                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
25767                 false,
25768         },
25769         {
25770                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
25771                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
25772                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
25773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
25774                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
25775                 false,
25776         },
25777         {
25778                 "spoolss_RouterReplyPrinterEx",
25779                 sizeof(struct spoolss_RouterReplyPrinterEx),
25780                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
25781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
25782                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
25783                 false,
25784         },
25785         {
25786                 "spoolss_RouterRefreshPrinterChangeNotify",
25787                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
25788                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
25789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
25790                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
25791                 false,
25792         },
25793         {
25794                 "spoolss_44",
25795                 sizeof(struct spoolss_44),
25796                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
25797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
25798                 (ndr_print_function_t) ndr_print_spoolss_44,
25799                 false,
25800         },
25801         {
25802                 "spoolss_OpenPrinterEx",
25803                 sizeof(struct spoolss_OpenPrinterEx),
25804                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
25805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
25806                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
25807                 false,
25808         },
25809         {
25810                 "spoolss_AddPrinterEx",
25811                 sizeof(struct spoolss_AddPrinterEx),
25812                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
25813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
25814                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
25815                 false,
25816         },
25817         {
25818                 "spoolss_47",
25819                 sizeof(struct spoolss_47),
25820                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
25821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
25822                 (ndr_print_function_t) ndr_print_spoolss_47,
25823                 false,
25824         },
25825         {
25826                 "spoolss_EnumPrinterData",
25827                 sizeof(struct spoolss_EnumPrinterData),
25828                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
25829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
25830                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
25831                 false,
25832         },
25833         {
25834                 "spoolss_DeletePrinterData",
25835                 sizeof(struct spoolss_DeletePrinterData),
25836                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
25837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
25838                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
25839                 false,
25840         },
25841         {
25842                 "spoolss_4a",
25843                 sizeof(struct spoolss_4a),
25844                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
25845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
25846                 (ndr_print_function_t) ndr_print_spoolss_4a,
25847                 false,
25848         },
25849         {
25850                 "spoolss_4b",
25851                 sizeof(struct spoolss_4b),
25852                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
25853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
25854                 (ndr_print_function_t) ndr_print_spoolss_4b,
25855                 false,
25856         },
25857         {
25858                 "spoolss_4c",
25859                 sizeof(struct spoolss_4c),
25860                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
25861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
25862                 (ndr_print_function_t) ndr_print_spoolss_4c,
25863                 false,
25864         },
25865         {
25866                 "spoolss_SetPrinterDataEx",
25867                 sizeof(struct spoolss_SetPrinterDataEx),
25868                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
25869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
25870                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
25871                 false,
25872         },
25873         {
25874                 "spoolss_GetPrinterDataEx",
25875                 sizeof(struct spoolss_GetPrinterDataEx),
25876                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
25877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
25878                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
25879                 false,
25880         },
25881         {
25882                 "spoolss_EnumPrinterDataEx",
25883                 sizeof(struct spoolss_EnumPrinterDataEx),
25884                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
25885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
25886                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
25887                 false,
25888         },
25889         {
25890                 "spoolss_EnumPrinterKey",
25891                 sizeof(struct spoolss_EnumPrinterKey),
25892                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
25893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
25894                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
25895                 false,
25896         },
25897         {
25898                 "spoolss_DeletePrinterDataEx",
25899                 sizeof(struct spoolss_DeletePrinterDataEx),
25900                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
25901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
25902                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
25903                 false,
25904         },
25905         {
25906                 "spoolss_DeletePrinterKey",
25907                 sizeof(struct spoolss_DeletePrinterKey),
25908                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
25909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
25910                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
25911                 false,
25912         },
25913         {
25914                 "spoolss_53",
25915                 sizeof(struct spoolss_53),
25916                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
25917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
25918                 (ndr_print_function_t) ndr_print_spoolss_53,
25919                 false,
25920         },
25921         {
25922                 "spoolss_DeletePrinterDriverEx",
25923                 sizeof(struct spoolss_DeletePrinterDriverEx),
25924                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
25925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
25926                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
25927                 false,
25928         },
25929         {
25930                 "spoolss_55",
25931                 sizeof(struct spoolss_55),
25932                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
25933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
25934                 (ndr_print_function_t) ndr_print_spoolss_55,
25935                 false,
25936         },
25937         {
25938                 "spoolss_56",
25939                 sizeof(struct spoolss_56),
25940                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
25941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
25942                 (ndr_print_function_t) ndr_print_spoolss_56,
25943                 false,
25944         },
25945         {
25946                 "spoolss_57",
25947                 sizeof(struct spoolss_57),
25948                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
25949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
25950                 (ndr_print_function_t) ndr_print_spoolss_57,
25951                 false,
25952         },
25953         {
25954                 "spoolss_XcvData",
25955                 sizeof(struct spoolss_XcvData),
25956                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
25957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
25958                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
25959                 false,
25960         },
25961         {
25962                 "spoolss_AddPrinterDriverEx",
25963                 sizeof(struct spoolss_AddPrinterDriverEx),
25964                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
25965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
25966                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
25967                 false,
25968         },
25969         {
25970                 "spoolss_5a",
25971                 sizeof(struct spoolss_5a),
25972                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
25973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
25974                 (ndr_print_function_t) ndr_print_spoolss_5a,
25975                 false,
25976         },
25977         {
25978                 "spoolss_5b",
25979                 sizeof(struct spoolss_5b),
25980                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
25981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
25982                 (ndr_print_function_t) ndr_print_spoolss_5b,
25983                 false,
25984         },
25985         {
25986                 "spoolss_5c",
25987                 sizeof(struct spoolss_5c),
25988                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
25989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
25990                 (ndr_print_function_t) ndr_print_spoolss_5c,
25991                 false,
25992         },
25993         {
25994                 "spoolss_5d",
25995                 sizeof(struct spoolss_5d),
25996                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
25997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
25998                 (ndr_print_function_t) ndr_print_spoolss_5d,
25999                 false,
26000         },
26001         {
26002                 "spoolss_5e",
26003                 sizeof(struct spoolss_5e),
26004                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
26005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
26006                 (ndr_print_function_t) ndr_print_spoolss_5e,
26007                 false,
26008         },
26009         {
26010                 "spoolss_5f",
26011                 sizeof(struct spoolss_5f),
26012                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
26013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
26014                 (ndr_print_function_t) ndr_print_spoolss_5f,
26015                 false,
26016         },
26017         { NULL, 0, NULL, NULL, NULL, false }
26018 };
26019
26020 static const char * const spoolss_endpoint_strings[] = {
26021         "ncacn_np:[\\pipe\\spoolss]",
26022 };
26023
26024 static const struct ndr_interface_string_array spoolss_endpoints = {
26025         .count  = 1,
26026         .names  = spoolss_endpoint_strings
26027 };
26028
26029 static const char * const spoolss_authservice_strings[] = {
26030         "host",
26031 };
26032
26033 static const struct ndr_interface_string_array spoolss_authservices = {
26034         .count  = 1,
26035         .names  = spoolss_authservice_strings
26036 };
26037
26038
26039 const struct ndr_interface_table ndr_table_spoolss = {
26040         .name           = "spoolss",
26041         .syntax_id      = {
26042                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
26043                 NDR_SPOOLSS_VERSION
26044         },
26045         .helpstring     = NDR_SPOOLSS_HELPSTRING,
26046         .num_calls      = 96,
26047         .calls          = spoolss_calls,
26048         .endpoints      = &spoolss_endpoints,
26049         .authservices   = &spoolss_authservices
26050 };
26051