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 enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
  61 {
  62         if (ndr_flags & NDR_SCALARS) {
  63                 NDR_CHECK(ndr_push_align(ndr, 4));
  64                 {
  65                         uint32_t _flags_save_string = ndr->flags;
  66                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
  67                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
  68                         ndr->flags = _flags_save_string;
  69                 }
  70                 {
  71                         uint32_t _flags_save_string = ndr->flags;
  72                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
  73                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
  74                         ndr->flags = _flags_save_string;
  75                 }
  76                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
  77                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
  78                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
  79                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
  80                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
  81                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
  82                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
  83                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown10));
  84                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown11));
  85                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown12));
  86                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
  87                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown14));
  88                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_errors));
  89                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown16));
  90                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown17));
  91                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown18));
  92                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown19));
  93                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
  94                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown21));
  95                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
  96                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown23));
  97                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
  98                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown25));
  99                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->unknown26));
 100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown27));
 101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown28));
 102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown29));
 103         }
 104         if (ndr_flags & NDR_BUFFERS) {
 105                 {
 106                         uint32_t _flags_save_string = ndr->flags;
 107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 108                         if (r->printername) {
 109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 111                         }
 112                         ndr->flags = _flags_save_string;
 113                 }
 114                 {
 115                         uint32_t _flags_save_string = ndr->flags;
 116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 117                         if (r->servername) {
 118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 119                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 120                         }
 121                         ndr->flags = _flags_save_string;
 122                 }
 123         }
 124         return NDR_ERR_SUCCESS;
 125 }
 126
 127 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 128 {
 129         uint32_t _ptr_printername;
 130         TALLOC_CTX *_mem_save_printername_0;
 131         uint32_t _ptr_servername;
 132         TALLOC_CTX *_mem_save_servername_0;
 133         if (ndr_flags & NDR_SCALARS) {
 134                 NDR_CHECK(ndr_pull_align(ndr, 4));
 135                 {
 136                         uint32_t _flags_save_string = ndr->flags;
 137                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 138                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 139                         if (_ptr_printername) {
 140                                 NDR_PULL_ALLOC(ndr, r->printername);
 141                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 142                         } else {
 143                                 r->printername = NULL;
 144                         }
 145                         ndr->flags = _flags_save_string;
 146                 }
 147                 {
 148                         uint32_t _flags_save_string = ndr->flags;
 149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 150                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 151                         if (_ptr_servername) {
 152                                 NDR_PULL_ALLOC(ndr, r->servername);
 153                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 154                         } else {
 155                                 r->servername = NULL;
 156                         }
 157                         ndr->flags = _flags_save_string;
 158                 }
 159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 160                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 161                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 162                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown10));
 167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown11));
 168                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown12));
 169                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown14));
 171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_errors));
 172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown16));
 173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown17));
 174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown18));
 175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown19));
 176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown21));
 178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
 179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown23));
 180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 181                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown25));
 182                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->unknown26));
 183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown27));
 184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown28));
 185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown29));
 186         }
 187         if (ndr_flags & NDR_BUFFERS) {
 188                 {
 189                         uint32_t _flags_save_string = ndr->flags;
 190                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 191                         if (r->printername) {
 192                                 uint32_t _relative_save_offset;
 193                                 _relative_save_offset = ndr->offset;
 194                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 195                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 196                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 197                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 198                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 199                                 ndr->offset = _relative_save_offset;
 200                         }
 201                         ndr->flags = _flags_save_string;
 202                 }
 203                 {
 204                         uint32_t _flags_save_string = ndr->flags;
 205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 206                         if (r->servername) {
 207                                 uint32_t _relative_save_offset;
 208                                 _relative_save_offset = ndr->offset;
 209                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 210                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 211                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 212                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 213                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 214                                 ndr->offset = _relative_save_offset;
 215                         }
 216                         ndr->flags = _flags_save_string;
 217                 }
 218         }
 219         return NDR_ERR_SUCCESS;
 220 }
 221
 222 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 223 {
 224         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 225         ndr->depth++;
 226         ndr_print_ptr(ndr, "printername", r->printername);
 227         ndr->depth++;
 228         if (r->printername) {
 229                 ndr_print_string(ndr, "printername", r->printername);
 230         }
 231         ndr->depth--;
 232         ndr_print_ptr(ndr, "servername", r->servername);
 233         ndr->depth++;
 234         if (r->servername) {
 235                 ndr_print_string(ndr, "servername", r->servername);
 236         }
 237         ndr->depth--;
 238         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 239         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 240         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 241         ndr_print_spoolss_Time(ndr, "time", &r->time);
 242         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 243         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 244         ndr_print_uint32(ndr, "version", r->version);
 245         ndr_print_uint32(ndr, "unknown10", r->unknown10);
 246         ndr_print_uint32(ndr, "unknown11", r->unknown11);
 247         ndr_print_uint32(ndr, "unknown12", r->unknown12);
 248         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 249         ndr_print_uint32(ndr, "unknown14", r->unknown14);
 250         ndr_print_uint32(ndr, "printer_errors", r->printer_errors);
 251         ndr_print_uint32(ndr, "unknown16", r->unknown16);
 252         ndr_print_uint32(ndr, "unknown17", r->unknown17);
 253         ndr_print_uint32(ndr, "unknown18", r->unknown18);
 254         ndr_print_uint32(ndr, "unknown19", r->unknown19);
 255         ndr_print_uint32(ndr, "change_id", r->change_id);
 256         ndr_print_uint32(ndr, "unknown21", r->unknown21);
 257         ndr_print_uint32(ndr, "status", r->status);
 258         ndr_print_uint32(ndr, "unknown23", r->unknown23);
 259         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 260         ndr_print_uint16(ndr, "unknown25", r->unknown25);
 261         ndr_print_uint16(ndr, "unknown26", r->unknown26);
 262         ndr_print_uint32(ndr, "unknown27", r->unknown27);
 263         ndr_print_uint32(ndr, "unknown28", r->unknown28);
 264         ndr_print_uint32(ndr, "unknown29", r->unknown29);
 265         ndr->depth--;
 266 }
 267
 268 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 269 {
 270         if (ndr_flags & NDR_SCALARS) {
 271                 NDR_CHECK(ndr_push_align(ndr, 4));
 272                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 273                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 274                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 275                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 276                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->fields));
 278                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 279                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 280                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 281                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 282                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 283                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 284                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 285                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 286                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 287                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 288                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 289                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 290                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 291                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 292                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 306                 {
 307                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 309                         {
 310                                 struct ndr_push *_ndr_driverextra_data;
 311                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 312                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 313                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 314                         }
 315                         ndr->flags = _flags_save_DATA_BLOB;
 316                 }
 317         }
 318         if (ndr_flags & NDR_BUFFERS) {
 319         }
 320         return NDR_ERR_SUCCESS;
 321 }
 322
 323 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 324 {
 325         if (ndr_flags & NDR_SCALARS) {
 326                 NDR_CHECK(ndr_pull_align(ndr, 4));
 327                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 328                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 329                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 330                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 331                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->fields));
 333                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 334                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 335                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 336                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 337                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 338                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 339                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 340                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 341                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 342                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 343                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 344                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 345                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 346                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 347                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 351                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 361                 {
 362                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 364                         {
 365                                 struct ndr_pull *_ndr_driverextra_data;
 366                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 367                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 368                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 369                         }
 370                         ndr->flags = _flags_save_DATA_BLOB;
 371                 }
 372         }
 373         if (ndr_flags & NDR_BUFFERS) {
 374         }
 375         return NDR_ERR_SUCCESS;
 376 }
 377
 378 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 379 {
 380         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 381         ndr->depth++;
 382         ndr_print_string(ndr, "devicename", r->devicename);
 383         ndr_print_uint16(ndr, "specversion", r->specversion);
 384         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 385         ndr_print_uint16(ndr, "size", r->size);
 386         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 387         ndr_print_uint32(ndr, "fields", r->fields);
 388         ndr_print_uint16(ndr, "orientation", r->orientation);
 389         ndr_print_uint16(ndr, "papersize", r->papersize);
 390         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 391         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 392         ndr_print_uint16(ndr, "scale", r->scale);
 393         ndr_print_uint16(ndr, "copies", r->copies);
 394         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 395         ndr_print_uint16(ndr, "printquality", r->printquality);
 396         ndr_print_uint16(ndr, "color", r->color);
 397         ndr_print_uint16(ndr, "duplex", r->duplex);
 398         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 399         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 400         ndr_print_uint16(ndr, "collate", r->collate);
 401         ndr_print_string(ndr, "formname", r->formname);
 402         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 403         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 404         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 405         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 406         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 407         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 408         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 409         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 410         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 411         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 412         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 413         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 414         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 415         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 416         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 417         ndr->depth--;
 418 }
 419
 420 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 421 {
 422         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 423 }
 424
 425 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 426 {
 427         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 428         return NDR_ERR_SUCCESS;
 429 }
 430
 431 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 432 {
 433         uint32_t v;
 434         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 435         *r = v;
 436         return NDR_ERR_SUCCESS;
 437 }
 438
 439 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 440 {
 441         ndr_print_uint32(ndr, name, r);
 442         ndr->depth++;
 443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 444         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 445         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 446         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 447         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 448         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 449         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 450         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 451         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 452         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 453         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 454         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 455         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 456         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 457         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 458         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 459         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 460         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 461         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 462         ndr->depth--;
 463 }
 464
 465 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 466 {
 467         if (ndr_flags & NDR_SCALARS) {
 468                 NDR_CHECK(ndr_push_align(ndr, 4));
 469                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 470                 {
 471                         uint32_t _flags_save_string = ndr->flags;
 472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 473                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 474                         ndr->flags = _flags_save_string;
 475                 }
 476                 {
 477                         uint32_t _flags_save_string = ndr->flags;
 478                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 479                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 480                         ndr->flags = _flags_save_string;
 481                 }
 482                 {
 483                         uint32_t _flags_save_string = ndr->flags;
 484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 485                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 486                         ndr->flags = _flags_save_string;
 487                 }
 488         }
 489         if (ndr_flags & NDR_BUFFERS) {
 490                 {
 491                         uint32_t _flags_save_string = ndr->flags;
 492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 493                         if (r->name) {
 494                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 495                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 496                         }
 497                         ndr->flags = _flags_save_string;
 498                 }
 499                 {
 500                         uint32_t _flags_save_string = ndr->flags;
 501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 502                         if (r->description) {
 503                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 504                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 505                         }
 506                         ndr->flags = _flags_save_string;
 507                 }
 508                 {
 509                         uint32_t _flags_save_string = ndr->flags;
 510                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 511                         if (r->comment) {
 512                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 513                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 514                         }
 515                         ndr->flags = _flags_save_string;
 516                 }
 517         }
 518         return NDR_ERR_SUCCESS;
 519 }
 520
 521 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 522 {
 523         uint32_t _ptr_name;
 524         TALLOC_CTX *_mem_save_name_0;
 525         uint32_t _ptr_description;
 526         TALLOC_CTX *_mem_save_description_0;
 527         uint32_t _ptr_comment;
 528         TALLOC_CTX *_mem_save_comment_0;
 529         if (ndr_flags & NDR_SCALARS) {
 530                 NDR_CHECK(ndr_pull_align(ndr, 4));
 531                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 532                 {
 533                         uint32_t _flags_save_string = ndr->flags;
 534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 535                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 536                         if (_ptr_name) {
 537                                 NDR_PULL_ALLOC(ndr, r->name);
 538                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 539                         } else {
 540                                 r->name = NULL;
 541                         }
 542                         ndr->flags = _flags_save_string;
 543                 }
 544                 {
 545                         uint32_t _flags_save_string = ndr->flags;
 546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 547                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 548                         if (_ptr_description) {
 549                                 NDR_PULL_ALLOC(ndr, r->description);
 550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 551                         } else {
 552                                 r->description = NULL;
 553                         }
 554                         ndr->flags = _flags_save_string;
 555                 }
 556                 {
 557                         uint32_t _flags_save_string = ndr->flags;
 558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 560                         if (_ptr_comment) {
 561                                 NDR_PULL_ALLOC(ndr, r->comment);
 562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 563                         } else {
 564                                 r->comment = NULL;
 565                         }
 566                         ndr->flags = _flags_save_string;
 567                 }
 568         }
 569         if (ndr_flags & NDR_BUFFERS) {
 570                 {
 571                         uint32_t _flags_save_string = ndr->flags;
 572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 573                         if (r->name) {
 574                                 uint32_t _relative_save_offset;
 575                                 _relative_save_offset = ndr->offset;
 576                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 577                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 578                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 579                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 580                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 581                                 ndr->offset = _relative_save_offset;
 582                         }
 583                         ndr->flags = _flags_save_string;
 584                 }
 585                 {
 586                         uint32_t _flags_save_string = ndr->flags;
 587                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 588                         if (r->description) {
 589                                 uint32_t _relative_save_offset;
 590                                 _relative_save_offset = ndr->offset;
 591                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 592                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 593                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 594                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 595                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 596                                 ndr->offset = _relative_save_offset;
 597                         }
 598                         ndr->flags = _flags_save_string;
 599                 }
 600                 {
 601                         uint32_t _flags_save_string = ndr->flags;
 602                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 603                         if (r->comment) {
 604                                 uint32_t _relative_save_offset;
 605                                 _relative_save_offset = ndr->offset;
 606                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 607                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 608                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 609                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 610                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 611                                 ndr->offset = _relative_save_offset;
 612                         }
 613                         ndr->flags = _flags_save_string;
 614                 }
 615         }
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 620 {
 621         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 622         ndr->depth++;
 623         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 624         ndr_print_ptr(ndr, "name", r->name);
 625         ndr->depth++;
 626         if (r->name) {
 627                 ndr_print_string(ndr, "name", r->name);
 628         }
 629         ndr->depth--;
 630         ndr_print_ptr(ndr, "description", r->description);
 631         ndr->depth++;
 632         if (r->description) {
 633                 ndr_print_string(ndr, "description", r->description);
 634         }
 635         ndr->depth--;
 636         ndr_print_ptr(ndr, "comment", r->comment);
 637         ndr->depth++;
 638         if (r->comment) {
 639                 ndr_print_string(ndr, "comment", r->comment);
 640         }
 641         ndr->depth--;
 642         ndr->depth--;
 643 }
 644
 645 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 646 {
 647         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 648         return NDR_ERR_SUCCESS;
 649 }
 650
 651 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 652 {
 653         uint32_t v;
 654         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 655         *r = v;
 656         return NDR_ERR_SUCCESS;
 657 }
 658
 659 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 660 {
 661         ndr_print_uint32(ndr, name, r);
 662         ndr->depth++;
 663         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 664         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 665         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 666         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 667         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 668         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 669         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 670         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 671         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 672         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 673         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 674         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 675         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 676         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 677         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 678         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 679         ndr->depth--;
 680 }
 681
 682 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 683 {
 684         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 685         return NDR_ERR_SUCCESS;
 686 }
 687
 688 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 689 {
 690         uint32_t v;
 691         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 692         *r = v;
 693         return NDR_ERR_SUCCESS;
 694 }
 695
 696 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 697 {
 698         ndr_print_uint32(ndr, name, r);
 699         ndr->depth++;
 700         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 701         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 702         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 703         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 704         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 705         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 706         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 707         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 708         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 709         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 710         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 711         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 712         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 713         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 714         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 715         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 716         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 717         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 718         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 719         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 720         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 721         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 722         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 723         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 724         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 725         ndr->depth--;
 726 }
 727
 728 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 729 {
 730         if (ndr_flags & NDR_SCALARS) {
 731                 NDR_CHECK(ndr_push_align(ndr, 4));
 732                 {
 733                         uint32_t _flags_save_string = ndr->flags;
 734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 735                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 736                         ndr->flags = _flags_save_string;
 737                 }
 738                 {
 739                         uint32_t _flags_save_string = ndr->flags;
 740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 741                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 742                         ndr->flags = _flags_save_string;
 743                 }
 744                 {
 745                         uint32_t _flags_save_string = ndr->flags;
 746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 747                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 748                         ndr->flags = _flags_save_string;
 749                 }
 750                 {
 751                         uint32_t _flags_save_string = ndr->flags;
 752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 753                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
 754                         ndr->flags = _flags_save_string;
 755                 }
 756                 {
 757                         uint32_t _flags_save_string = ndr->flags;
 758                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 759                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
 760                         ndr->flags = _flags_save_string;
 761                 }
 762                 {
 763                         uint32_t _flags_save_string = ndr->flags;
 764                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 765                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 766                         ndr->flags = _flags_save_string;
 767                 }
 768                 {
 769                         uint32_t _flags_save_string = ndr->flags;
 770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 771                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
 772                         ndr->flags = _flags_save_string;
 773                 }
 774                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
 775                 {
 776                         uint32_t _flags_save_string = ndr->flags;
 777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 778                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
 779                         ndr->flags = _flags_save_string;
 780                 }
 781                 {
 782                         uint32_t _flags_save_string = ndr->flags;
 783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 784                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
 785                         ndr->flags = _flags_save_string;
 786                 }
 787                 {
 788                         uint32_t _flags_save_string = ndr->flags;
 789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 790                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
 791                         ndr->flags = _flags_save_string;
 792                 }
 793                 {
 794                         uint32_t _flags_save_string = ndr->flags;
 795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 796                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
 797                         ndr->flags = _flags_save_string;
 798                 }
 799                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
 800                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
 801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
 802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
 803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
 804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
 805                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
 808         }
 809         if (ndr_flags & NDR_BUFFERS) {
 810                 {
 811                         uint32_t _flags_save_string = ndr->flags;
 812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 813                         if (r->servername) {
 814                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 815                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 816                         }
 817                         ndr->flags = _flags_save_string;
 818                 }
 819                 {
 820                         uint32_t _flags_save_string = ndr->flags;
 821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 822                         if (r->printername) {
 823                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 824                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 825                         }
 826                         ndr->flags = _flags_save_string;
 827                 }
 828                 {
 829                         uint32_t _flags_save_string = ndr->flags;
 830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 831                         if (r->sharename) {
 832                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
 833                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
 834                         }
 835                         ndr->flags = _flags_save_string;
 836                 }
 837                 {
 838                         uint32_t _flags_save_string = ndr->flags;
 839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 840                         if (r->portname) {
 841                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
 842                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
 843                         }
 844                         ndr->flags = _flags_save_string;
 845                 }
 846                 {
 847                         uint32_t _flags_save_string = ndr->flags;
 848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 849                         if (r->drivername) {
 850                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
 851                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
 852                         }
 853                         ndr->flags = _flags_save_string;
 854                 }
 855                 {
 856                         uint32_t _flags_save_string = ndr->flags;
 857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 858                         if (r->comment) {
 859                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 860                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 861                         }
 862                         ndr->flags = _flags_save_string;
 863                 }
 864                 {
 865                         uint32_t _flags_save_string = ndr->flags;
 866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 867                         if (r->location) {
 868                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
 869                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
 870                         }
 871                         ndr->flags = _flags_save_string;
 872                 }
 873                 if (r->devmode) {
 874                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
 875                         {
 876                                 struct ndr_push *_ndr_devmode;
 877                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
 878                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
 879                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
 880                         }
 881                 }
 882                 {
 883                         uint32_t _flags_save_string = ndr->flags;
 884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 885                         if (r->sepfile) {
 886                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
 887                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
 888                         }
 889                         ndr->flags = _flags_save_string;
 890                 }
 891                 {
 892                         uint32_t _flags_save_string = ndr->flags;
 893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 894                         if (r->printprocessor) {
 895                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
 896                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
 897                         }
 898                         ndr->flags = _flags_save_string;
 899                 }
 900                 {
 901                         uint32_t _flags_save_string = ndr->flags;
 902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 903                         if (r->datatype) {
 904                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
 905                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
 906                         }
 907                         ndr->flags = _flags_save_string;
 908                 }
 909                 {
 910                         uint32_t _flags_save_string = ndr->flags;
 911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 912                         if (r->parameters) {
 913                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
 914                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
 915                         }
 916                         ndr->flags = _flags_save_string;
 917                 }
 918                 if (r->secdesc) {
 919                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
 920                         {
 921                                 struct ndr_push *_ndr_secdesc;
 922                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
 923                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
 924                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
 925                         }
 926                 }
 927         }
 928         return NDR_ERR_SUCCESS;
 929 }
 930
 931 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
 932 {
 933         uint32_t _ptr_servername;
 934         TALLOC_CTX *_mem_save_servername_0;
 935         uint32_t _ptr_printername;
 936         TALLOC_CTX *_mem_save_printername_0;
 937         uint32_t _ptr_sharename;
 938         TALLOC_CTX *_mem_save_sharename_0;
 939         uint32_t _ptr_portname;
 940         TALLOC_CTX *_mem_save_portname_0;
 941         uint32_t _ptr_drivername;
 942         TALLOC_CTX *_mem_save_drivername_0;
 943         uint32_t _ptr_comment;
 944         TALLOC_CTX *_mem_save_comment_0;
 945         uint32_t _ptr_location;
 946         TALLOC_CTX *_mem_save_location_0;
 947         uint32_t _ptr_devmode;
 948         TALLOC_CTX *_mem_save_devmode_0;
 949         uint32_t _ptr_sepfile;
 950         TALLOC_CTX *_mem_save_sepfile_0;
 951         uint32_t _ptr_printprocessor;
 952         TALLOC_CTX *_mem_save_printprocessor_0;
 953         uint32_t _ptr_datatype;
 954         TALLOC_CTX *_mem_save_datatype_0;
 955         uint32_t _ptr_parameters;
 956         TALLOC_CTX *_mem_save_parameters_0;
 957         uint32_t _ptr_secdesc;
 958         TALLOC_CTX *_mem_save_secdesc_0;
 959         if (ndr_flags & NDR_SCALARS) {
 960                 NDR_CHECK(ndr_pull_align(ndr, 4));
 961                 {
 962                         uint32_t _flags_save_string = ndr->flags;
 963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 964                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 965                         if (_ptr_servername) {
 966                                 NDR_PULL_ALLOC(ndr, r->servername);
 967                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 968                         } else {
 969                                 r->servername = NULL;
 970                         }
 971                         ndr->flags = _flags_save_string;
 972                 }
 973                 {
 974                         uint32_t _flags_save_string = ndr->flags;
 975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 976                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 977                         if (_ptr_printername) {
 978                                 NDR_PULL_ALLOC(ndr, r->printername);
 979                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 980                         } else {
 981                                 r->printername = NULL;
 982                         }
 983                         ndr->flags = _flags_save_string;
 984                 }
 985                 {
 986                         uint32_t _flags_save_string = ndr->flags;
 987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 988                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
 989                         if (_ptr_sharename) {
 990                                 NDR_PULL_ALLOC(ndr, r->sharename);
 991                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
 992                         } else {
 993                                 r->sharename = NULL;
 994                         }
 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_pull_generic_ptr(ndr, &_ptr_portname));
1001                         if (_ptr_portname) {
1002                                 NDR_PULL_ALLOC(ndr, r->portname);
1003                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1004                         } else {
1005                                 r->portname = NULL;
1006                         }
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_pull_generic_ptr(ndr, &_ptr_drivername));
1013                         if (_ptr_drivername) {
1014                                 NDR_PULL_ALLOC(ndr, r->drivername);
1015                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1016                         } else {
1017                                 r->drivername = NULL;
1018                         }
1019                         ndr->flags = _flags_save_string;
1020                 }
1021                 {
1022                         uint32_t _flags_save_string = ndr->flags;
1023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1024                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1025                         if (_ptr_comment) {
1026                                 NDR_PULL_ALLOC(ndr, r->comment);
1027                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1028                         } else {
1029                                 r->comment = NULL;
1030                         }
1031                         ndr->flags = _flags_save_string;
1032                 }
1033                 {
1034                         uint32_t _flags_save_string = ndr->flags;
1035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1036                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1037                         if (_ptr_location) {
1038                                 NDR_PULL_ALLOC(ndr, r->location);
1039                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1040                         } else {
1041                                 r->location = NULL;
1042                         }
1043                         ndr->flags = _flags_save_string;
1044                 }
1045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1046                 if (_ptr_devmode) {
1047                         NDR_PULL_ALLOC(ndr, r->devmode);
1048                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1049                 } else {
1050                         r->devmode = NULL;
1051                 }
1052                 {
1053                         uint32_t _flags_save_string = ndr->flags;
1054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1055                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1056                         if (_ptr_sepfile) {
1057                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1058                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1059                         } else {
1060                                 r->sepfile = NULL;
1061                         }
1062                         ndr->flags = _flags_save_string;
1063                 }
1064                 {
1065                         uint32_t _flags_save_string = ndr->flags;
1066                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1067                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1068                         if (_ptr_printprocessor) {
1069                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1070                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1071                         } else {
1072                                 r->printprocessor = NULL;
1073                         }
1074                         ndr->flags = _flags_save_string;
1075                 }
1076                 {
1077                         uint32_t _flags_save_string = ndr->flags;
1078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1079                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1080                         if (_ptr_datatype) {
1081                                 NDR_PULL_ALLOC(ndr, r->datatype);
1082                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1083                         } else {
1084                                 r->datatype = NULL;
1085                         }
1086                         ndr->flags = _flags_save_string;
1087                 }
1088                 {
1089                         uint32_t _flags_save_string = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1091                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1092                         if (_ptr_parameters) {
1093                                 NDR_PULL_ALLOC(ndr, r->parameters);
1094                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1095                         } else {
1096                                 r->parameters = NULL;
1097                         }
1098                         ndr->flags = _flags_save_string;
1099                 }
1100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1101                 if (_ptr_secdesc) {
1102                         NDR_PULL_ALLOC(ndr, r->secdesc);
1103                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1104                 } else {
1105                         r->secdesc = NULL;
1106                 }
1107                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1112                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1115         }
1116         if (ndr_flags & NDR_BUFFERS) {
1117                 {
1118                         uint32_t _flags_save_string = ndr->flags;
1119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1120                         if (r->servername) {
1121                                 uint32_t _relative_save_offset;
1122                                 _relative_save_offset = ndr->offset;
1123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1124                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1125                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1128                                 ndr->offset = _relative_save_offset;
1129                         }
1130                         ndr->flags = _flags_save_string;
1131                 }
1132                 {
1133                         uint32_t _flags_save_string = ndr->flags;
1134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1135                         if (r->printername) {
1136                                 uint32_t _relative_save_offset;
1137                                 _relative_save_offset = ndr->offset;
1138                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1139                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1140                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1141                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1142                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1143                                 ndr->offset = _relative_save_offset;
1144                         }
1145                         ndr->flags = _flags_save_string;
1146                 }
1147                 {
1148                         uint32_t _flags_save_string = ndr->flags;
1149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1150                         if (r->sharename) {
1151                                 uint32_t _relative_save_offset;
1152                                 _relative_save_offset = ndr->offset;
1153                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1154                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1155                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1156                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1157                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1158                                 ndr->offset = _relative_save_offset;
1159                         }
1160                         ndr->flags = _flags_save_string;
1161                 }
1162                 {
1163                         uint32_t _flags_save_string = ndr->flags;
1164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1165                         if (r->portname) {
1166                                 uint32_t _relative_save_offset;
1167                                 _relative_save_offset = ndr->offset;
1168                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1169                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1170                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1171                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1172                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1173                                 ndr->offset = _relative_save_offset;
1174                         }
1175                         ndr->flags = _flags_save_string;
1176                 }
1177                 {
1178                         uint32_t _flags_save_string = ndr->flags;
1179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1180                         if (r->drivername) {
1181                                 uint32_t _relative_save_offset;
1182                                 _relative_save_offset = ndr->offset;
1183                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1184                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1185                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1186                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1187                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1188                                 ndr->offset = _relative_save_offset;
1189                         }
1190                         ndr->flags = _flags_save_string;
1191                 }
1192                 {
1193                         uint32_t _flags_save_string = ndr->flags;
1194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1195                         if (r->comment) {
1196                                 uint32_t _relative_save_offset;
1197                                 _relative_save_offset = ndr->offset;
1198                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1199                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1200                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1201                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1202                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1203                                 ndr->offset = _relative_save_offset;
1204                         }
1205                         ndr->flags = _flags_save_string;
1206                 }
1207                 {
1208                         uint32_t _flags_save_string = ndr->flags;
1209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1210                         if (r->location) {
1211                                 uint32_t _relative_save_offset;
1212                                 _relative_save_offset = ndr->offset;
1213                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1214                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1215                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1216                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1217                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1218                                 ndr->offset = _relative_save_offset;
1219                         }
1220                         ndr->flags = _flags_save_string;
1221                 }
1222                 if (r->devmode) {
1223                         uint32_t _relative_save_offset;
1224                         _relative_save_offset = ndr->offset;
1225                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1226                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1227                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1228                         {
1229                                 struct ndr_pull *_ndr_devmode;
1230                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1231                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1232                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1233                         }
1234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1235                         ndr->offset = _relative_save_offset;
1236                 }
1237                 {
1238                         uint32_t _flags_save_string = ndr->flags;
1239                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1240                         if (r->sepfile) {
1241                                 uint32_t _relative_save_offset;
1242                                 _relative_save_offset = ndr->offset;
1243                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1244                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1245                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1246                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1247                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1248                                 ndr->offset = _relative_save_offset;
1249                         }
1250                         ndr->flags = _flags_save_string;
1251                 }
1252                 {
1253                         uint32_t _flags_save_string = ndr->flags;
1254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1255                         if (r->printprocessor) {
1256                                 uint32_t _relative_save_offset;
1257                                 _relative_save_offset = ndr->offset;
1258                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1259                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1260                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1261                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1262                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1263                                 ndr->offset = _relative_save_offset;
1264                         }
1265                         ndr->flags = _flags_save_string;
1266                 }
1267                 {
1268                         uint32_t _flags_save_string = ndr->flags;
1269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1270                         if (r->datatype) {
1271                                 uint32_t _relative_save_offset;
1272                                 _relative_save_offset = ndr->offset;
1273                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1274                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1275                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1276                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1277                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1278                                 ndr->offset = _relative_save_offset;
1279                         }
1280                         ndr->flags = _flags_save_string;
1281                 }
1282                 {
1283                         uint32_t _flags_save_string = ndr->flags;
1284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1285                         if (r->parameters) {
1286                                 uint32_t _relative_save_offset;
1287                                 _relative_save_offset = ndr->offset;
1288                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1289                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1290                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1291                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1292                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1293                                 ndr->offset = _relative_save_offset;
1294                         }
1295                         ndr->flags = _flags_save_string;
1296                 }
1297                 if (r->secdesc) {
1298                         uint32_t _relative_save_offset;
1299                         _relative_save_offset = ndr->offset;
1300                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1301                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1302                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1303                         {
1304                                 struct ndr_pull *_ndr_secdesc;
1305                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1306                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1307                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1308                         }
1309                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1310                         ndr->offset = _relative_save_offset;
1311                 }
1312         }
1313         return NDR_ERR_SUCCESS;
1314 }
1315
1316 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1317 {
1318         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1319         ndr->depth++;
1320         ndr_print_ptr(ndr, "servername", r->servername);
1321         ndr->depth++;
1322         if (r->servername) {
1323                 ndr_print_string(ndr, "servername", r->servername);
1324         }
1325         ndr->depth--;
1326         ndr_print_ptr(ndr, "printername", r->printername);
1327         ndr->depth++;
1328         if (r->printername) {
1329                 ndr_print_string(ndr, "printername", r->printername);
1330         }
1331         ndr->depth--;
1332         ndr_print_ptr(ndr, "sharename", r->sharename);
1333         ndr->depth++;
1334         if (r->sharename) {
1335                 ndr_print_string(ndr, "sharename", r->sharename);
1336         }
1337         ndr->depth--;
1338         ndr_print_ptr(ndr, "portname", r->portname);
1339         ndr->depth++;
1340         if (r->portname) {
1341                 ndr_print_string(ndr, "portname", r->portname);
1342         }
1343         ndr->depth--;
1344         ndr_print_ptr(ndr, "drivername", r->drivername);
1345         ndr->depth++;
1346         if (r->drivername) {
1347                 ndr_print_string(ndr, "drivername", r->drivername);
1348         }
1349         ndr->depth--;
1350         ndr_print_ptr(ndr, "comment", r->comment);
1351         ndr->depth++;
1352         if (r->comment) {
1353                 ndr_print_string(ndr, "comment", r->comment);
1354         }
1355         ndr->depth--;
1356         ndr_print_ptr(ndr, "location", r->location);
1357         ndr->depth++;
1358         if (r->location) {
1359                 ndr_print_string(ndr, "location", r->location);
1360         }
1361         ndr->depth--;
1362         ndr_print_ptr(ndr, "devmode", r->devmode);
1363         ndr->depth++;
1364         if (r->devmode) {
1365                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1366         }
1367         ndr->depth--;
1368         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1369         ndr->depth++;
1370         if (r->sepfile) {
1371                 ndr_print_string(ndr, "sepfile", r->sepfile);
1372         }
1373         ndr->depth--;
1374         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1375         ndr->depth++;
1376         if (r->printprocessor) {
1377                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1378         }
1379         ndr->depth--;
1380         ndr_print_ptr(ndr, "datatype", r->datatype);
1381         ndr->depth++;
1382         if (r->datatype) {
1383                 ndr_print_string(ndr, "datatype", r->datatype);
1384         }
1385         ndr->depth--;
1386         ndr_print_ptr(ndr, "parameters", r->parameters);
1387         ndr->depth++;
1388         if (r->parameters) {
1389                 ndr_print_string(ndr, "parameters", r->parameters);
1390         }
1391         ndr->depth--;
1392         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1393         ndr->depth++;
1394         if (r->secdesc) {
1395                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1396         }
1397         ndr->depth--;
1398         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1399         ndr_print_uint32(ndr, "priority", r->priority);
1400         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1401         ndr_print_uint32(ndr, "starttime", r->starttime);
1402         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1403         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1404         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1405         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1406         ndr->depth--;
1407 }
1408
1409 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1410 {
1411         if (ndr_flags & NDR_SCALARS) {
1412                 NDR_CHECK(ndr_push_align(ndr, 4));
1413                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1414         }
1415         if (ndr_flags & NDR_BUFFERS) {
1416                 if (r->secdesc) {
1417                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1418                         {
1419                                 struct ndr_push *_ndr_secdesc;
1420                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1421                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1422                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1423                         }
1424                 }
1425         }
1426         return NDR_ERR_SUCCESS;
1427 }
1428
1429 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1430 {
1431         uint32_t _ptr_secdesc;
1432         TALLOC_CTX *_mem_save_secdesc_0;
1433         if (ndr_flags & NDR_SCALARS) {
1434                 NDR_CHECK(ndr_pull_align(ndr, 4));
1435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1436                 if (_ptr_secdesc) {
1437                         NDR_PULL_ALLOC(ndr, r->secdesc);
1438                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1439                 } else {
1440                         r->secdesc = NULL;
1441                 }
1442         }
1443         if (ndr_flags & NDR_BUFFERS) {
1444                 if (r->secdesc) {
1445                         uint32_t _relative_save_offset;
1446                         _relative_save_offset = ndr->offset;
1447                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1448                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1449                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1450                         {
1451                                 struct ndr_pull *_ndr_secdesc;
1452                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1453                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1454                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1455                         }
1456                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1457                         ndr->offset = _relative_save_offset;
1458                 }
1459         }
1460         return NDR_ERR_SUCCESS;
1461 }
1462
1463 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1464 {
1465         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1466         ndr->depth++;
1467         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1468         ndr->depth++;
1469         if (r->secdesc) {
1470                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1471         }
1472         ndr->depth--;
1473         ndr->depth--;
1474 }
1475
1476 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1477 {
1478         if (ndr_flags & NDR_SCALARS) {
1479                 NDR_CHECK(ndr_push_align(ndr, 4));
1480                 {
1481                         uint32_t _flags_save_string = ndr->flags;
1482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1483                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1484                         ndr->flags = _flags_save_string;
1485                 }
1486                 {
1487                         uint32_t _flags_save_string = ndr->flags;
1488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1489                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1490                         ndr->flags = _flags_save_string;
1491                 }
1492                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1493         }
1494         if (ndr_flags & NDR_BUFFERS) {
1495                 {
1496                         uint32_t _flags_save_string = ndr->flags;
1497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1498                         if (r->printername) {
1499                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1500                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1501                         }
1502                         ndr->flags = _flags_save_string;
1503                 }
1504                 {
1505                         uint32_t _flags_save_string = ndr->flags;
1506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1507                         if (r->servername) {
1508                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1509                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1510                         }
1511                         ndr->flags = _flags_save_string;
1512                 }
1513         }
1514         return NDR_ERR_SUCCESS;
1515 }
1516
1517 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1518 {
1519         uint32_t _ptr_printername;
1520         TALLOC_CTX *_mem_save_printername_0;
1521         uint32_t _ptr_servername;
1522         TALLOC_CTX *_mem_save_servername_0;
1523         if (ndr_flags & NDR_SCALARS) {
1524                 NDR_CHECK(ndr_pull_align(ndr, 4));
1525                 {
1526                         uint32_t _flags_save_string = ndr->flags;
1527                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1528                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1529                         if (_ptr_printername) {
1530                                 NDR_PULL_ALLOC(ndr, r->printername);
1531                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1532                         } else {
1533                                 r->printername = NULL;
1534                         }
1535                         ndr->flags = _flags_save_string;
1536                 }
1537                 {
1538                         uint32_t _flags_save_string = ndr->flags;
1539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1540                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1541                         if (_ptr_servername) {
1542                                 NDR_PULL_ALLOC(ndr, r->servername);
1543                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1544                         } else {
1545                                 r->servername = NULL;
1546                         }
1547                         ndr->flags = _flags_save_string;
1548                 }
1549                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1550         }
1551         if (ndr_flags & NDR_BUFFERS) {
1552                 {
1553                         uint32_t _flags_save_string = ndr->flags;
1554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1555                         if (r->printername) {
1556                                 uint32_t _relative_save_offset;
1557                                 _relative_save_offset = ndr->offset;
1558                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1559                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1560                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1561                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1562                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1563                                 ndr->offset = _relative_save_offset;
1564                         }
1565                         ndr->flags = _flags_save_string;
1566                 }
1567                 {
1568                         uint32_t _flags_save_string = ndr->flags;
1569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1570                         if (r->servername) {
1571                                 uint32_t _relative_save_offset;
1572                                 _relative_save_offset = ndr->offset;
1573                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1574                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1575                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1576                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1577                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1578                                 ndr->offset = _relative_save_offset;
1579                         }
1580                         ndr->flags = _flags_save_string;
1581                 }
1582         }
1583         return NDR_ERR_SUCCESS;
1584 }
1585
1586 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1587 {
1588         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1589         ndr->depth++;
1590         ndr_print_ptr(ndr, "printername", r->printername);
1591         ndr->depth++;
1592         if (r->printername) {
1593                 ndr_print_string(ndr, "printername", r->printername);
1594         }
1595         ndr->depth--;
1596         ndr_print_ptr(ndr, "servername", r->servername);
1597         ndr->depth++;
1598         if (r->servername) {
1599                 ndr_print_string(ndr, "servername", r->servername);
1600         }
1601         ndr->depth--;
1602         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1603         ndr->depth--;
1604 }
1605
1606 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1607 {
1608         if (ndr_flags & NDR_SCALARS) {
1609                 NDR_CHECK(ndr_push_align(ndr, 4));
1610                 {
1611                         uint32_t _flags_save_string = ndr->flags;
1612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1613                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1614                         ndr->flags = _flags_save_string;
1615                 }
1616                 {
1617                         uint32_t _flags_save_string = ndr->flags;
1618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1620                         ndr->flags = _flags_save_string;
1621                 }
1622                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1625         }
1626         if (ndr_flags & NDR_BUFFERS) {
1627                 {
1628                         uint32_t _flags_save_string = ndr->flags;
1629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1630                         if (r->printername) {
1631                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1632                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1633                         }
1634                         ndr->flags = _flags_save_string;
1635                 }
1636                 {
1637                         uint32_t _flags_save_string = ndr->flags;
1638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1639                         if (r->portname) {
1640                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1641                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1642                         }
1643                         ndr->flags = _flags_save_string;
1644                 }
1645         }
1646         return NDR_ERR_SUCCESS;
1647 }
1648
1649 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1650 {
1651         uint32_t _ptr_printername;
1652         TALLOC_CTX *_mem_save_printername_0;
1653         uint32_t _ptr_portname;
1654         TALLOC_CTX *_mem_save_portname_0;
1655         if (ndr_flags & NDR_SCALARS) {
1656                 NDR_CHECK(ndr_pull_align(ndr, 4));
1657                 {
1658                         uint32_t _flags_save_string = ndr->flags;
1659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1660                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1661                         if (_ptr_printername) {
1662                                 NDR_PULL_ALLOC(ndr, r->printername);
1663                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1664                         } else {
1665                                 r->printername = NULL;
1666                         }
1667                         ndr->flags = _flags_save_string;
1668                 }
1669                 {
1670                         uint32_t _flags_save_string = ndr->flags;
1671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1672                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1673                         if (_ptr_portname) {
1674                                 NDR_PULL_ALLOC(ndr, r->portname);
1675                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1676                         } else {
1677                                 r->portname = NULL;
1678                         }
1679                         ndr->flags = _flags_save_string;
1680                 }
1681                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1682                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1683                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1684         }
1685         if (ndr_flags & NDR_BUFFERS) {
1686                 {
1687                         uint32_t _flags_save_string = ndr->flags;
1688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1689                         if (r->printername) {
1690                                 uint32_t _relative_save_offset;
1691                                 _relative_save_offset = ndr->offset;
1692                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1693                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1694                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1695                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1696                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1697                                 ndr->offset = _relative_save_offset;
1698                         }
1699                         ndr->flags = _flags_save_string;
1700                 }
1701                 {
1702                         uint32_t _flags_save_string = ndr->flags;
1703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1704                         if (r->portname) {
1705                                 uint32_t _relative_save_offset;
1706                                 _relative_save_offset = ndr->offset;
1707                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1708                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1709                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1710                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1711                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1712                                 ndr->offset = _relative_save_offset;
1713                         }
1714                         ndr->flags = _flags_save_string;
1715                 }
1716         }
1717         return NDR_ERR_SUCCESS;
1718 }
1719
1720 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1721 {
1722         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1723         ndr->depth++;
1724         ndr_print_ptr(ndr, "printername", r->printername);
1725         ndr->depth++;
1726         if (r->printername) {
1727                 ndr_print_string(ndr, "printername", r->printername);
1728         }
1729         ndr->depth--;
1730         ndr_print_ptr(ndr, "portname", r->portname);
1731         ndr->depth++;
1732         if (r->portname) {
1733                 ndr_print_string(ndr, "portname", r->portname);
1734         }
1735         ndr->depth--;
1736         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1737         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1738         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1739         ndr->depth--;
1740 }
1741
1742 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1743 {
1744         if (ndr_flags & NDR_SCALARS) {
1745                 NDR_CHECK(ndr_push_align(ndr, 4));
1746                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1747         }
1748         if (ndr_flags & NDR_BUFFERS) {
1749         }
1750         return NDR_ERR_SUCCESS;
1751 }
1752
1753 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
1754 {
1755         if (ndr_flags & NDR_SCALARS) {
1756                 NDR_CHECK(ndr_pull_align(ndr, 4));
1757                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1758         }
1759         if (ndr_flags & NDR_BUFFERS) {
1760         }
1761         return NDR_ERR_SUCCESS;
1762 }
1763
1764 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
1765 {
1766         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
1767         ndr->depth++;
1768         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1769         ndr->depth--;
1770 }
1771
1772 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
1773 {
1774         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
1775         return NDR_ERR_SUCCESS;
1776 }
1777
1778 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
1779 {
1780         uint32_t v;
1781         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
1782         *r = v;
1783         return NDR_ERR_SUCCESS;
1784 }
1785
1786 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
1787 {
1788         ndr_print_uint32(ndr, name, r);
1789         ndr->depth++;
1790         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
1791         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
1792         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
1793         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
1794         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
1795         ndr->depth--;
1796 }
1797
1798 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
1799 {
1800         if (ndr_flags & NDR_SCALARS) {
1801                 NDR_CHECK(ndr_push_align(ndr, 4));
1802                 {
1803                         uint32_t _flags_save_string = ndr->flags;
1804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1805                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
1806                         ndr->flags = _flags_save_string;
1807                 }
1808                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
1809         }
1810         if (ndr_flags & NDR_BUFFERS) {
1811                 {
1812                         uint32_t _flags_save_string = ndr->flags;
1813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1814                         if (r->guid) {
1815                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
1816                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
1817                         }
1818                         ndr->flags = _flags_save_string;
1819                 }
1820         }
1821         return NDR_ERR_SUCCESS;
1822 }
1823
1824 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
1825 {
1826         uint32_t _ptr_guid;
1827         TALLOC_CTX *_mem_save_guid_0;
1828         if (ndr_flags & NDR_SCALARS) {
1829                 NDR_CHECK(ndr_pull_align(ndr, 4));
1830                 {
1831                         uint32_t _flags_save_string = ndr->flags;
1832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
1834                         if (_ptr_guid) {
1835                                 NDR_PULL_ALLOC(ndr, r->guid);
1836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
1837                         } else {
1838                                 r->guid = NULL;
1839                         }
1840                         ndr->flags = _flags_save_string;
1841                 }
1842                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
1843         }
1844         if (ndr_flags & NDR_BUFFERS) {
1845                 {
1846                         uint32_t _flags_save_string = ndr->flags;
1847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1848                         if (r->guid) {
1849                                 uint32_t _relative_save_offset;
1850                                 _relative_save_offset = ndr->offset;
1851                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
1852                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
1853                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
1854                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
1855                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
1856                                 ndr->offset = _relative_save_offset;
1857                         }
1858                         ndr->flags = _flags_save_string;
1859                 }
1860         }
1861         return NDR_ERR_SUCCESS;
1862 }
1863
1864 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
1865 {
1866         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
1867         ndr->depth++;
1868         ndr_print_ptr(ndr, "guid", r->guid);
1869         ndr->depth++;
1870         if (r->guid) {
1871                 ndr_print_string(ndr, "guid", r->guid);
1872         }
1873         ndr->depth--;
1874         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
1875         ndr->depth--;
1876 }
1877
1878 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
1879 {
1880         if (ndr_flags & NDR_SCALARS) {
1881                 NDR_CHECK(ndr_push_align(ndr, 4));
1882                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1883         }
1884         if (ndr_flags & NDR_BUFFERS) {
1885                 if (r->devmode) {
1886                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1887                         {
1888                                 struct ndr_push *_ndr_devmode;
1889                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1890                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1891                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1892                         }
1893                 }
1894         }
1895         return NDR_ERR_SUCCESS;
1896 }
1897
1898 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
1899 {
1900         uint32_t _ptr_devmode;
1901         TALLOC_CTX *_mem_save_devmode_0;
1902         if (ndr_flags & NDR_SCALARS) {
1903                 NDR_CHECK(ndr_pull_align(ndr, 4));
1904                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1905                 if (_ptr_devmode) {
1906                         NDR_PULL_ALLOC(ndr, r->devmode);
1907                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1908                 } else {
1909                         r->devmode = NULL;
1910                 }
1911         }
1912         if (ndr_flags & NDR_BUFFERS) {
1913                 if (r->devmode) {
1914                         uint32_t _relative_save_offset;
1915                         _relative_save_offset = ndr->offset;
1916                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1917                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1918                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1919                         {
1920                                 struct ndr_pull *_ndr_devmode;
1921                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1922                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1923                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1924                         }
1925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1926                         ndr->offset = _relative_save_offset;
1927                 }
1928         }
1929         return NDR_ERR_SUCCESS;
1930 }
1931
1932 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
1933 {
1934         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
1935         ndr->depth++;
1936         ndr_print_ptr(ndr, "devmode", r->devmode);
1937         ndr->depth++;
1938         if (r->devmode) {
1939                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1940         }
1941         ndr->depth--;
1942         ndr->depth--;
1943 }
1944
1945 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
1946 {
1947         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
1948         if (ndr_flags & NDR_SCALARS) {
1949                 int level = ndr_push_get_switch_value(ndr, r);
1950                 switch (level) {
1951                         case 0: {
1952                                 NDR_CHECK(ndr_push_align(ndr, 4));
1953                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1954                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
1955                         break; }
1956
1957                         case 1: {
1958                                 NDR_CHECK(ndr_push_align(ndr, 4));
1959                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1960                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
1961                         break; }
1962
1963                         case 2: {
1964                                 NDR_CHECK(ndr_push_align(ndr, 4));
1965                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1966                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
1967                         break; }
1968
1969                         case 3: {
1970                                 NDR_CHECK(ndr_push_align(ndr, 4));
1971                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1972                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
1973                         break; }
1974
1975                         case 4: {
1976                                 NDR_CHECK(ndr_push_align(ndr, 4));
1977                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1978                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
1979                         break; }
1980
1981                         case 5: {
1982                                 NDR_CHECK(ndr_push_align(ndr, 4));
1983                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1984                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
1985                         break; }
1986
1987                         case 6: {
1988                                 NDR_CHECK(ndr_push_align(ndr, 4));
1989                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1990                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
1991                         break; }
1992
1993                         case 7: {
1994                                 NDR_CHECK(ndr_push_align(ndr, 4));
1995                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
1996                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
1997                         break; }
1998
1999                         case 8: {
2000                                 NDR_CHECK(ndr_push_align(ndr, 4));
2001                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2002                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2003                         break; }
2004
2005                         case 9: {
2006                                 NDR_CHECK(ndr_push_align(ndr, 4));
2007                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2008                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2009                         break; }
2010
2011                         default: {
2012                         break; }
2013
2014                 }
2015         }
2016         if (ndr_flags & NDR_BUFFERS) {
2017                 int level = ndr_push_get_switch_value(ndr, r);
2018                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2019                 switch (level) {
2020                         case 0:
2021                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2022                         break;
2023
2024                         case 1:
2025                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2026                         break;
2027
2028                         case 2:
2029                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2030                         break;
2031
2032                         case 3:
2033                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2034                         break;
2035
2036                         case 4:
2037                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2038                         break;
2039
2040                         case 5:
2041                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2042                         break;
2043
2044                         case 6:
2045                         break;
2046
2047                         case 7:
2048                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2049                         break;
2050
2051                         case 8:
2052                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2053                         break;
2054
2055                         case 9:
2056                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2057                         break;
2058
2059                         default:
2060                         break;
2061
2062                 }
2063         }
2064         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2065         return NDR_ERR_SUCCESS;
2066 }
2067
2068 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2069 {
2070         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2071         int level;
2072         level = ndr_pull_get_switch_value(ndr, r);
2073         if (ndr_flags & NDR_SCALARS) {
2074                 switch (level) {
2075                         case 0: {
2076                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2077                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2078                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2079                         break; }
2080
2081                         case 1: {
2082                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2083                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2084                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2085                         break; }
2086
2087                         case 2: {
2088                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2089                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2090                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2091                         break; }
2092
2093                         case 3: {
2094                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2095                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2096                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2097                         break; }
2098
2099                         case 4: {
2100                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2101                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2102                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2103                         break; }
2104
2105                         case 5: {
2106                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2107                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2108                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2109                         break; }
2110
2111                         case 6: {
2112                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2113                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2114                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2115                         break; }
2116
2117                         case 7: {
2118                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2119                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2120                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2121                         break; }
2122
2123                         case 8: {
2124                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2125                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2126                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2127                         break; }
2128
2129                         case 9: {
2130                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2131                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2132                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2133                         break; }
2134
2135                         default: {
2136                         break; }
2137
2138                 }
2139         }
2140         if (ndr_flags & NDR_BUFFERS) {
2141                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2142                 switch (level) {
2143                         case 0:
2144                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2145                         break;
2146
2147                         case 1:
2148                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2149                         break;
2150
2151                         case 2:
2152                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2153                         break;
2154
2155                         case 3:
2156                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2157                         break;
2158
2159                         case 4:
2160                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2161                         break;
2162
2163                         case 5:
2164                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2165                         break;
2166
2167                         case 6:
2168                         break;
2169
2170                         case 7:
2171                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2172                         break;
2173
2174                         case 8:
2175                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2176                         break;
2177
2178                         case 9:
2179                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2180                         break;
2181
2182                         default:
2183                         break;
2184
2185                 }
2186         }
2187         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2188         return NDR_ERR_SUCCESS;
2189 }
2190
2191 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2192 {
2193         int level;
2194         level = ndr_print_get_switch_value(ndr, r);
2195         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2196         switch (level) {
2197                 case 0:
2198                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2199                 break;
2200
2201                 case 1:
2202                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2203                 break;
2204
2205                 case 2:
2206                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2207                 break;
2208
2209                 case 3:
2210                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2211                 break;
2212
2213                 case 4:
2214                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2215                 break;
2216
2217                 case 5:
2218                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2219                 break;
2220
2221                 case 6:
2222                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2223                 break;
2224
2225                 case 7:
2226                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2227                 break;
2228
2229                 case 8:
2230                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2231                 break;
2232
2233                 case 9:
2234                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2235                 break;
2236
2237                 default:
2238                 break;
2239
2240         }
2241 }
2242
2243 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2244 {
2245         if (ndr_flags & NDR_SCALARS) {
2246                 NDR_CHECK(ndr_push_align(ndr, 4));
2247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2249         }
2250         if (ndr_flags & NDR_BUFFERS) {
2251                 if (r->devmode) {
2252                         {
2253                                 struct ndr_push *_ndr_devmode;
2254                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2255                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2256                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2257                         }
2258                 }
2259         }
2260         return NDR_ERR_SUCCESS;
2261 }
2262
2263 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2264 {
2265         uint32_t _ptr_devmode;
2266         TALLOC_CTX *_mem_save_devmode_0;
2267         if (ndr_flags & NDR_SCALARS) {
2268                 NDR_CHECK(ndr_pull_align(ndr, 4));
2269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2271                 if (_ptr_devmode) {
2272                         NDR_PULL_ALLOC(ndr, r->devmode);
2273                 } else {
2274                         r->devmode = NULL;
2275                 }
2276         }
2277         if (ndr_flags & NDR_BUFFERS) {
2278                 if (r->devmode) {
2279                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2280                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2281                         {
2282                                 struct ndr_pull *_ndr_devmode;
2283                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2284                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2285                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2286                         }
2287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2288                 }
2289         }
2290         return NDR_ERR_SUCCESS;
2291 }
2292
2293 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2294 {
2295         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2296         ndr->depth++;
2297         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);
2298         ndr_print_ptr(ndr, "devmode", r->devmode);
2299         ndr->depth++;
2300         if (r->devmode) {
2301                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2302         }
2303         ndr->depth--;
2304         ndr->depth--;
2305 }
2306
2307 static enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2308 {
2309         if (ndr_flags & NDR_SCALARS) {
2310                 NDR_CHECK(ndr_push_align(ndr, 4));
2311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2312                 {
2313                         uint32_t _flags_save_string = ndr->flags;
2314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2316                         ndr->flags = _flags_save_string;
2317                 }
2318                 {
2319                         uint32_t _flags_save_string = ndr->flags;
2320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2321                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2322                         ndr->flags = _flags_save_string;
2323                 }
2324                 {
2325                         uint32_t _flags_save_string = ndr->flags;
2326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2327                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2328                         ndr->flags = _flags_save_string;
2329                 }
2330                 {
2331                         uint32_t _flags_save_string = ndr->flags;
2332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2333                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2334                         ndr->flags = _flags_save_string;
2335                 }
2336                 {
2337                         uint32_t _flags_save_string = ndr->flags;
2338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2339                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2340                         ndr->flags = _flags_save_string;
2341                 }
2342                 {
2343                         uint32_t _flags_save_string = ndr->flags;
2344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2345                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2346                         ndr->flags = _flags_save_string;
2347                 }
2348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
2349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2350                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2353                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2354         }
2355         if (ndr_flags & NDR_BUFFERS) {
2356                 {
2357                         uint32_t _flags_save_string = ndr->flags;
2358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2359                         if (r->printer_name) {
2360                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2361                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2362                         }
2363                         ndr->flags = _flags_save_string;
2364                 }
2365                 {
2366                         uint32_t _flags_save_string = ndr->flags;
2367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2368                         if (r->server_name) {
2369                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2370                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2371                         }
2372                         ndr->flags = _flags_save_string;
2373                 }
2374                 {
2375                         uint32_t _flags_save_string = ndr->flags;
2376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2377                         if (r->user_name) {
2378                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2379                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2380                         }
2381                         ndr->flags = _flags_save_string;
2382                 }
2383                 {
2384                         uint32_t _flags_save_string = ndr->flags;
2385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2386                         if (r->document_name) {
2387                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2388                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2389                         }
2390                         ndr->flags = _flags_save_string;
2391                 }
2392                 {
2393                         uint32_t _flags_save_string = ndr->flags;
2394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2395                         if (r->data_type) {
2396                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2397                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2398                         }
2399                         ndr->flags = _flags_save_string;
2400                 }
2401                 {
2402                         uint32_t _flags_save_string = ndr->flags;
2403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2404                         if (r->text_status) {
2405                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2406                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2407                         }
2408                         ndr->flags = _flags_save_string;
2409                 }
2410         }
2411         return NDR_ERR_SUCCESS;
2412 }
2413
2414 static enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2415 {
2416         uint32_t _ptr_printer_name;
2417         TALLOC_CTX *_mem_save_printer_name_0;
2418         uint32_t _ptr_server_name;
2419         TALLOC_CTX *_mem_save_server_name_0;
2420         uint32_t _ptr_user_name;
2421         TALLOC_CTX *_mem_save_user_name_0;
2422         uint32_t _ptr_document_name;
2423         TALLOC_CTX *_mem_save_document_name_0;
2424         uint32_t _ptr_data_type;
2425         TALLOC_CTX *_mem_save_data_type_0;
2426         uint32_t _ptr_text_status;
2427         TALLOC_CTX *_mem_save_text_status_0;
2428         if (ndr_flags & NDR_SCALARS) {
2429                 NDR_CHECK(ndr_pull_align(ndr, 4));
2430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2431                 {
2432                         uint32_t _flags_save_string = ndr->flags;
2433                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2434                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2435                         if (_ptr_printer_name) {
2436                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2437                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2438                         } else {
2439                                 r->printer_name = NULL;
2440                         }
2441                         ndr->flags = _flags_save_string;
2442                 }
2443                 {
2444                         uint32_t _flags_save_string = ndr->flags;
2445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2446                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2447                         if (_ptr_server_name) {
2448                                 NDR_PULL_ALLOC(ndr, r->server_name);
2449                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2450                         } else {
2451                                 r->server_name = NULL;
2452                         }
2453                         ndr->flags = _flags_save_string;
2454                 }
2455                 {
2456                         uint32_t _flags_save_string = ndr->flags;
2457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2458                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2459                         if (_ptr_user_name) {
2460                                 NDR_PULL_ALLOC(ndr, r->user_name);
2461                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2462                         } else {
2463                                 r->user_name = NULL;
2464                         }
2465                         ndr->flags = _flags_save_string;
2466                 }
2467                 {
2468                         uint32_t _flags_save_string = ndr->flags;
2469                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2470                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2471                         if (_ptr_document_name) {
2472                                 NDR_PULL_ALLOC(ndr, r->document_name);
2473                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2474                         } else {
2475                                 r->document_name = NULL;
2476                         }
2477                         ndr->flags = _flags_save_string;
2478                 }
2479                 {
2480                         uint32_t _flags_save_string = ndr->flags;
2481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2482                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2483                         if (_ptr_data_type) {
2484                                 NDR_PULL_ALLOC(ndr, r->data_type);
2485                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2486                         } else {
2487                                 r->data_type = NULL;
2488                         }
2489                         ndr->flags = _flags_save_string;
2490                 }
2491                 {
2492                         uint32_t _flags_save_string = ndr->flags;
2493                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2494                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2495                         if (_ptr_text_status) {
2496                                 NDR_PULL_ALLOC(ndr, r->text_status);
2497                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2498                         } else {
2499                                 r->text_status = NULL;
2500                         }
2501                         ndr->flags = _flags_save_string;
2502                 }
2503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
2504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2508                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
2509         }
2510         if (ndr_flags & NDR_BUFFERS) {
2511                 {
2512                         uint32_t _flags_save_string = ndr->flags;
2513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2514                         if (r->printer_name) {
2515                                 uint32_t _relative_save_offset;
2516                                 _relative_save_offset = ndr->offset;
2517                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2518                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2519                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2520                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2521                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2522                                 ndr->offset = _relative_save_offset;
2523                         }
2524                         ndr->flags = _flags_save_string;
2525                 }
2526                 {
2527                         uint32_t _flags_save_string = ndr->flags;
2528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2529                         if (r->server_name) {
2530                                 uint32_t _relative_save_offset;
2531                                 _relative_save_offset = ndr->offset;
2532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2533                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2534                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2537                                 ndr->offset = _relative_save_offset;
2538                         }
2539                         ndr->flags = _flags_save_string;
2540                 }
2541                 {
2542                         uint32_t _flags_save_string = ndr->flags;
2543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2544                         if (r->user_name) {
2545                                 uint32_t _relative_save_offset;
2546                                 _relative_save_offset = ndr->offset;
2547                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2548                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2549                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2550                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2551                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2552                                 ndr->offset = _relative_save_offset;
2553                         }
2554                         ndr->flags = _flags_save_string;
2555                 }
2556                 {
2557                         uint32_t _flags_save_string = ndr->flags;
2558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2559                         if (r->document_name) {
2560                                 uint32_t _relative_save_offset;
2561                                 _relative_save_offset = ndr->offset;
2562                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2563                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2564                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2565                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2566                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2567                                 ndr->offset = _relative_save_offset;
2568                         }
2569                         ndr->flags = _flags_save_string;
2570                 }
2571                 {
2572                         uint32_t _flags_save_string = ndr->flags;
2573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2574                         if (r->data_type) {
2575                                 uint32_t _relative_save_offset;
2576                                 _relative_save_offset = ndr->offset;
2577                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2578                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2579                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2580                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2581                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2582                                 ndr->offset = _relative_save_offset;
2583                         }
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                         if (r->text_status) {
2590                                 uint32_t _relative_save_offset;
2591                                 _relative_save_offset = ndr->offset;
2592                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2593                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2594                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2595                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2596                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2597                                 ndr->offset = _relative_save_offset;
2598                         }
2599                         ndr->flags = _flags_save_string;
2600                 }
2601         }
2602         return NDR_ERR_SUCCESS;
2603 }
2604
2605 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2606 {
2607         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2608         ndr->depth++;
2609         ndr_print_uint32(ndr, "job_id", r->job_id);
2610         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2611         ndr->depth++;
2612         if (r->printer_name) {
2613                 ndr_print_string(ndr, "printer_name", r->printer_name);
2614         }
2615         ndr->depth--;
2616         ndr_print_ptr(ndr, "server_name", r->server_name);
2617         ndr->depth++;
2618         if (r->server_name) {
2619                 ndr_print_string(ndr, "server_name", r->server_name);
2620         }
2621         ndr->depth--;
2622         ndr_print_ptr(ndr, "user_name", r->user_name);
2623         ndr->depth++;
2624         if (r->user_name) {
2625                 ndr_print_string(ndr, "user_name", r->user_name);
2626         }
2627         ndr->depth--;
2628         ndr_print_ptr(ndr, "document_name", r->document_name);
2629         ndr->depth++;
2630         if (r->document_name) {
2631                 ndr_print_string(ndr, "document_name", r->document_name);
2632         }
2633         ndr->depth--;
2634         ndr_print_ptr(ndr, "data_type", r->data_type);
2635         ndr->depth++;
2636         if (r->data_type) {
2637                 ndr_print_string(ndr, "data_type", r->data_type);
2638         }
2639         ndr->depth--;
2640         ndr_print_ptr(ndr, "text_status", r->text_status);
2641         ndr->depth++;
2642         if (r->text_status) {
2643                 ndr_print_string(ndr, "text_status", r->text_status);
2644         }
2645         ndr->depth--;
2646         ndr_print_uint32(ndr, "status", r->status);
2647         ndr_print_uint32(ndr, "priority", r->priority);
2648         ndr_print_uint32(ndr, "position", r->position);
2649         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2650         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2651         ndr_print_spoolss_Time(ndr, "time", &r->time);
2652         ndr->depth--;
2653 }
2654
2655 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
2656 {
2657         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2658         if (ndr_flags & NDR_SCALARS) {
2659                 int level = ndr_push_get_switch_value(ndr, r);
2660                 switch (level) {
2661                         case 1: {
2662                                 NDR_CHECK(ndr_push_align(ndr, 4));
2663                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2664                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2665                         break; }
2666
2667                         case 2: {
2668                         break; }
2669
2670                         case 3: {
2671                         break; }
2672
2673                         default: {
2674                         break; }
2675
2676                 }
2677         }
2678         if (ndr_flags & NDR_BUFFERS) {
2679                 int level = ndr_push_get_switch_value(ndr, r);
2680                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2681                 switch (level) {
2682                         case 1:
2683                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2684                         break;
2685
2686                         case 2:
2687                         break;
2688
2689                         case 3:
2690                         break;
2691
2692                         default:
2693                         break;
2694
2695                 }
2696         }
2697         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2698         return NDR_ERR_SUCCESS;
2699 }
2700
2701 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
2702 {
2703         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2704         int level;
2705         level = ndr_pull_get_switch_value(ndr, r);
2706         if (ndr_flags & NDR_SCALARS) {
2707                 switch (level) {
2708                         case 1: {
2709                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2710                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2711                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
2712                         break; }
2713
2714                         case 2: {
2715                         break; }
2716
2717                         case 3: {
2718                         break; }
2719
2720                         default: {
2721                         break; }
2722
2723                 }
2724         }
2725         if (ndr_flags & NDR_BUFFERS) {
2726                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2727                 switch (level) {
2728                         case 1:
2729                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
2730                         break;
2731
2732                         case 2:
2733                         break;
2734
2735                         case 3:
2736                         break;
2737
2738                         default:
2739                         break;
2740
2741                 }
2742         }
2743         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2744         return NDR_ERR_SUCCESS;
2745 }
2746
2747 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
2748 {
2749         int level;
2750         level = ndr_print_get_switch_value(ndr, r);
2751         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
2752         switch (level) {
2753                 case 1:
2754                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
2755                 break;
2756
2757                 case 2:
2758                 break;
2759
2760                 case 3:
2761                 break;
2762
2763                 default:
2764                 break;
2765
2766         }
2767 }
2768
2769 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
2770 {
2771         if (ndr_flags & NDR_SCALARS) {
2772                 NDR_CHECK(ndr_push_align(ndr, 4));
2773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
2774                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
2775                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2776         }
2777         if (ndr_flags & NDR_BUFFERS) {
2778                 NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2779         }
2780         return NDR_ERR_SUCCESS;
2781 }
2782
2783 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
2784 {
2785         if (ndr_flags & NDR_SCALARS) {
2786                 NDR_CHECK(ndr_pull_align(ndr, 4));
2787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
2788                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
2789                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->info));
2790         }
2791         if (ndr_flags & NDR_BUFFERS) {
2792                 NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->info));
2793         }
2794         return NDR_ERR_SUCCESS;
2795 }
2796
2797 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
2798 {
2799         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
2800         ndr->depth++;
2801         ndr_print_uint32(ndr, "level", r->level);
2802         ndr_print_set_switch_value(ndr, &r->info, r->level);
2803         ndr_print_spoolss_JobInfo(ndr, "info", &r->info);
2804         ndr->depth--;
2805 }
2806
2807 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
2808 {
2809         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2810         return NDR_ERR_SUCCESS;
2811 }
2812
2813 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
2814 {
2815         uint32_t v;
2816         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2817         *r = v;
2818         return NDR_ERR_SUCCESS;
2819 }
2820
2821 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
2822 {
2823         const char *val = NULL;
2824
2825         switch (r) {
2826                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
2827                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
2828                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
2829                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
2830                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
2831                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
2832                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
2833         }
2834         ndr_print_enum(ndr, name, "ENUM", val, r);
2835 }
2836
2837 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
2838 {
2839         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2840         return NDR_ERR_SUCCESS;
2841 }
2842
2843 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
2844 {
2845         uint32_t v;
2846         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2847         *r = v;
2848         return NDR_ERR_SUCCESS;
2849 }
2850
2851 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
2852 {
2853         const char *val = NULL;
2854
2855         switch (r) {
2856                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
2857                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
2858                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
2859                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
2860                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
2861         }
2862         ndr_print_enum(ndr, name, "ENUM", val, r);
2863 }
2864
2865 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
2866 {
2867         if (ndr_flags & NDR_SCALARS) {
2868                 int level = ndr_push_get_switch_value(ndr, r);
2869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
2870                 switch (level) {
2871                         case 0: {
2872                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
2873                         break; }
2874
2875                         case 1: {
2876                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
2877                         break; }
2878
2879                         case 2: {
2880                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
2881                         break; }
2882
2883                         case 3: {
2884                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
2885                         break; }
2886
2887                         case 4: {
2888                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
2889                         break; }
2890
2891                         case 5: {
2892                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
2893                         break; }
2894
2895                         case 6: {
2896                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
2897                         break; }
2898
2899                         case 7: {
2900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
2901                         break; }
2902
2903                         case 8: {
2904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
2905                         break; }
2906
2907                         case 9: {
2908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
2909                         break; }
2910
2911                         default: {
2912                         break; }
2913
2914                 }
2915         }
2916         if (ndr_flags & NDR_BUFFERS) {
2917                 int level = ndr_push_get_switch_value(ndr, r);
2918                 switch (level) {
2919                         case 0:
2920                                 if (r->info0) {
2921                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
2922                                 }
2923                         break;
2924
2925                         case 1:
2926                                 if (r->info1) {
2927                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
2928                                 }
2929                         break;
2930
2931                         case 2:
2932                                 if (r->info2) {
2933                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
2934                                 }
2935                         break;
2936
2937                         case 3:
2938                                 if (r->info3) {
2939                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
2940                                 }
2941                         break;
2942
2943                         case 4:
2944                                 if (r->info4) {
2945                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
2946                                 }
2947                         break;
2948
2949                         case 5:
2950                                 if (r->info5) {
2951                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
2952                                 }
2953                         break;
2954
2955                         case 6:
2956                                 if (r->info6) {
2957                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, r->info6));
2958                                 }
2959                         break;
2960
2961                         case 7:
2962                                 if (r->info7) {
2963                                         NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
2964                                 }
2965                         break;
2966
2967                         case 8:
2968                                 if (r->info8) {
2969                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
2970                                 }
2971                         break;
2972
2973                         case 9:
2974                                 if (r->info9) {
2975                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
2976                                 }
2977                         break;
2978
2979                         default:
2980                         break;
2981
2982                 }
2983         }
2984         return NDR_ERR_SUCCESS;
2985 }
2986
2987 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
2988 {
2989         int level;
2990         uint32_t _level;
2991         TALLOC_CTX *_mem_save_info0_0;
2992         TALLOC_CTX *_mem_save_info1_0;
2993         TALLOC_CTX *_mem_save_info2_0;
2994         TALLOC_CTX *_mem_save_info3_0;
2995         TALLOC_CTX *_mem_save_info4_0;
2996         TALLOC_CTX *_mem_save_info5_0;
2997         TALLOC_CTX *_mem_save_info6_0;
2998         TALLOC_CTX *_mem_save_info7_0;
2999         TALLOC_CTX *_mem_save_info8_0;
3000         TALLOC_CTX *_mem_save_info9_0;
3001         level = ndr_pull_get_switch_value(ndr, r);
3002         if (ndr_flags & NDR_SCALARS) {
3003                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
3004                 if (_level != level) {
3005                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
3006                 }
3007                 switch (level) {
3008                         case 0: {
3009                                 uint32_t _ptr_info0;
3010                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
3011                                 if (_ptr_info0) {
3012                                         NDR_PULL_ALLOC(ndr, r->info0);
3013                                 } else {
3014                                         r->info0 = NULL;
3015                                 }
3016                         break; }
3017
3018                         case 1: {
3019                                 uint32_t _ptr_info1;
3020                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
3021                                 if (_ptr_info1) {
3022                                         NDR_PULL_ALLOC(ndr, r->info1);
3023                                 } else {
3024                                         r->info1 = NULL;
3025                                 }
3026                         break; }
3027
3028                         case 2: {
3029                                 uint32_t _ptr_info2;
3030                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
3031                                 if (_ptr_info2) {
3032                                         NDR_PULL_ALLOC(ndr, r->info2);
3033                                 } else {
3034                                         r->info2 = NULL;
3035                                 }
3036                         break; }
3037
3038                         case 3: {
3039                                 uint32_t _ptr_info3;
3040                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
3041                                 if (_ptr_info3) {
3042                                         NDR_PULL_ALLOC(ndr, r->info3);
3043                                 } else {
3044                                         r->info3 = NULL;
3045                                 }
3046                         break; }
3047
3048                         case 4: {
3049                                 uint32_t _ptr_info4;
3050                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
3051                                 if (_ptr_info4) {
3052                                         NDR_PULL_ALLOC(ndr, r->info4);
3053                                 } else {
3054                                         r->info4 = NULL;
3055                                 }
3056                         break; }
3057
3058                         case 5: {
3059                                 uint32_t _ptr_info5;
3060                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
3061                                 if (_ptr_info5) {
3062                                         NDR_PULL_ALLOC(ndr, r->info5);
3063                                 } else {
3064                                         r->info5 = NULL;
3065                                 }
3066                         break; }
3067
3068                         case 6: {
3069                                 uint32_t _ptr_info6;
3070                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
3071                                 if (_ptr_info6) {
3072                                         NDR_PULL_ALLOC(ndr, r->info6);
3073                                 } else {
3074                                         r->info6 = NULL;
3075                                 }
3076                         break; }
3077
3078                         case 7: {
3079                                 uint32_t _ptr_info7;
3080                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
3081                                 if (_ptr_info7) {
3082                                         NDR_PULL_ALLOC(ndr, r->info7);
3083                                 } else {
3084                                         r->info7 = NULL;
3085                                 }
3086                         break; }
3087
3088                         case 8: {
3089                                 uint32_t _ptr_info8;
3090                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
3091                                 if (_ptr_info8) {
3092                                         NDR_PULL_ALLOC(ndr, r->info8);
3093                                 } else {
3094                                         r->info8 = NULL;
3095                                 }
3096                         break; }
3097
3098                         case 9: {
3099                                 uint32_t _ptr_info9;
3100                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
3101                                 if (_ptr_info9) {
3102                                         NDR_PULL_ALLOC(ndr, r->info9);
3103                                 } else {
3104                                         r->info9 = NULL;
3105                                 }
3106                         break; }
3107
3108                         default: {
3109                         break; }
3110
3111                 }
3112         }
3113         if (ndr_flags & NDR_BUFFERS) {
3114                 switch (level) {
3115                         case 0:
3116                                 if (r->info0) {
3117                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
3118                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
3119                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
3120                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
3121                                 }
3122                         break;
3123
3124                         case 1:
3125                                 if (r->info1) {
3126                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
3127                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
3128                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
3129                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
3130                                 }
3131                         break;
3132
3133                         case 2:
3134                                 if (r->info2) {
3135                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
3136                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
3137                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
3138                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
3139                                 }
3140                         break;
3141
3142                         case 3:
3143                                 if (r->info3) {
3144                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
3145                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
3146                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
3147                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
3148                                 }
3149                         break;
3150
3151                         case 4:
3152                                 if (r->info4) {
3153                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
3154                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
3155                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
3156                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
3157                                 }
3158                         break;
3159
3160                         case 5:
3161                                 if (r->info5) {
3162                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
3163                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
3164                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
3165                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
3166                                 }
3167                         break;
3168
3169                         case 6:
3170                                 if (r->info6) {
3171                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
3172                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
3173                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, r->info6));
3174                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
3175                                 }
3176                         break;
3177
3178                         case 7:
3179                                 if (r->info7) {
3180                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
3181                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
3182                                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
3183                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
3184                                 }
3185                         break;
3186
3187                         case 8:
3188                                 if (r->info8) {
3189                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
3190                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
3191                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
3192                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
3193                                 }
3194                         break;
3195
3196                         case 9:
3197                                 if (r->info9) {
3198                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
3199                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
3200                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
3201                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
3202                                 }
3203                         break;
3204
3205                         default:
3206                         break;
3207
3208                 }
3209         }
3210         return NDR_ERR_SUCCESS;
3211 }
3212
3213 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
3214 {
3215         int level;
3216         level = ndr_print_get_switch_value(ndr, r);
3217         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
3218         switch (level) {
3219                 case 0:
3220                         ndr_print_ptr(ndr, "info0", r->info0);
3221                         ndr->depth++;
3222                         if (r->info0) {
3223                                 ndr_print_spoolss_PrinterInfo0(ndr, "info0", r->info0);
3224                         }
3225                         ndr->depth--;
3226                 break;
3227
3228                 case 1:
3229                         ndr_print_ptr(ndr, "info1", r->info1);
3230                         ndr->depth++;
3231                         if (r->info1) {
3232                                 ndr_print_spoolss_PrinterInfo1(ndr, "info1", r->info1);
3233                         }
3234                         ndr->depth--;
3235                 break;
3236
3237                 case 2:
3238                         ndr_print_ptr(ndr, "info2", r->info2);
3239                         ndr->depth++;
3240                         if (r->info2) {
3241                                 ndr_print_spoolss_PrinterInfo2(ndr, "info2", r->info2);
3242                         }
3243                         ndr->depth--;
3244                 break;
3245
3246                 case 3:
3247                         ndr_print_ptr(ndr, "info3", r->info3);
3248                         ndr->depth++;
3249                         if (r->info3) {
3250                                 ndr_print_spoolss_PrinterInfo3(ndr, "info3", r->info3);
3251                         }
3252                         ndr->depth--;
3253                 break;
3254
3255                 case 4:
3256                         ndr_print_ptr(ndr, "info4", r->info4);
3257                         ndr->depth++;
3258                         if (r->info4) {
3259                                 ndr_print_spoolss_PrinterInfo4(ndr, "info4", r->info4);
3260                         }
3261                         ndr->depth--;
3262                 break;
3263
3264                 case 5:
3265                         ndr_print_ptr(ndr, "info5", r->info5);
3266                         ndr->depth++;
3267                         if (r->info5) {
3268                                 ndr_print_spoolss_PrinterInfo5(ndr, "info5", r->info5);
3269                         }
3270                         ndr->depth--;
3271                 break;
3272
3273                 case 6:
3274                         ndr_print_ptr(ndr, "info6", r->info6);
3275                         ndr->depth++;
3276                         if (r->info6) {
3277                                 ndr_print_spoolss_PrinterInfo6(ndr, "info6", r->info6);
3278                         }
3279                         ndr->depth--;
3280                 break;
3281
3282                 case 7:
3283                         ndr_print_ptr(ndr, "info7", r->info7);
3284                         ndr->depth++;
3285                         if (r->info7) {
3286                                 ndr_print_spoolss_PrinterInfo7(ndr, "info7", r->info7);
3287                         }
3288                         ndr->depth--;
3289                 break;
3290
3291                 case 8:
3292                         ndr_print_ptr(ndr, "info8", r->info8);
3293                         ndr->depth++;
3294                         if (r->info8) {
3295                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
3296                         }
3297                         ndr->depth--;
3298                 break;
3299
3300                 case 9:
3301                         ndr_print_ptr(ndr, "info9", r->info9);
3302                         ndr->depth++;
3303                         if (r->info9) {
3304                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
3305                         }
3306                         ndr->depth--;
3307                 break;
3308
3309                 default:
3310                 break;
3311
3312         }
3313 }
3314
3315 static enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
3316 {
3317         if (ndr_flags & NDR_SCALARS) {
3318                 NDR_CHECK(ndr_push_align(ndr, 4));
3319                 {
3320                         uint32_t _flags_save_string = ndr->flags;
3321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3322                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3323                         ndr->flags = _flags_save_string;
3324                 }
3325         }
3326         if (ndr_flags & NDR_BUFFERS) {
3327                 {
3328                         uint32_t _flags_save_string = ndr->flags;
3329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3330                         if (r->driver_name) {
3331                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3332                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3333                         }
3334                         ndr->flags = _flags_save_string;
3335                 }
3336         }
3337         return NDR_ERR_SUCCESS;
3338 }
3339
3340 static enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
3341 {
3342         uint32_t _ptr_driver_name;
3343         TALLOC_CTX *_mem_save_driver_name_0;
3344         if (ndr_flags & NDR_SCALARS) {
3345                 NDR_CHECK(ndr_pull_align(ndr, 4));
3346                 {
3347                         uint32_t _flags_save_string = ndr->flags;
3348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3349                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3350                         if (_ptr_driver_name) {
3351                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3352                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3353                         } else {
3354                                 r->driver_name = NULL;
3355                         }
3356                         ndr->flags = _flags_save_string;
3357                 }
3358         }
3359         if (ndr_flags & NDR_BUFFERS) {
3360                 {
3361                         uint32_t _flags_save_string = ndr->flags;
3362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3363                         if (r->driver_name) {
3364                                 uint32_t _relative_save_offset;
3365                                 _relative_save_offset = ndr->offset;
3366                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3367                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3368                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3369                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3370                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3371                                 ndr->offset = _relative_save_offset;
3372                         }
3373                         ndr->flags = _flags_save_string;
3374                 }
3375         }
3376         return NDR_ERR_SUCCESS;
3377 }
3378
3379 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
3380 {
3381         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
3382         ndr->depth++;
3383         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3384         ndr->depth++;
3385         if (r->driver_name) {
3386                 ndr_print_string(ndr, "driver_name", r->driver_name);
3387         }
3388         ndr->depth--;
3389         ndr->depth--;
3390 }
3391
3392 static enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
3393 {
3394         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
3395         return NDR_ERR_SUCCESS;
3396 }
3397
3398 static enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
3399 {
3400         uint32_t v;
3401         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
3402         *r = v;
3403         return NDR_ERR_SUCCESS;
3404 }
3405
3406 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
3407 {
3408         const char *val = NULL;
3409
3410         switch (r) {
3411                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
3412                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
3413                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
3414                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
3415         }
3416         ndr_print_enum(ndr, name, "ENUM", val, r);
3417 }
3418
3419 static enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
3420 {
3421         if (ndr_flags & NDR_SCALARS) {
3422                 NDR_CHECK(ndr_push_align(ndr, 4));
3423                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
3424                 {
3425                         uint32_t _flags_save_string = ndr->flags;
3426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3427                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3428                         ndr->flags = _flags_save_string;
3429                 }
3430                 {
3431                         uint32_t _flags_save_string = ndr->flags;
3432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3433                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
3434                         ndr->flags = _flags_save_string;
3435                 }
3436                 {
3437                         uint32_t _flags_save_string = ndr->flags;
3438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3439                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
3440                         ndr->flags = _flags_save_string;
3441                 }
3442                 {
3443                         uint32_t _flags_save_string = ndr->flags;
3444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3445                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
3446                         ndr->flags = _flags_save_string;
3447                 }
3448                 {
3449                         uint32_t _flags_save_string = ndr->flags;
3450                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3451                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
3452                         ndr->flags = _flags_save_string;
3453                 }
3454         }
3455         if (ndr_flags & NDR_BUFFERS) {
3456                 {
3457                         uint32_t _flags_save_string = ndr->flags;
3458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3459                         if (r->driver_name) {
3460                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3461                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3462                         }
3463                         ndr->flags = _flags_save_string;
3464                 }
3465                 {
3466                         uint32_t _flags_save_string = ndr->flags;
3467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3468                         if (r->architecture) {
3469                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
3470                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
3471                         }
3472                         ndr->flags = _flags_save_string;
3473                 }
3474                 {
3475                         uint32_t _flags_save_string = ndr->flags;
3476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3477                         if (r->driver_path) {
3478                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
3479                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
3480                         }
3481                         ndr->flags = _flags_save_string;
3482                 }
3483                 {
3484                         uint32_t _flags_save_string = ndr->flags;
3485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3486                         if (r->data_file) {
3487                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
3488                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
3489                         }
3490                         ndr->flags = _flags_save_string;
3491                 }
3492                 {
3493                         uint32_t _flags_save_string = ndr->flags;
3494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3495                         if (r->config_file) {
3496                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
3497                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
3498                         }
3499                         ndr->flags = _flags_save_string;
3500                 }
3501         }
3502         return NDR_ERR_SUCCESS;
3503 }
3504
3505 static enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
3506 {
3507         uint32_t _ptr_driver_name;
3508         TALLOC_CTX *_mem_save_driver_name_0;
3509         uint32_t _ptr_architecture;
3510         TALLOC_CTX *_mem_save_architecture_0;
3511         uint32_t _ptr_driver_path;
3512         TALLOC_CTX *_mem_save_driver_path_0;
3513         uint32_t _ptr_data_file;
3514         TALLOC_CTX *_mem_save_data_file_0;
3515         uint32_t _ptr_config_file;
3516         TALLOC_CTX *_mem_save_config_file_0;
3517         if (ndr_flags & NDR_SCALARS) {
3518                 NDR_CHECK(ndr_pull_align(ndr, 4));
3519                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
3520                 {
3521                         uint32_t _flags_save_string = ndr->flags;
3522                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3523                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3524                         if (_ptr_driver_name) {
3525                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3526                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3527                         } else {
3528                                 r->driver_name = NULL;
3529                         }
3530                         ndr->flags = _flags_save_string;
3531                 }
3532                 {
3533                         uint32_t _flags_save_string = ndr->flags;
3534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3535                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
3536                         if (_ptr_architecture) {
3537                                 NDR_PULL_ALLOC(ndr, r->architecture);
3538                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
3539                         } else {
3540                                 r->architecture = NULL;
3541                         }
3542                         ndr->flags = _flags_save_string;
3543                 }
3544                 {
3545                         uint32_t _flags_save_string = ndr->flags;
3546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3547                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
3548                         if (_ptr_driver_path) {
3549                                 NDR_PULL_ALLOC(ndr, r->driver_path);
3550                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
3551                         } else {
3552                                 r->driver_path = NULL;
3553                         }
3554                         ndr->flags = _flags_save_string;
3555                 }
3556                 {
3557                         uint32_t _flags_save_string = ndr->flags;
3558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
3560                         if (_ptr_data_file) {
3561                                 NDR_PULL_ALLOC(ndr, r->data_file);
3562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
3563                         } else {
3564                                 r->data_file = NULL;
3565                         }
3566                         ndr->flags = _flags_save_string;
3567                 }
3568                 {
3569                         uint32_t _flags_save_string = ndr->flags;
3570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
3572                         if (_ptr_config_file) {
3573                                 NDR_PULL_ALLOC(ndr, r->config_file);
3574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
3575                         } else {
3576                                 r->config_file = NULL;
3577                         }
3578                         ndr->flags = _flags_save_string;
3579                 }
3580         }
3581         if (ndr_flags & NDR_BUFFERS) {
3582                 {
3583                         uint32_t _flags_save_string = ndr->flags;
3584                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3585                         if (r->driver_name) {
3586                                 uint32_t _relative_save_offset;
3587                                 _relative_save_offset = ndr->offset;
3588                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3589                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3590                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3591                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3592                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3593                                 ndr->offset = _relative_save_offset;
3594                         }
3595                         ndr->flags = _flags_save_string;
3596                 }
3597                 {
3598                         uint32_t _flags_save_string = ndr->flags;
3599                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3600                         if (r->architecture) {
3601                                 uint32_t _relative_save_offset;
3602                                 _relative_save_offset = ndr->offset;
3603                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
3604                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
3605                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
3606                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
3607                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
3608                                 ndr->offset = _relative_save_offset;
3609                         }
3610                         ndr->flags = _flags_save_string;
3611                 }
3612                 {
3613                         uint32_t _flags_save_string = ndr->flags;
3614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3615                         if (r->driver_path) {
3616                                 uint32_t _relative_save_offset;
3617                                 _relative_save_offset = ndr->offset;
3618                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
3619                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
3620                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
3621                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
3622                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
3623                                 ndr->offset = _relative_save_offset;
3624                         }
3625                         ndr->flags = _flags_save_string;
3626                 }
3627                 {
3628                         uint32_t _flags_save_string = ndr->flags;
3629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3630                         if (r->data_file) {
3631                                 uint32_t _relative_save_offset;
3632                                 _relative_save_offset = ndr->offset;
3633                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
3634                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
3635                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
3636                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
3637                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
3638                                 ndr->offset = _relative_save_offset;
3639                         }
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 {
3643                         uint32_t _flags_save_string = ndr->flags;
3644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3645                         if (r->config_file) {
3646                                 uint32_t _relative_save_offset;
3647                                 _relative_save_offset = ndr->offset;
3648                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
3649                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
3650                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
3651                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
3652                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
3653                                 ndr->offset = _relative_save_offset;
3654                         }
3655                         ndr->flags = _flags_save_string;
3656                 }
3657         }
3658         return NDR_ERR_SUCCESS;
3659 }
3660
3661 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
3662 {
3663         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
3664         ndr->depth++;
3665         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
3666         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3667         ndr->depth++;
3668         if (r->driver_name) {
3669                 ndr_print_string(ndr, "driver_name", r->driver_name);
3670         }
3671         ndr->depth--;
3672         ndr_print_ptr(ndr, "architecture", r->architecture);
3673         ndr->depth++;
3674         if (r->architecture) {
3675                 ndr_print_string(ndr, "architecture", r->architecture);
3676         }
3677         ndr->depth--;
3678         ndr_print_ptr(ndr, "driver_path", r->driver_path);
3679         ndr->depth++;
3680         if (r->driver_path) {
3681                 ndr_print_string(ndr, "driver_path", r->driver_path);
3682         }
3683         ndr->depth--;
3684         ndr_print_ptr(ndr, "data_file", r->data_file);
3685         ndr->depth++;
3686         if (r->data_file) {
3687                 ndr_print_string(ndr, "data_file", r->data_file);
3688         }
3689         ndr->depth--;
3690         ndr_print_ptr(ndr, "config_file", r->config_file);
3691         ndr->depth++;
3692         if (r->config_file) {
3693                 ndr_print_string(ndr, "config_file", r->config_file);
3694         }
3695         ndr->depth--;
3696         ndr->depth--;
3697 }
3698
3699 static enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
3700 {
3701         if (ndr_flags & NDR_SCALARS) {
3702                 NDR_CHECK(ndr_push_align(ndr, 4));
3703                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
3704                 {
3705                         uint32_t _flags_save_string = ndr->flags;
3706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3707                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3708                         ndr->flags = _flags_save_string;
3709                 }
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
3714                         ndr->flags = _flags_save_string;
3715                 }
3716                 {
3717                         uint32_t _flags_save_string = ndr->flags;
3718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3719                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
3720                         ndr->flags = _flags_save_string;
3721                 }
3722                 {
3723                         uint32_t _flags_save_string = ndr->flags;
3724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3725                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
3726                         ndr->flags = _flags_save_string;
3727                 }
3728                 {
3729                         uint32_t _flags_save_string = ndr->flags;
3730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3731                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
3732                         ndr->flags = _flags_save_string;
3733                 }
3734                 {
3735                         uint32_t _flags_save_string = ndr->flags;
3736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3737                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
3738                         ndr->flags = _flags_save_string;
3739                 }
3740                 {
3741                         uint32_t _flags_save_string_array = ndr->flags;
3742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3743                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
3744                         ndr->flags = _flags_save_string_array;
3745                 }
3746                 {
3747                         uint32_t _flags_save_string = ndr->flags;
3748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
3750                         ndr->flags = _flags_save_string;
3751                 }
3752                 {
3753                         uint32_t _flags_save_string = ndr->flags;
3754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3755                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
3756                         ndr->flags = _flags_save_string;
3757                 }
3758         }
3759         if (ndr_flags & NDR_BUFFERS) {
3760                 {
3761                         uint32_t _flags_save_string = ndr->flags;
3762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3763                         if (r->driver_name) {
3764                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3765                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3766                         }
3767                         ndr->flags = _flags_save_string;
3768                 }
3769                 {
3770                         uint32_t _flags_save_string = ndr->flags;
3771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3772                         if (r->architecture) {
3773                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
3774                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
3775                         }
3776                         ndr->flags = _flags_save_string;
3777                 }
3778                 {
3779                         uint32_t _flags_save_string = ndr->flags;
3780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3781                         if (r->driver_path) {
3782                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
3783                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
3784                         }
3785                         ndr->flags = _flags_save_string;
3786                 }
3787                 {
3788                         uint32_t _flags_save_string = ndr->flags;
3789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3790                         if (r->data_file) {
3791                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
3792                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
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                         if (r->config_file) {
3800                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
3801                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
3802                         }
3803                         ndr->flags = _flags_save_string;
3804                 }
3805                 {
3806                         uint32_t _flags_save_string = ndr->flags;
3807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3808                         if (r->help_file) {
3809                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
3810                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
3811                         }
3812                         ndr->flags = _flags_save_string;
3813                 }
3814                 {
3815                         uint32_t _flags_save_string_array = ndr->flags;
3816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3817                         if (r->dependent_files) {
3818                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
3819                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
3820                         }
3821                         ndr->flags = _flags_save_string_array;
3822                 }
3823                 {
3824                         uint32_t _flags_save_string = ndr->flags;
3825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3826                         if (r->monitor_name) {
3827                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
3828                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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                         if (r->default_datatype) {
3836                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
3837                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
3838                         }
3839                         ndr->flags = _flags_save_string;
3840                 }
3841         }
3842         return NDR_ERR_SUCCESS;
3843 }
3844
3845 static enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
3846 {
3847         uint32_t _ptr_driver_name;
3848         TALLOC_CTX *_mem_save_driver_name_0;
3849         uint32_t _ptr_architecture;
3850         TALLOC_CTX *_mem_save_architecture_0;
3851         uint32_t _ptr_driver_path;
3852         TALLOC_CTX *_mem_save_driver_path_0;
3853         uint32_t _ptr_data_file;
3854         TALLOC_CTX *_mem_save_data_file_0;
3855         uint32_t _ptr_config_file;
3856         TALLOC_CTX *_mem_save_config_file_0;
3857         uint32_t _ptr_help_file;
3858         TALLOC_CTX *_mem_save_help_file_0;
3859         uint32_t _ptr_dependent_files;
3860         TALLOC_CTX *_mem_save_dependent_files_0;
3861         uint32_t _ptr_monitor_name;
3862         TALLOC_CTX *_mem_save_monitor_name_0;
3863         uint32_t _ptr_default_datatype;
3864         TALLOC_CTX *_mem_save_default_datatype_0;
3865         if (ndr_flags & NDR_SCALARS) {
3866                 NDR_CHECK(ndr_pull_align(ndr, 4));
3867                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
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                 {
3881                         uint32_t _flags_save_string = ndr->flags;
3882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3883                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
3884                         if (_ptr_architecture) {
3885                                 NDR_PULL_ALLOC(ndr, r->architecture);
3886                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
3887                         } else {
3888                                 r->architecture = NULL;
3889                         }
3890                         ndr->flags = _flags_save_string;
3891                 }
3892                 {
3893                         uint32_t _flags_save_string = ndr->flags;
3894                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3895                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
3896                         if (_ptr_driver_path) {
3897                                 NDR_PULL_ALLOC(ndr, r->driver_path);
3898                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
3899                         } else {
3900                                 r->driver_path = NULL;
3901                         }
3902                         ndr->flags = _flags_save_string;
3903                 }
3904                 {
3905                         uint32_t _flags_save_string = ndr->flags;
3906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
3908                         if (_ptr_data_file) {
3909                                 NDR_PULL_ALLOC(ndr, r->data_file);
3910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
3911                         } else {
3912                                 r->data_file = NULL;
3913                         }
3914                         ndr->flags = _flags_save_string;
3915                 }
3916                 {
3917                         uint32_t _flags_save_string = ndr->flags;
3918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
3920                         if (_ptr_config_file) {
3921                                 NDR_PULL_ALLOC(ndr, r->config_file);
3922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
3923                         } else {
3924                                 r->config_file = NULL;
3925                         }
3926                         ndr->flags = _flags_save_string;
3927                 }
3928                 {
3929                         uint32_t _flags_save_string = ndr->flags;
3930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3931                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
3932                         if (_ptr_help_file) {
3933                                 NDR_PULL_ALLOC(ndr, r->help_file);
3934                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
3935                         } else {
3936                                 r->help_file = NULL;
3937                         }
3938                         ndr->flags = _flags_save_string;
3939                 }
3940                 {
3941                         uint32_t _flags_save_string_array = ndr->flags;
3942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3943                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
3944                         if (_ptr_dependent_files) {
3945                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
3946                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
3947                         } else {
3948                                 r->dependent_files = NULL;
3949                         }
3950                         ndr->flags = _flags_save_string_array;
3951                 }
3952                 {
3953                         uint32_t _flags_save_string = ndr->flags;
3954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3955                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
3956                         if (_ptr_monitor_name) {
3957                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
3958                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
3959                         } else {
3960                                 r->monitor_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
3968                         if (_ptr_default_datatype) {
3969                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
3970                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
3971                         } else {
3972                                 r->default_datatype = NULL;
3973                         }
3974                         ndr->flags = _flags_save_string;
3975                 }
3976         }
3977         if (ndr_flags & NDR_BUFFERS) {
3978                 {
3979                         uint32_t _flags_save_string = ndr->flags;
3980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3981                         if (r->driver_name) {
3982                                 uint32_t _relative_save_offset;
3983                                 _relative_save_offset = ndr->offset;
3984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3985                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3986                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3989                                 ndr->offset = _relative_save_offset;
3990                         }
3991                         ndr->flags = _flags_save_string;
3992                 }
3993                 {
3994                         uint32_t _flags_save_string = ndr->flags;
3995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3996                         if (r->architecture) {
3997                                 uint32_t _relative_save_offset;
3998                                 _relative_save_offset = ndr->offset;
3999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
4000                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4001                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4002                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
4003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4004                                 ndr->offset = _relative_save_offset;
4005                         }
4006                         ndr->flags = _flags_save_string;
4007                 }
4008                 {
4009                         uint32_t _flags_save_string = ndr->flags;
4010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4011                         if (r->driver_path) {
4012                                 uint32_t _relative_save_offset;
4013                                 _relative_save_offset = ndr->offset;
4014                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
4015                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4016                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4017                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
4018                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4019                                 ndr->offset = _relative_save_offset;
4020                         }
4021                         ndr->flags = _flags_save_string;
4022                 }
4023                 {
4024                         uint32_t _flags_save_string = ndr->flags;
4025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4026                         if (r->data_file) {
4027                                 uint32_t _relative_save_offset;
4028                                 _relative_save_offset = ndr->offset;
4029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
4030                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4031                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
4033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4034                                 ndr->offset = _relative_save_offset;
4035                         }
4036                         ndr->flags = _flags_save_string;
4037                 }
4038                 {
4039                         uint32_t _flags_save_string = ndr->flags;
4040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4041                         if (r->config_file) {
4042                                 uint32_t _relative_save_offset;
4043                                 _relative_save_offset = ndr->offset;
4044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
4045                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4046                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4047                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
4048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4049                                 ndr->offset = _relative_save_offset;
4050                         }
4051                         ndr->flags = _flags_save_string;
4052                 }
4053                 {
4054                         uint32_t _flags_save_string = ndr->flags;
4055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4056                         if (r->help_file) {
4057                                 uint32_t _relative_save_offset;
4058                                 _relative_save_offset = ndr->offset;
4059                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
4060                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4061                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
4062                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
4063                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
4064                                 ndr->offset = _relative_save_offset;
4065                         }
4066                         ndr->flags = _flags_save_string;
4067                 }
4068                 {
4069                         uint32_t _flags_save_string_array = ndr->flags;
4070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4071                         if (r->dependent_files) {
4072                                 uint32_t _relative_save_offset;
4073                                 _relative_save_offset = ndr->offset;
4074                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
4075                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
4076                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
4077                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
4078                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
4079                                 ndr->offset = _relative_save_offset;
4080                         }
4081                         ndr->flags = _flags_save_string_array;
4082                 }
4083                 {
4084                         uint32_t _flags_save_string = ndr->flags;
4085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4086                         if (r->monitor_name) {
4087                                 uint32_t _relative_save_offset;
4088                                 _relative_save_offset = ndr->offset;
4089                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
4090                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4091                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
4092                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
4093                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
4094                                 ndr->offset = _relative_save_offset;
4095                         }
4096                         ndr->flags = _flags_save_string;
4097                 }
4098                 {
4099                         uint32_t _flags_save_string = ndr->flags;
4100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4101                         if (r->default_datatype) {
4102                                 uint32_t _relative_save_offset;
4103                                 _relative_save_offset = ndr->offset;
4104                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
4105                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
4106                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
4107                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
4108                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
4109                                 ndr->offset = _relative_save_offset;
4110                         }
4111                         ndr->flags = _flags_save_string;
4112                 }
4113         }
4114         return NDR_ERR_SUCCESS;
4115 }
4116
4117 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
4118 {
4119         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
4120         ndr->depth++;
4121         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4122         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4123         ndr->depth++;
4124         if (r->driver_name) {
4125                 ndr_print_string(ndr, "driver_name", r->driver_name);
4126         }
4127         ndr->depth--;
4128         ndr_print_ptr(ndr, "architecture", r->architecture);
4129         ndr->depth++;
4130         if (r->architecture) {
4131                 ndr_print_string(ndr, "architecture", r->architecture);
4132         }
4133         ndr->depth--;
4134         ndr_print_ptr(ndr, "driver_path", r->driver_path);
4135         ndr->depth++;
4136         if (r->driver_path) {
4137                 ndr_print_string(ndr, "driver_path", r->driver_path);
4138         }
4139         ndr->depth--;
4140         ndr_print_ptr(ndr, "data_file", r->data_file);
4141         ndr->depth++;
4142         if (r->data_file) {
4143                 ndr_print_string(ndr, "data_file", r->data_file);
4144         }
4145         ndr->depth--;
4146         ndr_print_ptr(ndr, "config_file", r->config_file);
4147         ndr->depth++;
4148         if (r->config_file) {
4149                 ndr_print_string(ndr, "config_file", r->config_file);
4150         }
4151         ndr->depth--;
4152         ndr_print_ptr(ndr, "help_file", r->help_file);
4153         ndr->depth++;
4154         if (r->help_file) {
4155                 ndr_print_string(ndr, "help_file", r->help_file);
4156         }
4157         ndr->depth--;
4158         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
4159         ndr->depth++;
4160         if (r->dependent_files) {
4161                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
4162         }
4163         ndr->depth--;
4164         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
4165         ndr->depth++;
4166         if (r->monitor_name) {
4167                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
4168         }
4169         ndr->depth--;
4170         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
4171         ndr->depth++;
4172         if (r->default_datatype) {
4173                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
4174         }
4175         ndr->depth--;
4176         ndr->depth--;
4177 }
4178
4179 static enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
4180 {
4181         if (ndr_flags & NDR_SCALARS) {
4182                 NDR_CHECK(ndr_push_align(ndr, 4));
4183                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4184                 {
4185                         uint32_t _flags_save_string = ndr->flags;
4186                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4187                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4188                         ndr->flags = _flags_save_string;
4189                 }
4190                 {
4191                         uint32_t _flags_save_string = ndr->flags;
4192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4193                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
4194                         ndr->flags = _flags_save_string;
4195                 }
4196                 {
4197                         uint32_t _flags_save_string = ndr->flags;
4198                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4199                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
4200                         ndr->flags = _flags_save_string;
4201                 }
4202                 {
4203                         uint32_t _flags_save_string = ndr->flags;
4204                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4205                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
4206                         ndr->flags = _flags_save_string;
4207                 }
4208                 {
4209                         uint32_t _flags_save_string = ndr->flags;
4210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4211                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
4212                         ndr->flags = _flags_save_string;
4213                 }
4214                 {
4215                         uint32_t _flags_save_string = ndr->flags;
4216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4217                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
4218                         ndr->flags = _flags_save_string;
4219                 }
4220                 {
4221                         uint32_t _flags_save_string_array = ndr->flags;
4222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
4224                         ndr->flags = _flags_save_string_array;
4225                 }
4226                 {
4227                         uint32_t _flags_save_string = ndr->flags;
4228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
4230                         ndr->flags = _flags_save_string;
4231                 }
4232                 {
4233                         uint32_t _flags_save_string = ndr->flags;
4234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
4236                         ndr->flags = _flags_save_string;
4237                 }
4238                 {
4239                         uint32_t _flags_save_string_array = ndr->flags;
4240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
4242                         ndr->flags = _flags_save_string_array;
4243                 }
4244         }
4245         if (ndr_flags & NDR_BUFFERS) {
4246                 {
4247                         uint32_t _flags_save_string = ndr->flags;
4248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4249                         if (r->driver_name) {
4250                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4251                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4252                         }
4253                         ndr->flags = _flags_save_string;
4254                 }
4255                 {
4256                         uint32_t _flags_save_string = ndr->flags;
4257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4258                         if (r->architecture) {
4259                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
4260                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
4261                         }
4262                         ndr->flags = _flags_save_string;
4263                 }
4264                 {
4265                         uint32_t _flags_save_string = ndr->flags;
4266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4267                         if (r->driver_path) {
4268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
4269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
4270                         }
4271                         ndr->flags = _flags_save_string;
4272                 }
4273                 {
4274                         uint32_t _flags_save_string = ndr->flags;
4275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4276                         if (r->data_file) {
4277                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
4278                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
4279                         }
4280                         ndr->flags = _flags_save_string;
4281                 }
4282                 {
4283                         uint32_t _flags_save_string = ndr->flags;
4284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4285                         if (r->config_file) {
4286                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
4287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
4288                         }
4289                         ndr->flags = _flags_save_string;
4290                 }
4291                 {
4292                         uint32_t _flags_save_string = ndr->flags;
4293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4294                         if (r->help_file) {
4295                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
4296                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
4297                         }
4298                         ndr->flags = _flags_save_string;
4299                 }
4300                 {
4301                         uint32_t _flags_save_string_array = ndr->flags;
4302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4303                         if (r->dependent_files) {
4304                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
4305                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
4306                         }
4307                         ndr->flags = _flags_save_string_array;
4308                 }
4309                 {
4310                         uint32_t _flags_save_string = ndr->flags;
4311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4312                         if (r->monitor_name) {
4313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
4314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
4315                         }
4316                         ndr->flags = _flags_save_string;
4317                 }
4318                 {
4319                         uint32_t _flags_save_string = ndr->flags;
4320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4321                         if (r->default_datatype) {
4322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
4323                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
4324                         }
4325                         ndr->flags = _flags_save_string;
4326                 }
4327                 {
4328                         uint32_t _flags_save_string_array = ndr->flags;
4329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4330                         if (r->previous_names) {
4331                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
4332                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
4333                         }
4334                         ndr->flags = _flags_save_string_array;
4335                 }
4336         }
4337         return NDR_ERR_SUCCESS;
4338 }
4339
4340 static enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
4341 {
4342         uint32_t _ptr_driver_name;
4343         TALLOC_CTX *_mem_save_driver_name_0;
4344         uint32_t _ptr_architecture;
4345         TALLOC_CTX *_mem_save_architecture_0;
4346         uint32_t _ptr_driver_path;
4347         TALLOC_CTX *_mem_save_driver_path_0;
4348         uint32_t _ptr_data_file;
4349         TALLOC_CTX *_mem_save_data_file_0;
4350         uint32_t _ptr_config_file;
4351         TALLOC_CTX *_mem_save_config_file_0;
4352         uint32_t _ptr_help_file;
4353         TALLOC_CTX *_mem_save_help_file_0;
4354         uint32_t _ptr_dependent_files;
4355         TALLOC_CTX *_mem_save_dependent_files_0;
4356         uint32_t _ptr_monitor_name;
4357         TALLOC_CTX *_mem_save_monitor_name_0;
4358         uint32_t _ptr_default_datatype;
4359         TALLOC_CTX *_mem_save_default_datatype_0;
4360         uint32_t _ptr_previous_names;
4361         TALLOC_CTX *_mem_save_previous_names_0;
4362         if (ndr_flags & NDR_SCALARS) {
4363                 NDR_CHECK(ndr_pull_align(ndr, 4));
4364                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4365                 {
4366                         uint32_t _flags_save_string = ndr->flags;
4367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4368                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4369                         if (_ptr_driver_name) {
4370                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4371                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4372                         } else {
4373                                 r->driver_name = NULL;
4374                         }
4375                         ndr->flags = _flags_save_string;
4376                 }
4377                 {
4378                         uint32_t _flags_save_string = ndr->flags;
4379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4380                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4381                         if (_ptr_architecture) {
4382                                 NDR_PULL_ALLOC(ndr, r->architecture);
4383                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
4384                         } else {
4385                                 r->architecture = NULL;
4386                         }
4387                         ndr->flags = _flags_save_string;
4388                 }
4389                 {
4390                         uint32_t _flags_save_string = ndr->flags;
4391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4392                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4393                         if (_ptr_driver_path) {
4394                                 NDR_PULL_ALLOC(ndr, r->driver_path);
4395                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
4396                         } else {
4397                                 r->driver_path = NULL;
4398                         }
4399                         ndr->flags = _flags_save_string;
4400                 }
4401                 {
4402                         uint32_t _flags_save_string = ndr->flags;
4403                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4404                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4405                         if (_ptr_data_file) {
4406                                 NDR_PULL_ALLOC(ndr, r->data_file);
4407                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
4408                         } else {
4409                                 r->data_file = NULL;
4410                         }
4411                         ndr->flags = _flags_save_string;
4412                 }
4413                 {
4414                         uint32_t _flags_save_string = ndr->flags;
4415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4416                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4417                         if (_ptr_config_file) {
4418                                 NDR_PULL_ALLOC(ndr, r->config_file);
4419                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
4420                         } else {
4421                                 r->config_file = NULL;
4422                         }
4423                         ndr->flags = _flags_save_string;
4424                 }
4425                 {
4426                         uint32_t _flags_save_string = ndr->flags;
4427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4428                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
4429                         if (_ptr_help_file) {
4430                                 NDR_PULL_ALLOC(ndr, r->help_file);
4431                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
4432                         } else {
4433                                 r->help_file = NULL;
4434                         }
4435                         ndr->flags = _flags_save_string;
4436                 }
4437                 {
4438                         uint32_t _flags_save_string_array = ndr->flags;
4439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4440                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
4441                         if (_ptr_dependent_files) {
4442                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
4443                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
4444                         } else {
4445                                 r->dependent_files = NULL;
4446                         }
4447                         ndr->flags = _flags_save_string_array;
4448                 }
4449                 {
4450                         uint32_t _flags_save_string = ndr->flags;
4451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4452                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
4453                         if (_ptr_monitor_name) {
4454                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
4455                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
4456                         } else {
4457                                 r->monitor_name = NULL;
4458                         }
4459                         ndr->flags = _flags_save_string;
4460                 }
4461                 {
4462                         uint32_t _flags_save_string = ndr->flags;
4463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4464                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
4465                         if (_ptr_default_datatype) {
4466                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
4467                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
4468                         } else {
4469                                 r->default_datatype = NULL;
4470                         }
4471                         ndr->flags = _flags_save_string;
4472                 }
4473                 {
4474                         uint32_t _flags_save_string_array = ndr->flags;
4475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4476                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
4477                         if (_ptr_previous_names) {
4478                                 NDR_PULL_ALLOC(ndr, r->previous_names);
4479                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
4480                         } else {
4481                                 r->previous_names = NULL;
4482                         }
4483                         ndr->flags = _flags_save_string_array;
4484                 }
4485         }
4486         if (ndr_flags & NDR_BUFFERS) {
4487                 {
4488                         uint32_t _flags_save_string = ndr->flags;
4489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4490                         if (r->driver_name) {
4491                                 uint32_t _relative_save_offset;
4492                                 _relative_save_offset = ndr->offset;
4493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4494                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4495                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4498                                 ndr->offset = _relative_save_offset;
4499                         }
4500                         ndr->flags = _flags_save_string;
4501                 }
4502                 {
4503                         uint32_t _flags_save_string = ndr->flags;
4504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4505                         if (r->architecture) {
4506                                 uint32_t _relative_save_offset;
4507                                 _relative_save_offset = ndr->offset;
4508                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
4509                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4510                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4511                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
4512                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4513                                 ndr->offset = _relative_save_offset;
4514                         }
4515                         ndr->flags = _flags_save_string;
4516                 }
4517                 {
4518                         uint32_t _flags_save_string = ndr->flags;
4519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4520                         if (r->driver_path) {
4521                                 uint32_t _relative_save_offset;
4522                                 _relative_save_offset = ndr->offset;
4523                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
4524                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4525                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4526                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
4527                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4528                                 ndr->offset = _relative_save_offset;
4529                         }
4530                         ndr->flags = _flags_save_string;
4531                 }
4532                 {
4533                         uint32_t _flags_save_string = ndr->flags;
4534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4535                         if (r->data_file) {
4536                                 uint32_t _relative_save_offset;
4537                                 _relative_save_offset = ndr->offset;
4538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
4539                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4540                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
4542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4543                                 ndr->offset = _relative_save_offset;
4544                         }
4545                         ndr->flags = _flags_save_string;
4546                 }
4547                 {
4548                         uint32_t _flags_save_string = ndr->flags;
4549                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4550                         if (r->config_file) {
4551                                 uint32_t _relative_save_offset;
4552                                 _relative_save_offset = ndr->offset;
4553                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
4554                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4555                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4556                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
4557                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4558                                 ndr->offset = _relative_save_offset;
4559                         }
4560                         ndr->flags = _flags_save_string;
4561                 }
4562                 {
4563                         uint32_t _flags_save_string = ndr->flags;
4564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4565                         if (r->help_file) {
4566                                 uint32_t _relative_save_offset;
4567                                 _relative_save_offset = ndr->offset;
4568                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
4569                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4570                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
4571                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
4572                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
4573                                 ndr->offset = _relative_save_offset;
4574                         }
4575                         ndr->flags = _flags_save_string;
4576                 }
4577                 {
4578                         uint32_t _flags_save_string_array = ndr->flags;
4579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4580                         if (r->dependent_files) {
4581                                 uint32_t _relative_save_offset;
4582                                 _relative_save_offset = ndr->offset;
4583                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
4584                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
4585                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
4586                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
4587                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
4588                                 ndr->offset = _relative_save_offset;
4589                         }
4590                         ndr->flags = _flags_save_string_array;
4591                 }
4592                 {
4593                         uint32_t _flags_save_string = ndr->flags;
4594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4595                         if (r->monitor_name) {
4596                                 uint32_t _relative_save_offset;
4597                                 _relative_save_offset = ndr->offset;
4598                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
4599                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4600                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
4601                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
4602                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
4603                                 ndr->offset = _relative_save_offset;
4604                         }
4605                         ndr->flags = _flags_save_string;
4606                 }
4607                 {
4608                         uint32_t _flags_save_string = ndr->flags;
4609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4610                         if (r->default_datatype) {
4611                                 uint32_t _relative_save_offset;
4612                                 _relative_save_offset = ndr->offset;
4613                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
4614                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
4615                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
4616                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
4617                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
4618                                 ndr->offset = _relative_save_offset;
4619                         }
4620                         ndr->flags = _flags_save_string;
4621                 }
4622                 {
4623                         uint32_t _flags_save_string_array = ndr->flags;
4624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4625                         if (r->previous_names) {
4626                                 uint32_t _relative_save_offset;
4627                                 _relative_save_offset = ndr->offset;
4628                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
4629                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
4630                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
4631                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
4632                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
4633                                 ndr->offset = _relative_save_offset;
4634                         }
4635                         ndr->flags = _flags_save_string_array;
4636                 }
4637         }
4638         return NDR_ERR_SUCCESS;
4639 }
4640
4641 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
4642 {
4643         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
4644         ndr->depth++;
4645         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4646         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4647         ndr->depth++;
4648         if (r->driver_name) {
4649                 ndr_print_string(ndr, "driver_name", r->driver_name);
4650         }
4651         ndr->depth--;
4652         ndr_print_ptr(ndr, "architecture", r->architecture);
4653         ndr->depth++;
4654         if (r->architecture) {
4655                 ndr_print_string(ndr, "architecture", r->architecture);
4656         }
4657         ndr->depth--;
4658         ndr_print_ptr(ndr, "driver_path", r->driver_path);
4659         ndr->depth++;
4660         if (r->driver_path) {
4661                 ndr_print_string(ndr, "driver_path", r->driver_path);
4662         }
4663         ndr->depth--;
4664         ndr_print_ptr(ndr, "data_file", r->data_file);
4665         ndr->depth++;
4666         if (r->data_file) {
4667                 ndr_print_string(ndr, "data_file", r->data_file);
4668         }
4669         ndr->depth--;
4670         ndr_print_ptr(ndr, "config_file", r->config_file);
4671         ndr->depth++;
4672         if (r->config_file) {
4673                 ndr_print_string(ndr, "config_file", r->config_file);
4674         }
4675         ndr->depth--;
4676         ndr_print_ptr(ndr, "help_file", r->help_file);
4677         ndr->depth++;
4678         if (r->help_file) {
4679                 ndr_print_string(ndr, "help_file", r->help_file);
4680         }
4681         ndr->depth--;
4682         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
4683         ndr->depth++;
4684         if (r->dependent_files) {
4685                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
4686         }
4687         ndr->depth--;
4688         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
4689         ndr->depth++;
4690         if (r->monitor_name) {
4691                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
4692         }
4693         ndr->depth--;
4694         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
4695         ndr->depth++;
4696         if (r->default_datatype) {
4697                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
4698         }
4699         ndr->depth--;
4700         ndr_print_ptr(ndr, "previous_names", r->previous_names);
4701         ndr->depth++;
4702         if (r->previous_names) {
4703                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
4704         }
4705         ndr->depth--;
4706         ndr->depth--;
4707 }
4708
4709 static enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
4710 {
4711         if (ndr_flags & NDR_SCALARS) {
4712                 NDR_CHECK(ndr_push_align(ndr, 4));
4713                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
4714                 {
4715                         uint32_t _flags_save_string = ndr->flags;
4716                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4717                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
4718                         ndr->flags = _flags_save_string;
4719                 }
4720                 {
4721                         uint32_t _flags_save_string = ndr->flags;
4722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4723                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
4724                         ndr->flags = _flags_save_string;
4725                 }
4726                 {
4727                         uint32_t _flags_save_string = ndr->flags;
4728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4729                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
4730                         ndr->flags = _flags_save_string;
4731                 }
4732                 {
4733                         uint32_t _flags_save_string = ndr->flags;
4734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4735                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
4736                         ndr->flags = _flags_save_string;
4737                 }
4738                 {
4739                         uint32_t _flags_save_string = ndr->flags;
4740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4741                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
4742                         ndr->flags = _flags_save_string;
4743                 }
4744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
4745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
4746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
4747         }
4748         if (ndr_flags & NDR_BUFFERS) {
4749                 {
4750                         uint32_t _flags_save_string = ndr->flags;
4751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4752                         if (r->driver_name) {
4753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
4754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
4755                         }
4756                         ndr->flags = _flags_save_string;
4757                 }
4758                 {
4759                         uint32_t _flags_save_string = ndr->flags;
4760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4761                         if (r->architecture) {
4762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
4763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
4764                         }
4765                         ndr->flags = _flags_save_string;
4766                 }
4767                 {
4768                         uint32_t _flags_save_string = ndr->flags;
4769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4770                         if (r->driver_path) {
4771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
4772                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
4773                         }
4774                         ndr->flags = _flags_save_string;
4775                 }
4776                 {
4777                         uint32_t _flags_save_string = ndr->flags;
4778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4779                         if (r->data_file) {
4780                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
4781                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
4782                         }
4783                         ndr->flags = _flags_save_string;
4784                 }
4785                 {
4786                         uint32_t _flags_save_string = ndr->flags;
4787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4788                         if (r->config_file) {
4789                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
4790                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
4791                         }
4792                         ndr->flags = _flags_save_string;
4793                 }
4794         }
4795         return NDR_ERR_SUCCESS;
4796 }
4797
4798 static enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
4799 {
4800         uint32_t _ptr_driver_name;
4801         TALLOC_CTX *_mem_save_driver_name_0;
4802         uint32_t _ptr_architecture;
4803         TALLOC_CTX *_mem_save_architecture_0;
4804         uint32_t _ptr_driver_path;
4805         TALLOC_CTX *_mem_save_driver_path_0;
4806         uint32_t _ptr_data_file;
4807         TALLOC_CTX *_mem_save_data_file_0;
4808         uint32_t _ptr_config_file;
4809         TALLOC_CTX *_mem_save_config_file_0;
4810         if (ndr_flags & NDR_SCALARS) {
4811                 NDR_CHECK(ndr_pull_align(ndr, 4));
4812                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
4813                 {
4814                         uint32_t _flags_save_string = ndr->flags;
4815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4816                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4817                         if (_ptr_driver_name) {
4818                                 NDR_PULL_ALLOC(ndr, r->driver_name);
4819                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
4820                         } else {
4821                                 r->driver_name = NULL;
4822                         }
4823                         ndr->flags = _flags_save_string;
4824                 }
4825                 {
4826                         uint32_t _flags_save_string = ndr->flags;
4827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4828                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
4829                         if (_ptr_architecture) {
4830                                 NDR_PULL_ALLOC(ndr, r->architecture);
4831                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
4832                         } else {
4833                                 r->architecture = NULL;
4834                         }
4835                         ndr->flags = _flags_save_string;
4836                 }
4837                 {
4838                         uint32_t _flags_save_string = ndr->flags;
4839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
4841                         if (_ptr_driver_path) {
4842                                 NDR_PULL_ALLOC(ndr, r->driver_path);
4843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
4844                         } else {
4845                                 r->driver_path = NULL;
4846                         }
4847                         ndr->flags = _flags_save_string;
4848                 }
4849                 {
4850                         uint32_t _flags_save_string = ndr->flags;
4851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4852                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
4853                         if (_ptr_data_file) {
4854                                 NDR_PULL_ALLOC(ndr, r->data_file);
4855                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
4856                         } else {
4857                                 r->data_file = NULL;
4858                         }
4859                         ndr->flags = _flags_save_string;
4860                 }
4861                 {
4862                         uint32_t _flags_save_string = ndr->flags;
4863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4864                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
4865                         if (_ptr_config_file) {
4866                                 NDR_PULL_ALLOC(ndr, r->config_file);
4867                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
4868                         } else {
4869                                 r->config_file = NULL;
4870                         }
4871                         ndr->flags = _flags_save_string;
4872                 }
4873                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
4874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
4875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
4876         }
4877         if (ndr_flags & NDR_BUFFERS) {
4878                 {
4879                         uint32_t _flags_save_string = ndr->flags;
4880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4881                         if (r->driver_name) {
4882                                 uint32_t _relative_save_offset;
4883                                 _relative_save_offset = ndr->offset;
4884                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4885                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4886                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4887                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4888                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4889                                 ndr->offset = _relative_save_offset;
4890                         }
4891                         ndr->flags = _flags_save_string;
4892                 }
4893                 {
4894                         uint32_t _flags_save_string = ndr->flags;
4895                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4896                         if (r->architecture) {
4897                                 uint32_t _relative_save_offset;
4898                                 _relative_save_offset = ndr->offset;
4899                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
4900                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
4901                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
4902                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
4903                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
4904                                 ndr->offset = _relative_save_offset;
4905                         }
4906                         ndr->flags = _flags_save_string;
4907                 }
4908                 {
4909                         uint32_t _flags_save_string = ndr->flags;
4910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4911                         if (r->driver_path) {
4912                                 uint32_t _relative_save_offset;
4913                                 _relative_save_offset = ndr->offset;
4914                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
4915                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
4916                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
4917                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
4918                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
4919                                 ndr->offset = _relative_save_offset;
4920                         }
4921                         ndr->flags = _flags_save_string;
4922                 }
4923                 {
4924                         uint32_t _flags_save_string = ndr->flags;
4925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4926                         if (r->data_file) {
4927                                 uint32_t _relative_save_offset;
4928                                 _relative_save_offset = ndr->offset;
4929                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
4930                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4931                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
4932                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
4933                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
4934                                 ndr->offset = _relative_save_offset;
4935                         }
4936                         ndr->flags = _flags_save_string;
4937                 }
4938                 {
4939                         uint32_t _flags_save_string = ndr->flags;
4940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4941                         if (r->config_file) {
4942                                 uint32_t _relative_save_offset;
4943                                 _relative_save_offset = ndr->offset;
4944                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
4945                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
4946                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
4947                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
4948                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
4949                                 ndr->offset = _relative_save_offset;
4950                         }
4951                         ndr->flags = _flags_save_string;
4952                 }
4953         }
4954         return NDR_ERR_SUCCESS;
4955 }
4956
4957 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
4958 {
4959         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
4960         ndr->depth++;
4961         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
4962         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4963         ndr->depth++;
4964         if (r->driver_name) {
4965                 ndr_print_string(ndr, "driver_name", r->driver_name);
4966         }
4967         ndr->depth--;
4968         ndr_print_ptr(ndr, "architecture", r->architecture);
4969         ndr->depth++;
4970         if (r->architecture) {
4971                 ndr_print_string(ndr, "architecture", r->architecture);
4972         }
4973         ndr->depth--;
4974         ndr_print_ptr(ndr, "driver_path", r->driver_path);
4975         ndr->depth++;
4976         if (r->driver_path) {
4977                 ndr_print_string(ndr, "driver_path", r->driver_path);
4978         }
4979         ndr->depth--;
4980         ndr_print_ptr(ndr, "data_file", r->data_file);
4981         ndr->depth++;
4982         if (r->data_file) {
4983                 ndr_print_string(ndr, "data_file", r->data_file);
4984         }
4985         ndr->depth--;
4986         ndr_print_ptr(ndr, "config_file", r->config_file);
4987         ndr->depth++;
4988         if (r->config_file) {
4989                 ndr_print_string(ndr, "config_file", r->config_file);
4990         }
4991         ndr->depth--;
4992         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
4993         ndr_print_uint32(ndr, "config_version", r->config_version);
4994         ndr_print_uint32(ndr, "driver_version", r->driver_version);
4995         ndr->depth--;
4996 }
4997
4998 static enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
4999 {
5000         if (ndr_flags & NDR_SCALARS) {
5001                 NDR_CHECK(ndr_push_align(ndr, 8));
5002                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
5003                 {
5004                         uint32_t _flags_save_string = ndr->flags;
5005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
5007                         ndr->flags = _flags_save_string;
5008                 }
5009                 {
5010                         uint32_t _flags_save_string = ndr->flags;
5011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5012                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
5013                         ndr->flags = _flags_save_string;
5014                 }
5015                 {
5016                         uint32_t _flags_save_string = ndr->flags;
5017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5018                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
5019                         ndr->flags = _flags_save_string;
5020                 }
5021                 {
5022                         uint32_t _flags_save_string = ndr->flags;
5023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5024                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
5025                         ndr->flags = _flags_save_string;
5026                 }
5027                 {
5028                         uint32_t _flags_save_string = ndr->flags;
5029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5030                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
5031                         ndr->flags = _flags_save_string;
5032                 }
5033                 {
5034                         uint32_t _flags_save_string = ndr->flags;
5035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5036                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
5037                         ndr->flags = _flags_save_string;
5038                 }
5039                 {
5040                         uint32_t _flags_save_string_array = ndr->flags;
5041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5042                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
5043                         ndr->flags = _flags_save_string_array;
5044                 }
5045                 {
5046                         uint32_t _flags_save_string = ndr->flags;
5047                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5048                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
5049                         ndr->flags = _flags_save_string;
5050                 }
5051                 {
5052                         uint32_t _flags_save_string = ndr->flags;
5053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5054                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
5055                         ndr->flags = _flags_save_string;
5056                 }
5057                 {
5058                         uint32_t _flags_save_string_array = ndr->flags;
5059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5060                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
5061                         ndr->flags = _flags_save_string_array;
5062                 }
5063                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_data));
5064                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
5065                 {
5066                         uint32_t _flags_save_string = ndr->flags;
5067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5068                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
5069                         ndr->flags = _flags_save_string;
5070                 }
5071                 {
5072                         uint32_t _flags_save_string = ndr->flags;
5073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5074                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
5075                         ndr->flags = _flags_save_string;
5076                 }
5077                 {
5078                         uint32_t _flags_save_string = ndr->flags;
5079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5080                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
5081                         ndr->flags = _flags_save_string;
5082                 }
5083                 {
5084                         uint32_t _flags_save_string = ndr->flags;
5085                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5086                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
5087                         ndr->flags = _flags_save_string;
5088                 }
5089         }
5090         if (ndr_flags & NDR_BUFFERS) {
5091                 {
5092                         uint32_t _flags_save_string = ndr->flags;
5093                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5094                         if (r->driver_name) {
5095                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
5096                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
5097                         }
5098                         ndr->flags = _flags_save_string;
5099                 }
5100                 {
5101                         uint32_t _flags_save_string = ndr->flags;
5102                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5103                         if (r->architecture) {
5104                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
5105                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
5106                         }
5107                         ndr->flags = _flags_save_string;
5108                 }
5109                 {
5110                         uint32_t _flags_save_string = ndr->flags;
5111                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5112                         if (r->driver_path) {
5113                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
5114                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
5115                         }
5116                         ndr->flags = _flags_save_string;
5117                 }
5118                 {
5119                         uint32_t _flags_save_string = ndr->flags;
5120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5121                         if (r->data_file) {
5122                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
5123                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
5124                         }
5125                         ndr->flags = _flags_save_string;
5126                 }
5127                 {
5128                         uint32_t _flags_save_string = ndr->flags;
5129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5130                         if (r->config_file) {
5131                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
5132                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
5133                         }
5134                         ndr->flags = _flags_save_string;
5135                 }
5136                 {
5137                         uint32_t _flags_save_string = ndr->flags;
5138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5139                         if (r->help_file) {
5140                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
5141                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
5142                         }
5143                         ndr->flags = _flags_save_string;
5144                 }
5145                 {
5146                         uint32_t _flags_save_string_array = ndr->flags;
5147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5148                         if (r->dependent_files) {
5149                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
5150                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
5151                         }
5152                         ndr->flags = _flags_save_string_array;
5153                 }
5154                 {
5155                         uint32_t _flags_save_string = ndr->flags;
5156                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5157                         if (r->monitor_name) {
5158                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
5159                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
5160                         }
5161                         ndr->flags = _flags_save_string;
5162                 }
5163                 {
5164                         uint32_t _flags_save_string = ndr->flags;
5165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5166                         if (r->default_datatype) {
5167                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
5168                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
5169                         }
5170                         ndr->flags = _flags_save_string;
5171                 }
5172                 {
5173                         uint32_t _flags_save_string_array = ndr->flags;
5174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5175                         if (r->previous_names) {
5176                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
5177                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
5178                         }
5179                         ndr->flags = _flags_save_string_array;
5180                 }
5181                 {
5182                         uint32_t _flags_save_string = ndr->flags;
5183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5184                         if (r->manufacturer_name) {
5185                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
5186                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
5187                         }
5188                         ndr->flags = _flags_save_string;
5189                 }
5190                 {
5191                         uint32_t _flags_save_string = ndr->flags;
5192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5193                         if (r->manufacturer_url) {
5194                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
5195                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
5196                         }
5197                         ndr->flags = _flags_save_string;
5198                 }
5199                 {
5200                         uint32_t _flags_save_string = ndr->flags;
5201                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5202                         if (r->hardware_id) {
5203                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
5204                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
5205                         }
5206                         ndr->flags = _flags_save_string;
5207                 }
5208                 {
5209                         uint32_t _flags_save_string = ndr->flags;
5210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5211                         if (r->provider) {
5212                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
5213                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
5214                         }
5215                         ndr->flags = _flags_save_string;
5216                 }
5217         }
5218         return NDR_ERR_SUCCESS;
5219 }
5220
5221 static enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
5222 {
5223         uint32_t _ptr_driver_name;
5224         TALLOC_CTX *_mem_save_driver_name_0;
5225         uint32_t _ptr_architecture;
5226         TALLOC_CTX *_mem_save_architecture_0;
5227         uint32_t _ptr_driver_path;
5228         TALLOC_CTX *_mem_save_driver_path_0;
5229         uint32_t _ptr_data_file;
5230         TALLOC_CTX *_mem_save_data_file_0;
5231         uint32_t _ptr_config_file;
5232         TALLOC_CTX *_mem_save_config_file_0;
5233         uint32_t _ptr_help_file;
5234         TALLOC_CTX *_mem_save_help_file_0;
5235         uint32_t _ptr_dependent_files;
5236         TALLOC_CTX *_mem_save_dependent_files_0;
5237         uint32_t _ptr_monitor_name;
5238         TALLOC_CTX *_mem_save_monitor_name_0;
5239         uint32_t _ptr_default_datatype;
5240         TALLOC_CTX *_mem_save_default_datatype_0;
5241         uint32_t _ptr_previous_names;
5242         TALLOC_CTX *_mem_save_previous_names_0;
5243         uint32_t _ptr_manufacturer_name;
5244         TALLOC_CTX *_mem_save_manufacturer_name_0;
5245         uint32_t _ptr_manufacturer_url;
5246         TALLOC_CTX *_mem_save_manufacturer_url_0;
5247         uint32_t _ptr_hardware_id;
5248         TALLOC_CTX *_mem_save_hardware_id_0;
5249         uint32_t _ptr_provider;
5250         TALLOC_CTX *_mem_save_provider_0;
5251         if (ndr_flags & NDR_SCALARS) {
5252                 NDR_CHECK(ndr_pull_align(ndr, 8));
5253                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
5254                 {
5255                         uint32_t _flags_save_string = ndr->flags;
5256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5257                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5258                         if (_ptr_driver_name) {
5259                                 NDR_PULL_ALLOC(ndr, r->driver_name);
5260                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
5261                         } else {
5262                                 r->driver_name = NULL;
5263                         }
5264                         ndr->flags = _flags_save_string;
5265                 }
5266                 {
5267                         uint32_t _flags_save_string = ndr->flags;
5268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5269                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
5270                         if (_ptr_architecture) {
5271                                 NDR_PULL_ALLOC(ndr, r->architecture);
5272                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
5273                         } else {
5274                                 r->architecture = NULL;
5275                         }
5276                         ndr->flags = _flags_save_string;
5277                 }
5278                 {
5279                         uint32_t _flags_save_string = ndr->flags;
5280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5281                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
5282                         if (_ptr_driver_path) {
5283                                 NDR_PULL_ALLOC(ndr, r->driver_path);
5284                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
5285                         } else {
5286                                 r->driver_path = NULL;
5287                         }
5288                         ndr->flags = _flags_save_string;
5289                 }
5290                 {
5291                         uint32_t _flags_save_string = ndr->flags;
5292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5293                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
5294                         if (_ptr_data_file) {
5295                                 NDR_PULL_ALLOC(ndr, r->data_file);
5296                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
5297                         } else {
5298                                 r->data_file = NULL;
5299                         }
5300                         ndr->flags = _flags_save_string;
5301                 }
5302                 {
5303                         uint32_t _flags_save_string = ndr->flags;
5304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
5306                         if (_ptr_config_file) {
5307                                 NDR_PULL_ALLOC(ndr, r->config_file);
5308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
5309                         } else {
5310                                 r->config_file = NULL;
5311                         }
5312                         ndr->flags = _flags_save_string;
5313                 }
5314                 {
5315                         uint32_t _flags_save_string = ndr->flags;
5316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
5318                         if (_ptr_help_file) {
5319                                 NDR_PULL_ALLOC(ndr, r->help_file);
5320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
5321                         } else {
5322                                 r->help_file = NULL;
5323                         }
5324                         ndr->flags = _flags_save_string;
5325                 }
5326                 {
5327                         uint32_t _flags_save_string_array = ndr->flags;
5328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
5330                         if (_ptr_dependent_files) {
5331                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
5332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
5333                         } else {
5334                                 r->dependent_files = NULL;
5335                         }
5336                         ndr->flags = _flags_save_string_array;
5337                 }
5338                 {
5339                         uint32_t _flags_save_string = ndr->flags;
5340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
5342                         if (_ptr_monitor_name) {
5343                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
5344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
5345                         } else {
5346                                 r->monitor_name = NULL;
5347                         }
5348                         ndr->flags = _flags_save_string;
5349                 }
5350                 {
5351                         uint32_t _flags_save_string = ndr->flags;
5352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
5354                         if (_ptr_default_datatype) {
5355                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
5356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
5357                         } else {
5358                                 r->default_datatype = NULL;
5359                         }
5360                         ndr->flags = _flags_save_string;
5361                 }
5362                 {
5363                         uint32_t _flags_save_string_array = ndr->flags;
5364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
5366                         if (_ptr_previous_names) {
5367                                 NDR_PULL_ALLOC(ndr, r->previous_names);
5368                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
5369                         } else {
5370                                 r->previous_names = NULL;
5371                         }
5372                         ndr->flags = _flags_save_string_array;
5373                 }
5374                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_data));
5375                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
5376                 {
5377                         uint32_t _flags_save_string = ndr->flags;
5378                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5379                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
5380                         if (_ptr_manufacturer_name) {
5381                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
5382                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
5383                         } else {
5384                                 r->manufacturer_name = NULL;
5385                         }
5386                         ndr->flags = _flags_save_string;
5387                 }
5388                 {
5389                         uint32_t _flags_save_string = ndr->flags;
5390                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5391                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
5392                         if (_ptr_manufacturer_url) {
5393                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
5394                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
5395                         } else {
5396                                 r->manufacturer_url = NULL;
5397                         }
5398                         ndr->flags = _flags_save_string;
5399                 }
5400                 {
5401                         uint32_t _flags_save_string = ndr->flags;
5402                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5403                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
5404                         if (_ptr_hardware_id) {
5405                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
5406                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
5407                         } else {
5408                                 r->hardware_id = NULL;
5409                         }
5410                         ndr->flags = _flags_save_string;
5411                 }
5412                 {
5413                         uint32_t _flags_save_string = ndr->flags;
5414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5415                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
5416                         if (_ptr_provider) {
5417                                 NDR_PULL_ALLOC(ndr, r->provider);
5418                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
5419                         } else {
5420                                 r->provider = NULL;
5421                         }
5422                         ndr->flags = _flags_save_string;
5423                 }
5424         }
5425         if (ndr_flags & NDR_BUFFERS) {
5426                 {
5427                         uint32_t _flags_save_string = ndr->flags;
5428                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5429                         if (r->driver_name) {
5430                                 uint32_t _relative_save_offset;
5431                                 _relative_save_offset = ndr->offset;
5432                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
5433                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5434                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5435                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
5436                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5437                                 ndr->offset = _relative_save_offset;
5438                         }
5439                         ndr->flags = _flags_save_string;
5440                 }
5441                 {
5442                         uint32_t _flags_save_string = ndr->flags;
5443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5444                         if (r->architecture) {
5445                                 uint32_t _relative_save_offset;
5446                                 _relative_save_offset = ndr->offset;
5447                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
5448                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
5449                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
5450                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
5451                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
5452                                 ndr->offset = _relative_save_offset;
5453                         }
5454                         ndr->flags = _flags_save_string;
5455                 }
5456                 {
5457                         uint32_t _flags_save_string = ndr->flags;
5458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5459                         if (r->driver_path) {
5460                                 uint32_t _relative_save_offset;
5461                                 _relative_save_offset = ndr->offset;
5462                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
5463                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
5464                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
5465                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
5466                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
5467                                 ndr->offset = _relative_save_offset;
5468                         }
5469                         ndr->flags = _flags_save_string;
5470                 }
5471                 {
5472                         uint32_t _flags_save_string = ndr->flags;
5473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5474                         if (r->data_file) {
5475                                 uint32_t _relative_save_offset;
5476                                 _relative_save_offset = ndr->offset;
5477                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
5478                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5479                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
5480                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
5481                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
5482                                 ndr->offset = _relative_save_offset;
5483                         }
5484                         ndr->flags = _flags_save_string;
5485                 }
5486                 {
5487                         uint32_t _flags_save_string = ndr->flags;
5488                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5489                         if (r->config_file) {
5490                                 uint32_t _relative_save_offset;
5491                                 _relative_save_offset = ndr->offset;
5492                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
5493                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5494                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
5495                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
5496                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
5497                                 ndr->offset = _relative_save_offset;
5498                         }
5499                         ndr->flags = _flags_save_string;
5500                 }
5501                 {
5502                         uint32_t _flags_save_string = ndr->flags;
5503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5504                         if (r->help_file) {
5505                                 uint32_t _relative_save_offset;
5506                                 _relative_save_offset = ndr->offset;
5507                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
5508                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
5509                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
5510                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
5511                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
5512                                 ndr->offset = _relative_save_offset;
5513                         }
5514                         ndr->flags = _flags_save_string;
5515                 }
5516                 {
5517                         uint32_t _flags_save_string_array = ndr->flags;
5518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5519                         if (r->dependent_files) {
5520                                 uint32_t _relative_save_offset;
5521                                 _relative_save_offset = ndr->offset;
5522                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
5523                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
5524                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
5525                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
5526                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
5527                                 ndr->offset = _relative_save_offset;
5528                         }
5529                         ndr->flags = _flags_save_string_array;
5530                 }
5531                 {
5532                         uint32_t _flags_save_string = ndr->flags;
5533                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5534                         if (r->monitor_name) {
5535                                 uint32_t _relative_save_offset;
5536                                 _relative_save_offset = ndr->offset;
5537                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
5538                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5539                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
5540                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
5541                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
5542                                 ndr->offset = _relative_save_offset;
5543                         }
5544                         ndr->flags = _flags_save_string;
5545                 }
5546                 {
5547                         uint32_t _flags_save_string = ndr->flags;
5548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5549                         if (r->default_datatype) {
5550                                 uint32_t _relative_save_offset;
5551                                 _relative_save_offset = ndr->offset;
5552                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
5553                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
5554                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
5555                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
5556                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
5557                                 ndr->offset = _relative_save_offset;
5558                         }
5559                         ndr->flags = _flags_save_string;
5560                 }
5561                 {
5562                         uint32_t _flags_save_string_array = ndr->flags;
5563                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5564                         if (r->previous_names) {
5565                                 uint32_t _relative_save_offset;
5566                                 _relative_save_offset = ndr->offset;
5567                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
5568                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
5569                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
5570                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
5571                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
5572                                 ndr->offset = _relative_save_offset;
5573                         }
5574                         ndr->flags = _flags_save_string_array;
5575                 }
5576                 {
5577                         uint32_t _flags_save_string = ndr->flags;
5578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5579                         if (r->manufacturer_name) {
5580                                 uint32_t _relative_save_offset;
5581                                 _relative_save_offset = ndr->offset;
5582                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
5583                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5584                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
5585                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
5586                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
5587                                 ndr->offset = _relative_save_offset;
5588                         }
5589                         ndr->flags = _flags_save_string;
5590                 }
5591                 {
5592                         uint32_t _flags_save_string = ndr->flags;
5593                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5594                         if (r->manufacturer_url) {
5595                                 uint32_t _relative_save_offset;
5596                                 _relative_save_offset = ndr->offset;
5597                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
5598                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
5599                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
5600                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
5601                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
5602                                 ndr->offset = _relative_save_offset;
5603                         }
5604                         ndr->flags = _flags_save_string;
5605                 }
5606                 {
5607                         uint32_t _flags_save_string = ndr->flags;
5608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5609                         if (r->hardware_id) {
5610                                 uint32_t _relative_save_offset;
5611                                 _relative_save_offset = ndr->offset;
5612                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
5613                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
5614                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
5615                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
5616                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
5617                                 ndr->offset = _relative_save_offset;
5618                         }
5619                         ndr->flags = _flags_save_string;
5620                 }
5621                 {
5622                         uint32_t _flags_save_string = ndr->flags;
5623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5624                         if (r->provider) {
5625                                 uint32_t _relative_save_offset;
5626                                 _relative_save_offset = ndr->offset;
5627                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
5628                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
5629                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
5630                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
5631                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
5632                                 ndr->offset = _relative_save_offset;
5633                         }
5634                         ndr->flags = _flags_save_string;
5635                 }
5636         }
5637         return NDR_ERR_SUCCESS;
5638 }
5639
5640 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
5641 {
5642         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
5643         ndr->depth++;
5644         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
5645         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5646         ndr->depth++;
5647         if (r->driver_name) {
5648                 ndr_print_string(ndr, "driver_name", r->driver_name);
5649         }
5650         ndr->depth--;
5651         ndr_print_ptr(ndr, "architecture", r->architecture);
5652         ndr->depth++;
5653         if (r->architecture) {
5654                 ndr_print_string(ndr, "architecture", r->architecture);
5655         }
5656         ndr->depth--;
5657         ndr_print_ptr(ndr, "driver_path", r->driver_path);
5658         ndr->depth++;
5659         if (r->driver_path) {
5660                 ndr_print_string(ndr, "driver_path", r->driver_path);
5661         }
5662         ndr->depth--;
5663         ndr_print_ptr(ndr, "data_file", r->data_file);
5664         ndr->depth++;
5665         if (r->data_file) {
5666                 ndr_print_string(ndr, "data_file", r->data_file);
5667         }
5668         ndr->depth--;
5669         ndr_print_ptr(ndr, "config_file", r->config_file);
5670         ndr->depth++;
5671         if (r->config_file) {
5672                 ndr_print_string(ndr, "config_file", r->config_file);
5673         }
5674         ndr->depth--;
5675         ndr_print_ptr(ndr, "help_file", r->help_file);
5676         ndr->depth++;
5677         if (r->help_file) {
5678                 ndr_print_string(ndr, "help_file", r->help_file);
5679         }
5680         ndr->depth--;
5681         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
5682         ndr->depth++;
5683         if (r->dependent_files) {
5684                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
5685         }
5686         ndr->depth--;
5687         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
5688         ndr->depth++;
5689         if (r->monitor_name) {
5690                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
5691         }
5692         ndr->depth--;
5693         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
5694         ndr->depth++;
5695         if (r->default_datatype) {
5696                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
5697         }
5698         ndr->depth--;
5699         ndr_print_ptr(ndr, "previous_names", r->previous_names);
5700         ndr->depth++;
5701         if (r->previous_names) {
5702                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
5703         }
5704         ndr->depth--;
5705         ndr_print_NTTIME(ndr, "driver_data", r->driver_data);
5706         ndr_print_hyper(ndr, "driver_version", r->driver_version);
5707         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
5708         ndr->depth++;
5709         if (r->manufacturer_name) {
5710                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
5711         }
5712         ndr->depth--;
5713         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
5714         ndr->depth++;
5715         if (r->manufacturer_url) {
5716                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
5717         }
5718         ndr->depth--;
5719         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
5720         ndr->depth++;
5721         if (r->hardware_id) {
5722                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
5723         }
5724         ndr->depth--;
5725         ndr_print_ptr(ndr, "provider", r->provider);
5726         ndr->depth++;
5727         if (r->provider) {
5728                 ndr_print_string(ndr, "provider", r->provider);
5729         }
5730         ndr->depth--;
5731         ndr->depth--;
5732 }
5733
5734 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
5735 {
5736         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
5737         if (ndr_flags & NDR_SCALARS) {
5738                 int level = ndr_push_get_switch_value(ndr, r);
5739                 switch (level) {
5740                         case 1: {
5741                                 NDR_CHECK(ndr_push_align(ndr, 4));
5742                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5743                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
5744                         break; }
5745
5746                         case 2: {
5747                                 NDR_CHECK(ndr_push_align(ndr, 4));
5748                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5749                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
5750                         break; }
5751
5752                         case 3: {
5753                                 NDR_CHECK(ndr_push_align(ndr, 4));
5754                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5755                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
5756                         break; }
5757
5758                         case 4: {
5759                                 NDR_CHECK(ndr_push_align(ndr, 4));
5760                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5761                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
5762                         break; }
5763
5764                         case 5: {
5765                                 NDR_CHECK(ndr_push_align(ndr, 4));
5766                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5767                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
5768                         break; }
5769
5770                         case 6: {
5771                                 NDR_CHECK(ndr_push_align(ndr, 8));
5772                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5773                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
5774                         break; }
5775
5776                         default: {
5777                         break; }
5778
5779                 }
5780         }
5781         if (ndr_flags & NDR_BUFFERS) {
5782                 int level = ndr_push_get_switch_value(ndr, r);
5783                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
5784                 switch (level) {
5785                         case 1:
5786                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
5787                         break;
5788
5789                         case 2:
5790                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
5791                         break;
5792
5793                         case 3:
5794                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
5795                         break;
5796
5797                         case 4:
5798                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
5799                         break;
5800
5801                         case 5:
5802                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
5803                         break;
5804
5805                         case 6:
5806                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
5807                         break;
5808
5809                         default:
5810                         break;
5811
5812                 }
5813         }
5814         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
5815         return NDR_ERR_SUCCESS;
5816 }
5817
5818 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
5819 {
5820         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
5821         int level;
5822         level = ndr_pull_get_switch_value(ndr, r);
5823         if (ndr_flags & NDR_SCALARS) {
5824                 switch (level) {
5825                         case 1: {
5826                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5827                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5828                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
5829                         break; }
5830
5831                         case 2: {
5832                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5833                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5834                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
5835                         break; }
5836
5837                         case 3: {
5838                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5839                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5840                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
5841                         break; }
5842
5843                         case 4: {
5844                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5845                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5846                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
5847                         break; }
5848
5849                         case 5: {
5850                                 NDR_CHECK(ndr_pull_align(ndr, 4));
5851                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5852                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
5853                         break; }
5854
5855                         case 6: {
5856                                 NDR_CHECK(ndr_pull_align(ndr, 8));
5857                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
5858                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
5859                         break; }
5860
5861                         default: {
5862                         break; }
5863
5864                 }
5865         }
5866         if (ndr_flags & NDR_BUFFERS) {
5867                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
5868                 switch (level) {
5869                         case 1:
5870                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
5871                         break;
5872
5873                         case 2:
5874                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
5875                         break;
5876
5877                         case 3:
5878                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
5879                         break;
5880
5881                         case 4:
5882                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
5883                         break;
5884
5885                         case 5:
5886                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
5887                         break;
5888
5889                         case 6:
5890                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
5891                         break;
5892
5893                         default:
5894                         break;
5895
5896                 }
5897         }
5898         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
5899         return NDR_ERR_SUCCESS;
5900 }
5901
5902 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
5903 {
5904         int level;
5905         level = ndr_print_get_switch_value(ndr, r);
5906         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
5907         switch (level) {
5908                 case 1:
5909                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
5910                 break;
5911
5912                 case 2:
5913                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
5914                 break;
5915
5916                 case 3:
5917                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
5918                 break;
5919
5920                 case 4:
5921                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
5922                 break;
5923
5924                 case 5:
5925                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
5926                 break;
5927
5928                 case 6:
5929                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
5930                 break;
5931
5932                 default:
5933                 break;
5934
5935         }
5936 }
5937
5938 static enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
5939 {
5940         if (ndr_flags & NDR_SCALARS) {
5941                 NDR_CHECK(ndr_push_align(ndr, 4));
5942                 {
5943                         uint32_t _flags_save_string = ndr->flags;
5944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5945                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
5946                         ndr->flags = _flags_save_string;
5947                 }
5948         }
5949         if (ndr_flags & NDR_BUFFERS) {
5950         }
5951         return NDR_ERR_SUCCESS;
5952 }
5953
5954 static enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
5955 {
5956         if (ndr_flags & NDR_SCALARS) {
5957                 NDR_CHECK(ndr_pull_align(ndr, 4));
5958                 {
5959                         uint32_t _flags_save_string = ndr->flags;
5960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
5961                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
5962                         ndr->flags = _flags_save_string;
5963                 }
5964         }
5965         if (ndr_flags & NDR_BUFFERS) {
5966         }
5967         return NDR_ERR_SUCCESS;
5968 }
5969
5970 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
5971 {
5972         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
5973         ndr->depth++;
5974         ndr_print_string(ndr, "directory_name", r->directory_name);
5975         ndr->depth--;
5976 }
5977
5978 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
5979 {
5980         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
5981         if (ndr_flags & NDR_SCALARS) {
5982                 int level = ndr_push_get_switch_value(ndr, r);
5983                 switch (level) {
5984                         case 1: {
5985                                 NDR_CHECK(ndr_push_align(ndr, 4));
5986                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5987                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
5988                         break; }
5989
5990                         default: {
5991                                 NDR_CHECK(ndr_push_align(ndr, 4));
5992                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
5993                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
5994                         break; }
5995
5996                 }
5997         }
5998         if (ndr_flags & NDR_BUFFERS) {
5999                 int level = ndr_push_get_switch_value(ndr, r);
6000                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
6001                 switch (level) {
6002                         case 1:
6003                         break;
6004
6005                         default:
6006                         break;
6007
6008                 }
6009         }
6010         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
6011         return NDR_ERR_SUCCESS;
6012 }
6013
6014 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
6015 {
6016         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
6017         int level;
6018         level = ndr_pull_get_switch_value(ndr, r);
6019         if (ndr_flags & NDR_SCALARS) {
6020                 switch (level) {
6021                         case 1: {
6022                                 NDR_CHECK(ndr_pull_align(ndr, 4));
6023                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
6024                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
6025                         break; }
6026
6027                         default: {
6028                                 NDR_CHECK(ndr_pull_align(ndr, 4));
6029                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
6030                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
6031                         break; }
6032
6033                 }
6034         }
6035         if (ndr_flags & NDR_BUFFERS) {
6036                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
6037                 switch (level) {
6038                         case 1:
6039                         break;
6040
6041                         default:
6042                         break;
6043
6044                 }
6045         }
6046         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
6047         return NDR_ERR_SUCCESS;
6048 }
6049
6050 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
6051 {
6052         int level;
6053         level = ndr_print_get_switch_value(ndr, r);
6054         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
6055         switch (level) {
6056                 case 1:
6057                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
6058                 break;
6059
6060                 default:
6061                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
6062                 break;
6063
6064         }
6065 }
6066
6067 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
6068 {
6069         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
6070 }
6071
6072 static enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
6073 {
6074         if (ndr_flags & NDR_SCALARS) {
6075                 NDR_CHECK(ndr_push_align(ndr, 4));
6076                 {
6077                         uint32_t _flags_save_string = ndr->flags;
6078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6079                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
6080                         ndr->flags = _flags_save_string;
6081                 }
6082         }
6083         if (ndr_flags & NDR_BUFFERS) {
6084                 {
6085                         uint32_t _flags_save_string = ndr->flags;
6086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6087                         if (r->print_processor_name) {
6088                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
6089                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
6090                         }
6091                         ndr->flags = _flags_save_string;
6092                 }
6093         }
6094         return NDR_ERR_SUCCESS;
6095 }
6096
6097 static enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
6098 {
6099         uint32_t _ptr_print_processor_name;
6100         TALLOC_CTX *_mem_save_print_processor_name_0;
6101         if (ndr_flags & NDR_SCALARS) {
6102                 NDR_CHECK(ndr_pull_align(ndr, 4));
6103                 {
6104                         uint32_t _flags_save_string = ndr->flags;
6105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6106                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
6107                         if (_ptr_print_processor_name) {
6108                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
6109                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
6110                         } else {
6111                                 r->print_processor_name = NULL;
6112                         }
6113                         ndr->flags = _flags_save_string;
6114                 }
6115         }
6116         if (ndr_flags & NDR_BUFFERS) {
6117                 {
6118                         uint32_t _flags_save_string = ndr->flags;
6119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6120                         if (r->print_processor_name) {
6121                                 uint32_t _relative_save_offset;
6122                                 _relative_save_offset = ndr->offset;
6123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
6124                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6125                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
6126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
6127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
6128                                 ndr->offset = _relative_save_offset;
6129                         }
6130                         ndr->flags = _flags_save_string;
6131                 }
6132         }
6133         return NDR_ERR_SUCCESS;
6134 }
6135
6136 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
6137 {
6138         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
6139         ndr->depth++;
6140         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
6141         ndr->depth++;
6142         if (r->print_processor_name) {
6143                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
6144         }
6145         ndr->depth--;
6146         ndr->depth--;
6147 }
6148
6149 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
6150 {
6151         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
6152         if (ndr_flags & NDR_SCALARS) {
6153                 int level = ndr_push_get_switch_value(ndr, r);
6154                 switch (level) {
6155                         case 1: {
6156                                 NDR_CHECK(ndr_push_align(ndr, 4));
6157                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
6158                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
6159                         break; }
6160
6161                         default: {
6162                         break; }
6163
6164                 }
6165         }
6166         if (ndr_flags & NDR_BUFFERS) {
6167                 int level = ndr_push_get_switch_value(ndr, r);
6168                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
6169                 switch (level) {
6170                         case 1:
6171                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
6172                         break;
6173
6174                         default:
6175                         break;
6176
6177                 }
6178         }
6179         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
6180         return NDR_ERR_SUCCESS;
6181 }
6182
6183 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
6184 {
6185         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
6186         int level;
6187         level = ndr_pull_get_switch_value(ndr, r);
6188         if (ndr_flags & NDR_SCALARS) {
6189                 switch (level) {
6190                         case 1: {
6191                                 NDR_CHECK(ndr_pull_align(ndr, 4));
6192                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
6193                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
6194                         break; }
6195
6196                         default: {
6197                         break; }
6198
6199                 }
6200         }
6201         if (ndr_flags & NDR_BUFFERS) {
6202                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
6203                 switch (level) {
6204                         case 1:
6205                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
6206                         break;
6207
6208                         default:
6209                         break;
6210
6211                 }
6212         }
6213         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
6214         return NDR_ERR_SUCCESS;
6215 }
6216
6217 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
6218 {
6219         int level;
6220         level = ndr_print_get_switch_value(ndr, r);
6221         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
6222         switch (level) {
6223                 case 1:
6224                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
6225                 break;
6226
6227                 default:
6228                 break;
6229
6230         }
6231 }
6232
6233 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
6234 {
6235         if (ndr_flags & NDR_SCALARS) {
6236                 NDR_CHECK(ndr_push_align(ndr, 4));
6237                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
6238                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
6239                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6240         }
6241         if (ndr_flags & NDR_BUFFERS) {
6242                 if (r->document_name) {
6243                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
6244                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6245                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
6246                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6247                 }
6248                 if (r->output_file) {
6249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
6250                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6251                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
6252                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6253                 }
6254                 if (r->datatype) {
6255                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6257                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6258                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6259                 }
6260         }
6261         return NDR_ERR_SUCCESS;
6262 }
6263
6264 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
6265 {
6266         uint32_t _ptr_document_name;
6267         TALLOC_CTX *_mem_save_document_name_0;
6268         uint32_t _ptr_output_file;
6269         TALLOC_CTX *_mem_save_output_file_0;
6270         uint32_t _ptr_datatype;
6271         TALLOC_CTX *_mem_save_datatype_0;
6272         if (ndr_flags & NDR_SCALARS) {
6273                 NDR_CHECK(ndr_pull_align(ndr, 4));
6274                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
6275                 if (_ptr_document_name) {
6276                         NDR_PULL_ALLOC(ndr, r->document_name);
6277                 } else {
6278                         r->document_name = NULL;
6279                 }
6280                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
6281                 if (_ptr_output_file) {
6282                         NDR_PULL_ALLOC(ndr, r->output_file);
6283                 } else {
6284                         r->output_file = NULL;
6285                 }
6286                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6287                 if (_ptr_datatype) {
6288                         NDR_PULL_ALLOC(ndr, r->datatype);
6289                 } else {
6290                         r->datatype = NULL;
6291                 }
6292         }
6293         if (ndr_flags & NDR_BUFFERS) {
6294                 if (r->document_name) {
6295                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6296                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
6297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
6298                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
6299                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
6300                                 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));
6301                         }
6302                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
6303                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
6304                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
6305                 }
6306                 if (r->output_file) {
6307                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
6308                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
6309                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
6310                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
6311                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
6312                                 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));
6313                         }
6314                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
6315                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
6316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
6317                 }
6318                 if (r->datatype) {
6319                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6320                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6321                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6322                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6323                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6324                                 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));
6325                         }
6326                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6327                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6328                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6329                 }
6330         }
6331         return NDR_ERR_SUCCESS;
6332 }
6333
6334 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
6335 {
6336         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
6337         ndr->depth++;
6338         ndr_print_ptr(ndr, "document_name", r->document_name);
6339         ndr->depth++;
6340         if (r->document_name) {
6341                 ndr_print_string(ndr, "document_name", r->document_name);
6342         }
6343         ndr->depth--;
6344         ndr_print_ptr(ndr, "output_file", r->output_file);
6345         ndr->depth++;
6346         if (r->output_file) {
6347                 ndr_print_string(ndr, "output_file", r->output_file);
6348         }
6349         ndr->depth--;
6350         ndr_print_ptr(ndr, "datatype", r->datatype);
6351         ndr->depth++;
6352         if (r->datatype) {
6353                 ndr_print_string(ndr, "datatype", r->datatype);
6354         }
6355         ndr->depth--;
6356         ndr->depth--;
6357 }
6358
6359 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
6360 {
6361         if (ndr_flags & NDR_SCALARS) {
6362                 int level = ndr_push_get_switch_value(ndr, r);
6363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6364                 switch (level) {
6365                         case 1: {
6366                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6367                         break; }
6368
6369                         case 2: {
6370                         break; }
6371
6372                         case 3: {
6373                         break; }
6374
6375                         default: {
6376                         break; }
6377
6378                 }
6379         }
6380         if (ndr_flags & NDR_BUFFERS) {
6381                 int level = ndr_push_get_switch_value(ndr, r);
6382                 switch (level) {
6383                         case 1:
6384                                 if (r->info1) {
6385                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6386                                 }
6387                         break;
6388
6389                         case 2:
6390                         break;
6391
6392                         case 3:
6393                         break;
6394
6395                         default:
6396                         break;
6397
6398                 }
6399         }
6400         return NDR_ERR_SUCCESS;
6401 }
6402
6403 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
6404 {
6405         int level;
6406         uint32_t _level;
6407         TALLOC_CTX *_mem_save_info1_0;
6408         level = ndr_pull_get_switch_value(ndr, r);
6409         if (ndr_flags & NDR_SCALARS) {
6410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6411                 if (_level != level) {
6412                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6413                 }
6414                 switch (level) {
6415                         case 1: {
6416                                 uint32_t _ptr_info1;
6417                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6418                                 if (_ptr_info1) {
6419                                         NDR_PULL_ALLOC(ndr, r->info1);
6420                                 } else {
6421                                         r->info1 = NULL;
6422                                 }
6423                         break; }
6424
6425                         case 2: {
6426                         break; }
6427
6428                         case 3: {
6429                         break; }
6430
6431                         default: {
6432                         break; }
6433
6434                 }
6435         }
6436         if (ndr_flags & NDR_BUFFERS) {
6437                 switch (level) {
6438                         case 1:
6439                                 if (r->info1) {
6440                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
6441                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
6442                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6443                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
6444                                 }
6445                         break;
6446
6447                         case 2:
6448                         break;
6449
6450                         case 3:
6451                         break;
6452
6453                         default:
6454                         break;
6455
6456                 }
6457         }
6458         return NDR_ERR_SUCCESS;
6459 }
6460
6461 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
6462 {
6463         int level;
6464         level = ndr_print_get_switch_value(ndr, r);
6465         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
6466         switch (level) {
6467                 case 1:
6468                         ndr_print_ptr(ndr, "info1", r->info1);
6469                         ndr->depth++;
6470                         if (r->info1) {
6471                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
6472                         }
6473                         ndr->depth--;
6474                 break;
6475
6476                 case 2:
6477                 break;
6478
6479                 case 3:
6480                 break;
6481
6482                 default:
6483                 break;
6484
6485         }
6486 }
6487
6488 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
6489 {
6490         if (ndr_flags & NDR_SCALARS) {
6491                 NDR_CHECK(ndr_push_align(ndr, 4));
6492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
6493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
6494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
6495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
6496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
6497                 {
6498                         uint32_t _flags_save_string = ndr->flags;
6499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6500                         {
6501                                 struct ndr_push *_ndr_extra_string;
6502                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
6503                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
6504                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
6505                         }
6506                         ndr->flags = _flags_save_string;
6507                 }
6508         }
6509         if (ndr_flags & NDR_BUFFERS) {
6510         }
6511         return NDR_ERR_SUCCESS;
6512 }
6513
6514 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
6515 {
6516         if (ndr_flags & NDR_SCALARS) {
6517                 NDR_CHECK(ndr_pull_align(ndr, 4));
6518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
6519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
6520                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
6521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
6522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
6523                 {
6524                         uint32_t _flags_save_string = ndr->flags;
6525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6526                         {
6527                                 struct ndr_pull *_ndr_extra_string;
6528                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
6529                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
6530                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
6531                         }
6532                         ndr->flags = _flags_save_string;
6533                 }
6534         }
6535         if (ndr_flags & NDR_BUFFERS) {
6536         }
6537         return NDR_ERR_SUCCESS;
6538 }
6539
6540 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
6541 {
6542         ndr_print_struct(ndr, name, "spoolss_OSVersion");
6543         ndr->depth++;
6544         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);
6545         ndr_print_uint32(ndr, "major", r->major);
6546         ndr_print_uint32(ndr, "minor", r->minor);
6547         ndr_print_uint32(ndr, "build", r->build);
6548         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
6549         ndr_print_string(ndr, "extra_string", r->extra_string);
6550         ndr->depth--;
6551 }
6552
6553 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
6554 {
6555         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
6556 }
6557
6558 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
6559 {
6560         if (ndr_flags & NDR_SCALARS) {
6561                 NDR_CHECK(ndr_push_align(ndr, 4));
6562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
6563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
6564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
6565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
6566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
6567                 {
6568                         uint32_t _flags_save_string = ndr->flags;
6569                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6570                         {
6571                                 struct ndr_push *_ndr_extra_string;
6572                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
6573                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
6574                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
6575                         }
6576                         ndr->flags = _flags_save_string;
6577                 }
6578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
6579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
6580         }
6581         if (ndr_flags & NDR_BUFFERS) {
6582         }
6583         return NDR_ERR_SUCCESS;
6584 }
6585
6586 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
6587 {
6588         if (ndr_flags & NDR_SCALARS) {
6589                 NDR_CHECK(ndr_pull_align(ndr, 4));
6590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
6591                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
6592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
6593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
6594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
6595                 {
6596                         uint32_t _flags_save_string = ndr->flags;
6597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6598                         {
6599                                 struct ndr_pull *_ndr_extra_string;
6600                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
6601                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
6602                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
6603                         }
6604                         ndr->flags = _flags_save_string;
6605                 }
6606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
6607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
6608         }
6609         if (ndr_flags & NDR_BUFFERS) {
6610         }
6611         return NDR_ERR_SUCCESS;
6612 }
6613
6614 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
6615 {
6616         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
6617         ndr->depth++;
6618         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);
6619         ndr_print_uint32(ndr, "major", r->major);
6620         ndr_print_uint32(ndr, "minor", r->minor);
6621         ndr_print_uint32(ndr, "build", r->build);
6622         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
6623         ndr_print_string(ndr, "extra_string", r->extra_string);
6624         ndr_print_uint32(ndr, "unknown2", r->unknown2);
6625         ndr_print_uint32(ndr, "unknown3", r->unknown3);
6626         ndr->depth--;
6627 }
6628
6629 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
6630 {
6631         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
6632 }
6633
6634 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
6635 {
6636         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6637         return NDR_ERR_SUCCESS;
6638 }
6639
6640 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
6641 {
6642         uint32_t v;
6643         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6644         *r = v;
6645         return NDR_ERR_SUCCESS;
6646 }
6647
6648 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
6649 {
6650         const char *val = NULL;
6651
6652         switch (r) {
6653                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
6654                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
6655                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
6656                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
6657                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
6658         }
6659         ndr_print_enum(ndr, name, "ENUM", val, r);
6660 }
6661
6662 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
6663 {
6664         if (ndr_flags & NDR_SCALARS) {
6665                 int level = ndr_push_get_switch_value(ndr, r);
6666                 switch (level) {
6667                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
6668                         break; }
6669
6670                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
6671                                 {
6672                                         uint32_t _flags_save_string = ndr->flags;
6673                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6674                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
6675                                         ndr->flags = _flags_save_string;
6676                                 }
6677                         break; }
6678
6679                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
6680                                 {
6681                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
6682                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
6683                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
6684                                         ndr->flags = _flags_save_DATA_BLOB;
6685                                 }
6686                         break; }
6687
6688                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
6689                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
6690                         break; }
6691
6692                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
6693                                 {
6694                                         uint32_t _flags_save_string_array = ndr->flags;
6695                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6696                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
6697                                         ndr->flags = _flags_save_string_array;
6698                                 }
6699                         break; }
6700
6701                         default: {
6702                                 {
6703                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
6704                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
6705                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
6706                                         ndr->flags = _flags_save_DATA_BLOB;
6707                                 }
6708                         break; }
6709
6710                 }
6711         }
6712         if (ndr_flags & NDR_BUFFERS) {
6713                 int level = ndr_push_get_switch_value(ndr, r);
6714                 switch (level) {
6715                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
6716                         break;
6717
6718                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
6719                         break;
6720
6721                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
6722                         break;
6723
6724                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
6725                         break;
6726
6727                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
6728                         break;
6729
6730                         default:
6731                         break;
6732
6733                 }
6734         }
6735         return NDR_ERR_SUCCESS;
6736 }
6737
6738 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
6739 {
6740         int level;
6741         level = ndr_pull_get_switch_value(ndr, r);
6742         if (ndr_flags & NDR_SCALARS) {
6743                 switch (level) {
6744                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
6745                         break; }
6746
6747                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
6748                                 {
6749                                         uint32_t _flags_save_string = ndr->flags;
6750                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6751                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
6752                                         ndr->flags = _flags_save_string;
6753                                 }
6754                         break; }
6755
6756                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
6757                                 {
6758                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
6759                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
6760                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
6761                                         ndr->flags = _flags_save_DATA_BLOB;
6762                                 }
6763                         break; }
6764
6765                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
6766                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
6767                         break; }
6768
6769                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
6770                                 {
6771                                         uint32_t _flags_save_string_array = ndr->flags;
6772                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6773                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
6774                                         ndr->flags = _flags_save_string_array;
6775                                 }
6776                         break; }
6777
6778                         default: {
6779                                 {
6780                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
6781                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
6782                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
6783                                         ndr->flags = _flags_save_DATA_BLOB;
6784                                 }
6785                         break; }
6786
6787                 }
6788         }
6789         if (ndr_flags & NDR_BUFFERS) {
6790                 switch (level) {
6791                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
6792                         break;
6793
6794                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
6795                         break;
6796
6797                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
6798                         break;
6799
6800                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
6801                         break;
6802
6803                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
6804                         break;
6805
6806                         default:
6807                         break;
6808
6809                 }
6810         }
6811         return NDR_ERR_SUCCESS;
6812 }
6813
6814 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
6815 {
6816         int level;
6817         level = ndr_print_get_switch_value(ndr, r);
6818         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
6819         switch (level) {
6820                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
6821                 break;
6822
6823                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
6824                         ndr_print_string(ndr, "string", r->string);
6825                 break;
6826
6827                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
6828                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
6829                 break;
6830
6831                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
6832                         ndr_print_uint32(ndr, "value", r->value);
6833                 break;
6834
6835                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
6836                         ndr_print_string_array(ndr, "string_array", r->string_array);
6837                 break;
6838
6839                 default:
6840                         ndr_print_DATA_BLOB(ndr, "data", r->data);
6841                 break;
6842
6843         }
6844 }
6845
6846 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
6847 {
6848         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
6849 }
6850
6851 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
6852 {
6853         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
6854         return NDR_ERR_SUCCESS;
6855 }
6856
6857 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
6858 {
6859         uint32_t v;
6860         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
6861         *r = v;
6862         return NDR_ERR_SUCCESS;
6863 }
6864
6865 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
6866 {
6867         const char *val = NULL;
6868
6869         switch (r) {
6870                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
6871                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
6872                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
6873         }
6874         ndr_print_enum(ndr, name, "ENUM", val, r);
6875 }
6876
6877 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
6878 {
6879         if (ndr_flags & NDR_SCALARS) {
6880                 NDR_CHECK(ndr_push_align(ndr, 4));
6881                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
6882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
6883         }
6884         if (ndr_flags & NDR_BUFFERS) {
6885         }
6886         return NDR_ERR_SUCCESS;
6887 }
6888
6889 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
6890 {
6891         if (ndr_flags & NDR_SCALARS) {
6892                 NDR_CHECK(ndr_pull_align(ndr, 4));
6893                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
6894                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
6895         }
6896         if (ndr_flags & NDR_BUFFERS) {
6897         }
6898         return NDR_ERR_SUCCESS;
6899 }
6900
6901 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
6902 {
6903         ndr_print_struct(ndr, name, "spoolss_FormSize");
6904         ndr->depth++;
6905         ndr_print_uint32(ndr, "width", r->width);
6906         ndr_print_uint32(ndr, "height", r->height);
6907         ndr->depth--;
6908 }
6909
6910 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
6911 {
6912         if (ndr_flags & NDR_SCALARS) {
6913                 NDR_CHECK(ndr_push_align(ndr, 4));
6914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
6915                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
6916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
6917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
6918         }
6919         if (ndr_flags & NDR_BUFFERS) {
6920         }
6921         return NDR_ERR_SUCCESS;
6922 }
6923
6924 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
6925 {
6926         if (ndr_flags & NDR_SCALARS) {
6927                 NDR_CHECK(ndr_pull_align(ndr, 4));
6928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
6929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
6930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
6931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
6932         }
6933         if (ndr_flags & NDR_BUFFERS) {
6934         }
6935         return NDR_ERR_SUCCESS;
6936 }
6937
6938 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
6939 {
6940         ndr_print_struct(ndr, name, "spoolss_FormArea");
6941         ndr->depth++;
6942         ndr_print_uint32(ndr, "left", r->left);
6943         ndr_print_uint32(ndr, "top", r->top);
6944         ndr_print_uint32(ndr, "right", r->right);
6945         ndr_print_uint32(ndr, "bottom", r->bottom);
6946         ndr->depth--;
6947 }
6948
6949 static enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
6950 {
6951         if (ndr_flags & NDR_SCALARS) {
6952                 NDR_CHECK(ndr_push_align(ndr, 4));
6953                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
6954                 {
6955                         uint32_t _flags_save_string = ndr->flags;
6956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
6958                         ndr->flags = _flags_save_string;
6959                 }
6960                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
6961                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
6962         }
6963         if (ndr_flags & NDR_BUFFERS) {
6964                 {
6965                         uint32_t _flags_save_string = ndr->flags;
6966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6967                         if (r->form_name) {
6968                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
6969                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
6970                         }
6971                         ndr->flags = _flags_save_string;
6972                 }
6973         }
6974         return NDR_ERR_SUCCESS;
6975 }
6976
6977 static enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
6978 {
6979         uint32_t _ptr_form_name;
6980         TALLOC_CTX *_mem_save_form_name_0;
6981         if (ndr_flags & NDR_SCALARS) {
6982                 NDR_CHECK(ndr_pull_align(ndr, 4));
6983                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
6984                 {
6985                         uint32_t _flags_save_string = ndr->flags;
6986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
6987                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
6988                         if (_ptr_form_name) {
6989                                 NDR_PULL_ALLOC(ndr, r->form_name);
6990                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
6991                         } else {
6992                                 r->form_name = NULL;
6993                         }
6994                         ndr->flags = _flags_save_string;
6995                 }
6996                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
6997                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
6998         }
6999         if (ndr_flags & NDR_BUFFERS) {
7000                 {
7001                         uint32_t _flags_save_string = ndr->flags;
7002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7003                         if (r->form_name) {
7004                                 uint32_t _relative_save_offset;
7005                                 _relative_save_offset = ndr->offset;
7006                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
7007                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7008                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
7009                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
7010                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
7011                                 ndr->offset = _relative_save_offset;
7012                         }
7013                         ndr->flags = _flags_save_string;
7014                 }
7015         }
7016         return NDR_ERR_SUCCESS;
7017 }
7018
7019 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
7020 {
7021         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
7022         ndr->depth++;
7023         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
7024         ndr_print_ptr(ndr, "form_name", r->form_name);
7025         ndr->depth++;
7026         if (r->form_name) {
7027                 ndr_print_string(ndr, "form_name", r->form_name);
7028         }
7029         ndr->depth--;
7030         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
7031         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
7032         ndr->depth--;
7033 }
7034
7035 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
7036 {
7037         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
7038         if (ndr_flags & NDR_SCALARS) {
7039                 int level = ndr_push_get_switch_value(ndr, r);
7040                 switch (level) {
7041                         case 1: {
7042                                 NDR_CHECK(ndr_push_align(ndr, 4));
7043                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
7044                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
7045                         break; }
7046
7047                         default: {
7048                         break; }
7049
7050                 }
7051         }
7052         if (ndr_flags & NDR_BUFFERS) {
7053                 int level = ndr_push_get_switch_value(ndr, r);
7054                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
7055                 switch (level) {
7056                         case 1:
7057                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
7058                         break;
7059
7060                         default:
7061                         break;
7062
7063                 }
7064         }
7065         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
7066         return NDR_ERR_SUCCESS;
7067 }
7068
7069 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
7070 {
7071         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
7072         int level;
7073         level = ndr_pull_get_switch_value(ndr, r);
7074         if (ndr_flags & NDR_SCALARS) {
7075                 switch (level) {
7076                         case 1: {
7077                                 NDR_CHECK(ndr_pull_align(ndr, 4));
7078                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
7079                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
7080                         break; }
7081
7082                         default: {
7083                         break; }
7084
7085                 }
7086         }
7087         if (ndr_flags & NDR_BUFFERS) {
7088                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
7089                 switch (level) {
7090                         case 1:
7091                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
7092                         break;
7093
7094                         default:
7095                         break;
7096
7097                 }
7098         }
7099         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
7100         return NDR_ERR_SUCCESS;
7101 }
7102
7103 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
7104 {
7105         int level;
7106         level = ndr_print_get_switch_value(ndr, r);
7107         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
7108         switch (level) {
7109                 case 1:
7110                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
7111                 break;
7112
7113                 default:
7114                 break;
7115
7116         }
7117 }
7118
7119 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
7120 {
7121         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
7122 }
7123
7124 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
7125 {
7126         if (ndr_flags & NDR_SCALARS) {
7127                 NDR_CHECK(ndr_push_align(ndr, 4));
7128                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
7129                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
7130                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
7131                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
7132         }
7133         if (ndr_flags & NDR_BUFFERS) {
7134                 if (r->form_name) {
7135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
7136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
7138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7139                 }
7140         }
7141         return NDR_ERR_SUCCESS;
7142 }
7143
7144 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
7145 {
7146         uint32_t _ptr_form_name;
7147         TALLOC_CTX *_mem_save_form_name_0;
7148         if (ndr_flags & NDR_SCALARS) {
7149                 NDR_CHECK(ndr_pull_align(ndr, 4));
7150                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
7151                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
7152                 if (_ptr_form_name) {
7153                         NDR_PULL_ALLOC(ndr, r->form_name);
7154                 } else {
7155                         r->form_name = NULL;
7156                 }
7157                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
7158                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
7159         }
7160         if (ndr_flags & NDR_BUFFERS) {
7161                 if (r->form_name) {
7162                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7163                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
7164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
7165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
7166                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
7167                                 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));
7168                         }
7169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
7170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
7171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
7172                 }
7173         }
7174         return NDR_ERR_SUCCESS;
7175 }
7176
7177 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
7178 {
7179         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
7180         ndr->depth++;
7181         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
7182         ndr_print_ptr(ndr, "form_name", r->form_name);
7183         ndr->depth++;
7184         if (r->form_name) {
7185                 ndr_print_string(ndr, "form_name", r->form_name);
7186         }
7187         ndr->depth--;
7188         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
7189         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
7190         ndr->depth--;
7191 }
7192
7193 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
7194 {
7195         if (ndr_flags & NDR_SCALARS) {
7196                 int level = ndr_push_get_switch_value(ndr, r);
7197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
7198                 switch (level) {
7199                         case 1: {
7200                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
7201                         break; }
7202
7203                         default:
7204                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7205                 }
7206         }
7207         if (ndr_flags & NDR_BUFFERS) {
7208                 int level = ndr_push_get_switch_value(ndr, r);
7209                 switch (level) {
7210                         case 1:
7211                                 if (r->info1) {
7212                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7213                                 }
7214                         break;
7215
7216                         default:
7217                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7218                 }
7219         }
7220         return NDR_ERR_SUCCESS;
7221 }
7222
7223 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
7224 {
7225         int level;
7226         uint32_t _level;
7227         TALLOC_CTX *_mem_save_info1_0;
7228         level = ndr_pull_get_switch_value(ndr, r);
7229         if (ndr_flags & NDR_SCALARS) {
7230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7231                 if (_level != level) {
7232                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7233                 }
7234                 switch (level) {
7235                         case 1: {
7236                                 uint32_t _ptr_info1;
7237                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7238                                 if (_ptr_info1) {
7239                                         NDR_PULL_ALLOC(ndr, r->info1);
7240                                 } else {
7241                                         r->info1 = NULL;
7242                                 }
7243                         break; }
7244
7245                         default:
7246                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7247                 }
7248         }
7249         if (ndr_flags & NDR_BUFFERS) {
7250                 switch (level) {
7251                         case 1:
7252                                 if (r->info1) {
7253                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7254                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7255                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7256                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7257                                 }
7258                         break;
7259
7260                         default:
7261                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
7262                 }
7263         }
7264         return NDR_ERR_SUCCESS;
7265 }
7266
7267 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
7268 {
7269         int level;
7270         level = ndr_print_get_switch_value(ndr, r);
7271         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
7272         switch (level) {
7273                 case 1:
7274                         ndr_print_ptr(ndr, "info1", r->info1);
7275                         ndr->depth++;
7276                         if (r->info1) {
7277                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
7278                         }
7279                         ndr->depth--;
7280                 break;
7281
7282                 default:
7283                         ndr_print_bad_level(ndr, name, level);
7284         }
7285 }
7286
7287 static enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
7288 {
7289         if (ndr_flags & NDR_SCALARS) {
7290                 NDR_CHECK(ndr_push_align(ndr, 4));
7291                 {
7292                         uint32_t _flags_save_string = ndr->flags;
7293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
7295                         ndr->flags = _flags_save_string;
7296                 }
7297         }
7298         if (ndr_flags & NDR_BUFFERS) {
7299                 {
7300                         uint32_t _flags_save_string = ndr->flags;
7301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7302                         if (r->port_name) {
7303                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
7304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
7305                         }
7306                         ndr->flags = _flags_save_string;
7307                 }
7308         }
7309         return NDR_ERR_SUCCESS;
7310 }
7311
7312 static enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
7313 {
7314         uint32_t _ptr_port_name;
7315         TALLOC_CTX *_mem_save_port_name_0;
7316         if (ndr_flags & NDR_SCALARS) {
7317                 NDR_CHECK(ndr_pull_align(ndr, 4));
7318                 {
7319                         uint32_t _flags_save_string = ndr->flags;
7320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7321                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
7322                         if (_ptr_port_name) {
7323                                 NDR_PULL_ALLOC(ndr, r->port_name);
7324                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
7325                         } else {
7326                                 r->port_name = NULL;
7327                         }
7328                         ndr->flags = _flags_save_string;
7329                 }
7330         }
7331         if (ndr_flags & NDR_BUFFERS) {
7332                 {
7333                         uint32_t _flags_save_string = ndr->flags;
7334                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7335                         if (r->port_name) {
7336                                 uint32_t _relative_save_offset;
7337                                 _relative_save_offset = ndr->offset;
7338                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
7339                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7340                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
7341                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
7342                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
7343                                 ndr->offset = _relative_save_offset;
7344                         }
7345                         ndr->flags = _flags_save_string;
7346                 }
7347         }
7348         return NDR_ERR_SUCCESS;
7349 }
7350
7351 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
7352 {
7353         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
7354         ndr->depth++;
7355         ndr_print_ptr(ndr, "port_name", r->port_name);
7356         ndr->depth++;
7357         if (r->port_name) {
7358                 ndr_print_string(ndr, "port_name", r->port_name);
7359         }
7360         ndr->depth--;
7361         ndr->depth--;
7362 }
7363
7364 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
7365 {
7366         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7367         return NDR_ERR_SUCCESS;
7368 }
7369
7370 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
7371 {
7372         uint32_t v;
7373         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7374         *r = v;
7375         return NDR_ERR_SUCCESS;
7376 }
7377
7378 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
7379 {
7380         ndr_print_uint32(ndr, name, r);
7381         ndr->depth++;
7382         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
7383         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
7384         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
7385         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
7386         ndr->depth--;
7387 }
7388
7389 static enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
7390 {
7391         if (ndr_flags & NDR_SCALARS) {
7392                 NDR_CHECK(ndr_push_align(ndr, 4));
7393                 {
7394                         uint32_t _flags_save_string = ndr->flags;
7395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7396                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
7397                         ndr->flags = _flags_save_string;
7398                 }
7399                 {
7400                         uint32_t _flags_save_string = ndr->flags;
7401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7402                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7403                         ndr->flags = _flags_save_string;
7404                 }
7405                 {
7406                         uint32_t _flags_save_string = ndr->flags;
7407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7408                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
7409                         ndr->flags = _flags_save_string;
7410                 }
7411                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
7412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
7413         }
7414         if (ndr_flags & NDR_BUFFERS) {
7415                 {
7416                         uint32_t _flags_save_string = ndr->flags;
7417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7418                         if (r->port_name) {
7419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
7420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
7421                         }
7422                         ndr->flags = _flags_save_string;
7423                 }
7424                 {
7425                         uint32_t _flags_save_string = ndr->flags;
7426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7427                         if (r->monitor_name) {
7428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7430                         }
7431                         ndr->flags = _flags_save_string;
7432                 }
7433                 {
7434                         uint32_t _flags_save_string = ndr->flags;
7435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7436                         if (r->description) {
7437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
7438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
7439                         }
7440                         ndr->flags = _flags_save_string;
7441                 }
7442         }
7443         return NDR_ERR_SUCCESS;
7444 }
7445
7446 static enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
7447 {
7448         uint32_t _ptr_port_name;
7449         TALLOC_CTX *_mem_save_port_name_0;
7450         uint32_t _ptr_monitor_name;
7451         TALLOC_CTX *_mem_save_monitor_name_0;
7452         uint32_t _ptr_description;
7453         TALLOC_CTX *_mem_save_description_0;
7454         if (ndr_flags & NDR_SCALARS) {
7455                 NDR_CHECK(ndr_pull_align(ndr, 4));
7456                 {
7457                         uint32_t _flags_save_string = ndr->flags;
7458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7459                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
7460                         if (_ptr_port_name) {
7461                                 NDR_PULL_ALLOC(ndr, r->port_name);
7462                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
7463                         } else {
7464                                 r->port_name = NULL;
7465                         }
7466                         ndr->flags = _flags_save_string;
7467                 }
7468                 {
7469                         uint32_t _flags_save_string = ndr->flags;
7470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7471                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7472                         if (_ptr_monitor_name) {
7473                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7474                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7475                         } else {
7476                                 r->monitor_name = NULL;
7477                         }
7478                         ndr->flags = _flags_save_string;
7479                 }
7480                 {
7481                         uint32_t _flags_save_string = ndr->flags;
7482                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7483                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
7484                         if (_ptr_description) {
7485                                 NDR_PULL_ALLOC(ndr, r->description);
7486                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
7487                         } else {
7488                                 r->description = NULL;
7489                         }
7490                         ndr->flags = _flags_save_string;
7491                 }
7492                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
7493                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
7494         }
7495         if (ndr_flags & NDR_BUFFERS) {
7496                 {
7497                         uint32_t _flags_save_string = ndr->flags;
7498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7499                         if (r->port_name) {
7500                                 uint32_t _relative_save_offset;
7501                                 _relative_save_offset = ndr->offset;
7502                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
7503                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7504                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
7505                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
7506                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
7507                                 ndr->offset = _relative_save_offset;
7508                         }
7509                         ndr->flags = _flags_save_string;
7510                 }
7511                 {
7512                         uint32_t _flags_save_string = ndr->flags;
7513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7514                         if (r->monitor_name) {
7515                                 uint32_t _relative_save_offset;
7516                                 _relative_save_offset = ndr->offset;
7517                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7518                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7519                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7520                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7521                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7522                                 ndr->offset = _relative_save_offset;
7523                         }
7524                         ndr->flags = _flags_save_string;
7525                 }
7526                 {
7527                         uint32_t _flags_save_string = ndr->flags;
7528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7529                         if (r->description) {
7530                                 uint32_t _relative_save_offset;
7531                                 _relative_save_offset = ndr->offset;
7532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
7533                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
7534                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
7535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
7536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
7537                                 ndr->offset = _relative_save_offset;
7538                         }
7539                         ndr->flags = _flags_save_string;
7540                 }
7541         }
7542         return NDR_ERR_SUCCESS;
7543 }
7544
7545 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
7546 {
7547         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
7548         ndr->depth++;
7549         ndr_print_ptr(ndr, "port_name", r->port_name);
7550         ndr->depth++;
7551         if (r->port_name) {
7552                 ndr_print_string(ndr, "port_name", r->port_name);
7553         }
7554         ndr->depth--;
7555         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7556         ndr->depth++;
7557         if (r->monitor_name) {
7558                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7559         }
7560         ndr->depth--;
7561         ndr_print_ptr(ndr, "description", r->description);
7562         ndr->depth++;
7563         if (r->description) {
7564                 ndr_print_string(ndr, "description", r->description);
7565         }
7566         ndr->depth--;
7567         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
7568         ndr_print_uint32(ndr, "reserved", r->reserved);
7569         ndr->depth--;
7570 }
7571
7572 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
7573 {
7574         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
7575         if (ndr_flags & NDR_SCALARS) {
7576                 int level = ndr_push_get_switch_value(ndr, r);
7577                 switch (level) {
7578                         case 1: {
7579                                 NDR_CHECK(ndr_push_align(ndr, 4));
7580                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
7581                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
7582                         break; }
7583
7584                         case 2: {
7585                                 NDR_CHECK(ndr_push_align(ndr, 4));
7586                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
7587                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
7588                         break; }
7589
7590                         case 3: {
7591                         break; }
7592
7593                         default: {
7594                         break; }
7595
7596                 }
7597         }
7598         if (ndr_flags & NDR_BUFFERS) {
7599                 int level = ndr_push_get_switch_value(ndr, r);
7600                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
7601                 switch (level) {
7602                         case 1:
7603                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
7604                         break;
7605
7606                         case 2:
7607                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
7608                         break;
7609
7610                         case 3:
7611                         break;
7612
7613                         default:
7614                         break;
7615
7616                 }
7617         }
7618         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
7619         return NDR_ERR_SUCCESS;
7620 }
7621
7622 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
7623 {
7624         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
7625         int level;
7626         level = ndr_pull_get_switch_value(ndr, r);
7627         if (ndr_flags & NDR_SCALARS) {
7628                 switch (level) {
7629                         case 1: {
7630                                 NDR_CHECK(ndr_pull_align(ndr, 4));
7631                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
7632                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
7633                         break; }
7634
7635                         case 2: {
7636                                 NDR_CHECK(ndr_pull_align(ndr, 4));
7637                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
7638                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
7639                         break; }
7640
7641                         case 3: {
7642                         break; }
7643
7644                         default: {
7645                         break; }
7646
7647                 }
7648         }
7649         if (ndr_flags & NDR_BUFFERS) {
7650                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
7651                 switch (level) {
7652                         case 1:
7653                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
7654                         break;
7655
7656                         case 2:
7657                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
7658                         break;
7659
7660                         case 3:
7661                         break;
7662
7663                         default:
7664                         break;
7665
7666                 }
7667         }
7668         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
7669         return NDR_ERR_SUCCESS;
7670 }
7671
7672 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
7673 {
7674         int level;
7675         level = ndr_print_get_switch_value(ndr, r);
7676         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
7677         switch (level) {
7678                 case 1:
7679                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
7680                 break;
7681
7682                 case 2:
7683                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
7684                 break;
7685
7686                 case 3:
7687                 break;
7688
7689                 default:
7690                 break;
7691
7692         }
7693 }
7694
7695 static enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
7696 {
7697         if (ndr_flags & NDR_SCALARS) {
7698                 NDR_CHECK(ndr_push_align(ndr, 4));
7699                 {
7700                         uint32_t _flags_save_string = ndr->flags;
7701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7702                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7703                         ndr->flags = _flags_save_string;
7704                 }
7705         }
7706         if (ndr_flags & NDR_BUFFERS) {
7707                 {
7708                         uint32_t _flags_save_string = ndr->flags;
7709                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7710                         if (r->monitor_name) {
7711                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7712                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7713                         }
7714                         ndr->flags = _flags_save_string;
7715                 }
7716         }
7717         return NDR_ERR_SUCCESS;
7718 }
7719
7720 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
7721 {
7722         uint32_t _ptr_monitor_name;
7723         TALLOC_CTX *_mem_save_monitor_name_0;
7724         if (ndr_flags & NDR_SCALARS) {
7725                 NDR_CHECK(ndr_pull_align(ndr, 4));
7726                 {
7727                         uint32_t _flags_save_string = ndr->flags;
7728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7729                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7730                         if (_ptr_monitor_name) {
7731                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7732                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7733                         } else {
7734                                 r->monitor_name = NULL;
7735                         }
7736                         ndr->flags = _flags_save_string;
7737                 }
7738         }
7739         if (ndr_flags & NDR_BUFFERS) {
7740                 {
7741                         uint32_t _flags_save_string = ndr->flags;
7742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7743                         if (r->monitor_name) {
7744                                 uint32_t _relative_save_offset;
7745                                 _relative_save_offset = ndr->offset;
7746                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7747                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7748                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7749                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7750                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7751                                 ndr->offset = _relative_save_offset;
7752                         }
7753                         ndr->flags = _flags_save_string;
7754                 }
7755         }
7756         return NDR_ERR_SUCCESS;
7757 }
7758
7759 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
7760 {
7761         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
7762         ndr->depth++;
7763         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7764         ndr->depth++;
7765         if (r->monitor_name) {
7766                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7767         }
7768         ndr->depth--;
7769         ndr->depth--;
7770 }
7771
7772 static enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
7773 {
7774         if (ndr_flags & NDR_SCALARS) {
7775                 NDR_CHECK(ndr_push_align(ndr, 4));
7776                 {
7777                         uint32_t _flags_save_string = ndr->flags;
7778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7779                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
7780                         ndr->flags = _flags_save_string;
7781                 }
7782                 {
7783                         uint32_t _flags_save_string = ndr->flags;
7784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7785                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
7786                         ndr->flags = _flags_save_string;
7787                 }
7788                 {
7789                         uint32_t _flags_save_string = ndr->flags;
7790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7791                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
7792                         ndr->flags = _flags_save_string;
7793                 }
7794         }
7795         if (ndr_flags & NDR_BUFFERS) {
7796                 {
7797                         uint32_t _flags_save_string = ndr->flags;
7798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7799                         if (r->monitor_name) {
7800                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
7801                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
7802                         }
7803                         ndr->flags = _flags_save_string;
7804                 }
7805                 {
7806                         uint32_t _flags_save_string = ndr->flags;
7807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7808                         if (r->environment) {
7809                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
7810                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
7811                         }
7812                         ndr->flags = _flags_save_string;
7813                 }
7814                 {
7815                         uint32_t _flags_save_string = ndr->flags;
7816                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7817                         if (r->dll_name) {
7818                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
7819                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
7820                         }
7821                         ndr->flags = _flags_save_string;
7822                 }
7823         }
7824         return NDR_ERR_SUCCESS;
7825 }
7826
7827 static enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
7828 {
7829         uint32_t _ptr_monitor_name;
7830         TALLOC_CTX *_mem_save_monitor_name_0;
7831         uint32_t _ptr_environment;
7832         TALLOC_CTX *_mem_save_environment_0;
7833         uint32_t _ptr_dll_name;
7834         TALLOC_CTX *_mem_save_dll_name_0;
7835         if (ndr_flags & NDR_SCALARS) {
7836                 NDR_CHECK(ndr_pull_align(ndr, 4));
7837                 {
7838                         uint32_t _flags_save_string = ndr->flags;
7839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7840                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7841                         if (_ptr_monitor_name) {
7842                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
7843                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
7844                         } else {
7845                                 r->monitor_name = NULL;
7846                         }
7847                         ndr->flags = _flags_save_string;
7848                 }
7849                 {
7850                         uint32_t _flags_save_string = ndr->flags;
7851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7852                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
7853                         if (_ptr_environment) {
7854                                 NDR_PULL_ALLOC(ndr, r->environment);
7855                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
7856                         } else {
7857                                 r->environment = NULL;
7858                         }
7859                         ndr->flags = _flags_save_string;
7860                 }
7861                 {
7862                         uint32_t _flags_save_string = ndr->flags;
7863                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7864                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
7865                         if (_ptr_dll_name) {
7866                                 NDR_PULL_ALLOC(ndr, r->dll_name);
7867                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
7868                         } else {
7869                                 r->dll_name = NULL;
7870                         }
7871                         ndr->flags = _flags_save_string;
7872                 }
7873         }
7874         if (ndr_flags & NDR_BUFFERS) {
7875                 {
7876                         uint32_t _flags_save_string = ndr->flags;
7877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7878                         if (r->monitor_name) {
7879                                 uint32_t _relative_save_offset;
7880                                 _relative_save_offset = ndr->offset;
7881                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
7882                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7883                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7884                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
7885                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7886                                 ndr->offset = _relative_save_offset;
7887                         }
7888                         ndr->flags = _flags_save_string;
7889                 }
7890                 {
7891                         uint32_t _flags_save_string = ndr->flags;
7892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7893                         if (r->environment) {
7894                                 uint32_t _relative_save_offset;
7895                                 _relative_save_offset = ndr->offset;
7896                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
7897                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
7898                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
7899                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
7900                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
7901                                 ndr->offset = _relative_save_offset;
7902                         }
7903                         ndr->flags = _flags_save_string;
7904                 }
7905                 {
7906                         uint32_t _flags_save_string = ndr->flags;
7907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7908                         if (r->dll_name) {
7909                                 uint32_t _relative_save_offset;
7910                                 _relative_save_offset = ndr->offset;
7911                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
7912                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7913                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
7914                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
7915                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
7916                                 ndr->offset = _relative_save_offset;
7917                         }
7918                         ndr->flags = _flags_save_string;
7919                 }
7920         }
7921         return NDR_ERR_SUCCESS;
7922 }
7923
7924 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
7925 {
7926         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
7927         ndr->depth++;
7928         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7929         ndr->depth++;
7930         if (r->monitor_name) {
7931                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7932         }
7933         ndr->depth--;
7934         ndr_print_ptr(ndr, "environment", r->environment);
7935         ndr->depth++;
7936         if (r->environment) {
7937                 ndr_print_string(ndr, "environment", r->environment);
7938         }
7939         ndr->depth--;
7940         ndr_print_ptr(ndr, "dll_name", r->dll_name);
7941         ndr->depth++;
7942         if (r->dll_name) {
7943                 ndr_print_string(ndr, "dll_name", r->dll_name);
7944         }
7945         ndr->depth--;
7946         ndr->depth--;
7947 }
7948
7949 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
7950 {
7951         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
7952         if (ndr_flags & NDR_SCALARS) {
7953                 int level = ndr_push_get_switch_value(ndr, r);
7954                 switch (level) {
7955                         case 1: {
7956                                 NDR_CHECK(ndr_push_align(ndr, 4));
7957                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
7958                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
7959                         break; }
7960
7961                         case 2: {
7962                                 NDR_CHECK(ndr_push_align(ndr, 4));
7963                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
7964                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
7965                         break; }
7966
7967                         default: {
7968                         break; }
7969
7970                 }
7971         }
7972         if (ndr_flags & NDR_BUFFERS) {
7973                 int level = ndr_push_get_switch_value(ndr, r);
7974                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
7975                 switch (level) {
7976                         case 1:
7977                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
7978                         break;
7979
7980                         case 2:
7981                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
7982                         break;
7983
7984                         default:
7985                         break;
7986
7987                 }
7988         }
7989         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
7990         return NDR_ERR_SUCCESS;
7991 }
7992
7993 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
7994 {
7995         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
7996         int level;
7997         level = ndr_pull_get_switch_value(ndr, r);
7998         if (ndr_flags & NDR_SCALARS) {
7999                 switch (level) {
8000                         case 1: {
8001                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8002                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8003                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
8004                         break; }
8005
8006                         case 2: {
8007                                 NDR_CHECK(ndr_pull_align(ndr, 4));
8008                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
8009                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
8010                         break; }
8011
8012                         default: {
8013                         break; }
8014
8015                 }
8016         }
8017         if (ndr_flags & NDR_BUFFERS) {
8018                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
8019                 switch (level) {
8020                         case 1:
8021                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
8022                         break;
8023
8024                         case 2:
8025                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
8026                         break;
8027
8028                         default:
8029                         break;
8030
8031                 }
8032         }
8033         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
8034         return NDR_ERR_SUCCESS;
8035 }
8036
8037 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
8038 {
8039         int level;
8040         level = ndr_print_get_switch_value(ndr, r);
8041         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
8042         switch (level) {
8043                 case 1:
8044                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
8045                 break;
8046
8047                 case 2:
8048                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
8049                 break;
8050
8051                 default:
8052                 break;
8053
8054         }
8055 }
8056
8057 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8058 {
8059         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8060         return NDR_ERR_SUCCESS;
8061 }
8062
8063 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8064 {
8065         uint32_t v;
8066         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8067         *r = v;
8068         return NDR_ERR_SUCCESS;
8069 }
8070
8071 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
8072 {
8073         ndr_print_uint32(ndr, name, r);
8074         ndr->depth++;
8075         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
8076         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
8077         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
8078         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
8079         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
8080         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
8081         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
8082         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
8083         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
8084         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
8085         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
8086         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
8087         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
8088         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
8089         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
8090         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
8091         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
8092         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
8093         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
8094         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
8095         ndr->depth--;
8096 }
8097
8098 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
8099 {
8100         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
8101         return NDR_ERR_SUCCESS;
8102 }
8103
8104 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
8105 {
8106         uint16_t v;
8107         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
8108         *r = v;
8109         return NDR_ERR_SUCCESS;
8110 }
8111
8112 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
8113 {
8114         const char *val = NULL;
8115
8116         switch (r) {
8117                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
8118                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
8119                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
8120                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
8121                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
8122                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
8123                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
8124                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
8125                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
8126                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
8127                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
8128                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
8129                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
8130                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
8131                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
8132                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
8133                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
8134                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
8135                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
8136                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
8137                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
8138                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
8139                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
8140                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
8141                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
8142                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
8143         }
8144         ndr_print_enum(ndr, name, "ENUM", val, r);
8145 }
8146
8147 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
8148 {
8149         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
8150         return NDR_ERR_SUCCESS;
8151 }
8152
8153 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
8154 {
8155         uint16_t v;
8156         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
8157         *r = v;
8158         return NDR_ERR_SUCCESS;
8159 }
8160
8161 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
8162 {
8163         const char *val = NULL;
8164
8165         switch (r) {
8166                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
8167                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
8168         }
8169         ndr_print_enum(ndr, name, "ENUM", val, r);
8170 }
8171
8172 static enum ndr_err_code ndr_push_spoolss_NotifyOptionsArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionsArray *r)
8173 {
8174         uint32_t cntr_fields_1;
8175         if (ndr_flags & NDR_SCALARS) {
8176                 NDR_CHECK(ndr_push_align(ndr, 4));
8177                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
8178                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
8179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
8180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
8181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
8183         }
8184         if (ndr_flags & NDR_BUFFERS) {
8185                 if (r->fields) {
8186                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8187                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
8188                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
8189                         }
8190                 }
8191         }
8192         return NDR_ERR_SUCCESS;
8193 }
8194
8195 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionsArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionsArray *r)
8196 {
8197         uint32_t _ptr_fields;
8198         uint32_t cntr_fields_1;
8199         TALLOC_CTX *_mem_save_fields_0;
8200         TALLOC_CTX *_mem_save_fields_1;
8201         if (ndr_flags & NDR_SCALARS) {
8202                 NDR_CHECK(ndr_pull_align(ndr, 4));
8203                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
8204                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
8205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
8206                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
8207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8208                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
8209                 if (_ptr_fields) {
8210                         NDR_PULL_ALLOC(ndr, r->fields);
8211                 } else {
8212                         r->fields = NULL;
8213                 }
8214         }
8215         if (ndr_flags & NDR_BUFFERS) {
8216                 if (r->fields) {
8217                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
8218                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
8219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
8220                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
8221                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
8222                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
8223                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
8224                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
8225                         }
8226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
8228                 }
8229                 if (r->fields) {
8230                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
8231                 }
8232         }
8233         return NDR_ERR_SUCCESS;
8234 }
8235
8236 _PUBLIC_ void ndr_print_spoolss_NotifyOptionsArray(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionsArray *r)
8237 {
8238         uint32_t cntr_fields_1;
8239         ndr_print_struct(ndr, name, "spoolss_NotifyOptionsArray");
8240         ndr->depth++;
8241         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
8242         ndr_print_uint16(ndr, "u1", r->u1);
8243         ndr_print_uint32(ndr, "u2", r->u2);
8244         ndr_print_uint32(ndr, "u3", r->u3);
8245         ndr_print_uint32(ndr, "count", r->count);
8246         ndr_print_ptr(ndr, "fields", r->fields);
8247         ndr->depth++;
8248         if (r->fields) {
8249                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
8250                 ndr->depth++;
8251                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
8252                         char *idx_1=NULL;
8253                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
8254                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
8255                                 free(idx_1);
8256                         }
8257                 }
8258                 ndr->depth--;
8259         }
8260         ndr->depth--;
8261         ndr->depth--;
8262 }
8263
8264 static enum ndr_err_code ndr_push_spoolss_NotifyOptionsContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionsContainer *r)
8265 {
8266         uint32_t cntr_options_1;
8267         if (ndr_flags & NDR_SCALARS) {
8268                 NDR_CHECK(ndr_push_align(ndr, 4));
8269                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
8270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
8271                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8272                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->options));
8273         }
8274         if (ndr_flags & NDR_BUFFERS) {
8275                 if (r->options) {
8276                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8277                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8278                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionsArray(ndr, NDR_SCALARS, &r->options[cntr_options_1]));
8279                         }
8280                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8281                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionsArray(ndr, NDR_BUFFERS, &r->options[cntr_options_1]));
8282                         }
8283                 }
8284         }
8285         return NDR_ERR_SUCCESS;
8286 }
8287
8288 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionsContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionsContainer *r)
8289 {
8290         uint32_t _ptr_options;
8291         uint32_t cntr_options_1;
8292         TALLOC_CTX *_mem_save_options_0;
8293         TALLOC_CTX *_mem_save_options_1;
8294         if (ndr_flags & NDR_SCALARS) {
8295                 NDR_CHECK(ndr_pull_align(ndr, 4));
8296                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
8297                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
8298                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
8300                 if (_ptr_options) {
8301                         NDR_PULL_ALLOC(ndr, r->options);
8302                 } else {
8303                         r->options = NULL;
8304                 }
8305         }
8306         if (ndr_flags & NDR_BUFFERS) {
8307                 if (r->options) {
8308                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
8309                         NDR_PULL_SET_MEM_CTX(ndr, r->options, 0);
8310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->options));
8311                         NDR_PULL_ALLOC_N(ndr, r->options, ndr_get_array_size(ndr, &r->options));
8312                         _mem_save_options_1 = NDR_PULL_GET_MEM_CTX(ndr);
8313                         NDR_PULL_SET_MEM_CTX(ndr, r->options, 0);
8314                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8315                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionsArray(ndr, NDR_SCALARS, &r->options[cntr_options_1]));
8316                         }
8317                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8318                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionsArray(ndr, NDR_BUFFERS, &r->options[cntr_options_1]));
8319                         }
8320                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_1, 0);
8321                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
8322                 }
8323                 if (r->options) {
8324                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->options, r->count));
8325                 }
8326         }
8327         return NDR_ERR_SUCCESS;
8328 }
8329
8330 _PUBLIC_ void ndr_print_spoolss_NotifyOptionsContainer(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionsContainer *r)
8331 {
8332         uint32_t cntr_options_1;
8333         ndr_print_struct(ndr, name, "spoolss_NotifyOptionsContainer");
8334         ndr->depth++;
8335         ndr_print_uint32(ndr, "version", r->version);
8336         ndr_print_uint32(ndr, "flags", r->flags);
8337         ndr_print_uint32(ndr, "count", r->count);
8338         ndr_print_ptr(ndr, "options", r->options);
8339         ndr->depth++;
8340         if (r->options) {
8341                 ndr->print(ndr, "%s: ARRAY(%d)", "options", (int)r->count);
8342                 ndr->depth++;
8343                 for (cntr_options_1=0;cntr_options_1<r->count;cntr_options_1++) {
8344                         char *idx_1=NULL;
8345                         if (asprintf(&idx_1, "[%d]", cntr_options_1) != -1) {
8346                                 ndr_print_spoolss_NotifyOptionsArray(ndr, "options", &r->options[cntr_options_1]);
8347                                 free(idx_1);
8348                         }
8349                 }
8350                 ndr->depth--;
8351         }
8352         ndr->depth--;
8353         ndr->depth--;
8354 }
8355
8356 static enum ndr_err_code ndr_push_spoolss_NotifyUTF16String(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyUTF16String *r)
8357 {
8358         if (ndr_flags & NDR_SCALARS) {
8359                 NDR_CHECK(ndr_push_align(ndr, 4));
8360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
8362         }
8363         if (ndr_flags & NDR_BUFFERS) {
8364                 if (r->string) {
8365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
8366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
8367                 }
8368         }
8369         return NDR_ERR_SUCCESS;
8370 }
8371
8372 static enum ndr_err_code ndr_pull_spoolss_NotifyUTF16String(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyUTF16String *r)
8373 {
8374         uint32_t _ptr_string;
8375         TALLOC_CTX *_mem_save_string_0;
8376         if (ndr_flags & NDR_SCALARS) {
8377                 NDR_CHECK(ndr_pull_align(ndr, 4));
8378                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8379                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
8380                 if (_ptr_string) {
8381                         NDR_PULL_ALLOC(ndr, r->string);
8382                 } else {
8383                         r->string = NULL;
8384                 }
8385         }
8386         if (ndr_flags & NDR_BUFFERS) {
8387                 if (r->string) {
8388                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
8389                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
8390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
8391                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
8392                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
8393                 }
8394                 if (r->string) {
8395                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
8396                 }
8397         }
8398         return NDR_ERR_SUCCESS;
8399 }
8400
8401 _PUBLIC_ void ndr_print_spoolss_NotifyUTF16String(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyUTF16String *r)
8402 {
8403         ndr_print_struct(ndr, name, "spoolss_NotifyUTF16String");
8404         ndr->depth++;
8405         ndr_print_uint32(ndr, "size", r->size);
8406         ndr_print_ptr(ndr, "string", r->string);
8407         ndr->depth++;
8408         if (r->string) {
8409                 ndr_print_string(ndr, "string", r->string);
8410         }
8411         ndr->depth--;
8412         ndr->depth--;
8413 }
8414
8415 static enum ndr_err_code ndr_push_spoolss_NotifyDOSString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyDOSString *r)
8416 {
8417         if (ndr_flags & NDR_SCALARS) {
8418                 NDR_CHECK(ndr_push_align(ndr, 4));
8419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
8421         }
8422         if (ndr_flags & NDR_BUFFERS) {
8423                 if (r->string) {
8424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8425                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size, sizeof(uint8_t), CH_DOS));
8426                 }
8427         }
8428         return NDR_ERR_SUCCESS;
8429 }
8430
8431 static enum ndr_err_code ndr_pull_spoolss_NotifyDOSString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyDOSString *r)
8432 {
8433         uint32_t _ptr_string;
8434         TALLOC_CTX *_mem_save_string_0;
8435         if (ndr_flags & NDR_SCALARS) {
8436                 NDR_CHECK(ndr_pull_align(ndr, 4));
8437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
8439                 if (_ptr_string) {
8440                         NDR_PULL_ALLOC(ndr, r->string);
8441                 } else {
8442                         r->string = NULL;
8443                 }
8444         }
8445         if (ndr_flags & NDR_BUFFERS) {
8446                 if (r->string) {
8447                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
8448                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
8449                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
8450                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint8_t), CH_DOS));
8451                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
8452                 }
8453                 if (r->string) {
8454                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size));
8455                 }
8456         }
8457         return NDR_ERR_SUCCESS;
8458 }
8459
8460 _PUBLIC_ void ndr_print_spoolss_NotifyDOSString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyDOSString *r)
8461 {
8462         ndr_print_struct(ndr, name, "spoolss_NotifyDOSString");
8463         ndr->depth++;
8464         ndr_print_uint32(ndr, "size", r->size);
8465         ndr_print_ptr(ndr, "string", r->string);
8466         ndr->depth++;
8467         if (r->string) {
8468                 ndr_print_string(ndr, "string", r->string);
8469         }
8470         ndr->depth--;
8471         ndr->depth--;
8472 }
8473
8474 static enum ndr_err_code ndr_push_spoolss_NotifyBlobData(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyBlobData *r)
8475 {
8476         uint32_t cntr_data_0;
8477         if (ndr_flags & NDR_SCALARS) {
8478                 NDR_CHECK(ndr_push_align(ndr, 2));
8479                 for (cntr_data_0 = 0; cntr_data_0 < 8; cntr_data_0++) {
8480                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->data[cntr_data_0]));
8481                 }
8482         }
8483         if (ndr_flags & NDR_BUFFERS) {
8484         }
8485         return NDR_ERR_SUCCESS;
8486 }
8487
8488 static enum ndr_err_code ndr_pull_spoolss_NotifyBlobData(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyBlobData *r)
8489 {
8490         uint32_t cntr_data_0;
8491         if (ndr_flags & NDR_SCALARS) {
8492                 NDR_CHECK(ndr_pull_align(ndr, 2));
8493                 for (cntr_data_0 = 0; cntr_data_0 < 8; cntr_data_0++) {
8494                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data[cntr_data_0]));
8495                 }
8496         }
8497         if (ndr_flags & NDR_BUFFERS) {
8498         }
8499         return NDR_ERR_SUCCESS;
8500 }
8501
8502 _PUBLIC_ void ndr_print_spoolss_NotifyBlobData(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyBlobData *r)
8503 {
8504         uint32_t cntr_data_0;
8505         ndr_print_struct(ndr, name, "spoolss_NotifyBlobData");
8506         ndr->depth++;
8507         ndr->print(ndr, "%s: ARRAY(%d)", "data", (int)8);
8508         ndr->depth++;
8509         for (cntr_data_0=0;cntr_data_0<8;cntr_data_0++) {
8510                 char *idx_0=NULL;
8511                 if (asprintf(&idx_0, "[%d]", cntr_data_0) != -1) {
8512                         ndr_print_uint16(ndr, "data", r->data[cntr_data_0]);
8513                         free(idx_0);
8514                 }
8515         }
8516         ndr->depth--;
8517         ndr->depth--;
8518 }
8519
8520 static enum ndr_err_code ndr_push_spoolss_NotifyBlob(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyBlob *r)
8521 {
8522         if (ndr_flags & NDR_SCALARS) {
8523                 NDR_CHECK(ndr_push_align(ndr, 4));
8524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
8525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8526         }
8527         if (ndr_flags & NDR_BUFFERS) {
8528                 if (r->data) {
8529                         NDR_CHECK(ndr_push_spoolss_NotifyBlobData(ndr, NDR_SCALARS, r->data));
8530                 }
8531         }
8532         return NDR_ERR_SUCCESS;
8533 }
8534
8535 static enum ndr_err_code ndr_pull_spoolss_NotifyBlob(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyBlob *r)
8536 {
8537         uint32_t _ptr_data;
8538         TALLOC_CTX *_mem_save_data_0;
8539         if (ndr_flags & NDR_SCALARS) {
8540                 NDR_CHECK(ndr_pull_align(ndr, 4));
8541                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
8542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8543                 if (_ptr_data) {
8544                         NDR_PULL_ALLOC(ndr, r->data);
8545                 } else {
8546                         r->data = NULL;
8547                 }
8548         }
8549         if (ndr_flags & NDR_BUFFERS) {
8550                 if (r->data) {
8551                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8552                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8553                         NDR_CHECK(ndr_pull_spoolss_NotifyBlobData(ndr, NDR_SCALARS, r->data));
8554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8555                 }
8556         }
8557         return NDR_ERR_SUCCESS;
8558 }
8559
8560 _PUBLIC_ void ndr_print_spoolss_NotifyBlob(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyBlob *r)
8561 {
8562         ndr_print_struct(ndr, name, "spoolss_NotifyBlob");
8563         ndr->depth++;
8564         ndr_print_uint32(ndr, "len", r->len);
8565         ndr_print_ptr(ndr, "data", r->data);
8566         ndr->depth++;
8567         if (r->data) {
8568                 ndr_print_spoolss_NotifyBlobData(ndr, "data", r->data);
8569         }
8570         ndr->depth--;
8571         ndr->depth--;
8572 }
8573
8574 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
8575 {
8576         if (ndr_flags & NDR_SCALARS) {
8577                 int level = ndr_push_get_switch_value(ndr, r);
8578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8579                 switch (level) {
8580                         case 1: {
8581                                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->integer));
8582                         break; }
8583
8584                         case 2: {
8585                                 NDR_CHECK(ndr_push_spoolss_NotifyUTF16String(ndr, NDR_SCALARS, &r->utf16_string));
8586                         break; }
8587
8588                         case 3: {
8589                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8590                         break; }
8591
8592                         case 4: {
8593                                 NDR_CHECK(ndr_push_spoolss_NotifyBlob(ndr, NDR_SCALARS, &r->blob));
8594                         break; }
8595
8596                         case 5: {
8597                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8598                         break; }
8599
8600                         default:
8601                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8602                 }
8603         }
8604         if (ndr_flags & NDR_BUFFERS) {
8605                 int level = ndr_push_get_switch_value(ndr, r);
8606                 switch (level) {
8607                         case 1:
8608                         break;
8609
8610                         case 2:
8611                                 NDR_CHECK(ndr_push_spoolss_NotifyUTF16String(ndr, NDR_BUFFERS, &r->utf16_string));
8612                         break;
8613
8614                         case 3:
8615                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8616                         break;
8617
8618                         case 4:
8619                                 NDR_CHECK(ndr_push_spoolss_NotifyBlob(ndr, NDR_BUFFERS, &r->blob));
8620                         break;
8621
8622                         case 5:
8623                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8624                         break;
8625
8626                         default:
8627                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8628                 }
8629         }
8630         return NDR_ERR_SUCCESS;
8631 }
8632
8633 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
8634 {
8635         int level;
8636         uint32_t _level;
8637         level = ndr_pull_get_switch_value(ndr, r);
8638         if (ndr_flags & NDR_SCALARS) {
8639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8640                 if (_level != level) {
8641                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8642                 }
8643                 switch (level) {
8644                         case 1: {
8645                                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->integer));
8646                         break; }
8647
8648                         case 2: {
8649                                 NDR_CHECK(ndr_pull_spoolss_NotifyUTF16String(ndr, NDR_SCALARS, &r->utf16_string));
8650                         break; }
8651
8652                         case 3: {
8653                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8654                         break; }
8655
8656                         case 4: {
8657                                 NDR_CHECK(ndr_pull_spoolss_NotifyBlob(ndr, NDR_SCALARS, &r->blob));
8658                         break; }
8659
8660                         case 5: {
8661                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8662                         break; }
8663
8664                         default:
8665                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8666                 }
8667         }
8668         if (ndr_flags & NDR_BUFFERS) {
8669                 switch (level) {
8670                         case 1:
8671                         break;
8672
8673                         case 2:
8674                                 NDR_CHECK(ndr_pull_spoolss_NotifyUTF16String(ndr, NDR_BUFFERS, &r->utf16_string));
8675                         break;
8676
8677                         case 3:
8678                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8679                         break;
8680
8681                         case 4:
8682                                 NDR_CHECK(ndr_pull_spoolss_NotifyBlob(ndr, NDR_BUFFERS, &r->blob));
8683                         break;
8684
8685                         case 5:
8686                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8687                         break;
8688
8689                         default:
8690                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8691                 }
8692         }
8693         return NDR_ERR_SUCCESS;
8694 }
8695
8696 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
8697 {
8698         int level;
8699         level = ndr_print_get_switch_value(ndr, r);
8700         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
8701         switch (level) {
8702                 case 1:
8703                         ndr_print_dlong(ndr, "integer", r->integer);
8704                 break;
8705
8706                 case 2:
8707                         ndr_print_spoolss_NotifyUTF16String(ndr, "utf16_string", &r->utf16_string);
8708                 break;
8709
8710                 case 3:
8711                         ndr_print_spoolss_NotifyDOSString(ndr, "ascii_string", &r->ascii_string);
8712                 break;
8713
8714                 case 4:
8715                         ndr_print_spoolss_NotifyBlob(ndr, "blob", &r->blob);
8716                 break;
8717
8718                 case 5:
8719                         ndr_print_spoolss_NotifyDOSString(ndr, "ascii_string", &r->ascii_string);
8720                 break;
8721
8722                 default:
8723                         ndr_print_bad_level(ndr, name, level);
8724         }
8725 }
8726
8727 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
8728 {
8729         if (ndr_flags & NDR_SCALARS) {
8730                 NDR_CHECK(ndr_push_align(ndr, 4));
8731                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
8732                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
8733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->variable_type));
8734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
8735                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
8736                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
8737         }
8738         if (ndr_flags & NDR_BUFFERS) {
8739                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
8740         }
8741         return NDR_ERR_SUCCESS;
8742 }
8743
8744 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
8745 {
8746         if (ndr_flags & NDR_SCALARS) {
8747                 NDR_CHECK(ndr_pull_align(ndr, 4));
8748                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
8749                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
8750                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->variable_type));
8751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
8752                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
8753                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
8754         }
8755         if (ndr_flags & NDR_BUFFERS) {
8756                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
8757         }
8758         return NDR_ERR_SUCCESS;
8759 }
8760
8761 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
8762 {
8763         ndr_print_struct(ndr, name, "spoolss_Notify");
8764         ndr->depth++;
8765         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
8766         ndr_print_spoolss_Field(ndr, "field", r->field);
8767         ndr_print_uint32(ndr, "variable_type", r->variable_type);
8768         ndr_print_uint32(ndr, "job_id", r->job_id);
8769         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
8770         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
8771         ndr->depth--;
8772 }
8773
8774 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
8775 {
8776         uint32_t cntr_notifies_0;
8777         if (ndr_flags & NDR_SCALARS) {
8778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8779                 NDR_CHECK(ndr_push_align(ndr, 4));
8780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
8781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
8782                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8783                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8784                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
8785                 }
8786         }
8787         if (ndr_flags & NDR_BUFFERS) {
8788                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8789                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
8790                 }
8791         }
8792         return NDR_ERR_SUCCESS;
8793 }
8794
8795 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
8796 {
8797         uint32_t cntr_notifies_0;
8798         TALLOC_CTX *_mem_save_notifies_0;
8799         if (ndr_flags & NDR_SCALARS) {
8800                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
8801                 NDR_CHECK(ndr_pull_align(ndr, 4));
8802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
8803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
8804                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8805                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
8806                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
8807                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
8808                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8809                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
8810                 }
8811                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
8812                 if (r->notifies) {
8813                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
8814                 }
8815         }
8816         if (ndr_flags & NDR_BUFFERS) {
8817                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
8818                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
8819                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8820                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
8821                 }
8822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
8823         }
8824         return NDR_ERR_SUCCESS;
8825 }
8826
8827 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
8828 {
8829         uint32_t cntr_notifies_0;
8830         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
8831         ndr->depth++;
8832         ndr_print_uint32(ndr, "version", r->version);
8833         ndr_print_uint32(ndr, "flags", r->flags);
8834         ndr_print_uint32(ndr, "count", r->count);
8835         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
8836         ndr->depth++;
8837         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
8838                 char *idx_0=NULL;
8839                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
8840                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
8841                         free(idx_0);
8842                 }
8843         }
8844         ndr->depth--;
8845         ndr->depth--;
8846 }
8847
8848 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
8849 {
8850         if (ndr_flags & NDR_SCALARS) {
8851                 NDR_CHECK(ndr_push_align(ndr, 4));
8852                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8853                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
8854                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
8855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
8856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
8857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
8858                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->processor));
8859         }
8860         if (ndr_flags & NDR_BUFFERS) {
8861                 if (r->client) {
8862                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
8863                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
8865                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8866                 }
8867                 if (r->user) {
8868                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
8869                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
8871                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8872                 }
8873         }
8874         return NDR_ERR_SUCCESS;
8875 }
8876
8877 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
8878 {
8879         uint32_t _ptr_client;
8880         TALLOC_CTX *_mem_save_client_0;
8881         uint32_t _ptr_user;
8882         TALLOC_CTX *_mem_save_user_0;
8883         if (ndr_flags & NDR_SCALARS) {
8884                 NDR_CHECK(ndr_pull_align(ndr, 4));
8885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8886                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
8887                 if (_ptr_client) {
8888                         NDR_PULL_ALLOC(ndr, r->client);
8889                 } else {
8890                         r->client = NULL;
8891                 }
8892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
8893                 if (_ptr_user) {
8894                         NDR_PULL_ALLOC(ndr, r->user);
8895                 } else {
8896                         r->user = NULL;
8897                 }
8898                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
8899                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
8900                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
8901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->processor));
8902         }
8903         if (ndr_flags & NDR_BUFFERS) {
8904                 if (r->client) {
8905                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
8906                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
8907                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
8908                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
8909                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
8910                                 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));
8911                         }
8912                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
8913                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
8914                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
8915                 }
8916                 if (r->user) {
8917                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
8918                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
8919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
8920                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
8921                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
8922                                 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));
8923                         }
8924                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
8925                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
8926                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
8927                 }
8928         }
8929         return NDR_ERR_SUCCESS;
8930 }
8931
8932 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
8933 {
8934         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
8935         ndr->depth++;
8936         ndr_print_uint32(ndr, "size", r->size);
8937         ndr_print_ptr(ndr, "client", r->client);
8938         ndr->depth++;
8939         if (r->client) {
8940                 ndr_print_string(ndr, "client", r->client);
8941         }
8942         ndr->depth--;
8943         ndr_print_ptr(ndr, "user", r->user);
8944         ndr->depth++;
8945         if (r->user) {
8946                 ndr_print_string(ndr, "user", r->user);
8947         }
8948         ndr->depth--;
8949         ndr_print_uint32(ndr, "build", r->build);
8950         ndr_print_uint32(ndr, "major", r->major);
8951         ndr_print_uint32(ndr, "minor", r->minor);
8952         ndr_print_uint32(ndr, "processor", r->processor);
8953         ndr->depth--;
8954 }
8955
8956 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
8957 {
8958         if (ndr_flags & NDR_SCALARS) {
8959                 int level = ndr_push_get_switch_value(ndr, r);
8960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8961                 switch (level) {
8962                         case 1: {
8963                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
8964                         break; }
8965
8966                         default:
8967                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8968                 }
8969         }
8970         if (ndr_flags & NDR_BUFFERS) {
8971                 int level = ndr_push_get_switch_value(ndr, r);
8972                 switch (level) {
8973                         case 1:
8974                                 if (r->level1) {
8975                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
8976                                 }
8977                         break;
8978
8979                         default:
8980                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8981                 }
8982         }
8983         return NDR_ERR_SUCCESS;
8984 }
8985
8986 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
8987 {
8988         int level;
8989         uint32_t _level;
8990         TALLOC_CTX *_mem_save_level1_0;
8991         level = ndr_pull_get_switch_value(ndr, r);
8992         if (ndr_flags & NDR_SCALARS) {
8993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8994                 if (_level != level) {
8995                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8996                 }
8997                 switch (level) {
8998                         case 1: {
8999                                 uint32_t _ptr_level1;
9000                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
9001                                 if (_ptr_level1) {
9002                                         NDR_PULL_ALLOC(ndr, r->level1);
9003                                 } else {
9004                                         r->level1 = NULL;
9005                                 }
9006                         break; }
9007
9008                         default:
9009                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9010                 }
9011         }
9012         if (ndr_flags & NDR_BUFFERS) {
9013                 switch (level) {
9014                         case 1:
9015                                 if (r->level1) {
9016                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9017                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
9018                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
9019                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
9020                                 }
9021                         break;
9022
9023                         default:
9024                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9025                 }
9026         }
9027         return NDR_ERR_SUCCESS;
9028 }
9029
9030 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
9031 {
9032         int level;
9033         level = ndr_print_get_switch_value(ndr, r);
9034         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
9035         switch (level) {
9036                 case 1:
9037                         ndr_print_ptr(ndr, "level1", r->level1);
9038                         ndr->depth++;
9039                         if (r->level1) {
9040                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
9041                         }
9042                         ndr->depth--;
9043                 break;
9044
9045                 default:
9046                         ndr_print_bad_level(ndr, name, level);
9047         }
9048 }
9049
9050 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
9051 {
9052         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
9053         return NDR_ERR_SUCCESS;
9054 }
9055
9056 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
9057 {
9058         uint32_t v;
9059         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
9060         *r = v;
9061         return NDR_ERR_SUCCESS;
9062 }
9063
9064 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
9065 {
9066         ndr_print_uint32(ndr, name, r);
9067         ndr->depth++;
9068         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
9069         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
9070         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
9071         ndr->depth--;
9072 }
9073
9074 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
9075 {
9076         if (flags & NDR_IN) {
9077                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
9078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
9079                 if (r->in.server) {
9080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
9081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
9083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9084                 }
9085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9087                 if (r->in.buffer) {
9088                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9089                 }
9090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9091         }
9092         if (flags & NDR_OUT) {
9093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9094                 if (r->out.info) {
9095                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
9096                 }
9097                 if (r->out.needed == NULL) {
9098                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9099                 }
9100                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
9101                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
9102                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9103         }
9104         return NDR_ERR_SUCCESS;
9105 }
9106
9107 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
9108 {
9109         uint32_t _ptr_server;
9110         uint32_t _ptr_buffer;
9111         uint32_t _ptr_info;
9112         TALLOC_CTX *_mem_save_server_0;
9113         TALLOC_CTX *_mem_save_buffer_0;
9114         TALLOC_CTX *_mem_save_info_0;
9115         TALLOC_CTX *_mem_save_needed_0;
9116         if (flags & NDR_IN) {
9117                 ZERO_STRUCT(r->out);
9118
9119                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
9120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
9121                 if (_ptr_server) {
9122                         NDR_PULL_ALLOC(ndr, r->in.server);
9123                 } else {
9124                         r->in.server = NULL;
9125                 }
9126                 if (r->in.server) {
9127                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
9128                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
9129                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
9130                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
9131                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
9132                                 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));
9133                         }
9134                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
9135                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
9136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
9137                 }
9138                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9140                 if (_ptr_buffer) {
9141                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9142                 } else {
9143                         r->in.buffer = NULL;
9144                 }
9145                 if (r->in.buffer) {
9146                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9147                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9148                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9149                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9150                 }
9151                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9152                 NDR_PULL_ALLOC(ndr, r->out.needed);
9153                 ZERO_STRUCTP(r->out.needed);
9154         }
9155         if (flags & NDR_OUT) {
9156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9157                 if (_ptr_info) {
9158                         NDR_PULL_ALLOC(ndr, r->out.info);
9159                 } else {
9160                         r->out.info = NULL;
9161                 }
9162                 if (r->out.info) {
9163                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9164                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9165                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
9166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9167                 }
9168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9169                         NDR_PULL_ALLOC(ndr, r->out.needed);
9170                 }
9171                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
9172                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
9173                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
9174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
9175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
9176                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9177         }
9178         return NDR_ERR_SUCCESS;
9179 }
9180
9181 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
9182 {
9183         uint32_t cntr_info_0;
9184         if (flags & NDR_IN) {
9185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
9187         }
9188         if (flags & NDR_OUT) {
9189                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9190                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9191                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9192                 }
9193                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9194                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9195                 }
9196         }
9197         return NDR_ERR_SUCCESS;
9198 }
9199
9200 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
9201 {
9202         uint32_t cntr_info_0;
9203         TALLOC_CTX *_mem_save_info_0;
9204         if (flags & NDR_IN) {
9205                 ZERO_STRUCT(r->out);
9206
9207                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9208                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
9209         }
9210         if (flags & NDR_OUT) {
9211                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
9212                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9213                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9214                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9215                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9216                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9217                 }
9218                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9219                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9220                 }
9221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9222         }
9223         return NDR_ERR_SUCCESS;
9224 }
9225
9226 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
9227 {
9228         uint32_t cntr_info_1;
9229         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
9230         ndr->depth++;
9231         if (flags & NDR_SET_VALUES) {
9232                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9233         }
9234         if (flags & NDR_IN) {
9235                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
9236                 ndr->depth++;
9237                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
9238                 ndr_print_ptr(ndr, "server", r->in.server);
9239                 ndr->depth++;
9240                 if (r->in.server) {
9241                         ndr_print_string(ndr, "server", r->in.server);
9242                 }
9243                 ndr->depth--;
9244                 ndr_print_uint32(ndr, "level", r->in.level);
9245                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
9246                 ndr->depth++;
9247                 if (r->in.buffer) {
9248                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
9249                 }
9250                 ndr->depth--;
9251                 ndr_print_uint32(ndr, "offered", r->in.offered);
9252                 ndr->depth--;
9253         }
9254         if (flags & NDR_OUT) {
9255                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
9256                 ndr->depth++;
9257                 ndr_print_ptr(ndr, "info", r->out.info);
9258                 ndr->depth++;
9259                 if (r->out.info) {
9260                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
9261                         ndr->depth++;
9262                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
9263                                 char *idx_1=NULL;
9264                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
9265                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
9266                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
9267                                         free(idx_1);
9268                                 }
9269                         }
9270                         ndr->depth--;
9271                 }
9272                 ndr->depth--;
9273                 ndr_print_ptr(ndr, "needed", r->out.needed);
9274                 ndr->depth++;
9275                 ndr_print_uint32(ndr, "needed", *r->out.needed);
9276                 ndr->depth--;
9277                 ndr_print_uint32(ndr, "count", r->out.count);
9278                 ndr_print_WERROR(ndr, "result", r->out.result);
9279                 ndr->depth--;
9280         }
9281         ndr->depth--;
9282 }
9283
9284 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
9285 {
9286         if (flags & NDR_IN) {
9287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
9288                 if (r->in.printername) {
9289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
9290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
9292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9293                 }
9294                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
9295                 if (r->in.datatype) {
9296                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
9297                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9298                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
9299                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9300                 }
9301                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
9303         }
9304         if (flags & NDR_OUT) {
9305                 if (r->out.handle == NULL) {
9306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9307                 }
9308                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9309                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9310         }
9311         return NDR_ERR_SUCCESS;
9312 }
9313
9314 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
9315 {
9316         uint32_t _ptr_printername;
9317         uint32_t _ptr_datatype;
9318         TALLOC_CTX *_mem_save_printername_0;
9319         TALLOC_CTX *_mem_save_datatype_0;
9320         TALLOC_CTX *_mem_save_handle_0;
9321         if (flags & NDR_IN) {
9322                 ZERO_STRUCT(r->out);
9323
9324                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
9325                 if (_ptr_printername) {
9326                         NDR_PULL_ALLOC(ndr, r->in.printername);
9327                 } else {
9328                         r->in.printername = NULL;
9329                 }
9330                 if (r->in.printername) {
9331                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
9332                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
9333                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
9334                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
9335                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
9336                                 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));
9337                         }
9338                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
9339                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
9340                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
9341                 }
9342                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
9343                 if (_ptr_datatype) {
9344                         NDR_PULL_ALLOC(ndr, r->in.datatype);
9345                 } else {
9346                         r->in.datatype = NULL;
9347                 }
9348                 if (r->in.datatype) {
9349                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9350                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
9351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
9352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
9353                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
9354                                 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));
9355                         }
9356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
9357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
9358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
9359                 }
9360                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
9362                 NDR_PULL_ALLOC(ndr, r->out.handle);
9363                 ZERO_STRUCTP(r->out.handle);
9364         }
9365         if (flags & NDR_OUT) {
9366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9367                         NDR_PULL_ALLOC(ndr, r->out.handle);
9368                 }
9369                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9370                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9371                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9373                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9374         }
9375         return NDR_ERR_SUCCESS;
9376 }
9377
9378 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
9379 {
9380         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
9381         ndr->depth++;
9382         if (flags & NDR_SET_VALUES) {
9383                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9384         }
9385         if (flags & NDR_IN) {
9386                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
9387                 ndr->depth++;
9388                 ndr_print_ptr(ndr, "printername", r->in.printername);
9389                 ndr->depth++;
9390                 if (r->in.printername) {
9391                         ndr_print_string(ndr, "printername", r->in.printername);
9392                 }
9393                 ndr->depth--;
9394                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
9395                 ndr->depth++;
9396                 if (r->in.datatype) {
9397                         ndr_print_string(ndr, "datatype", r->in.datatype);
9398                 }
9399                 ndr->depth--;
9400                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
9401                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
9402                 ndr->depth--;
9403         }
9404         if (flags & NDR_OUT) {
9405                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
9406                 ndr->depth++;
9407                 ndr_print_ptr(ndr, "handle", r->out.handle);
9408                 ndr->depth++;
9409                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
9410                 ndr->depth--;
9411                 ndr_print_WERROR(ndr, "result", r->out.result);
9412                 ndr->depth--;
9413         }
9414         ndr->depth--;
9415 }
9416
9417 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
9418 {
9419         if (flags & NDR_IN) {
9420                 if (r->in.handle == NULL) {
9421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9422                 }
9423                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
9425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
9426                 if (r->in.ctr) {
9427                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
9428                 }
9429                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
9430         }
9431         if (flags & NDR_OUT) {
9432                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9433         }
9434         return NDR_ERR_SUCCESS;
9435 }
9436
9437 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
9438 {
9439         uint32_t _ptr_ctr;
9440         TALLOC_CTX *_mem_save_handle_0;
9441         TALLOC_CTX *_mem_save_ctr_0;
9442         if (flags & NDR_IN) {
9443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9444                         NDR_PULL_ALLOC(ndr, r->in.handle);
9445                 }
9446                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9448                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
9451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
9452                 if (_ptr_ctr) {
9453                         NDR_PULL_ALLOC(ndr, r->in.ctr);
9454                 } else {
9455                         r->in.ctr = NULL;
9456                 }
9457                 if (r->in.ctr) {
9458                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
9459                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
9460                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
9461                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
9462                 }
9463                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
9464         }
9465         if (flags & NDR_OUT) {
9466                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9467         }
9468         return NDR_ERR_SUCCESS;
9469 }
9470
9471 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
9472 {
9473         ndr_print_struct(ndr, name, "spoolss_SetJob");
9474         ndr->depth++;
9475         if (flags & NDR_SET_VALUES) {
9476                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9477         }
9478         if (flags & NDR_IN) {
9479                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
9480                 ndr->depth++;
9481                 ndr_print_ptr(ndr, "handle", r->in.handle);
9482                 ndr->depth++;
9483                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9484                 ndr->depth--;
9485                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
9486                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
9487                 ndr->depth++;
9488                 if (r->in.ctr) {
9489                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
9490                 }
9491                 ndr->depth--;
9492                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
9493                 ndr->depth--;
9494         }
9495         if (flags & NDR_OUT) {
9496                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
9497                 ndr->depth++;
9498                 ndr_print_WERROR(ndr, "result", r->out.result);
9499                 ndr->depth--;
9500         }
9501         ndr->depth--;
9502 }
9503
9504 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
9505 {
9506         if (flags & NDR_IN) {
9507                 if (r->in.handle == NULL) {
9508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9509                 }
9510                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
9512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9513                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9514                 if (r->in.buffer) {
9515                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9516                 }
9517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9518         }
9519         if (flags & NDR_OUT) {
9520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9521                 if (r->out.info) {
9522                         {
9523                                 struct ndr_push *_ndr_info;
9524                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
9525                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
9526                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9527                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
9528                         }
9529                 }
9530                 if (r->out.needed == NULL) {
9531                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9532                 }
9533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
9534                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9535         }
9536         return NDR_ERR_SUCCESS;
9537 }
9538
9539 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
9540 {
9541         uint32_t _ptr_buffer;
9542         uint32_t _ptr_info;
9543         TALLOC_CTX *_mem_save_handle_0;
9544         TALLOC_CTX *_mem_save_buffer_0;
9545         TALLOC_CTX *_mem_save_info_0;
9546         TALLOC_CTX *_mem_save_needed_0;
9547         if (flags & NDR_IN) {
9548                 ZERO_STRUCT(r->out);
9549
9550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9551                         NDR_PULL_ALLOC(ndr, r->in.handle);
9552                 }
9553                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9554                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9555                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
9558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9559                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9560                 if (_ptr_buffer) {
9561                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9562                 } else {
9563                         r->in.buffer = NULL;
9564                 }
9565                 if (r->in.buffer) {
9566                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9567                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9568                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9570                 }
9571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9572                 NDR_PULL_ALLOC(ndr, r->out.needed);
9573                 ZERO_STRUCTP(r->out.needed);
9574         }
9575         if (flags & NDR_OUT) {
9576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9577                 if (_ptr_info) {
9578                         NDR_PULL_ALLOC(ndr, r->out.info);
9579                 } else {
9580                         r->out.info = NULL;
9581                 }
9582                 if (r->out.info) {
9583                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9584                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9585                         {
9586                                 struct ndr_pull *_ndr_info;
9587                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
9588                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
9589                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9590                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
9591                         }
9592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9593                 }
9594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9595                         NDR_PULL_ALLOC(ndr, r->out.needed);
9596                 }
9597                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
9598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
9599                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
9600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
9601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9602         }
9603         return NDR_ERR_SUCCESS;
9604 }
9605
9606 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
9607 {
9608         ndr_print_struct(ndr, name, "spoolss_GetJob");
9609         ndr->depth++;
9610         if (flags & NDR_SET_VALUES) {
9611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9612         }
9613         if (flags & NDR_IN) {
9614                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
9615                 ndr->depth++;
9616                 ndr_print_ptr(ndr, "handle", r->in.handle);
9617                 ndr->depth++;
9618                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9619                 ndr->depth--;
9620                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
9621                 ndr_print_uint32(ndr, "level", r->in.level);
9622                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
9623                 ndr->depth++;
9624                 if (r->in.buffer) {
9625                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
9626                 }
9627                 ndr->depth--;
9628                 ndr_print_uint32(ndr, "offered", r->in.offered);
9629                 ndr->depth--;
9630         }
9631         if (flags & NDR_OUT) {
9632                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
9633                 ndr->depth++;
9634                 ndr_print_ptr(ndr, "info", r->out.info);
9635                 ndr->depth++;
9636                 if (r->out.info) {
9637                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9638                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
9639                 }
9640                 ndr->depth--;
9641                 ndr_print_ptr(ndr, "needed", r->out.needed);
9642                 ndr->depth++;
9643                 ndr_print_uint32(ndr, "needed", *r->out.needed);
9644                 ndr->depth--;
9645                 ndr_print_WERROR(ndr, "result", r->out.result);
9646                 ndr->depth--;
9647         }
9648         ndr->depth--;
9649 }
9650
9651 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
9652 {
9653         if (flags & NDR_IN) {
9654                 if (r->in.handle == NULL) {
9655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9656                 }
9657                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
9659                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
9660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9661                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9662                 if (r->in.buffer) {
9663                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9664                 }
9665                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9666         }
9667         if (flags & NDR_OUT) {
9668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9669                 if (r->out.info) {
9670                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
9671                 }
9672                 if (r->out.needed == NULL) {
9673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9674                 }
9675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
9676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
9677                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9678         }
9679         return NDR_ERR_SUCCESS;
9680 }
9681
9682 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
9683 {
9684         uint32_t _ptr_buffer;
9685         uint32_t _ptr_info;
9686         TALLOC_CTX *_mem_save_handle_0;
9687         TALLOC_CTX *_mem_save_buffer_0;
9688         TALLOC_CTX *_mem_save_info_0;
9689         TALLOC_CTX *_mem_save_needed_0;
9690         if (flags & NDR_IN) {
9691                 ZERO_STRUCT(r->out);
9692
9693                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9694                         NDR_PULL_ALLOC(ndr, r->in.handle);
9695                 }
9696                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9697                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9698                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9699                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
9701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
9702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9704                 if (_ptr_buffer) {
9705                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9706                 } else {
9707                         r->in.buffer = NULL;
9708                 }
9709                 if (r->in.buffer) {
9710                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9711                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9712                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9713                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9714                 }
9715                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9716                 NDR_PULL_ALLOC(ndr, r->out.needed);
9717                 ZERO_STRUCTP(r->out.needed);
9718         }
9719         if (flags & NDR_OUT) {
9720                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9721                 if (_ptr_info) {
9722                         NDR_PULL_ALLOC(ndr, r->out.info);
9723                 } else {
9724                         r->out.info = NULL;
9725                 }
9726                 if (r->out.info) {
9727                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9728                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9729                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
9730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9731                 }
9732                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9733                         NDR_PULL_ALLOC(ndr, r->out.needed);
9734                 }
9735                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
9736                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
9737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
9738                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
9739                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
9740                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9741         }
9742         return NDR_ERR_SUCCESS;
9743 }
9744
9745 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
9746 {
9747         uint32_t cntr_info_0;
9748         if (flags & NDR_IN) {
9749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
9751         }
9752         if (flags & NDR_OUT) {
9753                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9754                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9755                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9756                 }
9757                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9758                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9759                 }
9760         }
9761         return NDR_ERR_SUCCESS;
9762 }
9763
9764 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
9765 {
9766         uint32_t cntr_info_0;
9767         TALLOC_CTX *_mem_save_info_0;
9768         if (flags & NDR_IN) {
9769                 ZERO_STRUCT(r->out);
9770
9771                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
9773         }
9774         if (flags & NDR_OUT) {
9775                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
9776                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9777                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9778                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9779                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9780                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9781                 }
9782                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9783                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9784                 }
9785                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9786         }
9787         return NDR_ERR_SUCCESS;
9788 }
9789
9790 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
9791 {
9792         uint32_t cntr_info_1;
9793         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
9794         ndr->depth++;
9795         if (flags & NDR_SET_VALUES) {
9796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9797         }
9798         if (flags & NDR_IN) {
9799                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
9800                 ndr->depth++;
9801                 ndr_print_ptr(ndr, "handle", r->in.handle);
9802                 ndr->depth++;
9803                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9804                 ndr->depth--;
9805                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
9806                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
9807                 ndr_print_uint32(ndr, "level", r->in.level);
9808                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
9809                 ndr->depth++;
9810                 if (r->in.buffer) {
9811                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
9812                 }
9813                 ndr->depth--;
9814                 ndr_print_uint32(ndr, "offered", r->in.offered);
9815                 ndr->depth--;
9816         }
9817         if (flags & NDR_OUT) {
9818                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
9819                 ndr->depth++;
9820                 ndr_print_ptr(ndr, "info", r->out.info);
9821                 ndr->depth++;
9822                 if (r->out.info) {
9823                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
9824                         ndr->depth++;
9825                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
9826                                 char *idx_1=NULL;
9827                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
9828                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
9829                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
9830                                         free(idx_1);
9831                                 }
9832                         }
9833                         ndr->depth--;
9834                 }
9835                 ndr->depth--;
9836                 ndr_print_ptr(ndr, "needed", r->out.needed);
9837                 ndr->depth++;
9838                 ndr_print_uint32(ndr, "needed", *r->out.needed);
9839                 ndr->depth--;
9840                 ndr_print_uint32(ndr, "count", r->out.count);
9841                 ndr_print_WERROR(ndr, "result", r->out.result);
9842                 ndr->depth--;
9843         }
9844         ndr->depth--;
9845 }
9846
9847 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
9848 {
9849         if (flags & NDR_IN) {
9850         }
9851         if (flags & NDR_OUT) {
9852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9853         }
9854         return NDR_ERR_SUCCESS;
9855 }
9856
9857 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
9858 {
9859         if (flags & NDR_IN) {
9860         }
9861         if (flags & NDR_OUT) {
9862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9863         }
9864         return NDR_ERR_SUCCESS;
9865 }
9866
9867 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
9868 {
9869         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
9870         ndr->depth++;
9871         if (flags & NDR_SET_VALUES) {
9872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9873         }
9874         if (flags & NDR_IN) {
9875                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
9876                 ndr->depth++;
9877                 ndr->depth--;
9878         }
9879         if (flags & NDR_OUT) {
9880                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
9881                 ndr->depth++;
9882                 ndr_print_WERROR(ndr, "result", r->out.result);
9883                 ndr->depth--;
9884         }
9885         ndr->depth--;
9886 }
9887
9888 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
9889 {
9890         if (flags & NDR_IN) {
9891                 if (r->in.handle == NULL) {
9892                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9893                 }
9894                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9895         }
9896         if (flags & NDR_OUT) {
9897                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9898         }
9899         return NDR_ERR_SUCCESS;
9900 }
9901
9902 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
9903 {
9904         TALLOC_CTX *_mem_save_handle_0;
9905         if (flags & NDR_IN) {
9906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9907                         NDR_PULL_ALLOC(ndr, r->in.handle);
9908                 }
9909                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9910                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9913         }
9914         if (flags & NDR_OUT) {
9915                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9916         }
9917         return NDR_ERR_SUCCESS;
9918 }
9919
9920 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
9921 {
9922         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
9923         ndr->depth++;
9924         if (flags & NDR_SET_VALUES) {
9925                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9926         }
9927         if (flags & NDR_IN) {
9928                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
9929                 ndr->depth++;
9930                 ndr_print_ptr(ndr, "handle", r->in.handle);
9931                 ndr->depth++;
9932                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9933                 ndr->depth--;
9934                 ndr->depth--;
9935         }
9936         if (flags & NDR_OUT) {
9937                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
9938                 ndr->depth++;
9939                 ndr_print_WERROR(ndr, "result", r->out.result);
9940                 ndr->depth--;
9941         }
9942         ndr->depth--;
9943 }
9944
9945 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
9946 {
9947         if (flags & NDR_IN) {
9948                 if (r->in.handle == NULL) {
9949                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9950                 }
9951                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9953                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
9954                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
9955                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9956                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.secdesc_ctr));
9957                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
9958         }
9959         if (flags & NDR_OUT) {
9960                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9961         }
9962         return NDR_ERR_SUCCESS;
9963 }
9964
9965 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
9966 {
9967         TALLOC_CTX *_mem_save_handle_0;
9968         if (flags & NDR_IN) {
9969                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9970                         NDR_PULL_ALLOC(ndr, r->in.handle);
9971                 }
9972                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9973                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9974                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9975                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9977                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
9978                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
9979                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9980                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.secdesc_ctr));
9981                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
9982         }
9983         if (flags & NDR_OUT) {
9984                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9985         }
9986         return NDR_ERR_SUCCESS;
9987 }
9988
9989 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
9990 {
9991         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
9992         ndr->depth++;
9993         if (flags & NDR_SET_VALUES) {
9994                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9995         }
9996         if (flags & NDR_IN) {
9997                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
9998                 ndr->depth++;
9999                 ndr_print_ptr(ndr, "handle", r->in.handle);
10000                 ndr->depth++;
10001                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10002                 ndr->depth--;
10003                 ndr_print_uint32(ndr, "level", r->in.level);
10004                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
10005                 ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->in.info);
10006                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
10007                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", &r->in.secdesc_ctr);
10008                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
10009                 ndr->depth--;
10010         }
10011         if (flags & NDR_OUT) {
10012                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
10013                 ndr->depth++;
10014                 ndr_print_WERROR(ndr, "result", r->out.result);
10015                 ndr->depth--;
10016         }
10017         ndr->depth--;
10018 }
10019
10020 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
10021 {
10022         if (flags & NDR_IN) {
10023                 if (r->in.handle == NULL) {
10024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10025                 }
10026                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10029                 if (r->in.buffer) {
10030                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10031                 }
10032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10033         }
10034         if (flags & NDR_OUT) {
10035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10036                 if (r->out.info) {
10037                         {
10038                                 struct ndr_push *_ndr_info;
10039                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
10040                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
10041                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10042                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
10043                         }
10044                 }
10045                 if (r->out.needed == NULL) {
10046                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10047                 }
10048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
10049                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10050         }
10051         return NDR_ERR_SUCCESS;
10052 }
10053
10054 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
10055 {
10056         uint32_t _ptr_buffer;
10057         uint32_t _ptr_info;
10058         TALLOC_CTX *_mem_save_handle_0;
10059         TALLOC_CTX *_mem_save_buffer_0;
10060         TALLOC_CTX *_mem_save_info_0;
10061         TALLOC_CTX *_mem_save_needed_0;
10062         if (flags & NDR_IN) {
10063                 ZERO_STRUCT(r->out);
10064
10065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10066                         NDR_PULL_ALLOC(ndr, r->in.handle);
10067                 }
10068                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10069                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10070                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10072                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10074                 if (_ptr_buffer) {
10075                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10076                 } else {
10077                         r->in.buffer = NULL;
10078                 }
10079                 if (r->in.buffer) {
10080                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10081                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10082                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10084                 }
10085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10086                 NDR_PULL_ALLOC(ndr, r->out.needed);
10087                 ZERO_STRUCTP(r->out.needed);
10088         }
10089         if (flags & NDR_OUT) {
10090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10091                 if (_ptr_info) {
10092                         NDR_PULL_ALLOC(ndr, r->out.info);
10093                 } else {
10094                         r->out.info = NULL;
10095                 }
10096                 if (r->out.info) {
10097                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10098                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10099                         {
10100                                 struct ndr_pull *_ndr_info;
10101                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
10102                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
10103                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
10104                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
10105                         }
10106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10107                 }
10108                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10109                         NDR_PULL_ALLOC(ndr, r->out.needed);
10110                 }
10111                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
10112                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
10113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
10114                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
10115                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10116         }
10117         return NDR_ERR_SUCCESS;
10118 }
10119
10120 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
10121 {
10122         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
10123         ndr->depth++;
10124         if (flags & NDR_SET_VALUES) {
10125                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10126         }
10127         if (flags & NDR_IN) {
10128                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
10129                 ndr->depth++;
10130                 ndr_print_ptr(ndr, "handle", r->in.handle);
10131                 ndr->depth++;
10132                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10133                 ndr->depth--;
10134                 ndr_print_uint32(ndr, "level", r->in.level);
10135                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10136                 ndr->depth++;
10137                 if (r->in.buffer) {
10138                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10139                 }
10140                 ndr->depth--;
10141                 ndr_print_uint32(ndr, "offered", r->in.offered);
10142                 ndr->depth--;
10143         }
10144         if (flags & NDR_OUT) {
10145                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
10146                 ndr->depth++;
10147                 ndr_print_ptr(ndr, "info", r->out.info);
10148                 ndr->depth++;
10149                 if (r->out.info) {
10150                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10151                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
10152                 }
10153                 ndr->depth--;
10154                 ndr_print_ptr(ndr, "needed", r->out.needed);
10155                 ndr->depth++;
10156                 ndr_print_uint32(ndr, "needed", *r->out.needed);
10157                 ndr->depth--;
10158                 ndr_print_WERROR(ndr, "result", r->out.result);
10159                 ndr->depth--;
10160         }
10161         ndr->depth--;
10162 }
10163
10164 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
10165 {
10166         if (flags & NDR_IN) {
10167         }
10168         if (flags & NDR_OUT) {
10169                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10170         }
10171         return NDR_ERR_SUCCESS;
10172 }
10173
10174 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
10175 {
10176         if (flags & NDR_IN) {
10177         }
10178         if (flags & NDR_OUT) {
10179                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10180         }
10181         return NDR_ERR_SUCCESS;
10182 }
10183
10184 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
10185 {
10186         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
10187         ndr->depth++;
10188         if (flags & NDR_SET_VALUES) {
10189                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10190         }
10191         if (flags & NDR_IN) {
10192                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
10193                 ndr->depth++;
10194                 ndr->depth--;
10195         }
10196         if (flags & NDR_OUT) {
10197                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
10198                 ndr->depth++;
10199                 ndr_print_WERROR(ndr, "result", r->out.result);
10200                 ndr->depth--;
10201         }
10202         ndr->depth--;
10203 }
10204
10205 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
10206 {
10207         if (flags & NDR_IN) {
10208                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10209                 if (r->in.server) {
10210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10211                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10212                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10213                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10214                 }
10215                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
10216                 if (r->in.environment) {
10217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10219                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10220                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10221                 }
10222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10224                 if (r->in.buffer) {
10225                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10226                 }
10227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10228         }
10229         if (flags & NDR_OUT) {
10230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10231                 if (r->out.info) {
10232                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
10233                 }
10234                 if (r->out.needed == NULL) {
10235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10236                 }
10237                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
10238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
10239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10240         }
10241         return NDR_ERR_SUCCESS;
10242 }
10243
10244 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
10245 {
10246         uint32_t _ptr_server;
10247         uint32_t _ptr_environment;
10248         uint32_t _ptr_buffer;
10249         uint32_t _ptr_info;
10250         TALLOC_CTX *_mem_save_server_0;
10251         TALLOC_CTX *_mem_save_environment_0;
10252         TALLOC_CTX *_mem_save_buffer_0;
10253         TALLOC_CTX *_mem_save_info_0;
10254         TALLOC_CTX *_mem_save_needed_0;
10255         if (flags & NDR_IN) {
10256                 ZERO_STRUCT(r->out);
10257
10258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10259                 if (_ptr_server) {
10260                         NDR_PULL_ALLOC(ndr, r->in.server);
10261                 } else {
10262                         r->in.server = NULL;
10263                 }
10264                 if (r->in.server) {
10265                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10266                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10269                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10270                                 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));
10271                         }
10272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10275                 }
10276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10277                 if (_ptr_environment) {
10278                         NDR_PULL_ALLOC(ndr, r->in.environment);
10279                 } else {
10280                         r->in.environment = NULL;
10281                 }
10282                 if (r->in.environment) {
10283                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10284                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
10285                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
10286                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
10287                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
10288                                 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));
10289                         }
10290                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
10291                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
10292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10293                 }
10294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10296                 if (_ptr_buffer) {
10297                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10298                 } else {
10299                         r->in.buffer = NULL;
10300                 }
10301                 if (r->in.buffer) {
10302                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10303                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10304                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10306                 }
10307                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10308                 NDR_PULL_ALLOC(ndr, r->out.needed);
10309                 ZERO_STRUCTP(r->out.needed);
10310         }
10311         if (flags & NDR_OUT) {
10312                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10313                 if (_ptr_info) {
10314                         NDR_PULL_ALLOC(ndr, r->out.info);
10315                 } else {
10316                         r->out.info = NULL;
10317                 }
10318                 if (r->out.info) {
10319                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10320                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10321                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
10322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10323                 }
10324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10325                         NDR_PULL_ALLOC(ndr, r->out.needed);
10326                 }
10327                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
10328                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
10329                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
10330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
10331                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
10332                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10333         }
10334         return NDR_ERR_SUCCESS;
10335 }
10336
10337 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
10338 {
10339         uint32_t cntr_info_0;
10340         if (flags & NDR_IN) {
10341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
10343         }
10344         if (flags & NDR_OUT) {
10345                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10346                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
10347                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
10348                 }
10349                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10350                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
10351                 }
10352         }
10353         return NDR_ERR_SUCCESS;
10354 }
10355
10356 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
10357 {
10358         uint32_t cntr_info_0;
10359         TALLOC_CTX *_mem_save_info_0;
10360         if (flags & NDR_IN) {
10361                 ZERO_STRUCT(r->out);
10362
10363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
10365         }
10366         if (flags & NDR_OUT) {
10367                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
10368                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10369                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10370                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10371                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
10372                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
10373                 }
10374                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10375                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
10376                 }
10377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10378         }
10379         return NDR_ERR_SUCCESS;
10380 }
10381
10382 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
10383 {
10384         uint32_t cntr_info_1;
10385         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
10386         ndr->depth++;
10387         if (flags & NDR_SET_VALUES) {
10388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10389         }
10390         if (flags & NDR_IN) {
10391                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
10392                 ndr->depth++;
10393                 ndr_print_ptr(ndr, "server", r->in.server);
10394                 ndr->depth++;
10395                 if (r->in.server) {
10396                         ndr_print_string(ndr, "server", r->in.server);
10397                 }
10398                 ndr->depth--;
10399                 ndr_print_ptr(ndr, "environment", r->in.environment);
10400                 ndr->depth++;
10401                 if (r->in.environment) {
10402                         ndr_print_string(ndr, "environment", r->in.environment);
10403                 }
10404                 ndr->depth--;
10405                 ndr_print_uint32(ndr, "level", r->in.level);
10406                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10407                 ndr->depth++;
10408                 if (r->in.buffer) {
10409                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10410                 }
10411                 ndr->depth--;
10412                 ndr_print_uint32(ndr, "offered", r->in.offered);
10413                 ndr->depth--;
10414         }
10415         if (flags & NDR_OUT) {
10416                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
10417                 ndr->depth++;
10418                 ndr_print_ptr(ndr, "info", r->out.info);
10419                 ndr->depth++;
10420                 if (r->out.info) {
10421                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
10422                         ndr->depth++;
10423                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
10424                                 char *idx_1=NULL;
10425                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
10426                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
10427                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
10428                                         free(idx_1);
10429                                 }
10430                         }
10431                         ndr->depth--;
10432                 }
10433                 ndr->depth--;
10434                 ndr_print_ptr(ndr, "needed", r->out.needed);
10435                 ndr->depth++;
10436                 ndr_print_uint32(ndr, "needed", *r->out.needed);
10437                 ndr->depth--;
10438                 ndr_print_uint32(ndr, "count", r->out.count);
10439                 ndr_print_WERROR(ndr, "result", r->out.result);
10440                 ndr->depth--;
10441         }
10442         ndr->depth--;
10443 }
10444
10445 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
10446 {
10447         if (flags & NDR_IN) {
10448         }
10449         if (flags & NDR_OUT) {
10450                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10451         }
10452         return NDR_ERR_SUCCESS;
10453 }
10454
10455 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
10456 {
10457         if (flags & NDR_IN) {
10458         }
10459         if (flags & NDR_OUT) {
10460                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10461         }
10462         return NDR_ERR_SUCCESS;
10463 }
10464
10465 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
10466 {
10467         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
10468         ndr->depth++;
10469         if (flags & NDR_SET_VALUES) {
10470                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10471         }
10472         if (flags & NDR_IN) {
10473                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
10474                 ndr->depth++;
10475                 ndr->depth--;
10476         }
10477         if (flags & NDR_OUT) {
10478                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
10479                 ndr->depth++;
10480                 ndr_print_WERROR(ndr, "result", r->out.result);
10481                 ndr->depth--;
10482         }
10483         ndr->depth--;
10484 }
10485
10486 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
10487 {
10488         if (flags & NDR_IN) {
10489                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10490                 if (r->in.server) {
10491                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10492                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10494                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10495                 }
10496                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
10497                 if (r->in.environment) {
10498                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10499                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10501                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10502                 }
10503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10504                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10505                 if (r->in.buffer) {
10506                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10507                 }
10508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10509         }
10510         if (flags & NDR_OUT) {
10511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10512                 if (r->out.info) {
10513                         {
10514                                 struct ndr_push *_ndr_info;
10515                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
10516                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
10517                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
10518                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
10519                         }
10520                 }
10521                 if (r->out.needed == NULL) {
10522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10523                 }
10524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
10525                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10526         }
10527         return NDR_ERR_SUCCESS;
10528 }
10529
10530 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
10531 {
10532         uint32_t _ptr_server;
10533         uint32_t _ptr_environment;
10534         uint32_t _ptr_buffer;
10535         uint32_t _ptr_info;
10536         TALLOC_CTX *_mem_save_server_0;
10537         TALLOC_CTX *_mem_save_environment_0;
10538         TALLOC_CTX *_mem_save_buffer_0;
10539         TALLOC_CTX *_mem_save_info_0;
10540         TALLOC_CTX *_mem_save_needed_0;
10541         if (flags & NDR_IN) {
10542                 ZERO_STRUCT(r->out);
10543
10544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10545                 if (_ptr_server) {
10546                         NDR_PULL_ALLOC(ndr, r->in.server);
10547                 } else {
10548                         r->in.server = NULL;
10549                 }
10550                 if (r->in.server) {
10551                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10552                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10553                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10554                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10555                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10556                                 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));
10557                         }
10558                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10559                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10560                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10561                 }
10562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10563                 if (_ptr_environment) {
10564                         NDR_PULL_ALLOC(ndr, r->in.environment);
10565                 } else {
10566                         r->in.environment = NULL;
10567                 }
10568                 if (r->in.environment) {
10569                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10570                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
10571                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
10572                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
10573                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
10574                                 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));
10575                         }
10576                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
10577                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
10578                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10579                 }
10580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10582                 if (_ptr_buffer) {
10583                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10584                 } else {
10585                         r->in.buffer = NULL;
10586                 }
10587                 if (r->in.buffer) {
10588                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10589                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10590                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10592                 }
10593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10594                 NDR_PULL_ALLOC(ndr, r->out.needed);
10595                 ZERO_STRUCTP(r->out.needed);
10596         }
10597         if (flags & NDR_OUT) {
10598                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10599                 if (_ptr_info) {
10600                         NDR_PULL_ALLOC(ndr, r->out.info);
10601                 } else {
10602                         r->out.info = NULL;
10603                 }
10604                 if (r->out.info) {
10605                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10606                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10607                         {
10608                                 struct ndr_pull *_ndr_info;
10609                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
10610                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
10611                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
10612                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
10613                         }
10614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10615                 }
10616                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10617                         NDR_PULL_ALLOC(ndr, r->out.needed);
10618                 }
10619                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
10620                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
10621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
10622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
10623                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10624         }
10625         return NDR_ERR_SUCCESS;
10626 }
10627
10628 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
10629 {
10630         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
10631         ndr->depth++;
10632         if (flags & NDR_SET_VALUES) {
10633                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10634         }
10635         if (flags & NDR_IN) {
10636                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
10637                 ndr->depth++;
10638                 ndr_print_ptr(ndr, "server", r->in.server);
10639                 ndr->depth++;
10640                 if (r->in.server) {
10641                         ndr_print_string(ndr, "server", r->in.server);
10642                 }
10643                 ndr->depth--;
10644                 ndr_print_ptr(ndr, "environment", r->in.environment);
10645                 ndr->depth++;
10646                 if (r->in.environment) {
10647                         ndr_print_string(ndr, "environment", r->in.environment);
10648                 }
10649                 ndr->depth--;
10650                 ndr_print_uint32(ndr, "level", r->in.level);
10651                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10652                 ndr->depth++;
10653                 if (r->in.buffer) {
10654                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10655                 }
10656                 ndr->depth--;
10657                 ndr_print_uint32(ndr, "offered", r->in.offered);
10658                 ndr->depth--;
10659         }
10660         if (flags & NDR_OUT) {
10661                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
10662                 ndr->depth++;
10663                 ndr_print_ptr(ndr, "info", r->out.info);
10664                 ndr->depth++;
10665                 if (r->out.info) {
10666                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10667                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
10668                 }
10669                 ndr->depth--;
10670                 ndr_print_ptr(ndr, "needed", r->out.needed);
10671                 ndr->depth++;
10672                 ndr_print_uint32(ndr, "needed", *r->out.needed);
10673                 ndr->depth--;
10674                 ndr_print_WERROR(ndr, "result", r->out.result);
10675                 ndr->depth--;
10676         }
10677         ndr->depth--;
10678 }
10679
10680 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
10681 {
10682         if (flags & NDR_IN) {
10683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10684                 if (r->in.server) {
10685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10689                 }
10690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
10691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
10693                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
10695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
10697                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10698         }
10699         if (flags & NDR_OUT) {
10700                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10701         }
10702         return NDR_ERR_SUCCESS;
10703 }
10704
10705 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
10706 {
10707         uint32_t _ptr_server;
10708         TALLOC_CTX *_mem_save_server_0;
10709         if (flags & NDR_IN) {
10710                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10711                 if (_ptr_server) {
10712                         NDR_PULL_ALLOC(ndr, r->in.server);
10713                 } else {
10714                         r->in.server = NULL;
10715                 }
10716                 if (r->in.server) {
10717                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10718                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10719                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10720                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10721                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10722                                 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));
10723                         }
10724                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10725                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10726                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10727                 }
10728                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
10729                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
10730                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
10731                         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));
10732                 }
10733                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
10734                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
10735                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
10736                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
10737                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
10738                         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));
10739                 }
10740                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
10741                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
10742         }
10743         if (flags & NDR_OUT) {
10744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10745         }
10746         return NDR_ERR_SUCCESS;
10747 }
10748
10749 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
10750 {
10751         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
10752         ndr->depth++;
10753         if (flags & NDR_SET_VALUES) {
10754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10755         }
10756         if (flags & NDR_IN) {
10757                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
10758                 ndr->depth++;
10759                 ndr_print_ptr(ndr, "server", r->in.server);
10760                 ndr->depth++;
10761                 if (r->in.server) {
10762                         ndr_print_string(ndr, "server", r->in.server);
10763                 }
10764                 ndr->depth--;
10765                 ndr_print_string(ndr, "architecture", r->in.architecture);
10766                 ndr_print_string(ndr, "driver", r->in.driver);
10767                 ndr->depth--;
10768         }
10769         if (flags & NDR_OUT) {
10770                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
10771                 ndr->depth++;
10772                 ndr_print_WERROR(ndr, "result", r->out.result);
10773                 ndr->depth--;
10774         }
10775         ndr->depth--;
10776 }
10777
10778 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
10779 {
10780         if (flags & NDR_IN) {
10781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10782                 if (r->in.server) {
10783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10785                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10786                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10787                 }
10788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
10789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
10791                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
10793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
10795                 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));
10796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
10797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
10799                 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));
10800         }
10801         if (flags & NDR_OUT) {
10802                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10803         }
10804         return NDR_ERR_SUCCESS;
10805 }
10806
10807 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
10808 {
10809         uint32_t _ptr_server;
10810         TALLOC_CTX *_mem_save_server_0;
10811         if (flags & NDR_IN) {
10812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10813                 if (_ptr_server) {
10814                         NDR_PULL_ALLOC(ndr, r->in.server);
10815                 } else {
10816                         r->in.server = NULL;
10817                 }
10818                 if (r->in.server) {
10819                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10820                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10823                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10824                                 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));
10825                         }
10826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10829                 }
10830                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
10831                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
10832                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
10833                         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));
10834                 }
10835                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
10836                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
10837                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
10838                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
10839                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
10840                         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));
10841                 }
10842                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
10843                 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));
10844                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
10845                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
10846                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
10847                         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));
10848                 }
10849                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
10850                 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));
10851         }
10852         if (flags & NDR_OUT) {
10853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10854         }
10855         return NDR_ERR_SUCCESS;
10856 }
10857
10858 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
10859 {
10860         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
10861         ndr->depth++;
10862         if (flags & NDR_SET_VALUES) {
10863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10864         }
10865         if (flags & NDR_IN) {
10866                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
10867                 ndr->depth++;
10868                 ndr_print_ptr(ndr, "server", r->in.server);
10869                 ndr->depth++;
10870                 if (r->in.server) {
10871                         ndr_print_string(ndr, "server", r->in.server);
10872                 }
10873                 ndr->depth--;
10874                 ndr_print_string(ndr, "architecture", r->in.architecture);
10875                 ndr_print_string(ndr, "path_name", r->in.path_name);
10876                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
10877                 ndr->depth--;
10878         }
10879         if (flags & NDR_OUT) {
10880                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
10881                 ndr->depth++;
10882                 ndr_print_WERROR(ndr, "result", r->out.result);
10883                 ndr->depth--;
10884         }
10885         ndr->depth--;
10886 }
10887
10888 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
10889 {
10890         if (flags & NDR_IN) {
10891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
10892                 if (r->in.servername) {
10893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
10894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10895                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
10896                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10897                 }
10898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
10899                 if (r->in.environment) {
10900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10904                 }
10905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10907                 if (r->in.buffer) {
10908                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10909                 }
10910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10911         }
10912         if (flags & NDR_OUT) {
10913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10914                 if (r->out.info) {
10915                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
10916                 }
10917                 if (r->out.needed == NULL) {
10918                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10919                 }
10920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
10921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
10922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10923         }
10924         return NDR_ERR_SUCCESS;
10925 }
10926
10927 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
10928 {
10929         uint32_t _ptr_servername;
10930         uint32_t _ptr_environment;
10931         uint32_t _ptr_buffer;
10932         uint32_t _ptr_info;
10933         TALLOC_CTX *_mem_save_servername_0;
10934         TALLOC_CTX *_mem_save_environment_0;
10935         TALLOC_CTX *_mem_save_buffer_0;
10936         TALLOC_CTX *_mem_save_info_0;
10937         TALLOC_CTX *_mem_save_needed_0;
10938         if (flags & NDR_IN) {
10939                 ZERO_STRUCT(r->out);
10940
10941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
10942                 if (_ptr_servername) {
10943                         NDR_PULL_ALLOC(ndr, r->in.servername);
10944                 } else {
10945                         r->in.servername = NULL;
10946                 }
10947                 if (r->in.servername) {
10948                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
10949                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
10950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
10951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
10952                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
10953                                 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));
10954                         }
10955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
10956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
10957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
10958                 }
10959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10960                 if (_ptr_environment) {
10961                         NDR_PULL_ALLOC(ndr, r->in.environment);
10962                 } else {
10963                         r->in.environment = NULL;
10964                 }
10965                 if (r->in.environment) {
10966                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10967                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
10968                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
10969                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
10970                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
10971                                 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));
10972                         }
10973                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
10974                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
10975                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10976                 }
10977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10979                 if (_ptr_buffer) {
10980                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10981                 } else {
10982                         r->in.buffer = NULL;
10983                 }
10984                 if (r->in.buffer) {
10985                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10986                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10987                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10989                 }
10990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10991                 NDR_PULL_ALLOC(ndr, r->out.needed);
10992                 ZERO_STRUCTP(r->out.needed);
10993         }
10994         if (flags & NDR_OUT) {
10995                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10996                 if (_ptr_info) {
10997                         NDR_PULL_ALLOC(ndr, r->out.info);
10998                 } else {
10999                         r->out.info = NULL;
11000                 }
11001                 if (r->out.info) {
11002                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11003                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
11004                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
11005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
11006                 }
11007                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11008                         NDR_PULL_ALLOC(ndr, r->out.needed);
11009                 }
11010                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
11011                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
11012                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
11013                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
11014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
11015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11016         }
11017         return NDR_ERR_SUCCESS;
11018 }
11019
11020 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
11021 {
11022         uint32_t cntr_info_0;
11023         if (flags & NDR_IN) {
11024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
11025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
11026         }
11027         if (flags & NDR_OUT) {
11028                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
11029                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
11030                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
11031                 }
11032                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
11033                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
11034                 }
11035         }
11036         return NDR_ERR_SUCCESS;
11037 }
11038
11039 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
11040 {
11041         uint32_t cntr_info_0;
11042         TALLOC_CTX *_mem_save_info_0;
11043         if (flags & NDR_IN) {
11044                 ZERO_STRUCT(r->out);
11045
11046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
11047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
11048         }
11049         if (flags & NDR_OUT) {
11050                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
11051                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
11052                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
11053                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
11054                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
11055                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
11056                 }
11057                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
11058                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
11059                 }
11060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
11061         }
11062         return NDR_ERR_SUCCESS;
11063 }
11064
11065 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
11066 {
11067         uint32_t cntr_info_1;
11068         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
11069         ndr->depth++;
11070         if (flags & NDR_SET_VALUES) {
11071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11072         }
11073         if (flags & NDR_IN) {
11074                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
11075                 ndr->depth++;
11076                 ndr_print_ptr(ndr, "servername", r->in.servername);
11077                 ndr->depth++;
11078                 if (r->in.servername) {
11079                         ndr_print_string(ndr, "servername", r->in.servername);
11080                 }
11081                 ndr->depth--;
11082                 ndr_print_ptr(ndr, "environment", r->in.environment);
11083                 ndr->depth++;
11084                 if (r->in.environment) {
11085                         ndr_print_string(ndr, "environment", r->in.environment);
11086                 }
11087                 ndr->depth--;
11088                 ndr_print_uint32(ndr, "level", r->in.level);
11089                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
11090                 ndr->depth++;
11091                 if (r->in.buffer) {
11092                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
11093                 }
11094                 ndr->depth--;
11095                 ndr_print_uint32(ndr, "offered", r->in.offered);
11096                 ndr->depth--;
11097         }
11098         if (flags & NDR_OUT) {
11099                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
11100                 ndr->depth++;
11101                 ndr_print_ptr(ndr, "info", r->out.info);
11102                 ndr->depth++;
11103                 if (r->out.info) {
11104                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
11105                         ndr->depth++;
11106                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
11107                                 char *idx_1=NULL;
11108                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
11109                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
11110                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
11111                                         free(idx_1);
11112                                 }
11113                         }
11114                         ndr->depth--;
11115                 }
11116                 ndr->depth--;
11117                 ndr_print_ptr(ndr, "needed", r->out.needed);
11118                 ndr->depth++;
11119                 ndr_print_uint32(ndr, "needed", *r->out.needed);
11120                 ndr->depth--;
11121                 ndr_print_uint32(ndr, "count", r->out.count);
11122                 ndr_print_WERROR(ndr, "result", r->out.result);
11123                 ndr->depth--;
11124         }
11125         ndr->depth--;
11126 }
11127
11128 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
11129 {
11130         if (flags & NDR_IN) {
11131         }
11132         if (flags & NDR_OUT) {
11133                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11134         }
11135         return NDR_ERR_SUCCESS;
11136 }
11137
11138 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
11139 {
11140         if (flags & NDR_IN) {
11141         }
11142         if (flags & NDR_OUT) {
11143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11144         }
11145         return NDR_ERR_SUCCESS;
11146 }
11147
11148 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
11149 {
11150         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
11151         ndr->depth++;
11152         if (flags & NDR_SET_VALUES) {
11153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11154         }
11155         if (flags & NDR_IN) {
11156                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
11157                 ndr->depth++;
11158                 ndr->depth--;
11159         }
11160         if (flags & NDR_OUT) {
11161                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
11162                 ndr->depth++;
11163                 ndr_print_WERROR(ndr, "result", r->out.result);
11164                 ndr->depth--;
11165         }
11166         ndr->depth--;
11167 }
11168
11169 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
11170 {
11171         if (flags & NDR_IN) {
11172                 if (r->in.handle == NULL) {
11173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11174                 }
11175                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
11177                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
11178                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
11179         }
11180         if (flags & NDR_OUT) {
11181                 if (r->out.job_id == NULL) {
11182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11183                 }
11184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
11185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11186         }
11187         return NDR_ERR_SUCCESS;
11188 }
11189
11190 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
11191 {
11192         TALLOC_CTX *_mem_save_handle_0;
11193         TALLOC_CTX *_mem_save_job_id_0;
11194         if (flags & NDR_IN) {
11195                 ZERO_STRUCT(r->out);
11196
11197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11198                         NDR_PULL_ALLOC(ndr, r->in.handle);
11199                 }
11200                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11201                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
11205                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
11206                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
11207                 NDR_PULL_ALLOC(ndr, r->out.job_id);
11208                 ZERO_STRUCTP(r->out.job_id);
11209         }
11210         if (flags & NDR_OUT) {
11211                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11212                         NDR_PULL_ALLOC(ndr, r->out.job_id);
11213                 }
11214                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
11215                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
11216                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
11217                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
11218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11219         }
11220         return NDR_ERR_SUCCESS;
11221 }
11222
11223 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
11224 {
11225         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
11226         ndr->depth++;
11227         if (flags & NDR_SET_VALUES) {
11228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11229         }
11230         if (flags & NDR_IN) {
11231                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
11232                 ndr->depth++;
11233                 ndr_print_ptr(ndr, "handle", r->in.handle);
11234                 ndr->depth++;
11235                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11236                 ndr->depth--;
11237                 ndr_print_uint32(ndr, "level", r->in.level);
11238                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
11239                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
11240                 ndr->depth--;
11241         }
11242         if (flags & NDR_OUT) {
11243                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
11244                 ndr->depth++;
11245                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
11246                 ndr->depth++;
11247                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
11248                 ndr->depth--;
11249                 ndr_print_WERROR(ndr, "result", r->out.result);
11250                 ndr->depth--;
11251         }
11252         ndr->depth--;
11253 }
11254
11255 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
11256 {
11257         if (flags & NDR_IN) {
11258                 if (r->in.handle == NULL) {
11259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11260                 }
11261                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11262         }
11263         if (flags & NDR_OUT) {
11264                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11265         }
11266         return NDR_ERR_SUCCESS;
11267 }
11268
11269 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
11270 {
11271         TALLOC_CTX *_mem_save_handle_0;
11272         if (flags & NDR_IN) {
11273                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11274                         NDR_PULL_ALLOC(ndr, r->in.handle);
11275                 }
11276                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11277                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11278                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11279                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11280         }
11281         if (flags & NDR_OUT) {
11282                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11283         }
11284         return NDR_ERR_SUCCESS;
11285 }
11286
11287 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
11288 {
11289         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
11290         ndr->depth++;
11291         if (flags & NDR_SET_VALUES) {
11292                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11293         }
11294         if (flags & NDR_IN) {
11295                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
11296                 ndr->depth++;
11297                 ndr_print_ptr(ndr, "handle", r->in.handle);
11298                 ndr->depth++;
11299                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11300                 ndr->depth--;
11301                 ndr->depth--;
11302         }
11303         if (flags & NDR_OUT) {
11304                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
11305                 ndr->depth++;
11306                 ndr_print_WERROR(ndr, "result", r->out.result);
11307                 ndr->depth--;
11308         }
11309         ndr->depth--;
11310 }
11311
11312 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
11313 {
11314         if (flags & NDR_IN) {
11315                 if (r->in.handle == NULL) {
11316                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11317                 }
11318                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11319                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
11320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
11321         }
11322         if (flags & NDR_OUT) {
11323                 if (r->out.num_written == NULL) {
11324                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11325                 }
11326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
11327                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11328         }
11329         return NDR_ERR_SUCCESS;
11330 }
11331
11332 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
11333 {
11334         TALLOC_CTX *_mem_save_handle_0;
11335         TALLOC_CTX *_mem_save_num_written_0;
11336         if (flags & NDR_IN) {
11337                 ZERO_STRUCT(r->out);
11338
11339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11340                         NDR_PULL_ALLOC(ndr, r->in.handle);
11341                 }
11342                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11344                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11346                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
11347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
11348                 NDR_PULL_ALLOC(ndr, r->out.num_written);
11349                 ZERO_STRUCTP(r->out.num_written);
11350         }
11351         if (flags & NDR_OUT) {
11352                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11353                         NDR_PULL_ALLOC(ndr, r->out.num_written);
11354                 }
11355                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
11356                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
11357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
11358                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
11359                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11360         }
11361         return NDR_ERR_SUCCESS;
11362 }
11363
11364 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
11365 {
11366         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
11367         ndr->depth++;
11368         if (flags & NDR_SET_VALUES) {
11369                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11370         }
11371         if (flags & NDR_IN) {
11372                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
11373                 ndr->depth++;
11374                 ndr_print_ptr(ndr, "handle", r->in.handle);
11375                 ndr->depth++;
11376                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11377                 ndr->depth--;
11378                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
11379                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
11380                 ndr->depth--;
11381         }
11382         if (flags & NDR_OUT) {
11383                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
11384                 ndr->depth++;
11385                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
11386                 ndr->depth++;
11387                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
11388                 ndr->depth--;
11389                 ndr_print_WERROR(ndr, "result", r->out.result);
11390                 ndr->depth--;
11391         }
11392         ndr->depth--;
11393 }
11394
11395 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
11396 {
11397         if (flags & NDR_IN) {
11398                 if (r->in.handle == NULL) {
11399                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11400                 }
11401                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11402         }
11403         if (flags & NDR_OUT) {
11404                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11405         }
11406         return NDR_ERR_SUCCESS;
11407 }
11408
11409 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
11410 {
11411         TALLOC_CTX *_mem_save_handle_0;
11412         if (flags & NDR_IN) {
11413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11414                         NDR_PULL_ALLOC(ndr, r->in.handle);
11415                 }
11416                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11418                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11420         }
11421         if (flags & NDR_OUT) {
11422                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11423         }
11424         return NDR_ERR_SUCCESS;
11425 }
11426
11427 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
11428 {
11429         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
11430         ndr->depth++;
11431         if (flags & NDR_SET_VALUES) {
11432                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11433         }
11434         if (flags & NDR_IN) {
11435                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
11436                 ndr->depth++;
11437                 ndr_print_ptr(ndr, "handle", r->in.handle);
11438                 ndr->depth++;
11439                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11440                 ndr->depth--;
11441                 ndr->depth--;
11442         }
11443         if (flags & NDR_OUT) {
11444                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
11445                 ndr->depth++;
11446                 ndr_print_WERROR(ndr, "result", r->out.result);
11447                 ndr->depth--;
11448         }
11449         ndr->depth--;
11450 }
11451
11452 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
11453 {
11454         if (flags & NDR_IN) {
11455                 if (r->in.handle == NULL) {
11456                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11457                 }
11458                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11459         }
11460         if (flags & NDR_OUT) {
11461                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11462         }
11463         return NDR_ERR_SUCCESS;
11464 }
11465
11466 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
11467 {
11468         TALLOC_CTX *_mem_save_handle_0;
11469         if (flags & NDR_IN) {
11470                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11471                         NDR_PULL_ALLOC(ndr, r->in.handle);
11472                 }
11473                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11474                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11475                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11476                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11477         }
11478         if (flags & NDR_OUT) {
11479                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11480         }
11481         return NDR_ERR_SUCCESS;
11482 }
11483
11484 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
11485 {
11486         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
11487         ndr->depth++;
11488         if (flags & NDR_SET_VALUES) {
11489                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11490         }
11491         if (flags & NDR_IN) {
11492                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
11493                 ndr->depth++;
11494                 ndr_print_ptr(ndr, "handle", r->in.handle);
11495                 ndr->depth++;
11496                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11497                 ndr->depth--;
11498                 ndr->depth--;
11499         }
11500         if (flags & NDR_OUT) {
11501                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
11502                 ndr->depth++;
11503                 ndr_print_WERROR(ndr, "result", r->out.result);
11504                 ndr->depth--;
11505         }
11506         ndr->depth--;
11507 }
11508
11509 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
11510 {
11511         if (flags & NDR_IN) {
11512                 if (r->in.handle == NULL) {
11513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11514                 }
11515                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
11517         }
11518         if (flags & NDR_OUT) {
11519                 if (r->out.data == NULL) {
11520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11521                 }
11522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
11523                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
11524                 if (r->out._data_size == NULL) {
11525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11526                 }
11527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
11528                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11529         }
11530         return NDR_ERR_SUCCESS;
11531 }
11532
11533 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
11534 {
11535         TALLOC_CTX *_mem_save_handle_0;
11536         TALLOC_CTX *_mem_save__data_size_0;
11537         if (flags & NDR_IN) {
11538                 ZERO_STRUCT(r->out);
11539
11540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11541                         NDR_PULL_ALLOC(ndr, r->in.handle);
11542                 }
11543                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11544                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11545                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
11548                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
11549                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
11550                 NDR_PULL_ALLOC(ndr, r->out._data_size);
11551                 ZERO_STRUCTP(r->out._data_size);
11552         }
11553         if (flags & NDR_OUT) {
11554                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
11555                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11556                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
11557                 }
11558                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
11559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11560                         NDR_PULL_ALLOC(ndr, r->out._data_size);
11561                 }
11562                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
11563                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
11564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
11565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
11566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11567                 if (r->out.data) {
11568                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
11569                 }
11570         }
11571         return NDR_ERR_SUCCESS;
11572 }
11573
11574 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
11575 {
11576         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
11577         ndr->depth++;
11578         if (flags & NDR_SET_VALUES) {
11579                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11580         }
11581         if (flags & NDR_IN) {
11582                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
11583                 ndr->depth++;
11584                 ndr_print_ptr(ndr, "handle", r->in.handle);
11585                 ndr->depth++;
11586                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11587                 ndr->depth--;
11588                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
11589                 ndr->depth--;
11590         }
11591         if (flags & NDR_OUT) {
11592                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
11593                 ndr->depth++;
11594                 ndr_print_ptr(ndr, "data", r->out.data);
11595                 ndr->depth++;
11596                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
11597                 ndr->depth--;
11598                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
11599                 ndr->depth++;
11600                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
11601                 ndr->depth--;
11602                 ndr_print_WERROR(ndr, "result", r->out.result);
11603                 ndr->depth--;
11604         }
11605         ndr->depth--;
11606 }
11607
11608 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
11609 {
11610         if (flags & NDR_IN) {
11611                 if (r->in.handle == NULL) {
11612                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11613                 }
11614                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11615         }
11616         if (flags & NDR_OUT) {
11617                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11618         }
11619         return NDR_ERR_SUCCESS;
11620 }
11621
11622 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
11623 {
11624         TALLOC_CTX *_mem_save_handle_0;
11625         if (flags & NDR_IN) {
11626                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11627                         NDR_PULL_ALLOC(ndr, r->in.handle);
11628                 }
11629                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11630                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11631                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11632                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11633         }
11634         if (flags & NDR_OUT) {
11635                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11636         }
11637         return NDR_ERR_SUCCESS;
11638 }
11639
11640 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
11641 {
11642         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
11643         ndr->depth++;
11644         if (flags & NDR_SET_VALUES) {
11645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11646         }
11647         if (flags & NDR_IN) {
11648                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
11649                 ndr->depth++;
11650                 ndr_print_ptr(ndr, "handle", r->in.handle);
11651                 ndr->depth++;
11652                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11653                 ndr->depth--;
11654                 ndr->depth--;
11655         }
11656         if (flags & NDR_OUT) {
11657                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
11658                 ndr->depth++;
11659                 ndr_print_WERROR(ndr, "result", r->out.result);
11660                 ndr->depth--;
11661         }
11662         ndr->depth--;
11663 }
11664
11665 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
11666 {
11667         if (flags & NDR_IN) {
11668                 if (r->in.handle == NULL) {
11669                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11670                 }
11671                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
11673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
11674                 if (r->in.buffer) {
11675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11676                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
11677                 }
11678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11679         }
11680         if (flags & NDR_OUT) {
11681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
11682                 if (r->out.buffer) {
11683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11684                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
11685                 }
11686                 if (r->out.needed == NULL) {
11687                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11688                 }
11689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
11690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11691         }
11692         return NDR_ERR_SUCCESS;
11693 }
11694
11695 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
11696 {
11697         uint32_t _ptr_buffer;
11698         TALLOC_CTX *_mem_save_handle_0;
11699         TALLOC_CTX *_mem_save_buffer_0;
11700         TALLOC_CTX *_mem_save_needed_0;
11701         if (flags & NDR_IN) {
11702                 ZERO_STRUCT(r->out);
11703
11704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11705                         NDR_PULL_ALLOC(ndr, r->in.handle);
11706                 }
11707                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11708                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11709                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11711                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
11712                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
11713                 if (_ptr_buffer) {
11714                         NDR_PULL_ALLOC(ndr, r->in.buffer);
11715                 } else {
11716                         r->in.buffer = NULL;
11717                 }
11718                 if (r->in.buffer) {
11719                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
11720                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
11721                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
11722                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
11723                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
11724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
11725                 }
11726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
11727                 NDR_PULL_ALLOC(ndr, r->out.needed);
11728                 ZERO_STRUCTP(r->out.needed);
11729                 if (r->in.buffer) {
11730                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
11731                 }
11732         }
11733         if (flags & NDR_OUT) {
11734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
11735                 if (_ptr_buffer) {
11736                         NDR_PULL_ALLOC(ndr, r->out.buffer);
11737                 } else {
11738                         r->out.buffer = NULL;
11739                 }
11740                 if (r->out.buffer) {
11741                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
11742                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
11743                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
11744                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
11745                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
11746                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
11747                 }
11748                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11749                         NDR_PULL_ALLOC(ndr, r->out.needed);
11750                 }
11751                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
11752                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
11753                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
11754                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
11755                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11756                 if (r->out.buffer) {
11757                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
11758                 }
11759         }
11760         return NDR_ERR_SUCCESS;
11761 }
11762
11763 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
11764 {
11765         ndr_print_struct(ndr, name, "spoolss_AddJob");
11766         ndr->depth++;
11767         if (flags & NDR_SET_VALUES) {
11768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11769         }
11770         if (flags & NDR_IN) {
11771                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
11772                 ndr->depth++;
11773                 ndr_print_ptr(ndr, "handle", r->in.handle);
11774                 ndr->depth++;
11775                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11776                 ndr->depth--;
11777                 ndr_print_uint32(ndr, "level", r->in.level);
11778                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
11779                 ndr->depth++;
11780                 if (r->in.buffer) {
11781                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
11782                 }
11783                 ndr->depth--;
11784                 ndr_print_uint32(ndr, "offered", r->in.offered);
11785                 ndr->depth--;
11786         }
11787         if (flags & NDR_OUT) {
11788                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
11789                 ndr->depth++;
11790                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
11791                 ndr->depth++;
11792                 if (r->out.buffer) {
11793                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
11794                 }
11795                 ndr->depth--;
11796                 ndr_print_ptr(ndr, "needed", r->out.needed);
11797                 ndr->depth++;
11798                 ndr_print_uint32(ndr, "needed", *r->out.needed);
11799                 ndr->depth--;
11800                 ndr_print_WERROR(ndr, "result", r->out.result);
11801                 ndr->depth--;
11802         }
11803         ndr->depth--;
11804 }
11805
11806 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
11807 {
11808         if (flags & NDR_IN) {
11809                 if (r->in.handle == NULL) {
11810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11811                 }
11812                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
11814         }
11815         if (flags & NDR_OUT) {
11816                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11817         }
11818         return NDR_ERR_SUCCESS;
11819 }
11820
11821 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
11822 {
11823         TALLOC_CTX *_mem_save_handle_0;
11824         if (flags & NDR_IN) {
11825                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11826                         NDR_PULL_ALLOC(ndr, r->in.handle);
11827                 }
11828                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11829                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11830                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11831                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11832                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
11833         }
11834         if (flags & NDR_OUT) {
11835                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11836         }
11837         return NDR_ERR_SUCCESS;
11838 }
11839
11840 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
11841 {
11842         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
11843         ndr->depth++;
11844         if (flags & NDR_SET_VALUES) {
11845                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11846         }
11847         if (flags & NDR_IN) {
11848                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
11849                 ndr->depth++;
11850                 ndr_print_ptr(ndr, "handle", r->in.handle);
11851                 ndr->depth++;
11852                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11853                 ndr->depth--;
11854                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
11855                 ndr->depth--;
11856         }
11857         if (flags & NDR_OUT) {
11858                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
11859                 ndr->depth++;
11860                 ndr_print_WERROR(ndr, "result", r->out.result);
11861                 ndr->depth--;
11862         }
11863         ndr->depth--;
11864 }
11865
11866 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
11867 {
11868         if (flags & NDR_IN) {
11869                 if (r->in.handle == NULL) {
11870                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11871                 }
11872                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11876                 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));
11877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11878         }
11879         if (flags & NDR_OUT) {
11880                 if (r->out.type == NULL) {
11881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11882                 }
11883                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
11884                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
11885                 if (r->out.needed == NULL) {
11886                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11887                 }
11888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
11889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11890         }
11891         return NDR_ERR_SUCCESS;
11892 }
11893
11894 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
11895 {
11896         TALLOC_CTX *_mem_save_handle_0;
11897         TALLOC_CTX *_mem_save_type_0;
11898         TALLOC_CTX *_mem_save_needed_0;
11899         if (flags & NDR_IN) {
11900                 ZERO_STRUCT(r->out);
11901
11902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11903                         NDR_PULL_ALLOC(ndr, r->in.handle);
11904                 }
11905                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11906                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11907                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11909                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
11910                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
11911                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
11912                         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));
11913                 }
11914                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
11915                 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));
11916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
11917                 NDR_PULL_ALLOC(ndr, r->out.type);
11918                 ZERO_STRUCTP(r->out.type);
11919                 NDR_PULL_ALLOC(ndr, r->out.needed);
11920                 ZERO_STRUCTP(r->out.needed);
11921         }
11922         if (flags & NDR_OUT) {
11923                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11924                         NDR_PULL_ALLOC(ndr, r->out.type);
11925                 }
11926                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
11927                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
11928                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
11929                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
11930                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
11931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11932                         NDR_PULL_ALLOC(ndr, r->out.needed);
11933                 }
11934                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
11935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
11936                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
11937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
11938                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11939         }
11940         return NDR_ERR_SUCCESS;
11941 }
11942
11943 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
11944 {
11945         if (flags & NDR_IN) {
11946                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11947         }
11948         if (flags & NDR_OUT) {
11949                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
11950                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11951         }
11952         return NDR_ERR_SUCCESS;
11953 }
11954
11955 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
11956 {
11957         if (flags & NDR_IN) {
11958                 ZERO_STRUCT(r->out);
11959
11960                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
11961         }
11962         if (flags & NDR_OUT) {
11963                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
11964                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11965         }
11966         return NDR_ERR_SUCCESS;
11967 }
11968
11969 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
11970 {
11971         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
11972         ndr->depth++;
11973         if (flags & NDR_SET_VALUES) {
11974                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11975         }
11976         if (flags & NDR_IN) {
11977                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
11978                 ndr->depth++;
11979                 ndr_print_ptr(ndr, "handle", r->in.handle);
11980                 ndr->depth++;
11981                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11982                 ndr->depth--;
11983                 ndr_print_string(ndr, "value_name", r->in.value_name);
11984                 ndr_print_uint32(ndr, "offered", r->in.offered);
11985                 ndr->depth--;
11986         }
11987         if (flags & NDR_OUT) {
11988                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
11989                 ndr->depth++;
11990                 ndr_print_ptr(ndr, "type", r->out.type);
11991                 ndr->depth++;
11992                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
11993                 ndr->depth--;
11994                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
11995                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
11996                 ndr_print_ptr(ndr, "needed", r->out.needed);
11997                 ndr->depth++;
11998                 ndr_print_uint32(ndr, "needed", *r->out.needed);
11999                 ndr->depth--;
12000                 ndr_print_WERROR(ndr, "result", r->out.result);
12001                 ndr->depth--;
12002         }
12003         ndr->depth--;
12004 }
12005
12006 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
12007 {
12008         if (flags & NDR_IN) {
12009                 if (r->in.handle == NULL) {
12010                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12011                 }
12012                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
12014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
12016                 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));
12017                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
12018                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
12019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
12020         }
12021         if (flags & NDR_OUT) {
12022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12023         }
12024         return NDR_ERR_SUCCESS;
12025 }
12026
12027 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
12028 {
12029         if (flags & NDR_IN) {
12030                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
12031         }
12032         if (flags & NDR_OUT) {
12033                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
12034                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
12035         }
12036         return NDR_ERR_SUCCESS;
12037 }
12038
12039 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
12040 {
12041         TALLOC_CTX *_mem_save_handle_0;
12042         if (flags & NDR_IN) {
12043                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12044                         NDR_PULL_ALLOC(ndr, r->in.handle);
12045                 }
12046                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12047                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12048                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12049                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12050                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
12051                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
12052                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
12053                         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));
12054                 }
12055                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
12056                 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));
12057                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
12058                 {
12059                         struct ndr_pull *_ndr_data;
12060                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
12061                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
12062                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
12063                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
12064                 }
12065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
12066         }
12067         if (flags & NDR_OUT) {
12068                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12069         }
12070         return NDR_ERR_SUCCESS;
12071 }
12072
12073 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
12074 {
12075         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
12076         ndr->depth++;
12077         if (flags & NDR_SET_VALUES) {
12078                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12079         }
12080         if (flags & NDR_IN) {
12081                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
12082                 ndr->depth++;
12083                 ndr_print_ptr(ndr, "handle", r->in.handle);
12084                 ndr->depth++;
12085                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12086                 ndr->depth--;
12087                 ndr_print_string(ndr, "value_name", r->in.value_name);
12088                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
12089                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
12090                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
12091                 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);
12092                 ndr->depth--;
12093         }
12094         if (flags & NDR_OUT) {
12095                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
12096                 ndr->depth++;
12097                 ndr_print_WERROR(ndr, "result", r->out.result);
12098                 ndr->depth--;
12099         }
12100         ndr->depth--;
12101 }
12102
12103 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
12104 {
12105         if (flags & NDR_IN) {
12106         }
12107         if (flags & NDR_OUT) {
12108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12109         }
12110         return NDR_ERR_SUCCESS;
12111 }
12112
12113 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
12114 {
12115         if (flags & NDR_IN) {
12116         }
12117         if (flags & NDR_OUT) {
12118                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12119         }
12120         return NDR_ERR_SUCCESS;
12121 }
12122
12123 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
12124 {
12125         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
12126         ndr->depth++;
12127         if (flags & NDR_SET_VALUES) {
12128                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12129         }
12130         if (flags & NDR_IN) {
12131                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
12132                 ndr->depth++;
12133                 ndr->depth--;
12134         }
12135         if (flags & NDR_OUT) {
12136                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
12137                 ndr->depth++;
12138                 ndr_print_WERROR(ndr, "result", r->out.result);
12139                 ndr->depth--;
12140         }
12141         ndr->depth--;
12142 }
12143
12144 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
12145 {
12146         if (flags & NDR_IN) {
12147                 if (r->in.handle == NULL) {
12148                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12149                 }
12150                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12151         }
12152         if (flags & NDR_OUT) {
12153                 if (r->out.handle == NULL) {
12154                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12155                 }
12156                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
12157                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12158         }
12159         return NDR_ERR_SUCCESS;
12160 }
12161
12162 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
12163 {
12164         TALLOC_CTX *_mem_save_handle_0;
12165         if (flags & NDR_IN) {
12166                 ZERO_STRUCT(r->out);
12167
12168                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12169                         NDR_PULL_ALLOC(ndr, r->in.handle);
12170                 }
12171                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12172                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12173                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12174                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12175                 NDR_PULL_ALLOC(ndr, r->out.handle);
12176                 *r->out.handle = *r->in.handle;
12177         }
12178         if (flags & NDR_OUT) {
12179                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12180                         NDR_PULL_ALLOC(ndr, r->out.handle);
12181                 }
12182                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12183                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
12184                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
12185                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12186                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12187         }
12188         return NDR_ERR_SUCCESS;
12189 }
12190
12191 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
12192 {
12193         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
12194         ndr->depth++;
12195         if (flags & NDR_SET_VALUES) {
12196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12197         }
12198         if (flags & NDR_IN) {
12199                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
12200                 ndr->depth++;
12201                 ndr_print_ptr(ndr, "handle", r->in.handle);
12202                 ndr->depth++;
12203                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12204                 ndr->depth--;
12205                 ndr->depth--;
12206         }
12207         if (flags & NDR_OUT) {
12208                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
12209                 ndr->depth++;
12210                 ndr_print_ptr(ndr, "handle", r->out.handle);
12211                 ndr->depth++;
12212                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
12213                 ndr->depth--;
12214                 ndr_print_WERROR(ndr, "result", r->out.result);
12215                 ndr->depth--;
12216         }
12217         ndr->depth--;
12218 }
12219
12220 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
12221 {
12222         if (flags & NDR_IN) {
12223                 if (r->in.handle == NULL) {
12224                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12225                 }
12226                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12227                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12228                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
12229                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12230         }
12231         if (flags & NDR_OUT) {
12232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12233         }
12234         return NDR_ERR_SUCCESS;
12235 }
12236
12237 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
12238 {
12239         TALLOC_CTX *_mem_save_handle_0;
12240         if (flags & NDR_IN) {
12241                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12242                         NDR_PULL_ALLOC(ndr, r->in.handle);
12243                 }
12244                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12245                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12246                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12247                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12249                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
12250                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12251         }
12252         if (flags & NDR_OUT) {
12253                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12254         }
12255         return NDR_ERR_SUCCESS;
12256 }
12257
12258 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
12259 {
12260         ndr_print_struct(ndr, name, "spoolss_AddForm");
12261         ndr->depth++;
12262         if (flags & NDR_SET_VALUES) {
12263                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12264         }
12265         if (flags & NDR_IN) {
12266                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
12267                 ndr->depth++;
12268                 ndr_print_ptr(ndr, "handle", r->in.handle);
12269                 ndr->depth++;
12270                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12271                 ndr->depth--;
12272                 ndr_print_uint32(ndr, "level", r->in.level);
12273                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
12274                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
12275                 ndr->depth--;
12276         }
12277         if (flags & NDR_OUT) {
12278                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
12279                 ndr->depth++;
12280                 ndr_print_WERROR(ndr, "result", r->out.result);
12281                 ndr->depth--;
12282         }
12283         ndr->depth--;
12284 }
12285
12286 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
12287 {
12288         if (flags & NDR_IN) {
12289                 if (r->in.handle == NULL) {
12290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12291                 }
12292                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12296                 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));
12297         }
12298         if (flags & NDR_OUT) {
12299                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12300         }
12301         return NDR_ERR_SUCCESS;
12302 }
12303
12304 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
12305 {
12306         TALLOC_CTX *_mem_save_handle_0;
12307         if (flags & NDR_IN) {
12308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12309                         NDR_PULL_ALLOC(ndr, r->in.handle);
12310                 }
12311                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12312                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12313                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12315                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12316                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12317                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12318                         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));
12319                 }
12320                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12321                 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));
12322         }
12323         if (flags & NDR_OUT) {
12324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12325         }
12326         return NDR_ERR_SUCCESS;
12327 }
12328
12329 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
12330 {
12331         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
12332         ndr->depth++;
12333         if (flags & NDR_SET_VALUES) {
12334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12335         }
12336         if (flags & NDR_IN) {
12337                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
12338                 ndr->depth++;
12339                 ndr_print_ptr(ndr, "handle", r->in.handle);
12340                 ndr->depth++;
12341                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12342                 ndr->depth--;
12343                 ndr_print_string(ndr, "form_name", r->in.form_name);
12344                 ndr->depth--;
12345         }
12346         if (flags & NDR_OUT) {
12347                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
12348                 ndr->depth++;
12349                 ndr_print_WERROR(ndr, "result", r->out.result);
12350                 ndr->depth--;
12351         }
12352         ndr->depth--;
12353 }
12354
12355 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
12356 {
12357         if (flags & NDR_IN) {
12358                 if (r->in.handle == NULL) {
12359                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12360                 }
12361                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12365                 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));
12366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12368                 if (r->in.buffer) {
12369                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12370                 }
12371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12372         }
12373         if (flags & NDR_OUT) {
12374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12375                 if (r->out.info) {
12376                         {
12377                                 struct ndr_push *_ndr_info;
12378                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12379                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
12380                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12381                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12382                         }
12383                 }
12384                 if (r->out.needed == NULL) {
12385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12386                 }
12387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12388                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12389         }
12390         return NDR_ERR_SUCCESS;
12391 }
12392
12393 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
12394 {
12395         uint32_t _ptr_buffer;
12396         uint32_t _ptr_info;
12397         TALLOC_CTX *_mem_save_handle_0;
12398         TALLOC_CTX *_mem_save_buffer_0;
12399         TALLOC_CTX *_mem_save_info_0;
12400         TALLOC_CTX *_mem_save_needed_0;
12401         if (flags & NDR_IN) {
12402                 ZERO_STRUCT(r->out);
12403
12404                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12405                         NDR_PULL_ALLOC(ndr, r->in.handle);
12406                 }
12407                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12408                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12409                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12410                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12411                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12412                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12413                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12414                         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));
12415                 }
12416                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12417                 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));
12418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12419                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12420                 if (_ptr_buffer) {
12421                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12422                 } else {
12423                         r->in.buffer = NULL;
12424                 }
12425                 if (r->in.buffer) {
12426                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12427                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12428                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12430                 }
12431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12432                 NDR_PULL_ALLOC(ndr, r->out.needed);
12433                 ZERO_STRUCTP(r->out.needed);
12434         }
12435         if (flags & NDR_OUT) {
12436                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12437                 if (_ptr_info) {
12438                         NDR_PULL_ALLOC(ndr, r->out.info);
12439                 } else {
12440                         r->out.info = NULL;
12441                 }
12442                 if (r->out.info) {
12443                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12444                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12445                         {
12446                                 struct ndr_pull *_ndr_info;
12447                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12448                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
12449                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12450                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12451                         }
12452                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12453                 }
12454                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12455                         NDR_PULL_ALLOC(ndr, r->out.needed);
12456                 }
12457                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12458                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12459                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12461                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12462         }
12463         return NDR_ERR_SUCCESS;
12464 }
12465
12466 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
12467 {
12468         ndr_print_struct(ndr, name, "spoolss_GetForm");
12469         ndr->depth++;
12470         if (flags & NDR_SET_VALUES) {
12471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12472         }
12473         if (flags & NDR_IN) {
12474                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
12475                 ndr->depth++;
12476                 ndr_print_ptr(ndr, "handle", r->in.handle);
12477                 ndr->depth++;
12478                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12479                 ndr->depth--;
12480                 ndr_print_string(ndr, "form_name", r->in.form_name);
12481                 ndr_print_uint32(ndr, "level", r->in.level);
12482                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12483                 ndr->depth++;
12484                 if (r->in.buffer) {
12485                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12486                 }
12487                 ndr->depth--;
12488                 ndr_print_uint32(ndr, "offered", r->in.offered);
12489                 ndr->depth--;
12490         }
12491         if (flags & NDR_OUT) {
12492                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
12493                 ndr->depth++;
12494                 ndr_print_ptr(ndr, "info", r->out.info);
12495                 ndr->depth++;
12496                 if (r->out.info) {
12497                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
12498                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
12499                 }
12500                 ndr->depth--;
12501                 ndr_print_ptr(ndr, "needed", r->out.needed);
12502                 ndr->depth++;
12503                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12504                 ndr->depth--;
12505                 ndr_print_WERROR(ndr, "result", r->out.result);
12506                 ndr->depth--;
12507         }
12508         ndr->depth--;
12509 }
12510
12511 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
12512 {
12513         if (flags & NDR_IN) {
12514                 if (r->in.handle == NULL) {
12515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12516                 }
12517                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12521                 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));
12522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12523                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
12524                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12525         }
12526         if (flags & NDR_OUT) {
12527                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12528         }
12529         return NDR_ERR_SUCCESS;
12530 }
12531
12532 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
12533 {
12534         TALLOC_CTX *_mem_save_handle_0;
12535         if (flags & NDR_IN) {
12536                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12537                         NDR_PULL_ALLOC(ndr, r->in.handle);
12538                 }
12539                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12540                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12541                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12542                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12543                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12544                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12545                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12546                         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));
12547                 }
12548                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12549                 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));
12550                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12551                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
12552                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12553         }
12554         if (flags & NDR_OUT) {
12555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12556         }
12557         return NDR_ERR_SUCCESS;
12558 }
12559
12560 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
12561 {
12562         ndr_print_struct(ndr, name, "spoolss_SetForm");
12563         ndr->depth++;
12564         if (flags & NDR_SET_VALUES) {
12565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12566         }
12567         if (flags & NDR_IN) {
12568                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
12569                 ndr->depth++;
12570                 ndr_print_ptr(ndr, "handle", r->in.handle);
12571                 ndr->depth++;
12572                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12573                 ndr->depth--;
12574                 ndr_print_string(ndr, "form_name", r->in.form_name);
12575                 ndr_print_uint32(ndr, "level", r->in.level);
12576                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
12577                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
12578                 ndr->depth--;
12579         }
12580         if (flags & NDR_OUT) {
12581                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
12582                 ndr->depth++;
12583                 ndr_print_WERROR(ndr, "result", r->out.result);
12584                 ndr->depth--;
12585         }
12586         ndr->depth--;
12587 }
12588
12589 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
12590 {
12591         if (flags & NDR_IN) {
12592                 if (r->in.handle == NULL) {
12593                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12594                 }
12595                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12597                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12598                 if (r->in.buffer) {
12599                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12600                 }
12601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12602         }
12603         if (flags & NDR_OUT) {
12604                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12605                 if (r->out.info) {
12606                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12607                 }
12608                 if (r->out.needed == NULL) {
12609                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12610                 }
12611                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12613                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12614         }
12615         return NDR_ERR_SUCCESS;
12616 }
12617
12618 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
12619 {
12620         uint32_t _ptr_buffer;
12621         uint32_t _ptr_info;
12622         TALLOC_CTX *_mem_save_handle_0;
12623         TALLOC_CTX *_mem_save_buffer_0;
12624         TALLOC_CTX *_mem_save_info_0;
12625         TALLOC_CTX *_mem_save_needed_0;
12626         if (flags & NDR_IN) {
12627                 ZERO_STRUCT(r->out);
12628
12629                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12630                         NDR_PULL_ALLOC(ndr, r->in.handle);
12631                 }
12632                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12633                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12634                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12635                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12637                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12638                 if (_ptr_buffer) {
12639                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12640                 } else {
12641                         r->in.buffer = NULL;
12642                 }
12643                 if (r->in.buffer) {
12644                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12645                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12646                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12648                 }
12649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12650                 NDR_PULL_ALLOC(ndr, r->out.needed);
12651                 ZERO_STRUCTP(r->out.needed);
12652         }
12653         if (flags & NDR_OUT) {
12654                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12655                 if (_ptr_info) {
12656                         NDR_PULL_ALLOC(ndr, r->out.info);
12657                 } else {
12658                         r->out.info = NULL;
12659                 }
12660                 if (r->out.info) {
12661                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12662                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12663                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12664                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12665                 }
12666                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12667                         NDR_PULL_ALLOC(ndr, r->out.needed);
12668                 }
12669                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12670                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12671                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12672                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12673                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12674                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12675         }
12676         return NDR_ERR_SUCCESS;
12677 }
12678
12679 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
12680 {
12681         uint32_t cntr_info_0;
12682         if (flags & NDR_IN) {
12683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12685         }
12686         if (flags & NDR_OUT) {
12687                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12688                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12689                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12690                 }
12691                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12692                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12693                 }
12694         }
12695         return NDR_ERR_SUCCESS;
12696 }
12697
12698 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
12699 {
12700         uint32_t cntr_info_0;
12701         TALLOC_CTX *_mem_save_info_0;
12702         if (flags & NDR_IN) {
12703                 ZERO_STRUCT(r->out);
12704
12705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12707         }
12708         if (flags & NDR_OUT) {
12709                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12710                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12711                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12712                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12713                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12714                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12715                 }
12716                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12717                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12718                 }
12719                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12720         }
12721         return NDR_ERR_SUCCESS;
12722 }
12723
12724 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
12725 {
12726         uint32_t cntr_info_1;
12727         ndr_print_struct(ndr, name, "spoolss_EnumForms");
12728         ndr->depth++;
12729         if (flags & NDR_SET_VALUES) {
12730                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12731         }
12732         if (flags & NDR_IN) {
12733                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
12734                 ndr->depth++;
12735                 ndr_print_ptr(ndr, "handle", r->in.handle);
12736                 ndr->depth++;
12737                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12738                 ndr->depth--;
12739                 ndr_print_uint32(ndr, "level", r->in.level);
12740                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12741                 ndr->depth++;
12742                 if (r->in.buffer) {
12743                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12744                 }
12745                 ndr->depth--;
12746                 ndr_print_uint32(ndr, "offered", r->in.offered);
12747                 ndr->depth--;
12748         }
12749         if (flags & NDR_OUT) {
12750                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
12751                 ndr->depth++;
12752                 ndr_print_ptr(ndr, "info", r->out.info);
12753                 ndr->depth++;
12754                 if (r->out.info) {
12755                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12756                         ndr->depth++;
12757                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12758                                 char *idx_1=NULL;
12759                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12760                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12761                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
12762                                         free(idx_1);
12763                                 }
12764                         }
12765                         ndr->depth--;
12766                 }
12767                 ndr->depth--;
12768                 ndr_print_ptr(ndr, "needed", r->out.needed);
12769                 ndr->depth++;
12770                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12771                 ndr->depth--;
12772                 ndr_print_uint32(ndr, "count", r->out.count);
12773                 ndr_print_WERROR(ndr, "result", r->out.result);
12774                 ndr->depth--;
12775         }
12776         ndr->depth--;
12777 }
12778
12779 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
12780 {
12781         if (flags & NDR_IN) {
12782                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
12783                 if (r->in.servername) {
12784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12785                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12786                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12787                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12788                 }
12789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12790                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12791                 if (r->in.buffer) {
12792                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12793                 }
12794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12795         }
12796         if (flags & NDR_OUT) {
12797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12798                 if (r->out.info) {
12799                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12800                 }
12801                 if (r->out.needed == NULL) {
12802                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12803                 }
12804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12807         }
12808         return NDR_ERR_SUCCESS;
12809 }
12810
12811 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
12812 {
12813         uint32_t _ptr_servername;
12814         uint32_t _ptr_buffer;
12815         uint32_t _ptr_info;
12816         TALLOC_CTX *_mem_save_servername_0;
12817         TALLOC_CTX *_mem_save_buffer_0;
12818         TALLOC_CTX *_mem_save_info_0;
12819         TALLOC_CTX *_mem_save_needed_0;
12820         if (flags & NDR_IN) {
12821                 ZERO_STRUCT(r->out);
12822
12823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
12824                 if (_ptr_servername) {
12825                         NDR_PULL_ALLOC(ndr, r->in.servername);
12826                 } else {
12827                         r->in.servername = NULL;
12828                 }
12829                 if (r->in.servername) {
12830                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
12831                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
12832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
12833                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
12834                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
12835                                 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));
12836                         }
12837                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
12838                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
12839                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
12840                 }
12841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12843                 if (_ptr_buffer) {
12844                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12845                 } else {
12846                         r->in.buffer = NULL;
12847                 }
12848                 if (r->in.buffer) {
12849                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12851                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12853                 }
12854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12855                 NDR_PULL_ALLOC(ndr, r->out.needed);
12856                 ZERO_STRUCTP(r->out.needed);
12857         }
12858         if (flags & NDR_OUT) {
12859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12860                 if (_ptr_info) {
12861                         NDR_PULL_ALLOC(ndr, r->out.info);
12862                 } else {
12863                         r->out.info = NULL;
12864                 }
12865                 if (r->out.info) {
12866                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12867                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12868                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12870                 }
12871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12872                         NDR_PULL_ALLOC(ndr, r->out.needed);
12873                 }
12874                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12875                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12879                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12880         }
12881         return NDR_ERR_SUCCESS;
12882 }
12883
12884 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
12885 {
12886         uint32_t cntr_info_0;
12887         if (flags & NDR_IN) {
12888                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12890         }
12891         if (flags & NDR_OUT) {
12892                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12893                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12894                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12895                 }
12896                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12897                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12898                 }
12899         }
12900         return NDR_ERR_SUCCESS;
12901 }
12902
12903 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
12904 {
12905         uint32_t cntr_info_0;
12906         TALLOC_CTX *_mem_save_info_0;
12907         if (flags & NDR_IN) {
12908                 ZERO_STRUCT(r->out);
12909
12910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12912         }
12913         if (flags & NDR_OUT) {
12914                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12915                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12916                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12917                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12918                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12919                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12920                 }
12921                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12922                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12923                 }
12924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12925         }
12926         return NDR_ERR_SUCCESS;
12927 }
12928
12929 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
12930 {
12931         uint32_t cntr_info_1;
12932         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
12933         ndr->depth++;
12934         if (flags & NDR_SET_VALUES) {
12935                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12936         }
12937         if (flags & NDR_IN) {
12938                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
12939                 ndr->depth++;
12940                 ndr_print_ptr(ndr, "servername", r->in.servername);
12941                 ndr->depth++;
12942                 if (r->in.servername) {
12943                         ndr_print_string(ndr, "servername", r->in.servername);
12944                 }
12945                 ndr->depth--;
12946                 ndr_print_uint32(ndr, "level", r->in.level);
12947                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12948                 ndr->depth++;
12949                 if (r->in.buffer) {
12950                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12951                 }
12952                 ndr->depth--;
12953                 ndr_print_uint32(ndr, "offered", r->in.offered);
12954                 ndr->depth--;
12955         }
12956         if (flags & NDR_OUT) {
12957                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
12958                 ndr->depth++;
12959                 ndr_print_ptr(ndr, "info", r->out.info);
12960                 ndr->depth++;
12961                 if (r->out.info) {
12962                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12963                         ndr->depth++;
12964                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12965                                 char *idx_1=NULL;
12966                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12967                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12968                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
12969                                         free(idx_1);
12970                                 }
12971                         }
12972                         ndr->depth--;
12973                 }
12974                 ndr->depth--;
12975                 ndr_print_ptr(ndr, "needed", r->out.needed);
12976                 ndr->depth++;
12977                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12978                 ndr->depth--;
12979                 ndr_print_uint32(ndr, "count", r->out.count);
12980                 ndr_print_WERROR(ndr, "result", r->out.result);
12981                 ndr->depth--;
12982         }
12983         ndr->depth--;
12984 }
12985
12986 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
12987 {
12988         if (flags & NDR_IN) {
12989                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
12990                 if (r->in.servername) {
12991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12994                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12995                 }
12996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12997                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12998                 if (r->in.buffer) {
12999                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13000                 }
13001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13002         }
13003         if (flags & NDR_OUT) {
13004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13005                 if (r->out.info) {
13006                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
13007                 }
13008                 if (r->out.needed == NULL) {
13009                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13010                 }
13011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
13013                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13014         }
13015         return NDR_ERR_SUCCESS;
13016 }
13017
13018 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
13019 {
13020         uint32_t _ptr_servername;
13021         uint32_t _ptr_buffer;
13022         uint32_t _ptr_info;
13023         TALLOC_CTX *_mem_save_servername_0;
13024         TALLOC_CTX *_mem_save_buffer_0;
13025         TALLOC_CTX *_mem_save_info_0;
13026         TALLOC_CTX *_mem_save_needed_0;
13027         if (flags & NDR_IN) {
13028                 ZERO_STRUCT(r->out);
13029
13030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
13031                 if (_ptr_servername) {
13032                         NDR_PULL_ALLOC(ndr, r->in.servername);
13033                 } else {
13034                         r->in.servername = NULL;
13035                 }
13036                 if (r->in.servername) {
13037                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
13038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
13039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
13040                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
13041                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
13042                                 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));
13043                         }
13044                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
13045                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
13046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
13047                 }
13048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13049                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13050                 if (_ptr_buffer) {
13051                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13052                 } else {
13053                         r->in.buffer = NULL;
13054                 }
13055                 if (r->in.buffer) {
13056                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13057                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13058                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13059                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13060                 }
13061                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13062                 NDR_PULL_ALLOC(ndr, r->out.needed);
13063                 ZERO_STRUCTP(r->out.needed);
13064         }
13065         if (flags & NDR_OUT) {
13066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13067                 if (_ptr_info) {
13068                         NDR_PULL_ALLOC(ndr, r->out.info);
13069                 } else {
13070                         r->out.info = NULL;
13071                 }
13072                 if (r->out.info) {
13073                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13074                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13075                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
13076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13077                 }
13078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13079                         NDR_PULL_ALLOC(ndr, r->out.needed);
13080                 }
13081                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
13082                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
13083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
13084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
13085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
13086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13087         }
13088         return NDR_ERR_SUCCESS;
13089 }
13090
13091 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
13092 {
13093         uint32_t cntr_info_0;
13094         if (flags & NDR_IN) {
13095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
13097         }
13098         if (flags & NDR_OUT) {
13099                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13100                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13101                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13102                 }
13103                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13104                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13105                 }
13106         }
13107         return NDR_ERR_SUCCESS;
13108 }
13109
13110 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
13111 {
13112         uint32_t cntr_info_0;
13113         TALLOC_CTX *_mem_save_info_0;
13114         if (flags & NDR_IN) {
13115                 ZERO_STRUCT(r->out);
13116
13117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
13119         }
13120         if (flags & NDR_OUT) {
13121                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
13122                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13123                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13124                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13125                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13126                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13127                 }
13128                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13129                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13130                 }
13131                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13132         }
13133         return NDR_ERR_SUCCESS;
13134 }
13135
13136 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
13137 {
13138         uint32_t cntr_info_1;
13139         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
13140         ndr->depth++;
13141         if (flags & NDR_SET_VALUES) {
13142                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13143         }
13144         if (flags & NDR_IN) {
13145                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
13146                 ndr->depth++;
13147                 ndr_print_ptr(ndr, "servername", r->in.servername);
13148                 ndr->depth++;
13149                 if (r->in.servername) {
13150                         ndr_print_string(ndr, "servername", r->in.servername);
13151                 }
13152                 ndr->depth--;
13153                 ndr_print_uint32(ndr, "level", r->in.level);
13154                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13155                 ndr->depth++;
13156                 if (r->in.buffer) {
13157                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13158                 }
13159                 ndr->depth--;
13160                 ndr_print_uint32(ndr, "offered", r->in.offered);
13161                 ndr->depth--;
13162         }
13163         if (flags & NDR_OUT) {
13164                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
13165                 ndr->depth++;
13166                 ndr_print_ptr(ndr, "info", r->out.info);
13167                 ndr->depth++;
13168                 if (r->out.info) {
13169                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
13170                         ndr->depth++;
13171                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
13172                                 char *idx_1=NULL;
13173                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13174                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
13175                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
13176                                         free(idx_1);
13177                                 }
13178                         }
13179                         ndr->depth--;
13180                 }
13181                 ndr->depth--;
13182                 ndr_print_ptr(ndr, "needed", r->out.needed);
13183                 ndr->depth++;
13184                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13185                 ndr->depth--;
13186                 ndr_print_uint32(ndr, "count", r->out.count);
13187                 ndr_print_WERROR(ndr, "result", r->out.result);
13188                 ndr->depth--;
13189         }
13190         ndr->depth--;
13191 }
13192
13193 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
13194 {
13195         if (flags & NDR_IN) {
13196                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
13197                 if (r->in.server_name) {
13198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
13199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
13201                         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));
13202                 }
13203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
13204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
13205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13206                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
13207                 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));
13208         }
13209         if (flags & NDR_OUT) {
13210                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13211         }
13212         return NDR_ERR_SUCCESS;
13213 }
13214
13215 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
13216 {
13217         uint32_t _ptr_server_name;
13218         TALLOC_CTX *_mem_save_server_name_0;
13219         if (flags & NDR_IN) {
13220                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
13221                 if (_ptr_server_name) {
13222                         NDR_PULL_ALLOC(ndr, r->in.server_name);
13223                 } else {
13224                         r->in.server_name = NULL;
13225                 }
13226                 if (r->in.server_name) {
13227                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13228                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
13229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
13230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
13231                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
13232                                 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));
13233                         }
13234                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
13235                         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));
13236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
13237                 }
13238                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
13239                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
13240                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
13241                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
13242                         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));
13243                 }
13244                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
13245                 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));
13246         }
13247         if (flags & NDR_OUT) {
13248                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13249         }
13250         return NDR_ERR_SUCCESS;
13251 }
13252
13253 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
13254 {
13255         ndr_print_struct(ndr, name, "spoolss_AddPort");
13256         ndr->depth++;
13257         if (flags & NDR_SET_VALUES) {
13258                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13259         }
13260         if (flags & NDR_IN) {
13261                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
13262                 ndr->depth++;
13263                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
13264                 ndr->depth++;
13265                 if (r->in.server_name) {
13266                         ndr_print_string(ndr, "server_name", r->in.server_name);
13267                 }
13268                 ndr->depth--;
13269                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
13270                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
13271                 ndr->depth--;
13272         }
13273         if (flags & NDR_OUT) {
13274                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
13275                 ndr->depth++;
13276                 ndr_print_WERROR(ndr, "result", r->out.result);
13277                 ndr->depth--;
13278         }
13279         ndr->depth--;
13280 }
13281
13282 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
13283 {
13284         if (flags & NDR_IN) {
13285         }
13286         if (flags & NDR_OUT) {
13287                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13288         }
13289         return NDR_ERR_SUCCESS;
13290 }
13291
13292 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
13293 {
13294         if (flags & NDR_IN) {
13295         }
13296         if (flags & NDR_OUT) {
13297                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13298         }
13299         return NDR_ERR_SUCCESS;
13300 }
13301
13302 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
13303 {
13304         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
13305         ndr->depth++;
13306         if (flags & NDR_SET_VALUES) {
13307                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13308         }
13309         if (flags & NDR_IN) {
13310                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
13311                 ndr->depth++;
13312                 ndr->depth--;
13313         }
13314         if (flags & NDR_OUT) {
13315                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
13316                 ndr->depth++;
13317                 ndr_print_WERROR(ndr, "result", r->out.result);
13318                 ndr->depth--;
13319         }
13320         ndr->depth--;
13321 }
13322
13323 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
13324 {
13325         if (flags & NDR_IN) {
13326         }
13327         if (flags & NDR_OUT) {
13328                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13329         }
13330         return NDR_ERR_SUCCESS;
13331 }
13332
13333 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
13334 {
13335         if (flags & NDR_IN) {
13336         }
13337         if (flags & NDR_OUT) {
13338                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13339         }
13340         return NDR_ERR_SUCCESS;
13341 }
13342
13343 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
13344 {
13345         ndr_print_struct(ndr, name, "spoolss_DeletePort");
13346         ndr->depth++;
13347         if (flags & NDR_SET_VALUES) {
13348                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13349         }
13350         if (flags & NDR_IN) {
13351                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
13352                 ndr->depth++;
13353                 ndr->depth--;
13354         }
13355         if (flags & NDR_OUT) {
13356                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
13357                 ndr->depth++;
13358                 ndr_print_WERROR(ndr, "result", r->out.result);
13359                 ndr->depth--;
13360         }
13361         ndr->depth--;
13362 }
13363
13364 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
13365 {
13366         if (flags & NDR_IN) {
13367         }
13368         if (flags & NDR_OUT) {
13369                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13370         }
13371         return NDR_ERR_SUCCESS;
13372 }
13373
13374 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
13375 {
13376         if (flags & NDR_IN) {
13377         }
13378         if (flags & NDR_OUT) {
13379                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13380         }
13381         return NDR_ERR_SUCCESS;
13382 }
13383
13384 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
13385 {
13386         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
13387         ndr->depth++;
13388         if (flags & NDR_SET_VALUES) {
13389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13390         }
13391         if (flags & NDR_IN) {
13392                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
13393                 ndr->depth++;
13394                 ndr->depth--;
13395         }
13396         if (flags & NDR_OUT) {
13397                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
13398                 ndr->depth++;
13399                 ndr_print_WERROR(ndr, "result", r->out.result);
13400                 ndr->depth--;
13401         }
13402         ndr->depth--;
13403 }
13404
13405 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
13406 {
13407         if (flags & NDR_IN) {
13408         }
13409         if (flags & NDR_OUT) {
13410                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13411         }
13412         return NDR_ERR_SUCCESS;
13413 }
13414
13415 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
13416 {
13417         if (flags & NDR_IN) {
13418         }
13419         if (flags & NDR_OUT) {
13420                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13421         }
13422         return NDR_ERR_SUCCESS;
13423 }
13424
13425 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
13426 {
13427         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
13428         ndr->depth++;
13429         if (flags & NDR_SET_VALUES) {
13430                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13431         }
13432         if (flags & NDR_IN) {
13433                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
13434                 ndr->depth++;
13435                 ndr->depth--;
13436         }
13437         if (flags & NDR_OUT) {
13438                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
13439                 ndr->depth++;
13440                 ndr_print_WERROR(ndr, "result", r->out.result);
13441                 ndr->depth--;
13442         }
13443         ndr->depth--;
13444 }
13445
13446 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
13447 {
13448         if (flags & NDR_IN) {
13449         }
13450         if (flags & NDR_OUT) {
13451                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13452         }
13453         return NDR_ERR_SUCCESS;
13454 }
13455
13456 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
13457 {
13458         if (flags & NDR_IN) {
13459         }
13460         if (flags & NDR_OUT) {
13461                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13462         }
13463         return NDR_ERR_SUCCESS;
13464 }
13465
13466 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
13467 {
13468         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
13469         ndr->depth++;
13470         if (flags & NDR_SET_VALUES) {
13471                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13472         }
13473         if (flags & NDR_IN) {
13474                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
13475                 ndr->depth++;
13476                 ndr->depth--;
13477         }
13478         if (flags & NDR_OUT) {
13479                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
13480                 ndr->depth++;
13481                 ndr_print_WERROR(ndr, "result", r->out.result);
13482                 ndr->depth--;
13483         }
13484         ndr->depth--;
13485 }
13486
13487 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
13488 {
13489         if (flags & NDR_IN) {
13490         }
13491         if (flags & NDR_OUT) {
13492                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13493         }
13494         return NDR_ERR_SUCCESS;
13495 }
13496
13497 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
13498 {
13499         if (flags & NDR_IN) {
13500         }
13501         if (flags & NDR_OUT) {
13502                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13503         }
13504         return NDR_ERR_SUCCESS;
13505 }
13506
13507 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
13508 {
13509         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
13510         ndr->depth++;
13511         if (flags & NDR_SET_VALUES) {
13512                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13513         }
13514         if (flags & NDR_IN) {
13515                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
13516                 ndr->depth++;
13517                 ndr->depth--;
13518         }
13519         if (flags & NDR_OUT) {
13520                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
13521                 ndr->depth++;
13522                 ndr_print_WERROR(ndr, "result", r->out.result);
13523                 ndr->depth--;
13524         }
13525         ndr->depth--;
13526 }
13527
13528 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
13529 {
13530         if (flags & NDR_IN) {
13531         }
13532         if (flags & NDR_OUT) {
13533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13534         }
13535         return NDR_ERR_SUCCESS;
13536 }
13537
13538 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
13539 {
13540         if (flags & NDR_IN) {
13541         }
13542         if (flags & NDR_OUT) {
13543                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13544         }
13545         return NDR_ERR_SUCCESS;
13546 }
13547
13548 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
13549 {
13550         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
13551         ndr->depth++;
13552         if (flags & NDR_SET_VALUES) {
13553                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13554         }
13555         if (flags & NDR_IN) {
13556                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
13557                 ndr->depth++;
13558                 ndr->depth--;
13559         }
13560         if (flags & NDR_OUT) {
13561                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
13562                 ndr->depth++;
13563                 ndr_print_WERROR(ndr, "result", r->out.result);
13564                 ndr->depth--;
13565         }
13566         ndr->depth--;
13567 }
13568
13569 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
13570 {
13571         if (flags & NDR_IN) {
13572         }
13573         if (flags & NDR_OUT) {
13574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13575         }
13576         return NDR_ERR_SUCCESS;
13577 }
13578
13579 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
13580 {
13581         if (flags & NDR_IN) {
13582         }
13583         if (flags & NDR_OUT) {
13584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13585         }
13586         return NDR_ERR_SUCCESS;
13587 }
13588
13589 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
13590 {
13591         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
13592         ndr->depth++;
13593         if (flags & NDR_SET_VALUES) {
13594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13595         }
13596         if (flags & NDR_IN) {
13597                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
13598                 ndr->depth++;
13599                 ndr->depth--;
13600         }
13601         if (flags & NDR_OUT) {
13602                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
13603                 ndr->depth++;
13604                 ndr_print_WERROR(ndr, "result", r->out.result);
13605                 ndr->depth--;
13606         }
13607         ndr->depth--;
13608 }
13609
13610 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
13611 {
13612         if (flags & NDR_IN) {
13613         }
13614         if (flags & NDR_OUT) {
13615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13616         }
13617         return NDR_ERR_SUCCESS;
13618 }
13619
13620 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
13621 {
13622         if (flags & NDR_IN) {
13623         }
13624         if (flags & NDR_OUT) {
13625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13626         }
13627         return NDR_ERR_SUCCESS;
13628 }
13629
13630 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
13631 {
13632         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
13633         ndr->depth++;
13634         if (flags & NDR_SET_VALUES) {
13635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13636         }
13637         if (flags & NDR_IN) {
13638                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
13639                 ndr->depth++;
13640                 ndr->depth--;
13641         }
13642         if (flags & NDR_OUT) {
13643                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
13644                 ndr->depth++;
13645                 ndr_print_WERROR(ndr, "result", r->out.result);
13646                 ndr->depth--;
13647         }
13648         ndr->depth--;
13649 }
13650
13651 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
13652 {
13653         if (flags & NDR_IN) {
13654         }
13655         if (flags & NDR_OUT) {
13656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13657         }
13658         return NDR_ERR_SUCCESS;
13659 }
13660
13661 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
13662 {
13663         if (flags & NDR_IN) {
13664         }
13665         if (flags & NDR_OUT) {
13666                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13667         }
13668         return NDR_ERR_SUCCESS;
13669 }
13670
13671 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
13672 {
13673         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
13674         ndr->depth++;
13675         if (flags & NDR_SET_VALUES) {
13676                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13677         }
13678         if (flags & NDR_IN) {
13679                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
13680                 ndr->depth++;
13681                 ndr->depth--;
13682         }
13683         if (flags & NDR_OUT) {
13684                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
13685                 ndr->depth++;
13686                 ndr_print_WERROR(ndr, "result", r->out.result);
13687                 ndr->depth--;
13688         }
13689         ndr->depth--;
13690 }
13691
13692 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
13693 {
13694         if (flags & NDR_IN) {
13695         }
13696         if (flags & NDR_OUT) {
13697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13698         }
13699         return NDR_ERR_SUCCESS;
13700 }
13701
13702 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
13703 {
13704         if (flags & NDR_IN) {
13705         }
13706         if (flags & NDR_OUT) {
13707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13708         }
13709         return NDR_ERR_SUCCESS;
13710 }
13711
13712 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
13713 {
13714         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
13715         ndr->depth++;
13716         if (flags & NDR_SET_VALUES) {
13717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13718         }
13719         if (flags & NDR_IN) {
13720                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
13721                 ndr->depth++;
13722                 ndr->depth--;
13723         }
13724         if (flags & NDR_OUT) {
13725                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
13726                 ndr->depth++;
13727                 ndr_print_WERROR(ndr, "result", r->out.result);
13728                 ndr->depth--;
13729         }
13730         ndr->depth--;
13731 }
13732
13733 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
13734 {
13735         if (flags & NDR_IN) {
13736         }
13737         if (flags & NDR_OUT) {
13738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13739         }
13740         return NDR_ERR_SUCCESS;
13741 }
13742
13743 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
13744 {
13745         if (flags & NDR_IN) {
13746         }
13747         if (flags & NDR_OUT) {
13748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13749         }
13750         return NDR_ERR_SUCCESS;
13751 }
13752
13753 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
13754 {
13755         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
13756         ndr->depth++;
13757         if (flags & NDR_SET_VALUES) {
13758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13759         }
13760         if (flags & NDR_IN) {
13761                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
13762                 ndr->depth++;
13763                 ndr->depth--;
13764         }
13765         if (flags & NDR_OUT) {
13766                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
13767                 ndr->depth++;
13768                 ndr_print_WERROR(ndr, "result", r->out.result);
13769                 ndr->depth--;
13770         }
13771         ndr->depth--;
13772 }
13773
13774 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
13775 {
13776         if (flags & NDR_IN) {
13777         }
13778         if (flags & NDR_OUT) {
13779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13780         }
13781         return NDR_ERR_SUCCESS;
13782 }
13783
13784 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
13785 {
13786         if (flags & NDR_IN) {
13787         }
13788         if (flags & NDR_OUT) {
13789                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13790         }
13791         return NDR_ERR_SUCCESS;
13792 }
13793
13794 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
13795 {
13796         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
13797         ndr->depth++;
13798         if (flags & NDR_SET_VALUES) {
13799                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13800         }
13801         if (flags & NDR_IN) {
13802                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
13803                 ndr->depth++;
13804                 ndr->depth--;
13805         }
13806         if (flags & NDR_OUT) {
13807                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
13808                 ndr->depth++;
13809                 ndr_print_WERROR(ndr, "result", r->out.result);
13810                 ndr->depth--;
13811         }
13812         ndr->depth--;
13813 }
13814
13815 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
13816 {
13817         if (flags & NDR_IN) {
13818         }
13819         if (flags & NDR_OUT) {
13820                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13821         }
13822         return NDR_ERR_SUCCESS;
13823 }
13824
13825 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
13826 {
13827         if (flags & NDR_IN) {
13828         }
13829         if (flags & NDR_OUT) {
13830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13831         }
13832         return NDR_ERR_SUCCESS;
13833 }
13834
13835 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
13836 {
13837         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
13838         ndr->depth++;
13839         if (flags & NDR_SET_VALUES) {
13840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13841         }
13842         if (flags & NDR_IN) {
13843                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
13844                 ndr->depth++;
13845                 ndr->depth--;
13846         }
13847         if (flags & NDR_OUT) {
13848                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
13849                 ndr->depth++;
13850                 ndr_print_WERROR(ndr, "result", r->out.result);
13851                 ndr->depth--;
13852         }
13853         ndr->depth--;
13854 }
13855
13856 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
13857 {
13858         if (flags & NDR_IN) {
13859         }
13860         if (flags & NDR_OUT) {
13861                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13862         }
13863         return NDR_ERR_SUCCESS;
13864 }
13865
13866 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
13867 {
13868         if (flags & NDR_IN) {
13869         }
13870         if (flags & NDR_OUT) {
13871                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13872         }
13873         return NDR_ERR_SUCCESS;
13874 }
13875
13876 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
13877 {
13878         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
13879         ndr->depth++;
13880         if (flags & NDR_SET_VALUES) {
13881                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13882         }
13883         if (flags & NDR_IN) {
13884                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
13885                 ndr->depth++;
13886                 ndr->depth--;
13887         }
13888         if (flags & NDR_OUT) {
13889                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
13890                 ndr->depth++;
13891                 ndr_print_WERROR(ndr, "result", r->out.result);
13892                 ndr->depth--;
13893         }
13894         ndr->depth--;
13895 }
13896
13897 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
13898 {
13899         if (flags & NDR_IN) {
13900                 if (r->in.handle == NULL) {
13901                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13902                 }
13903                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
13905                 if (r->in.architecture) {
13906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
13907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
13909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13910                 }
13911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13913                 if (r->in.buffer) {
13914                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13915                 }
13916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
13918                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
13919         }
13920         if (flags & NDR_OUT) {
13921                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13922                 if (r->out.info) {
13923                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
13924                 }
13925                 if (r->out.needed == NULL) {
13926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13927                 }
13928                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13929                 if (r->out.server_major_version == NULL) {
13930                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13931                 }
13932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
13933                 if (r->out.server_minor_version == NULL) {
13934                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13935                 }
13936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
13937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13938         }
13939         return NDR_ERR_SUCCESS;
13940 }
13941
13942 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
13943 {
13944         uint32_t _ptr_architecture;
13945         uint32_t _ptr_buffer;
13946         uint32_t _ptr_info;
13947         TALLOC_CTX *_mem_save_handle_0;
13948         TALLOC_CTX *_mem_save_architecture_0;
13949         TALLOC_CTX *_mem_save_buffer_0;
13950         TALLOC_CTX *_mem_save_info_0;
13951         TALLOC_CTX *_mem_save_needed_0;
13952         TALLOC_CTX *_mem_save_server_major_version_0;
13953         TALLOC_CTX *_mem_save_server_minor_version_0;
13954         if (flags & NDR_IN) {
13955                 ZERO_STRUCT(r->out);
13956
13957                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13958                         NDR_PULL_ALLOC(ndr, r->in.handle);
13959                 }
13960                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13961                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13962                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13963                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13964                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13965                 if (_ptr_architecture) {
13966                         NDR_PULL_ALLOC(ndr, r->in.architecture);
13967                 } else {
13968                         r->in.architecture = NULL;
13969                 }
13970                 if (r->in.architecture) {
13971                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13972                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
13973                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
13974                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
13975                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
13976                                 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));
13977                         }
13978                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
13979                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
13980                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13981                 }
13982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13983                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13984                 if (_ptr_buffer) {
13985                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13986                 } else {
13987                         r->in.buffer = NULL;
13988                 }
13989                 if (r->in.buffer) {
13990                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13991                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13992                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13993                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13994                 }
13995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
13997                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
13998                 NDR_PULL_ALLOC(ndr, r->out.needed);
13999                 ZERO_STRUCTP(r->out.needed);
14000                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
14001                 ZERO_STRUCTP(r->out.server_major_version);
14002                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
14003                 ZERO_STRUCTP(r->out.server_minor_version);
14004         }
14005         if (flags & NDR_OUT) {
14006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14007                 if (_ptr_info) {
14008                         NDR_PULL_ALLOC(ndr, r->out.info);
14009                 } else {
14010                         r->out.info = NULL;
14011                 }
14012                 if (r->out.info) {
14013                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14014                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
14015                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
14016                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14017                 }
14018                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14019                         NDR_PULL_ALLOC(ndr, r->out.needed);
14020                 }
14021                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14022                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
14023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
14024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
14025                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14026                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
14027                 }
14028                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
14029                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
14030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
14031                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
14032                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14033                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
14034                 }
14035                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
14036                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
14037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
14038                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
14039                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14040         }
14041         return NDR_ERR_SUCCESS;
14042 }
14043
14044 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
14045 {
14046         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
14047         ndr->depth++;
14048         if (flags & NDR_SET_VALUES) {
14049                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14050         }
14051         if (flags & NDR_IN) {
14052                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
14053                 ndr->depth++;
14054                 ndr_print_ptr(ndr, "handle", r->in.handle);
14055                 ndr->depth++;
14056                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14057                 ndr->depth--;
14058                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
14059                 ndr->depth++;
14060                 if (r->in.architecture) {
14061                         ndr_print_string(ndr, "architecture", r->in.architecture);
14062                 }
14063                 ndr->depth--;
14064                 ndr_print_uint32(ndr, "level", r->in.level);
14065                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14066                 ndr->depth++;
14067                 if (r->in.buffer) {
14068                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
14069                 }
14070                 ndr->depth--;
14071                 ndr_print_uint32(ndr, "offered", r->in.offered);
14072                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
14073                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
14074                 ndr->depth--;
14075         }
14076         if (flags & NDR_OUT) {
14077                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
14078                 ndr->depth++;
14079                 ndr_print_ptr(ndr, "info", r->out.info);
14080                 ndr->depth++;
14081                 if (r->out.info) {
14082                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
14083                 }
14084                 ndr->depth--;
14085                 ndr_print_ptr(ndr, "needed", r->out.needed);
14086                 ndr->depth++;
14087                 ndr_print_uint32(ndr, "needed", *r->out.needed);
14088                 ndr->depth--;
14089                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
14090                 ndr->depth++;
14091                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
14092                 ndr->depth--;
14093                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
14094                 ndr->depth++;
14095                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
14096                 ndr->depth--;
14097                 ndr_print_WERROR(ndr, "result", r->out.result);
14098                 ndr->depth--;
14099         }
14100         ndr->depth--;
14101 }
14102
14103 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
14104 {
14105         if (flags & NDR_IN) {
14106         }
14107         if (flags & NDR_OUT) {
14108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14109         }
14110         return NDR_ERR_SUCCESS;
14111 }
14112
14113 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
14114 {
14115         if (flags & NDR_IN) {
14116         }
14117         if (flags & NDR_OUT) {
14118                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14119         }
14120         return NDR_ERR_SUCCESS;
14121 }
14122
14123 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
14124 {
14125         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
14126         ndr->depth++;
14127         if (flags & NDR_SET_VALUES) {
14128                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14129         }
14130         if (flags & NDR_IN) {
14131                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
14132                 ndr->depth++;
14133                 ndr->depth--;
14134         }
14135         if (flags & NDR_OUT) {
14136                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
14137                 ndr->depth++;
14138                 ndr_print_WERROR(ndr, "result", r->out.result);
14139                 ndr->depth--;
14140         }
14141         ndr->depth--;
14142 }
14143
14144 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
14145 {
14146         if (flags & NDR_IN) {
14147         }
14148         if (flags & NDR_OUT) {
14149                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14150         }
14151         return NDR_ERR_SUCCESS;
14152 }
14153
14154 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
14155 {
14156         if (flags & NDR_IN) {
14157         }
14158         if (flags & NDR_OUT) {
14159                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14160         }
14161         return NDR_ERR_SUCCESS;
14162 }
14163
14164 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
14165 {
14166         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
14167         ndr->depth++;
14168         if (flags & NDR_SET_VALUES) {
14169                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14170         }
14171         if (flags & NDR_IN) {
14172                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
14173                 ndr->depth++;
14174                 ndr->depth--;
14175         }
14176         if (flags & NDR_OUT) {
14177                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
14178                 ndr->depth++;
14179                 ndr_print_WERROR(ndr, "result", r->out.result);
14180                 ndr->depth--;
14181         }
14182         ndr->depth--;
14183 }
14184
14185 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
14186 {
14187         if (flags & NDR_IN) {
14188                 if (r->in.handle == NULL) {
14189                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14190                 }
14191                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14192         }
14193         if (flags & NDR_OUT) {
14194                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14195         }
14196         return NDR_ERR_SUCCESS;
14197 }
14198
14199 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
14200 {
14201         TALLOC_CTX *_mem_save_handle_0;
14202         if (flags & NDR_IN) {
14203                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14204                         NDR_PULL_ALLOC(ndr, r->in.handle);
14205                 }
14206                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14207                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14208                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14209                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14210         }
14211         if (flags & NDR_OUT) {
14212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14213         }
14214         return NDR_ERR_SUCCESS;
14215 }
14216
14217 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
14218 {
14219         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
14220         ndr->depth++;
14221         if (flags & NDR_SET_VALUES) {
14222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14223         }
14224         if (flags & NDR_IN) {
14225                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
14226                 ndr->depth++;
14227                 ndr_print_ptr(ndr, "handle", r->in.handle);
14228                 ndr->depth++;
14229                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14230                 ndr->depth--;
14231                 ndr->depth--;
14232         }
14233         if (flags & NDR_OUT) {
14234                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
14235                 ndr->depth++;
14236                 ndr_print_WERROR(ndr, "result", r->out.result);
14237                 ndr->depth--;
14238         }
14239         ndr->depth--;
14240 }
14241
14242 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
14243 {
14244         if (flags & NDR_IN) {
14245         }
14246         if (flags & NDR_OUT) {
14247                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14248         }
14249         return NDR_ERR_SUCCESS;
14250 }
14251
14252 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
14253 {
14254         if (flags & NDR_IN) {
14255         }
14256         if (flags & NDR_OUT) {
14257                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14258         }
14259         return NDR_ERR_SUCCESS;
14260 }
14261
14262 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
14263 {
14264         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
14265         ndr->depth++;
14266         if (flags & NDR_SET_VALUES) {
14267                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14268         }
14269         if (flags & NDR_IN) {
14270                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
14271                 ndr->depth++;
14272                 ndr->depth--;
14273         }
14274         if (flags & NDR_OUT) {
14275                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
14276                 ndr->depth++;
14277                 ndr_print_WERROR(ndr, "result", r->out.result);
14278                 ndr->depth--;
14279         }
14280         ndr->depth--;
14281 }
14282
14283 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
14284 {
14285         if (flags & NDR_IN) {
14286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
14287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
14289                 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));
14290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
14291                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
14292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
14293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
14294         }
14295         if (flags & NDR_OUT) {
14296                 if (r->out.handle == NULL) {
14297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14298                 }
14299                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14300                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14301         }
14302         return NDR_ERR_SUCCESS;
14303 }
14304
14305 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
14306 {
14307         TALLOC_CTX *_mem_save_handle_0;
14308         if (flags & NDR_IN) {
14309                 ZERO_STRUCT(r->out);
14310
14311                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
14312                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
14313                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
14314                         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));
14315                 }
14316                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
14317                 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));
14318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
14319                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
14320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
14321                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
14322                 NDR_PULL_ALLOC(ndr, r->out.handle);
14323                 ZERO_STRUCTP(r->out.handle);
14324         }
14325         if (flags & NDR_OUT) {
14326                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14327                         NDR_PULL_ALLOC(ndr, r->out.handle);
14328                 }
14329                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14330                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14331                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14332                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14333                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14334         }
14335         return NDR_ERR_SUCCESS;
14336 }
14337
14338 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
14339 {
14340         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
14341         ndr->depth++;
14342         if (flags & NDR_SET_VALUES) {
14343                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14344         }
14345         if (flags & NDR_IN) {
14346                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
14347                 ndr->depth++;
14348                 ndr_print_string(ndr, "server_name", r->in.server_name);
14349                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
14350                 ndr_print_winreg_Type(ndr, "type", r->in.type);
14351                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
14352                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
14353                 ndr->depth--;
14354         }
14355         if (flags & NDR_OUT) {
14356                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
14357                 ndr->depth++;
14358                 ndr_print_ptr(ndr, "handle", r->out.handle);
14359                 ndr->depth++;
14360                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14361                 ndr->depth--;
14362                 ndr_print_WERROR(ndr, "result", r->out.result);
14363                 ndr->depth--;
14364         }
14365         ndr->depth--;
14366 }
14367
14368 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
14369 {
14370         if (flags & NDR_IN) {
14371                 if (r->in.handle == NULL) {
14372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14373                 }
14374                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14375                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
14376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
14377                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14378                 if (r->in.buffer) {
14379                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
14380                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
14381                 }
14382         }
14383         if (flags & NDR_OUT) {
14384                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14385         }
14386         return NDR_ERR_SUCCESS;
14387 }
14388
14389 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
14390 {
14391         uint32_t _ptr_buffer;
14392         TALLOC_CTX *_mem_save_handle_0;
14393         TALLOC_CTX *_mem_save_buffer_0;
14394         if (flags & NDR_IN) {
14395                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14396                         NDR_PULL_ALLOC(ndr, r->in.handle);
14397                 }
14398                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14399                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14400                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14402                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
14403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
14404                 if (r->in.bufsize > 512) {
14405                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
14406                 }
14407                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14408                 if (_ptr_buffer) {
14409                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14410                 } else {
14411                         r->in.buffer = NULL;
14412                 }
14413                 if (r->in.buffer) {
14414                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14415                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14416                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
14417                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
14418                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
14419                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14420                 }
14421                 if (r->in.buffer) {
14422                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
14423                 }
14424         }
14425         if (flags & NDR_OUT) {
14426                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14427         }
14428         return NDR_ERR_SUCCESS;
14429 }
14430
14431 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
14432 {
14433         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
14434         ndr->depth++;
14435         if (flags & NDR_SET_VALUES) {
14436                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14437         }
14438         if (flags & NDR_IN) {
14439                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
14440                 ndr->depth++;
14441                 ndr_print_ptr(ndr, "handle", r->in.handle);
14442                 ndr->depth++;
14443                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14444                 ndr->depth--;
14445                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
14446                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
14447                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14448                 ndr->depth++;
14449                 if (r->in.buffer) {
14450                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
14451                 }
14452                 ndr->depth--;
14453                 ndr->depth--;
14454         }
14455         if (flags & NDR_OUT) {
14456                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
14457                 ndr->depth++;
14458                 ndr_print_WERROR(ndr, "result", r->out.result);
14459                 ndr->depth--;
14460         }
14461         ndr->depth--;
14462 }
14463
14464 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
14465 {
14466         if (flags & NDR_IN) {
14467                 if (r->in.handle == NULL) {
14468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14469                 }
14470                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14471         }
14472         if (flags & NDR_OUT) {
14473                 if (r->out.handle == NULL) {
14474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14475                 }
14476                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14477                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14478         }
14479         return NDR_ERR_SUCCESS;
14480 }
14481
14482 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
14483 {
14484         TALLOC_CTX *_mem_save_handle_0;
14485         if (flags & NDR_IN) {
14486                 ZERO_STRUCT(r->out);
14487
14488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14489                         NDR_PULL_ALLOC(ndr, r->in.handle);
14490                 }
14491                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14492                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14493                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14495                 NDR_PULL_ALLOC(ndr, r->out.handle);
14496                 *r->out.handle = *r->in.handle;
14497         }
14498         if (flags & NDR_OUT) {
14499                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14500                         NDR_PULL_ALLOC(ndr, r->out.handle);
14501                 }
14502                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14503                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14504                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14505                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14506                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14507         }
14508         return NDR_ERR_SUCCESS;
14509 }
14510
14511 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
14512 {
14513         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
14514         ndr->depth++;
14515         if (flags & NDR_SET_VALUES) {
14516                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14517         }
14518         if (flags & NDR_IN) {
14519                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
14520                 ndr->depth++;
14521                 ndr_print_ptr(ndr, "handle", r->in.handle);
14522                 ndr->depth++;
14523                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14524                 ndr->depth--;
14525                 ndr->depth--;
14526         }
14527         if (flags & NDR_OUT) {
14528                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
14529                 ndr->depth++;
14530                 ndr_print_ptr(ndr, "handle", r->out.handle);
14531                 ndr->depth++;
14532                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14533                 ndr->depth--;
14534                 ndr_print_WERROR(ndr, "result", r->out.result);
14535                 ndr->depth--;
14536         }
14537         ndr->depth--;
14538 }
14539
14540 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
14541 {
14542         if (flags & NDR_IN) {
14543         }
14544         if (flags & NDR_OUT) {
14545                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14546         }
14547         return NDR_ERR_SUCCESS;
14548 }
14549
14550 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
14551 {
14552         if (flags & NDR_IN) {
14553         }
14554         if (flags & NDR_OUT) {
14555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14556         }
14557         return NDR_ERR_SUCCESS;
14558 }
14559
14560 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
14561 {
14562         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
14563         ndr->depth++;
14564         if (flags & NDR_SET_VALUES) {
14565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14566         }
14567         if (flags & NDR_IN) {
14568                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
14569                 ndr->depth++;
14570                 ndr->depth--;
14571         }
14572         if (flags & NDR_OUT) {
14573                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
14574                 ndr->depth++;
14575                 ndr_print_WERROR(ndr, "result", r->out.result);
14576                 ndr->depth--;
14577         }
14578         ndr->depth--;
14579 }
14580
14581 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14582 {
14583         if (flags & NDR_IN) {
14584         }
14585         if (flags & NDR_OUT) {
14586                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14587         }
14588         return NDR_ERR_SUCCESS;
14589 }
14590
14591 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14592 {
14593         if (flags & NDR_IN) {
14594         }
14595         if (flags & NDR_OUT) {
14596                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14597         }
14598         return NDR_ERR_SUCCESS;
14599 }
14600
14601 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14602 {
14603         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
14604         ndr->depth++;
14605         if (flags & NDR_SET_VALUES) {
14606                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14607         }
14608         if (flags & NDR_IN) {
14609                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
14610                 ndr->depth++;
14611                 ndr->depth--;
14612         }
14613         if (flags & NDR_OUT) {
14614                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
14615                 ndr->depth++;
14616                 ndr_print_WERROR(ndr, "result", r->out.result);
14617                 ndr->depth--;
14618         }
14619         ndr->depth--;
14620 }
14621
14622 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
14623 {
14624         if (flags & NDR_IN) {
14625         }
14626         if (flags & NDR_OUT) {
14627                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14628         }
14629         return NDR_ERR_SUCCESS;
14630 }
14631
14632 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
14633 {
14634         if (flags & NDR_IN) {
14635         }
14636         if (flags & NDR_OUT) {
14637                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14638         }
14639         return NDR_ERR_SUCCESS;
14640 }
14641
14642 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
14643 {
14644         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
14645         ndr->depth++;
14646         if (flags & NDR_SET_VALUES) {
14647                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14648         }
14649         if (flags & NDR_IN) {
14650                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
14651                 ndr->depth++;
14652                 ndr->depth--;
14653         }
14654         if (flags & NDR_OUT) {
14655                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
14656                 ndr->depth++;
14657                 ndr_print_WERROR(ndr, "result", r->out.result);
14658                 ndr->depth--;
14659         }
14660         ndr->depth--;
14661 }
14662
14663 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
14664 {
14665         if (flags & NDR_IN) {
14666         }
14667         if (flags & NDR_OUT) {
14668                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14669         }
14670         return NDR_ERR_SUCCESS;
14671 }
14672
14673 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
14674 {
14675         if (flags & NDR_IN) {
14676         }
14677         if (flags & NDR_OUT) {
14678                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14679         }
14680         return NDR_ERR_SUCCESS;
14681 }
14682
14683 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
14684 {
14685         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
14686         ndr->depth++;
14687         if (flags & NDR_SET_VALUES) {
14688                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14689         }
14690         if (flags & NDR_IN) {
14691                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
14692                 ndr->depth++;
14693                 ndr->depth--;
14694         }
14695         if (flags & NDR_OUT) {
14696                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
14697                 ndr->depth++;
14698                 ndr_print_WERROR(ndr, "result", r->out.result);
14699                 ndr->depth--;
14700         }
14701         ndr->depth--;
14702 }
14703
14704 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14705 {
14706         if (flags & NDR_IN) {
14707                 if (r->in.handle == NULL) {
14708                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14709                 }
14710                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
14712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
14713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.str));
14714                 if (r->in.str) {
14715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.str, CH_UTF16)));
14716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.str, CH_UTF16)));
14718                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.str, ndr_charset_length(r->in.str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14719                 }
14720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
14721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.t1));
14722                 if (r->in.t1) {
14723                         NDR_CHECK(ndr_push_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.t1));
14724                 }
14725         }
14726         if (flags & NDR_OUT) {
14727                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14728         }
14729         return NDR_ERR_SUCCESS;
14730 }
14731
14732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14733 {
14734         uint32_t _ptr_str;
14735         uint32_t _ptr_t1;
14736         TALLOC_CTX *_mem_save_handle_0;
14737         TALLOC_CTX *_mem_save_str_0;
14738         TALLOC_CTX *_mem_save_t1_0;
14739         if (flags & NDR_IN) {
14740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14741                         NDR_PULL_ALLOC(ndr, r->in.handle);
14742                 }
14743                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
14748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
14749                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
14750                 if (_ptr_str) {
14751                         NDR_PULL_ALLOC(ndr, r->in.str);
14752                 } else {
14753                         r->in.str = NULL;
14754                 }
14755                 if (r->in.str) {
14756                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
14757                         NDR_PULL_SET_MEM_CTX(ndr, r->in.str, 0);
14758                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.str));
14759                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.str));
14760                         if (ndr_get_array_length(ndr, &r->in.str) > ndr_get_array_size(ndr, &r->in.str)) {
14761                                 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.str), ndr_get_array_length(ndr, &r->in.str));
14762                         }
14763                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.str), sizeof(uint16_t)));
14764                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.str, ndr_get_array_length(ndr, &r->in.str), sizeof(uint16_t), CH_UTF16));
14765                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
14766                 }
14767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
14768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_t1));
14769                 if (_ptr_t1) {
14770                         NDR_PULL_ALLOC(ndr, r->in.t1);
14771                 } else {
14772                         r->in.t1 = NULL;
14773                 }
14774                 if (r->in.t1) {
14775                         _mem_save_t1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14776                         NDR_PULL_SET_MEM_CTX(ndr, r->in.t1, 0);
14777                         NDR_CHECK(ndr_pull_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.t1));
14778                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_t1_0, 0);
14779                 }
14780         }
14781         if (flags & NDR_OUT) {
14782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14783         }
14784         return NDR_ERR_SUCCESS;
14785 }
14786
14787 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14788 {
14789         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14790         ndr->depth++;
14791         if (flags & NDR_SET_VALUES) {
14792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14793         }
14794         if (flags & NDR_IN) {
14795                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14796                 ndr->depth++;
14797                 ndr_print_ptr(ndr, "handle", r->in.handle);
14798                 ndr->depth++;
14799                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14800                 ndr->depth--;
14801                 ndr_print_uint32(ndr, "flags", r->in.flags);
14802                 ndr_print_uint32(ndr, "options", r->in.options);
14803                 ndr_print_ptr(ndr, "str", r->in.str);
14804                 ndr->depth++;
14805                 if (r->in.str) {
14806                         ndr_print_string(ndr, "str", r->in.str);
14807                 }
14808                 ndr->depth--;
14809                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
14810                 ndr_print_ptr(ndr, "t1", r->in.t1);
14811                 ndr->depth++;
14812                 if (r->in.t1) {
14813                         ndr_print_spoolss_NotifyOptionsContainer(ndr, "t1", r->in.t1);
14814                 }
14815                 ndr->depth--;
14816                 ndr->depth--;
14817         }
14818         if (flags & NDR_OUT) {
14819                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14820                 ndr->depth++;
14821                 ndr_print_WERROR(ndr, "result", r->out.result);
14822                 ndr->depth--;
14823         }
14824         ndr->depth--;
14825 }
14826
14827 static enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotification *r)
14828 {
14829         if (flags & NDR_IN) {
14830         }
14831         if (flags & NDR_OUT) {
14832                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14833         }
14834         return NDR_ERR_SUCCESS;
14835 }
14836
14837 static enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotification *r)
14838 {
14839         if (flags & NDR_IN) {
14840         }
14841         if (flags & NDR_OUT) {
14842                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14843         }
14844         return NDR_ERR_SUCCESS;
14845 }
14846
14847 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotification *r)
14848 {
14849         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotification");
14850         ndr->depth++;
14851         if (flags & NDR_SET_VALUES) {
14852                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14853         }
14854         if (flags & NDR_IN) {
14855                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotification");
14856                 ndr->depth++;
14857                 ndr->depth--;
14858         }
14859         if (flags & NDR_OUT) {
14860                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotification");
14861                 ndr->depth++;
14862                 ndr_print_WERROR(ndr, "result", r->out.result);
14863                 ndr->depth--;
14864         }
14865         ndr->depth--;
14866 }
14867
14868 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14869 {
14870         if (flags & NDR_IN) {
14871                 if (r->in.handle == NULL) {
14872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14873                 }
14874                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
14876                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.container));
14877                 if (r->in.container) {
14878                         NDR_CHECK(ndr_push_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.container));
14879                 }
14880         }
14881         if (flags & NDR_OUT) {
14882                 if (r->out.info == NULL) {
14883                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14884                 }
14885                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
14886                 if (*r->out.info) {
14887                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
14888                 }
14889                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14890         }
14891         return NDR_ERR_SUCCESS;
14892 }
14893
14894 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14895 {
14896         uint32_t _ptr_container;
14897         uint32_t _ptr_info;
14898         TALLOC_CTX *_mem_save_handle_0;
14899         TALLOC_CTX *_mem_save_container_0;
14900         TALLOC_CTX *_mem_save_info_0;
14901         TALLOC_CTX *_mem_save_info_1;
14902         if (flags & NDR_IN) {
14903                 ZERO_STRUCT(r->out);
14904
14905                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14906                         NDR_PULL_ALLOC(ndr, r->in.handle);
14907                 }
14908                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14909                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14910                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14911                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
14913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_container));
14914                 if (_ptr_container) {
14915                         NDR_PULL_ALLOC(ndr, r->in.container);
14916                 } else {
14917                         r->in.container = NULL;
14918                 }
14919                 if (r->in.container) {
14920                         _mem_save_container_0 = NDR_PULL_GET_MEM_CTX(ndr);
14921                         NDR_PULL_SET_MEM_CTX(ndr, r->in.container, 0);
14922                         NDR_CHECK(ndr_pull_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.container));
14923                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_container_0, 0);
14924                 }
14925                 NDR_PULL_ALLOC(ndr, r->out.info);
14926                 ZERO_STRUCTP(r->out.info);
14927         }
14928         if (flags & NDR_OUT) {
14929                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14930                         NDR_PULL_ALLOC(ndr, r->out.info);
14931                 }
14932                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14933                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14935                 if (_ptr_info) {
14936                         NDR_PULL_ALLOC(ndr, *r->out.info);
14937                 } else {
14938                         *r->out.info = NULL;
14939                 }
14940                 if (*r->out.info) {
14941                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
14942                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
14943                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
14944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
14945                 }
14946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14947                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14948         }
14949         return NDR_ERR_SUCCESS;
14950 }
14951
14952 _PUBLIC_ void ndr_print_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14953 {
14954         ndr_print_struct(ndr, name, "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14955         ndr->depth++;
14956         if (flags & NDR_SET_VALUES) {
14957                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14958         }
14959         if (flags & NDR_IN) {
14960                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14961                 ndr->depth++;
14962                 ndr_print_ptr(ndr, "handle", r->in.handle);
14963                 ndr->depth++;
14964                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14965                 ndr->depth--;
14966                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
14967                 ndr_print_ptr(ndr, "container", r->in.container);
14968                 ndr->depth++;
14969                 if (r->in.container) {
14970                         ndr_print_spoolss_NotifyOptionsContainer(ndr, "container", r->in.container);
14971                 }
14972                 ndr->depth--;
14973                 ndr->depth--;
14974         }
14975         if (flags & NDR_OUT) {
14976                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14977                 ndr->depth++;
14978                 ndr_print_ptr(ndr, "info", r->out.info);
14979                 ndr->depth++;
14980                 ndr_print_ptr(ndr, "info", *r->out.info);
14981                 ndr->depth++;
14982                 if (*r->out.info) {
14983                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
14984                 }
14985                 ndr->depth--;
14986                 ndr->depth--;
14987                 ndr_print_WERROR(ndr, "result", r->out.result);
14988                 ndr->depth--;
14989         }
14990         ndr->depth--;
14991 }
14992
14993 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
14994 {
14995         if (flags & NDR_IN) {
14996         }
14997         if (flags & NDR_OUT) {
14998                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14999         }
15000         return NDR_ERR_SUCCESS;
15001 }
15002
15003 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
15004 {
15005         if (flags & NDR_IN) {
15006         }
15007         if (flags & NDR_OUT) {
15008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15009         }
15010         return NDR_ERR_SUCCESS;
15011 }
15012
15013 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
15014 {
15015         ndr_print_struct(ndr, name, "spoolss_44");
15016         ndr->depth++;
15017         if (flags & NDR_SET_VALUES) {
15018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15019         }
15020         if (flags & NDR_IN) {
15021                 ndr_print_struct(ndr, "in", "spoolss_44");
15022                 ndr->depth++;
15023                 ndr->depth--;
15024         }
15025         if (flags & NDR_OUT) {
15026                 ndr_print_struct(ndr, "out", "spoolss_44");
15027                 ndr->depth++;
15028                 ndr_print_WERROR(ndr, "result", r->out.result);
15029                 ndr->depth--;
15030         }
15031         ndr->depth--;
15032 }
15033
15034 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
15035 {
15036         if (flags & NDR_IN) {
15037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
15038                 if (r->in.printername) {
15039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
15040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15041                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
15042                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15043                 }
15044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
15045                 if (r->in.datatype) {
15046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
15047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
15049                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15050                 }
15051                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
15053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15054                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
15055                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
15056         }
15057         if (flags & NDR_OUT) {
15058                 if (r->out.handle == NULL) {
15059                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15060                 }
15061                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15063         }
15064         return NDR_ERR_SUCCESS;
15065 }
15066
15067 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
15068 {
15069         uint32_t _ptr_printername;
15070         uint32_t _ptr_datatype;
15071         TALLOC_CTX *_mem_save_printername_0;
15072         TALLOC_CTX *_mem_save_datatype_0;
15073         TALLOC_CTX *_mem_save_handle_0;
15074         if (flags & NDR_IN) {
15075                 ZERO_STRUCT(r->out);
15076
15077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
15078                 if (_ptr_printername) {
15079                         NDR_PULL_ALLOC(ndr, r->in.printername);
15080                 } else {
15081                         r->in.printername = NULL;
15082                 }
15083                 if (r->in.printername) {
15084                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
15085                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
15086                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
15087                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
15088                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
15089                                 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));
15090                         }
15091                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
15092                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
15093                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
15094                 }
15095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
15096                 if (_ptr_datatype) {
15097                         NDR_PULL_ALLOC(ndr, r->in.datatype);
15098                 } else {
15099                         r->in.datatype = NULL;
15100                 }
15101                 if (r->in.datatype) {
15102                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
15103                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
15104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
15105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
15106                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
15107                                 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));
15108                         }
15109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
15110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
15111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
15112                 }
15113                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
15115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15116                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
15117                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
15118                 NDR_PULL_ALLOC(ndr, r->out.handle);
15119                 ZERO_STRUCTP(r->out.handle);
15120         }
15121         if (flags & NDR_OUT) {
15122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15123                         NDR_PULL_ALLOC(ndr, r->out.handle);
15124                 }
15125                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15126                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
15127                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15130         }
15131         return NDR_ERR_SUCCESS;
15132 }
15133
15134 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
15135 {
15136         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
15137         ndr->depth++;
15138         if (flags & NDR_SET_VALUES) {
15139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15140         }
15141         if (flags & NDR_IN) {
15142                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
15143                 ndr->depth++;
15144                 ndr_print_ptr(ndr, "printername", r->in.printername);
15145                 ndr->depth++;
15146                 if (r->in.printername) {
15147                         ndr_print_string(ndr, "printername", r->in.printername);
15148                 }
15149                 ndr->depth--;
15150                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
15151                 ndr->depth++;
15152                 if (r->in.datatype) {
15153                         ndr_print_string(ndr, "datatype", r->in.datatype);
15154                 }
15155                 ndr->depth--;
15156                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
15157                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
15158                 ndr_print_uint32(ndr, "level", r->in.level);
15159                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
15160                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
15161                 ndr->depth--;
15162         }
15163         if (flags & NDR_OUT) {
15164                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
15165                 ndr->depth++;
15166                 ndr_print_ptr(ndr, "handle", r->out.handle);
15167                 ndr->depth++;
15168                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
15169                 ndr->depth--;
15170                 ndr_print_WERROR(ndr, "result", r->out.result);
15171                 ndr->depth--;
15172         }
15173         ndr->depth--;
15174 }
15175
15176 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
15177 {
15178         if (flags & NDR_IN) {
15179                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15180                 if (r->in.server) {
15181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15184                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15185                 }
15186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15187                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
15188                 if (r->in.info) {
15189                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
15190                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15191                 }
15192                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));
15194                 if (r->in.secdesc) {
15195                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
15196                 }
15197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.ulevel));
15198                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel));
15199                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
15200         }
15201         if (flags & NDR_OUT) {
15202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15203         }
15204         return NDR_ERR_SUCCESS;
15205 }
15206
15207 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
15208 {
15209         uint32_t _ptr_server;
15210         uint32_t _ptr_info;
15211         uint32_t _ptr_secdesc;
15212         TALLOC_CTX *_mem_save_server_0;
15213         TALLOC_CTX *_mem_save_info_0;
15214         TALLOC_CTX *_mem_save_secdesc_0;
15215         if (flags & NDR_IN) {
15216                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15217                 if (_ptr_server) {
15218                         NDR_PULL_ALLOC(ndr, r->in.server);
15219                 } else {
15220                         r->in.server = NULL;
15221                 }
15222                 if (r->in.server) {
15223                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15224                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15225                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15226                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15227                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15228                                 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));
15229                         }
15230                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15231                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15232                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15233                 }
15234                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15236                 if (_ptr_info) {
15237                         NDR_PULL_ALLOC(ndr, r->in.info);
15238                 } else {
15239                         r->in.info = NULL;
15240                 }
15241                 if (r->in.info) {
15242                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15243                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
15244                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
15245                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15246                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15247                 }
15248                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15249                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
15250                 if (_ptr_secdesc) {
15251                         NDR_PULL_ALLOC(ndr, r->in.secdesc);
15252                 } else {
15253                         r->in.secdesc = NULL;
15254                 }
15255                 if (r->in.secdesc) {
15256                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15257                         NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);
15258                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
15259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
15260                 }
15261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.ulevel));
15262                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel));
15263                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
15264         }
15265         if (flags & NDR_OUT) {
15266                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15267         }
15268         return NDR_ERR_SUCCESS;
15269 }
15270
15271 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
15272 {
15273         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
15274         ndr->depth++;
15275         if (flags & NDR_SET_VALUES) {
15276                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15277         }
15278         if (flags & NDR_IN) {
15279                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
15280                 ndr->depth++;
15281                 ndr_print_ptr(ndr, "server", r->in.server);
15282                 ndr->depth++;
15283                 if (r->in.server) {
15284                         ndr_print_string(ndr, "server", r->in.server);
15285                 }
15286                 ndr->depth--;
15287                 ndr_print_uint32(ndr, "level", r->in.level);
15288                 ndr_print_ptr(ndr, "info", r->in.info);
15289                 ndr->depth++;
15290                 if (r->in.info) {
15291                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
15292                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->in.info);
15293                 }
15294                 ndr->depth--;
15295                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
15296                 ndr_print_ptr(ndr, "secdesc", r->in.secdesc);
15297                 ndr->depth++;
15298                 if (r->in.secdesc) {
15299                         ndr_print_security_descriptor(ndr, "secdesc", r->in.secdesc);
15300                 }
15301                 ndr->depth--;
15302                 ndr_print_uint32(ndr, "ulevel", r->in.ulevel);
15303                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel);
15304                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
15305                 ndr->depth--;
15306         }
15307         if (flags & NDR_OUT) {
15308                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
15309                 ndr->depth++;
15310                 ndr_print_WERROR(ndr, "result", r->out.result);
15311                 ndr->depth--;
15312         }
15313         ndr->depth--;
15314 }
15315
15316 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
15317 {
15318         if (flags & NDR_IN) {
15319         }
15320         if (flags & NDR_OUT) {
15321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15322         }
15323         return NDR_ERR_SUCCESS;
15324 }
15325
15326 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
15327 {
15328         if (flags & NDR_IN) {
15329         }
15330         if (flags & NDR_OUT) {
15331                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15332         }
15333         return NDR_ERR_SUCCESS;
15334 }
15335
15336 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
15337 {
15338         ndr_print_struct(ndr, name, "spoolss_47");
15339         ndr->depth++;
15340         if (flags & NDR_SET_VALUES) {
15341                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15342         }
15343         if (flags & NDR_IN) {
15344                 ndr_print_struct(ndr, "in", "spoolss_47");
15345                 ndr->depth++;
15346                 ndr->depth--;
15347         }
15348         if (flags & NDR_OUT) {
15349                 ndr_print_struct(ndr, "out", "spoolss_47");
15350                 ndr->depth++;
15351                 ndr_print_WERROR(ndr, "result", r->out.result);
15352                 ndr->depth--;
15353         }
15354         ndr->depth--;
15355 }
15356
15357 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
15358 {
15359         if (flags & NDR_IN) {
15360                 if (r->in.handle == NULL) {
15361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15362                 }
15363                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
15365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
15366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
15367         }
15368         if (flags & NDR_OUT) {
15369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
15370                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
15371                 if (r->out.value_needed == NULL) {
15372                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15373                 }
15374                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
15375                 if (r->out.printerdata_type == NULL) {
15376                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15377                 }
15378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
15379                 if (r->out.buffer == NULL) {
15380                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15381                 }
15382                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
15383                 if (r->out.data_needed == NULL) {
15384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15385                 }
15386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
15387                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15388         }
15389         return NDR_ERR_SUCCESS;
15390 }
15391
15392 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
15393 {
15394         TALLOC_CTX *_mem_save_handle_0;
15395         TALLOC_CTX *_mem_save_value_needed_0;
15396         TALLOC_CTX *_mem_save_printerdata_type_0;
15397         TALLOC_CTX *_mem_save_buffer_0;
15398         TALLOC_CTX *_mem_save_data_needed_0;
15399         if (flags & NDR_IN) {
15400                 ZERO_STRUCT(r->out);
15401
15402                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15403                         NDR_PULL_ALLOC(ndr, r->in.handle);
15404                 }
15405                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15406                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15407                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15408                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
15410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
15411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
15412                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
15413                 ZERO_STRUCTP(r->out.value_needed);
15414                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
15415                 ZERO_STRUCTP(r->out.printerdata_type);
15416                 NDR_PULL_ALLOC(ndr, r->out.buffer);
15417                 ZERO_STRUCTP(r->out.buffer);
15418                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
15419                 ZERO_STRUCTP(r->out.data_needed);
15420         }
15421         if (flags & NDR_OUT) {
15422                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
15423                 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));
15424                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15425                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
15426                 }
15427                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15428                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
15429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
15430                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
15431                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15432                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
15433                 }
15434                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15435                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
15436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
15437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
15438                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15439                         NDR_PULL_ALLOC(ndr, r->out.buffer);
15440                 }
15441                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15442                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
15443                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
15444                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
15445                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15446                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
15447                 }
15448                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15449                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
15450                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
15451                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
15452                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15453                 if (r->out.value_name) {
15454                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
15455                 }
15456         }
15457         return NDR_ERR_SUCCESS;
15458 }
15459
15460 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
15461 {
15462         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
15463         ndr->depth++;
15464         if (flags & NDR_SET_VALUES) {
15465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15466         }
15467         if (flags & NDR_IN) {
15468                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
15469                 ndr->depth++;
15470                 ndr_print_ptr(ndr, "handle", r->in.handle);
15471                 ndr->depth++;
15472                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15473                 ndr->depth--;
15474                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
15475                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
15476                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
15477                 ndr->depth--;
15478         }
15479         if (flags & NDR_OUT) {
15480                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
15481                 ndr->depth++;
15482                 ndr_print_string(ndr, "value_name", r->out.value_name);
15483                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
15484                 ndr->depth++;
15485                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
15486                 ndr->depth--;
15487                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
15488                 ndr->depth++;
15489                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
15490                 ndr->depth--;
15491                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
15492                 ndr->depth++;
15493                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
15494                 ndr->depth--;
15495                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
15496                 ndr->depth++;
15497                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
15498                 ndr->depth--;
15499                 ndr_print_WERROR(ndr, "result", r->out.result);
15500                 ndr->depth--;
15501         }
15502         ndr->depth--;
15503 }
15504
15505 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
15506 {
15507         if (flags & NDR_IN) {
15508                 if (r->in.handle == NULL) {
15509                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15510                 }
15511                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15515                 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));
15516         }
15517         if (flags & NDR_OUT) {
15518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15519         }
15520         return NDR_ERR_SUCCESS;
15521 }
15522
15523 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
15524 {
15525         TALLOC_CTX *_mem_save_handle_0;
15526         if (flags & NDR_IN) {
15527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15528                         NDR_PULL_ALLOC(ndr, r->in.handle);
15529                 }
15530                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15531                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15532                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15534                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15535                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15536                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15537                         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));
15538                 }
15539                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15540                 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));
15541         }
15542         if (flags & NDR_OUT) {
15543                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15544         }
15545         return NDR_ERR_SUCCESS;
15546 }
15547
15548 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
15549 {
15550         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
15551         ndr->depth++;
15552         if (flags & NDR_SET_VALUES) {
15553                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15554         }
15555         if (flags & NDR_IN) {
15556                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
15557                 ndr->depth++;
15558                 ndr_print_ptr(ndr, "handle", r->in.handle);
15559                 ndr->depth++;
15560                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15561                 ndr->depth--;
15562                 ndr_print_string(ndr, "value_name", r->in.value_name);
15563                 ndr->depth--;
15564         }
15565         if (flags & NDR_OUT) {
15566                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
15567                 ndr->depth++;
15568                 ndr_print_WERROR(ndr, "result", r->out.result);
15569                 ndr->depth--;
15570         }
15571         ndr->depth--;
15572 }
15573
15574 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
15575 {
15576         if (flags & NDR_IN) {
15577         }
15578         if (flags & NDR_OUT) {
15579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15580         }
15581         return NDR_ERR_SUCCESS;
15582 }
15583
15584 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
15585 {
15586         if (flags & NDR_IN) {
15587         }
15588         if (flags & NDR_OUT) {
15589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15590         }
15591         return NDR_ERR_SUCCESS;
15592 }
15593
15594 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
15595 {
15596         ndr_print_struct(ndr, name, "spoolss_4a");
15597         ndr->depth++;
15598         if (flags & NDR_SET_VALUES) {
15599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15600         }
15601         if (flags & NDR_IN) {
15602                 ndr_print_struct(ndr, "in", "spoolss_4a");
15603                 ndr->depth++;
15604                 ndr->depth--;
15605         }
15606         if (flags & NDR_OUT) {
15607                 ndr_print_struct(ndr, "out", "spoolss_4a");
15608                 ndr->depth++;
15609                 ndr_print_WERROR(ndr, "result", r->out.result);
15610                 ndr->depth--;
15611         }
15612         ndr->depth--;
15613 }
15614
15615 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
15616 {
15617         if (flags & NDR_IN) {
15618         }
15619         if (flags & NDR_OUT) {
15620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15621         }
15622         return NDR_ERR_SUCCESS;
15623 }
15624
15625 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
15626 {
15627         if (flags & NDR_IN) {
15628         }
15629         if (flags & NDR_OUT) {
15630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15631         }
15632         return NDR_ERR_SUCCESS;
15633 }
15634
15635 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
15636 {
15637         ndr_print_struct(ndr, name, "spoolss_4b");
15638         ndr->depth++;
15639         if (flags & NDR_SET_VALUES) {
15640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15641         }
15642         if (flags & NDR_IN) {
15643                 ndr_print_struct(ndr, "in", "spoolss_4b");
15644                 ndr->depth++;
15645                 ndr->depth--;
15646         }
15647         if (flags & NDR_OUT) {
15648                 ndr_print_struct(ndr, "out", "spoolss_4b");
15649                 ndr->depth++;
15650                 ndr_print_WERROR(ndr, "result", r->out.result);
15651                 ndr->depth--;
15652         }
15653         ndr->depth--;
15654 }
15655
15656 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
15657 {
15658         if (flags & NDR_IN) {
15659         }
15660         if (flags & NDR_OUT) {
15661                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15662         }
15663         return NDR_ERR_SUCCESS;
15664 }
15665
15666 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
15667 {
15668         if (flags & NDR_IN) {
15669         }
15670         if (flags & NDR_OUT) {
15671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15672         }
15673         return NDR_ERR_SUCCESS;
15674 }
15675
15676 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
15677 {
15678         ndr_print_struct(ndr, name, "spoolss_4c");
15679         ndr->depth++;
15680         if (flags & NDR_SET_VALUES) {
15681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15682         }
15683         if (flags & NDR_IN) {
15684                 ndr_print_struct(ndr, "in", "spoolss_4c");
15685                 ndr->depth++;
15686                 ndr->depth--;
15687         }
15688         if (flags & NDR_OUT) {
15689                 ndr_print_struct(ndr, "out", "spoolss_4c");
15690                 ndr->depth++;
15691                 ndr_print_WERROR(ndr, "result", r->out.result);
15692                 ndr->depth--;
15693         }
15694         ndr->depth--;
15695 }
15696
15697 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
15698 {
15699         if (flags & NDR_IN) {
15700                 if (r->in.handle == NULL) {
15701                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15702                 }
15703                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15704                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15707                 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));
15708                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15711                 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));
15712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
15713                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15715         }
15716         if (flags & NDR_OUT) {
15717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15718         }
15719         return NDR_ERR_SUCCESS;
15720 }
15721
15722 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
15723 {
15724         TALLOC_CTX *_mem_save_handle_0;
15725         if (flags & NDR_IN) {
15726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15727                         NDR_PULL_ALLOC(ndr, r->in.handle);
15728                 }
15729                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15730                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15731                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15733                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15734                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15735                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15736                         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));
15737                 }
15738                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15739                 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));
15740                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15741                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15742                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15743                         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));
15744                 }
15745                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15746                 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));
15747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
15748                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.buffer));
15749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15750         }
15751         if (flags & NDR_OUT) {
15752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15753         }
15754         return NDR_ERR_SUCCESS;
15755 }
15756
15757 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
15758 {
15759         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
15760         ndr->depth++;
15761         if (flags & NDR_SET_VALUES) {
15762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15763         }
15764         if (flags & NDR_IN) {
15765                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
15766                 ndr->depth++;
15767                 ndr_print_ptr(ndr, "handle", r->in.handle);
15768                 ndr->depth++;
15769                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15770                 ndr->depth--;
15771                 ndr_print_string(ndr, "key_name", r->in.key_name);
15772                 ndr_print_string(ndr, "value_name", r->in.value_name);
15773                 ndr_print_uint32(ndr, "type", r->in.type);
15774                 ndr_print_DATA_BLOB(ndr, "buffer", r->in.buffer);
15775                 ndr_print_uint32(ndr, "offered", r->in.offered);
15776                 ndr->depth--;
15777         }
15778         if (flags & NDR_OUT) {
15779                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
15780                 ndr->depth++;
15781                 ndr_print_WERROR(ndr, "result", r->out.result);
15782                 ndr->depth--;
15783         }
15784         ndr->depth--;
15785 }
15786
15787 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
15788 {
15789         if (flags & NDR_IN) {
15790                 if (r->in.handle == NULL) {
15791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15792                 }
15793                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15797                 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));
15798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15801                 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));
15802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15803         }
15804         if (flags & NDR_OUT) {
15805                 if (r->out.type == NULL) {
15806                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15807                 }
15808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
15809                 if (r->out.buffer == NULL) {
15810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15811                 }
15812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15813                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
15814                 if (r->out.needed == NULL) {
15815                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15816                 }
15817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15818                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15819         }
15820         return NDR_ERR_SUCCESS;
15821 }
15822
15823 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
15824 {
15825         TALLOC_CTX *_mem_save_handle_0;
15826         TALLOC_CTX *_mem_save_type_0;
15827         TALLOC_CTX *_mem_save_needed_0;
15828         if (flags & NDR_IN) {
15829                 ZERO_STRUCT(r->out);
15830
15831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15832                         NDR_PULL_ALLOC(ndr, r->in.handle);
15833                 }
15834                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15835                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15836                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15838                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15839                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15840                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15841                         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));
15842                 }
15843                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15844                 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));
15845                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15846                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15847                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15848                         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));
15849                 }
15850                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15851                 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));
15852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15853                 NDR_PULL_ALLOC(ndr, r->out.type);
15854                 ZERO_STRUCTP(r->out.type);
15855                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
15856                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
15857                 NDR_PULL_ALLOC(ndr, r->out.needed);
15858                 ZERO_STRUCTP(r->out.needed);
15859         }
15860         if (flags & NDR_OUT) {
15861                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15862                         NDR_PULL_ALLOC(ndr, r->out.type);
15863                 }
15864                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15865                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
15866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
15867                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
15868                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
15869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15870                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
15871                 }
15872                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
15873                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15874                         NDR_PULL_ALLOC(ndr, r->out.needed);
15875                 }
15876                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15877                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15879                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15880                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15881                 if (r->out.buffer) {
15882                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
15883                 }
15884         }
15885         return NDR_ERR_SUCCESS;
15886 }
15887
15888 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
15889 {
15890         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
15891         ndr->depth++;
15892         if (flags & NDR_SET_VALUES) {
15893                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15894         }
15895         if (flags & NDR_IN) {
15896                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
15897                 ndr->depth++;
15898                 ndr_print_ptr(ndr, "handle", r->in.handle);
15899                 ndr->depth++;
15900                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15901                 ndr->depth--;
15902                 ndr_print_string(ndr, "key_name", r->in.key_name);
15903                 ndr_print_string(ndr, "value_name", r->in.value_name);
15904                 ndr_print_uint32(ndr, "offered", r->in.offered);
15905                 ndr->depth--;
15906         }
15907         if (flags & NDR_OUT) {
15908                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
15909                 ndr->depth++;
15910                 ndr_print_ptr(ndr, "type", r->out.type);
15911                 ndr->depth++;
15912                 ndr_print_uint32(ndr, "type", *r->out.type);
15913                 ndr->depth--;
15914                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
15915                 ndr->depth++;
15916                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
15917                 ndr->depth--;
15918                 ndr_print_ptr(ndr, "needed", r->out.needed);
15919                 ndr->depth++;
15920                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15921                 ndr->depth--;
15922                 ndr_print_WERROR(ndr, "result", r->out.result);
15923                 ndr->depth--;
15924         }
15925         ndr->depth--;
15926 }
15927
15928 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
15929 {
15930         if (flags & NDR_IN) {
15931                 if (r->in.handle == NULL) {
15932                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15933                 }
15934                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15938                 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));
15939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15940         }
15941         if (flags & NDR_OUT) {
15942                 if (r->out.buffer == NULL) {
15943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15944                 }
15945                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15946                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
15947                 if (r->out.needed == NULL) {
15948                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15949                 }
15950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15951                 if (r->out.count == NULL) {
15952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15953                 }
15954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15955                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15956         }
15957         return NDR_ERR_SUCCESS;
15958 }
15959
15960 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
15961 {
15962         TALLOC_CTX *_mem_save_handle_0;
15963         TALLOC_CTX *_mem_save_needed_0;
15964         TALLOC_CTX *_mem_save_count_0;
15965         if (flags & NDR_IN) {
15966                 ZERO_STRUCT(r->out);
15967
15968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15969                         NDR_PULL_ALLOC(ndr, r->in.handle);
15970                 }
15971                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15972                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15973                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15974                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15975                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15976                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15977                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15978                         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));
15979                 }
15980                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15981                 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));
15982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15983                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
15984                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
15985                 NDR_PULL_ALLOC(ndr, r->out.needed);
15986                 ZERO_STRUCTP(r->out.needed);
15987                 NDR_PULL_ALLOC(ndr, r->out.count);
15988                 ZERO_STRUCTP(r->out.count);
15989         }
15990         if (flags & NDR_OUT) {
15991                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
15992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15993                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
15994                 }
15995                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
15996                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15997                         NDR_PULL_ALLOC(ndr, r->out.needed);
15998                 }
15999                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16000                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16002                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16004                         NDR_PULL_ALLOC(ndr, r->out.count);
16005                 }
16006                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
16007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
16008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
16009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
16010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16011                 if (r->out.buffer) {
16012                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
16013                 }
16014         }
16015         return NDR_ERR_SUCCESS;
16016 }
16017
16018 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
16019 {
16020         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
16021         ndr->depth++;
16022         if (flags & NDR_SET_VALUES) {
16023                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16024         }
16025         if (flags & NDR_IN) {
16026                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
16027                 ndr->depth++;
16028                 ndr_print_ptr(ndr, "handle", r->in.handle);
16029                 ndr->depth++;
16030                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16031                 ndr->depth--;
16032                 ndr_print_string(ndr, "key_name", r->in.key_name);
16033                 ndr_print_uint32(ndr, "offered", r->in.offered);
16034                 ndr->depth--;
16035         }
16036         if (flags & NDR_OUT) {
16037                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
16038                 ndr->depth++;
16039                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
16040                 ndr->depth++;
16041                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
16042                 ndr->depth--;
16043                 ndr_print_ptr(ndr, "needed", r->out.needed);
16044                 ndr->depth++;
16045                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16046                 ndr->depth--;
16047                 ndr_print_ptr(ndr, "count", r->out.count);
16048                 ndr->depth++;
16049                 ndr_print_uint32(ndr, "count", *r->out.count);
16050                 ndr->depth--;
16051                 ndr_print_WERROR(ndr, "result", r->out.result);
16052                 ndr->depth--;
16053         }
16054         ndr->depth--;
16055 }
16056
16057 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
16058 {
16059         uint32_t cntr_key_buffer_1;
16060         if (flags & NDR_IN) {
16061                 if (r->in.handle == NULL) {
16062                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16063                 }
16064                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16068                 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));
16069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
16070         }
16071         if (flags & NDR_OUT) {
16072                 if (r->out.key_buffer == NULL) {
16073                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16074                 }
16075                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
16076                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
16077                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
16078                 }
16079                 if (r->out.needed == NULL) {
16080                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16081                 }
16082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16084         }
16085         return NDR_ERR_SUCCESS;
16086 }
16087
16088 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
16089 {
16090         uint32_t cntr_key_buffer_1;
16091         TALLOC_CTX *_mem_save_handle_0;
16092         TALLOC_CTX *_mem_save_key_buffer_1;
16093         TALLOC_CTX *_mem_save_needed_0;
16094         if (flags & NDR_IN) {
16095                 ZERO_STRUCT(r->out);
16096
16097                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16098                         NDR_PULL_ALLOC(ndr, r->in.handle);
16099                 }
16100                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16101                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16102                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16104                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
16105                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
16106                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
16107                         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));
16108                 }
16109                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
16110                 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));
16111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
16112                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
16113                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
16114                 NDR_PULL_ALLOC(ndr, r->out.needed);
16115                 ZERO_STRUCTP(r->out.needed);
16116         }
16117         if (flags & NDR_OUT) {
16118                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
16119                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16120                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
16121                 }
16122                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
16123                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
16124                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
16125                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
16126                 }
16127                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
16128                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16129                         NDR_PULL_ALLOC(ndr, r->out.needed);
16130                 }
16131                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16132                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16133                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16134                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16135                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16136                 if (r->out.key_buffer) {
16137                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
16138                 }
16139         }
16140         return NDR_ERR_SUCCESS;
16141 }
16142
16143 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
16144 {
16145         uint32_t cntr_key_buffer_1;
16146         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
16147         ndr->depth++;
16148         if (flags & NDR_SET_VALUES) {
16149                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16150         }
16151         if (flags & NDR_IN) {
16152                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
16153                 ndr->depth++;
16154                 ndr_print_ptr(ndr, "handle", r->in.handle);
16155                 ndr->depth++;
16156                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16157                 ndr->depth--;
16158                 ndr_print_string(ndr, "key_name", r->in.key_name);
16159                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
16160                 ndr->depth--;
16161         }
16162         if (flags & NDR_OUT) {
16163                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
16164                 ndr->depth++;
16165                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
16166                 ndr->depth++;
16167                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
16168                 ndr->depth++;
16169                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
16170                         char *idx_1=NULL;
16171                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
16172                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
16173                                 free(idx_1);
16174                         }
16175                 }
16176                 ndr->depth--;
16177                 ndr->depth--;
16178                 ndr_print_ptr(ndr, "needed", r->out.needed);
16179                 ndr->depth++;
16180                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16181                 ndr->depth--;
16182                 ndr_print_WERROR(ndr, "result", r->out.result);
16183                 ndr->depth--;
16184         }
16185         ndr->depth--;
16186 }
16187
16188 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
16189 {
16190         if (flags & NDR_IN) {
16191                 if (r->in.handle == NULL) {
16192                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16193                 }
16194                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16198                 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));
16199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
16200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
16202                 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));
16203         }
16204         if (flags & NDR_OUT) {
16205                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16206         }
16207         return NDR_ERR_SUCCESS;
16208 }
16209
16210 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
16211 {
16212         TALLOC_CTX *_mem_save_handle_0;
16213         if (flags & NDR_IN) {
16214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16215                         NDR_PULL_ALLOC(ndr, r->in.handle);
16216                 }
16217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16221                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
16222                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
16223                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
16224                         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));
16225                 }
16226                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
16227                 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));
16228                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
16229                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
16230                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
16231                         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));
16232                 }
16233                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
16234                 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));
16235         }
16236         if (flags & NDR_OUT) {
16237                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16238         }
16239         return NDR_ERR_SUCCESS;
16240 }
16241
16242 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
16243 {
16244         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
16245         ndr->depth++;
16246         if (flags & NDR_SET_VALUES) {
16247                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16248         }
16249         if (flags & NDR_IN) {
16250                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
16251                 ndr->depth++;
16252                 ndr_print_ptr(ndr, "handle", r->in.handle);
16253                 ndr->depth++;
16254                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16255                 ndr->depth--;
16256                 ndr_print_string(ndr, "key_name", r->in.key_name);
16257                 ndr_print_string(ndr, "value_name", r->in.value_name);
16258                 ndr->depth--;
16259         }
16260         if (flags & NDR_OUT) {
16261                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
16262                 ndr->depth++;
16263                 ndr_print_WERROR(ndr, "result", r->out.result);
16264                 ndr->depth--;
16265         }
16266         ndr->depth--;
16267 }
16268
16269 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
16270 {
16271         if (flags & NDR_IN) {
16272                 if (r->in.handle == NULL) {
16273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16274                 }
16275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16279                 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));
16280         }
16281         if (flags & NDR_OUT) {
16282                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16283         }
16284         return NDR_ERR_SUCCESS;
16285 }
16286
16287 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
16288 {
16289         TALLOC_CTX *_mem_save_handle_0;
16290         if (flags & NDR_IN) {
16291                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16292                         NDR_PULL_ALLOC(ndr, r->in.handle);
16293                 }
16294                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16295                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16296                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16297                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16298                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
16299                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
16300                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
16301                         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));
16302                 }
16303                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
16304                 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));
16305         }
16306         if (flags & NDR_OUT) {
16307                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16308         }
16309         return NDR_ERR_SUCCESS;
16310 }
16311
16312 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
16313 {
16314         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
16315         ndr->depth++;
16316         if (flags & NDR_SET_VALUES) {
16317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16318         }
16319         if (flags & NDR_IN) {
16320                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
16321                 ndr->depth++;
16322                 ndr_print_ptr(ndr, "handle", r->in.handle);
16323                 ndr->depth++;
16324                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16325                 ndr->depth--;
16326                 ndr_print_string(ndr, "key_name", r->in.key_name);
16327                 ndr->depth--;
16328         }
16329         if (flags & NDR_OUT) {
16330                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
16331                 ndr->depth++;
16332                 ndr_print_WERROR(ndr, "result", r->out.result);
16333                 ndr->depth--;
16334         }
16335         ndr->depth--;
16336 }
16337
16338 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
16339 {
16340         if (flags & NDR_IN) {
16341         }
16342         if (flags & NDR_OUT) {
16343                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16344         }
16345         return NDR_ERR_SUCCESS;
16346 }
16347
16348 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
16349 {
16350         if (flags & NDR_IN) {
16351         }
16352         if (flags & NDR_OUT) {
16353                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16354         }
16355         return NDR_ERR_SUCCESS;
16356 }
16357
16358 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
16359 {
16360         ndr_print_struct(ndr, name, "spoolss_53");
16361         ndr->depth++;
16362         if (flags & NDR_SET_VALUES) {
16363                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16364         }
16365         if (flags & NDR_IN) {
16366                 ndr_print_struct(ndr, "in", "spoolss_53");
16367                 ndr->depth++;
16368                 ndr->depth--;
16369         }
16370         if (flags & NDR_OUT) {
16371                 ndr_print_struct(ndr, "out", "spoolss_53");
16372                 ndr->depth++;
16373                 ndr_print_WERROR(ndr, "result", r->out.result);
16374                 ndr->depth--;
16375         }
16376         ndr->depth--;
16377 }
16378
16379 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
16380 {
16381         if (flags & NDR_IN) {
16382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16383                 if (r->in.server) {
16384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16387                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16388                 }
16389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16392                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16394                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16396                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16397                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
16398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
16399         }
16400         if (flags & NDR_OUT) {
16401                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16402         }
16403         return NDR_ERR_SUCCESS;
16404 }
16405
16406 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
16407 {
16408         uint32_t _ptr_server;
16409         TALLOC_CTX *_mem_save_server_0;
16410         if (flags & NDR_IN) {
16411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16412                 if (_ptr_server) {
16413                         NDR_PULL_ALLOC(ndr, r->in.server);
16414                 } else {
16415                         r->in.server = NULL;
16416                 }
16417                 if (r->in.server) {
16418                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16419                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16422                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16423                                 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));
16424                         }
16425                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16428                 }
16429                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16430                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16431                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16432                         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));
16433                 }
16434                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16435                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16436                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16437                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16438                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16439                         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));
16440                 }
16441                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16442                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16443                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
16444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
16445         }
16446         if (flags & NDR_OUT) {
16447                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16448         }
16449         return NDR_ERR_SUCCESS;
16450 }
16451
16452 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
16453 {
16454         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
16455         ndr->depth++;
16456         if (flags & NDR_SET_VALUES) {
16457                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16458         }
16459         if (flags & NDR_IN) {
16460                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
16461                 ndr->depth++;
16462                 ndr_print_ptr(ndr, "server", r->in.server);
16463                 ndr->depth++;
16464                 if (r->in.server) {
16465                         ndr_print_string(ndr, "server", r->in.server);
16466                 }
16467                 ndr->depth--;
16468                 ndr_print_string(ndr, "architecture", r->in.architecture);
16469                 ndr_print_string(ndr, "driver", r->in.driver);
16470                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
16471                 ndr_print_uint32(ndr, "version", r->in.version);
16472                 ndr->depth--;
16473         }
16474         if (flags & NDR_OUT) {
16475                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
16476                 ndr->depth++;
16477                 ndr_print_WERROR(ndr, "result", r->out.result);
16478                 ndr->depth--;
16479         }
16480         ndr->depth--;
16481 }
16482
16483 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
16484 {
16485         if (flags & NDR_IN) {
16486         }
16487         if (flags & NDR_OUT) {
16488                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16489         }
16490         return NDR_ERR_SUCCESS;
16491 }
16492
16493 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
16494 {
16495         if (flags & NDR_IN) {
16496         }
16497         if (flags & NDR_OUT) {
16498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16499         }
16500         return NDR_ERR_SUCCESS;
16501 }
16502
16503 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
16504 {
16505         ndr_print_struct(ndr, name, "spoolss_55");
16506         ndr->depth++;
16507         if (flags & NDR_SET_VALUES) {
16508                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16509         }
16510         if (flags & NDR_IN) {
16511                 ndr_print_struct(ndr, "in", "spoolss_55");
16512                 ndr->depth++;
16513                 ndr->depth--;
16514         }
16515         if (flags & NDR_OUT) {
16516                 ndr_print_struct(ndr, "out", "spoolss_55");
16517                 ndr->depth++;
16518                 ndr_print_WERROR(ndr, "result", r->out.result);
16519                 ndr->depth--;
16520         }
16521         ndr->depth--;
16522 }
16523
16524 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
16525 {
16526         if (flags & NDR_IN) {
16527         }
16528         if (flags & NDR_OUT) {
16529                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16530         }
16531         return NDR_ERR_SUCCESS;
16532 }
16533
16534 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
16535 {
16536         if (flags & NDR_IN) {
16537         }
16538         if (flags & NDR_OUT) {
16539                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16540         }
16541         return NDR_ERR_SUCCESS;
16542 }
16543
16544 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
16545 {
16546         ndr_print_struct(ndr, name, "spoolss_56");
16547         ndr->depth++;
16548         if (flags & NDR_SET_VALUES) {
16549                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16550         }
16551         if (flags & NDR_IN) {
16552                 ndr_print_struct(ndr, "in", "spoolss_56");
16553                 ndr->depth++;
16554                 ndr->depth--;
16555         }
16556         if (flags & NDR_OUT) {
16557                 ndr_print_struct(ndr, "out", "spoolss_56");
16558                 ndr->depth++;
16559                 ndr_print_WERROR(ndr, "result", r->out.result);
16560                 ndr->depth--;
16561         }
16562         ndr->depth--;
16563 }
16564
16565 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
16566 {
16567         if (flags & NDR_IN) {
16568         }
16569         if (flags & NDR_OUT) {
16570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16571         }
16572         return NDR_ERR_SUCCESS;
16573 }
16574
16575 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
16576 {
16577         if (flags & NDR_IN) {
16578         }
16579         if (flags & NDR_OUT) {
16580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16581         }
16582         return NDR_ERR_SUCCESS;
16583 }
16584
16585 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
16586 {
16587         ndr_print_struct(ndr, name, "spoolss_57");
16588         ndr->depth++;
16589         if (flags & NDR_SET_VALUES) {
16590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16591         }
16592         if (flags & NDR_IN) {
16593                 ndr_print_struct(ndr, "in", "spoolss_57");
16594                 ndr->depth++;
16595                 ndr->depth--;
16596         }
16597         if (flags & NDR_OUT) {
16598                 ndr_print_struct(ndr, "out", "spoolss_57");
16599                 ndr->depth++;
16600                 ndr_print_WERROR(ndr, "result", r->out.result);
16601                 ndr->depth--;
16602         }
16603         ndr->depth--;
16604 }
16605
16606 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
16607 {
16608         if (flags & NDR_IN) {
16609                 if (r->in.handle == NULL) {
16610                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16611                 }
16612                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
16614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16615                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
16616                 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));
16617                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
16618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
16619                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
16620                 if (r->in.status_code == NULL) {
16621                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16622                 }
16623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
16624         }
16625         if (flags & NDR_OUT) {
16626                 if (r->out.out_data == NULL) {
16627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16628                 }
16629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
16630                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
16631                 if (r->out.needed == NULL) {
16632                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16633                 }
16634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16635                 if (r->out.status_code == NULL) {
16636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16637                 }
16638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
16639                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16640         }
16641         return NDR_ERR_SUCCESS;
16642 }
16643
16644 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
16645 {
16646         TALLOC_CTX *_mem_save_handle_0;
16647         TALLOC_CTX *_mem_save_needed_0;
16648         TALLOC_CTX *_mem_save_status_code_0;
16649         if (flags & NDR_IN) {
16650                 ZERO_STRUCT(r->out);
16651
16652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16653                         NDR_PULL_ALLOC(ndr, r->in.handle);
16654                 }
16655                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16656                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16657                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16659                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
16660                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
16661                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
16662                         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));
16663                 }
16664                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
16665                 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));
16666                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
16667                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
16668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
16669                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16670                         NDR_PULL_ALLOC(ndr, r->in.status_code);
16671                 }
16672                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
16673                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
16674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
16675                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
16676                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
16677                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
16678                 NDR_PULL_ALLOC(ndr, r->out.needed);
16679                 ZERO_STRUCTP(r->out.needed);
16680                 NDR_PULL_ALLOC(ndr, r->out.status_code);
16681                 *r->out.status_code = *r->in.status_code;
16682         }
16683         if (flags & NDR_OUT) {
16684                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
16685                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16686                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
16687                 }
16688                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
16689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16690                         NDR_PULL_ALLOC(ndr, r->out.needed);
16691                 }
16692                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16693                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16697                         NDR_PULL_ALLOC(ndr, r->out.status_code);
16698                 }
16699                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
16700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
16701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
16702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
16703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16704                 if (r->out.out_data) {
16705                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
16706                 }
16707         }
16708         return NDR_ERR_SUCCESS;
16709 }
16710
16711 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
16712 {
16713         ndr_print_struct(ndr, name, "spoolss_XcvData");
16714         ndr->depth++;
16715         if (flags & NDR_SET_VALUES) {
16716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16717         }
16718         if (flags & NDR_IN) {
16719                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
16720                 ndr->depth++;
16721                 ndr_print_ptr(ndr, "handle", r->in.handle);
16722                 ndr->depth++;
16723                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16724                 ndr->depth--;
16725                 ndr_print_string(ndr, "function_name", r->in.function_name);
16726                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
16727                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
16728                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
16729                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
16730                 ndr->depth++;
16731                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
16732                 ndr->depth--;
16733                 ndr->depth--;
16734         }
16735         if (flags & NDR_OUT) {
16736                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
16737                 ndr->depth++;
16738                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
16739                 ndr->depth++;
16740                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
16741                 ndr->depth--;
16742                 ndr_print_ptr(ndr, "needed", r->out.needed);
16743                 ndr->depth++;
16744                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16745                 ndr->depth--;
16746                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
16747                 ndr->depth++;
16748                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
16749                 ndr->depth--;
16750                 ndr_print_WERROR(ndr, "result", r->out.result);
16751                 ndr->depth--;
16752         }
16753         ndr->depth--;
16754 }
16755
16756 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
16757 {
16758         if (flags & NDR_IN) {
16759         }
16760         if (flags & NDR_OUT) {
16761                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16762         }
16763         return NDR_ERR_SUCCESS;
16764 }
16765
16766 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
16767 {
16768         if (flags & NDR_IN) {
16769         }
16770         if (flags & NDR_OUT) {
16771                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16772         }
16773         return NDR_ERR_SUCCESS;
16774 }
16775
16776 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
16777 {
16778         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
16779         ndr->depth++;
16780         if (flags & NDR_SET_VALUES) {
16781                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16782         }
16783         if (flags & NDR_IN) {
16784                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
16785                 ndr->depth++;
16786                 ndr->depth--;
16787         }
16788         if (flags & NDR_OUT) {
16789                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
16790                 ndr->depth++;
16791                 ndr_print_WERROR(ndr, "result", r->out.result);
16792                 ndr->depth--;
16793         }
16794         ndr->depth--;
16795 }
16796
16797 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
16798 {
16799         if (flags & NDR_IN) {
16800         }
16801         if (flags & NDR_OUT) {
16802                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16803         }
16804         return NDR_ERR_SUCCESS;
16805 }
16806
16807 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
16808 {
16809         if (flags & NDR_IN) {
16810         }
16811         if (flags & NDR_OUT) {
16812                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16813         }
16814         return NDR_ERR_SUCCESS;
16815 }
16816
16817 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
16818 {
16819         ndr_print_struct(ndr, name, "spoolss_5a");
16820         ndr->depth++;
16821         if (flags & NDR_SET_VALUES) {
16822                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16823         }
16824         if (flags & NDR_IN) {
16825                 ndr_print_struct(ndr, "in", "spoolss_5a");
16826                 ndr->depth++;
16827                 ndr->depth--;
16828         }
16829         if (flags & NDR_OUT) {
16830                 ndr_print_struct(ndr, "out", "spoolss_5a");
16831                 ndr->depth++;
16832                 ndr_print_WERROR(ndr, "result", r->out.result);
16833                 ndr->depth--;
16834         }
16835         ndr->depth--;
16836 }
16837
16838 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
16839 {
16840         if (flags & NDR_IN) {
16841         }
16842         if (flags & NDR_OUT) {
16843                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16844         }
16845         return NDR_ERR_SUCCESS;
16846 }
16847
16848 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
16849 {
16850         if (flags & NDR_IN) {
16851         }
16852         if (flags & NDR_OUT) {
16853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16854         }
16855         return NDR_ERR_SUCCESS;
16856 }
16857
16858 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
16859 {
16860         ndr_print_struct(ndr, name, "spoolss_5b");
16861         ndr->depth++;
16862         if (flags & NDR_SET_VALUES) {
16863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16864         }
16865         if (flags & NDR_IN) {
16866                 ndr_print_struct(ndr, "in", "spoolss_5b");
16867                 ndr->depth++;
16868                 ndr->depth--;
16869         }
16870         if (flags & NDR_OUT) {
16871                 ndr_print_struct(ndr, "out", "spoolss_5b");
16872                 ndr->depth++;
16873                 ndr_print_WERROR(ndr, "result", r->out.result);
16874                 ndr->depth--;
16875         }
16876         ndr->depth--;
16877 }
16878
16879 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
16880 {
16881         if (flags & NDR_IN) {
16882         }
16883         if (flags & NDR_OUT) {
16884                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16885         }
16886         return NDR_ERR_SUCCESS;
16887 }
16888
16889 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
16890 {
16891         if (flags & NDR_IN) {
16892         }
16893         if (flags & NDR_OUT) {
16894                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16895         }
16896         return NDR_ERR_SUCCESS;
16897 }
16898
16899 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
16900 {
16901         ndr_print_struct(ndr, name, "spoolss_5c");
16902         ndr->depth++;
16903         if (flags & NDR_SET_VALUES) {
16904                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16905         }
16906         if (flags & NDR_IN) {
16907                 ndr_print_struct(ndr, "in", "spoolss_5c");
16908                 ndr->depth++;
16909                 ndr->depth--;
16910         }
16911         if (flags & NDR_OUT) {
16912                 ndr_print_struct(ndr, "out", "spoolss_5c");
16913                 ndr->depth++;
16914                 ndr_print_WERROR(ndr, "result", r->out.result);
16915                 ndr->depth--;
16916         }
16917         ndr->depth--;
16918 }
16919
16920 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
16921 {
16922         if (flags & NDR_IN) {
16923         }
16924         if (flags & NDR_OUT) {
16925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16926         }
16927         return NDR_ERR_SUCCESS;
16928 }
16929
16930 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
16931 {
16932         if (flags & NDR_IN) {
16933         }
16934         if (flags & NDR_OUT) {
16935                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16936         }
16937         return NDR_ERR_SUCCESS;
16938 }
16939
16940 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
16941 {
16942         ndr_print_struct(ndr, name, "spoolss_5d");
16943         ndr->depth++;
16944         if (flags & NDR_SET_VALUES) {
16945                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16946         }
16947         if (flags & NDR_IN) {
16948                 ndr_print_struct(ndr, "in", "spoolss_5d");
16949                 ndr->depth++;
16950                 ndr->depth--;
16951         }
16952         if (flags & NDR_OUT) {
16953                 ndr_print_struct(ndr, "out", "spoolss_5d");
16954                 ndr->depth++;
16955                 ndr_print_WERROR(ndr, "result", r->out.result);
16956                 ndr->depth--;
16957         }
16958         ndr->depth--;
16959 }
16960
16961 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
16962 {
16963         if (flags & NDR_IN) {
16964         }
16965         if (flags & NDR_OUT) {
16966                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16967         }
16968         return NDR_ERR_SUCCESS;
16969 }
16970
16971 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
16972 {
16973         if (flags & NDR_IN) {
16974         }
16975         if (flags & NDR_OUT) {
16976                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16977         }
16978         return NDR_ERR_SUCCESS;
16979 }
16980
16981 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
16982 {
16983         ndr_print_struct(ndr, name, "spoolss_5e");
16984         ndr->depth++;
16985         if (flags & NDR_SET_VALUES) {
16986                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16987         }
16988         if (flags & NDR_IN) {
16989                 ndr_print_struct(ndr, "in", "spoolss_5e");
16990                 ndr->depth++;
16991                 ndr->depth--;
16992         }
16993         if (flags & NDR_OUT) {
16994                 ndr_print_struct(ndr, "out", "spoolss_5e");
16995                 ndr->depth++;
16996                 ndr_print_WERROR(ndr, "result", r->out.result);
16997                 ndr->depth--;
16998         }
16999         ndr->depth--;
17000 }
17001
17002 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
17003 {
17004         if (flags & NDR_IN) {
17005         }
17006         if (flags & NDR_OUT) {
17007                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
17008         }
17009         return NDR_ERR_SUCCESS;
17010 }
17011
17012 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
17013 {
17014         if (flags & NDR_IN) {
17015         }
17016         if (flags & NDR_OUT) {
17017                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
17018         }
17019         return NDR_ERR_SUCCESS;
17020 }
17021
17022 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
17023 {
17024         ndr_print_struct(ndr, name, "spoolss_5f");
17025         ndr->depth++;
17026         if (flags & NDR_SET_VALUES) {
17027                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
17028         }
17029         if (flags & NDR_IN) {
17030                 ndr_print_struct(ndr, "in", "spoolss_5f");
17031                 ndr->depth++;
17032                 ndr->depth--;
17033         }
17034         if (flags & NDR_OUT) {
17035                 ndr_print_struct(ndr, "out", "spoolss_5f");
17036                 ndr->depth++;
17037                 ndr_print_WERROR(ndr, "result", r->out.result);
17038                 ndr->depth--;
17039         }
17040         ndr->depth--;
17041 }
17042
17043 static const struct ndr_interface_call spoolss_calls[] = {
17044         {
17045                 "spoolss_EnumPrinters",
17046                 sizeof(struct spoolss_EnumPrinters),
17047                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
17048                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
17049                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
17050                 false,
17051         },
17052         {
17053                 "spoolss_OpenPrinter",
17054                 sizeof(struct spoolss_OpenPrinter),
17055                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
17056                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
17057                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
17058                 false,
17059         },
17060         {
17061                 "spoolss_SetJob",
17062                 sizeof(struct spoolss_SetJob),
17063                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
17064                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
17065                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
17066                 false,
17067         },
17068         {
17069                 "spoolss_GetJob",
17070                 sizeof(struct spoolss_GetJob),
17071                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
17072                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
17073                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
17074                 false,
17075         },
17076         {
17077                 "spoolss_EnumJobs",
17078                 sizeof(struct spoolss_EnumJobs),
17079                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
17080                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
17081                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
17082                 false,
17083         },
17084         {
17085                 "spoolss_AddPrinter",
17086                 sizeof(struct spoolss_AddPrinter),
17087                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
17088                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
17089                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
17090                 false,
17091         },
17092         {
17093                 "spoolss_DeletePrinter",
17094                 sizeof(struct spoolss_DeletePrinter),
17095                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
17096                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
17097                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
17098                 false,
17099         },
17100         {
17101                 "spoolss_SetPrinter",
17102                 sizeof(struct spoolss_SetPrinter),
17103                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
17104                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
17105                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
17106                 false,
17107         },
17108         {
17109                 "spoolss_GetPrinter",
17110                 sizeof(struct spoolss_GetPrinter),
17111                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
17112                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
17113                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
17114                 false,
17115         },
17116         {
17117                 "spoolss_AddPrinterDriver",
17118                 sizeof(struct spoolss_AddPrinterDriver),
17119                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
17120                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
17121                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
17122                 false,
17123         },
17124         {
17125                 "spoolss_EnumPrinterDrivers",
17126                 sizeof(struct spoolss_EnumPrinterDrivers),
17127                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
17128                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
17129                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
17130                 false,
17131         },
17132         {
17133                 "spoolss_GetPrinterDriver",
17134                 sizeof(struct spoolss_GetPrinterDriver),
17135                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
17136                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
17137                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
17138                 false,
17139         },
17140         {
17141                 "spoolss_GetPrinterDriverDirectory",
17142                 sizeof(struct spoolss_GetPrinterDriverDirectory),
17143                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
17144                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
17145                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
17146                 false,
17147         },
17148         {
17149                 "spoolss_DeletePrinterDriver",
17150                 sizeof(struct spoolss_DeletePrinterDriver),
17151                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
17152                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
17153                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
17154                 false,
17155         },
17156         {
17157                 "spoolss_AddPrintProcessor",
17158                 sizeof(struct spoolss_AddPrintProcessor),
17159                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
17160                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
17161                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
17162                 false,
17163         },
17164         {
17165                 "spoolss_EnumPrintProcessors",
17166                 sizeof(struct spoolss_EnumPrintProcessors),
17167                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
17168                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
17169                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
17170                 false,
17171         },
17172         {
17173                 "spoolss_GetPrintProcessorDirectory",
17174                 sizeof(struct spoolss_GetPrintProcessorDirectory),
17175                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
17176                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
17177                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
17178                 false,
17179         },
17180         {
17181                 "spoolss_StartDocPrinter",
17182                 sizeof(struct spoolss_StartDocPrinter),
17183                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
17184                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
17185                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
17186                 false,
17187         },
17188         {
17189                 "spoolss_StartPagePrinter",
17190                 sizeof(struct spoolss_StartPagePrinter),
17191                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
17192                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
17193                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
17194                 false,
17195         },
17196         {
17197                 "spoolss_WritePrinter",
17198                 sizeof(struct spoolss_WritePrinter),
17199                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
17200                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
17201                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
17202                 false,
17203         },
17204         {
17205                 "spoolss_EndPagePrinter",
17206                 sizeof(struct spoolss_EndPagePrinter),
17207                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
17208                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
17209                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
17210                 false,
17211         },
17212         {
17213                 "spoolss_AbortPrinter",
17214                 sizeof(struct spoolss_AbortPrinter),
17215                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
17216                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
17217                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
17218                 false,
17219         },
17220         {
17221                 "spoolss_ReadPrinter",
17222                 sizeof(struct spoolss_ReadPrinter),
17223                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
17224                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
17225                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
17226                 false,
17227         },
17228         {
17229                 "spoolss_EndDocPrinter",
17230                 sizeof(struct spoolss_EndDocPrinter),
17231                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
17232                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
17233                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
17234                 false,
17235         },
17236         {
17237                 "spoolss_AddJob",
17238                 sizeof(struct spoolss_AddJob),
17239                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
17240                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
17241                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
17242                 false,
17243         },
17244         {
17245                 "spoolss_ScheduleJob",
17246                 sizeof(struct spoolss_ScheduleJob),
17247                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
17248                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
17249                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
17250                 false,
17251         },
17252         {
17253                 "spoolss_GetPrinterData",
17254                 sizeof(struct spoolss_GetPrinterData),
17255                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
17256                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
17257                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
17258                 false,
17259         },
17260         {
17261                 "spoolss_SetPrinterData",
17262                 sizeof(struct spoolss_SetPrinterData),
17263                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
17264                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
17265                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
17266                 false,
17267         },
17268         {
17269                 "spoolss_WaitForPrinterChange",
17270                 sizeof(struct spoolss_WaitForPrinterChange),
17271                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
17272                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
17273                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
17274                 false,
17275         },
17276         {
17277                 "spoolss_ClosePrinter",
17278                 sizeof(struct spoolss_ClosePrinter),
17279                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
17280                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
17281                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
17282                 false,
17283         },
17284         {
17285                 "spoolss_AddForm",
17286                 sizeof(struct spoolss_AddForm),
17287                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
17288                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
17289                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
17290                 false,
17291         },
17292         {
17293                 "spoolss_DeleteForm",
17294                 sizeof(struct spoolss_DeleteForm),
17295                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
17296                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
17297                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
17298                 false,
17299         },
17300         {
17301                 "spoolss_GetForm",
17302                 sizeof(struct spoolss_GetForm),
17303                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
17304                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
17305                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
17306                 false,
17307         },
17308         {
17309                 "spoolss_SetForm",
17310                 sizeof(struct spoolss_SetForm),
17311                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
17312                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
17313                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
17314                 false,
17315         },
17316         {
17317                 "spoolss_EnumForms",
17318                 sizeof(struct spoolss_EnumForms),
17319                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
17320                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
17321                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
17322                 false,
17323         },
17324         {
17325                 "spoolss_EnumPorts",
17326                 sizeof(struct spoolss_EnumPorts),
17327                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
17328                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
17329                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
17330                 false,
17331         },
17332         {
17333                 "spoolss_EnumMonitors",
17334                 sizeof(struct spoolss_EnumMonitors),
17335                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
17336                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
17337                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
17338                 false,
17339         },
17340         {
17341                 "spoolss_AddPort",
17342                 sizeof(struct spoolss_AddPort),
17343                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
17344                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
17345                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
17346                 false,
17347         },
17348         {
17349                 "spoolss_ConfigurePort",
17350                 sizeof(struct spoolss_ConfigurePort),
17351                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
17352                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
17353                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
17354                 false,
17355         },
17356         {
17357                 "spoolss_DeletePort",
17358                 sizeof(struct spoolss_DeletePort),
17359                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
17360                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
17361                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
17362                 false,
17363         },
17364         {
17365                 "spoolss_CreatePrinterIC",
17366                 sizeof(struct spoolss_CreatePrinterIC),
17367                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
17368                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
17369                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
17370                 false,
17371         },
17372         {
17373                 "spoolss_PlayGDIScriptOnPrinterIC",
17374                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
17375                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
17376                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
17377                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
17378                 false,
17379         },
17380         {
17381                 "spoolss_DeletePrinterIC",
17382                 sizeof(struct spoolss_DeletePrinterIC),
17383                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
17384                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
17385                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
17386                 false,
17387         },
17388         {
17389                 "spoolss_AddPrinterConnection",
17390                 sizeof(struct spoolss_AddPrinterConnection),
17391                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
17392                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
17393                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
17394                 false,
17395         },
17396         {
17397                 "spoolss_DeletePrinterConnection",
17398                 sizeof(struct spoolss_DeletePrinterConnection),
17399                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
17400                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
17401                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
17402                 false,
17403         },
17404         {
17405                 "spoolss_PrinterMessageBox",
17406                 sizeof(struct spoolss_PrinterMessageBox),
17407                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
17408                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
17409                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
17410                 false,
17411         },
17412         {
17413                 "spoolss_AddMonitor",
17414                 sizeof(struct spoolss_AddMonitor),
17415                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
17416                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
17417                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
17418                 false,
17419         },
17420         {
17421                 "spoolss_DeleteMonitor",
17422                 sizeof(struct spoolss_DeleteMonitor),
17423                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
17424                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
17425                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
17426                 false,
17427         },
17428         {
17429                 "spoolss_DeletePrintProcessor",
17430                 sizeof(struct spoolss_DeletePrintProcessor),
17431                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
17432                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
17433                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
17434                 false,
17435         },
17436         {
17437                 "spoolss_AddPrintProvidor",
17438                 sizeof(struct spoolss_AddPrintProvidor),
17439                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
17440                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
17441                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
17442                 false,
17443         },
17444         {
17445                 "spoolss_DeletePrintProvidor",
17446                 sizeof(struct spoolss_DeletePrintProvidor),
17447                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
17448                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
17449                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
17450                 false,
17451         },
17452         {
17453                 "spoolss_EnumPrintProcDataTypes",
17454                 sizeof(struct spoolss_EnumPrintProcDataTypes),
17455                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
17456                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
17457                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
17458                 false,
17459         },
17460         {
17461                 "spoolss_ResetPrinter",
17462                 sizeof(struct spoolss_ResetPrinter),
17463                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
17464                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
17465                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
17466                 false,
17467         },
17468         {
17469                 "spoolss_GetPrinterDriver2",
17470                 sizeof(struct spoolss_GetPrinterDriver2),
17471                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
17472                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
17473                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
17474                 false,
17475         },
17476         {
17477                 "spoolss_FindFirstPrinterChangeNotification",
17478                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
17479                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
17480                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
17481                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
17482                 false,
17483         },
17484         {
17485                 "spoolss_FindNextPrinterChangeNotification",
17486                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
17487                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
17488                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
17489                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
17490                 false,
17491         },
17492         {
17493                 "spoolss_FindClosePrinterNotify",
17494                 sizeof(struct spoolss_FindClosePrinterNotify),
17495                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
17496                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
17497                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
17498                 false,
17499         },
17500         {
17501                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
17502                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
17503                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
17504                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
17505                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
17506                 false,
17507         },
17508         {
17509                 "spoolss_ReplyOpenPrinter",
17510                 sizeof(struct spoolss_ReplyOpenPrinter),
17511                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
17512                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
17513                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
17514                 false,
17515         },
17516         {
17517                 "spoolss_RouterReplyPrinter",
17518                 sizeof(struct spoolss_RouterReplyPrinter),
17519                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
17520                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
17521                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
17522                 false,
17523         },
17524         {
17525                 "spoolss_ReplyClosePrinter",
17526                 sizeof(struct spoolss_ReplyClosePrinter),
17527                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
17528                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
17529                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
17530                 false,
17531         },
17532         {
17533                 "spoolss_AddPortEx",
17534                 sizeof(struct spoolss_AddPortEx),
17535                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
17536                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
17537                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
17538                 false,
17539         },
17540         {
17541                 "spoolss_RouterFindFirstPrinterChangeNotification",
17542                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
17543                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
17544                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
17545                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
17546                 false,
17547         },
17548         {
17549                 "spoolss_SpoolerInit",
17550                 sizeof(struct spoolss_SpoolerInit),
17551                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
17552                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
17553                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
17554                 false,
17555         },
17556         {
17557                 "spoolss_ResetPrinterEx",
17558                 sizeof(struct spoolss_ResetPrinterEx),
17559                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
17560                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
17561                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
17562                 false,
17563         },
17564         {
17565                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
17566                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
17567                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
17568                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
17569                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
17570                 false,
17571         },
17572         {
17573                 "spoolss_RouterRefreshPrinterChangeNotification",
17574                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotification),
17575                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotification,
17576                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotification,
17577                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotification,
17578                 false,
17579         },
17580         {
17581                 "spoolss_RemoteFindNextPrinterChangeNotifyEx",
17582                 sizeof(struct spoolss_RemoteFindNextPrinterChangeNotifyEx),
17583                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindNextPrinterChangeNotifyEx,
17584                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindNextPrinterChangeNotifyEx,
17585                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindNextPrinterChangeNotifyEx,
17586                 false,
17587         },
17588         {
17589                 "spoolss_44",
17590                 sizeof(struct spoolss_44),
17591                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
17592                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
17593                 (ndr_print_function_t) ndr_print_spoolss_44,
17594                 false,
17595         },
17596         {
17597                 "spoolss_OpenPrinterEx",
17598                 sizeof(struct spoolss_OpenPrinterEx),
17599                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
17600                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
17601                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
17602                 false,
17603         },
17604         {
17605                 "spoolss_AddPrinterEx",
17606                 sizeof(struct spoolss_AddPrinterEx),
17607                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
17608                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
17609                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
17610                 false,
17611         },
17612         {
17613                 "spoolss_47",
17614                 sizeof(struct spoolss_47),
17615                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
17616                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
17617                 (ndr_print_function_t) ndr_print_spoolss_47,
17618                 false,
17619         },
17620         {
17621                 "spoolss_EnumPrinterData",
17622                 sizeof(struct spoolss_EnumPrinterData),
17623                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
17624                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
17625                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
17626                 false,
17627         },
17628         {
17629                 "spoolss_DeletePrinterData",
17630                 sizeof(struct spoolss_DeletePrinterData),
17631                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
17632                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
17633                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
17634                 false,
17635         },
17636         {
17637                 "spoolss_4a",
17638                 sizeof(struct spoolss_4a),
17639                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
17640                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
17641                 (ndr_print_function_t) ndr_print_spoolss_4a,
17642                 false,
17643         },
17644         {
17645                 "spoolss_4b",
17646                 sizeof(struct spoolss_4b),
17647                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
17648                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
17649                 (ndr_print_function_t) ndr_print_spoolss_4b,
17650                 false,
17651         },
17652         {
17653                 "spoolss_4c",
17654                 sizeof(struct spoolss_4c),
17655                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
17656                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
17657                 (ndr_print_function_t) ndr_print_spoolss_4c,
17658                 false,
17659         },
17660         {
17661                 "spoolss_SetPrinterDataEx",
17662                 sizeof(struct spoolss_SetPrinterDataEx),
17663                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
17664                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
17665                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
17666                 false,
17667         },
17668         {
17669                 "spoolss_GetPrinterDataEx",
17670                 sizeof(struct spoolss_GetPrinterDataEx),
17671                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
17672                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
17673                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
17674                 false,
17675         },
17676         {
17677                 "spoolss_EnumPrinterDataEx",
17678                 sizeof(struct spoolss_EnumPrinterDataEx),
17679                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
17680                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
17681                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
17682                 false,
17683         },
17684         {
17685                 "spoolss_EnumPrinterKey",
17686                 sizeof(struct spoolss_EnumPrinterKey),
17687                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
17688                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
17689                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
17690                 false,
17691         },
17692         {
17693                 "spoolss_DeletePrinterDataEx",
17694                 sizeof(struct spoolss_DeletePrinterDataEx),
17695                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
17696                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
17697                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
17698                 false,
17699         },
17700         {
17701                 "spoolss_DeletePrinterKey",
17702                 sizeof(struct spoolss_DeletePrinterKey),
17703                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
17704                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
17705                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
17706                 false,
17707         },
17708         {
17709                 "spoolss_53",
17710                 sizeof(struct spoolss_53),
17711                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
17712                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
17713                 (ndr_print_function_t) ndr_print_spoolss_53,
17714                 false,
17715         },
17716         {
17717                 "spoolss_DeletePrinterDriverEx",
17718                 sizeof(struct spoolss_DeletePrinterDriverEx),
17719                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
17720                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
17721                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
17722                 false,
17723         },
17724         {
17725                 "spoolss_55",
17726                 sizeof(struct spoolss_55),
17727                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
17728                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
17729                 (ndr_print_function_t) ndr_print_spoolss_55,
17730                 false,
17731         },
17732         {
17733                 "spoolss_56",
17734                 sizeof(struct spoolss_56),
17735                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
17736                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
17737                 (ndr_print_function_t) ndr_print_spoolss_56,
17738                 false,
17739         },
17740         {
17741                 "spoolss_57",
17742                 sizeof(struct spoolss_57),
17743                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
17744                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
17745                 (ndr_print_function_t) ndr_print_spoolss_57,
17746                 false,
17747         },
17748         {
17749                 "spoolss_XcvData",
17750                 sizeof(struct spoolss_XcvData),
17751                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
17752                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
17753                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
17754                 false,
17755         },
17756         {
17757                 "spoolss_AddPrinterDriverEx",
17758                 sizeof(struct spoolss_AddPrinterDriverEx),
17759                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
17760                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
17761                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
17762                 false,
17763         },
17764         {
17765                 "spoolss_5a",
17766                 sizeof(struct spoolss_5a),
17767                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
17768                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
17769                 (ndr_print_function_t) ndr_print_spoolss_5a,
17770                 false,
17771         },
17772         {
17773                 "spoolss_5b",
17774                 sizeof(struct spoolss_5b),
17775                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
17776                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
17777                 (ndr_print_function_t) ndr_print_spoolss_5b,
17778                 false,
17779         },
17780         {
17781                 "spoolss_5c",
17782                 sizeof(struct spoolss_5c),
17783                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
17784                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
17785                 (ndr_print_function_t) ndr_print_spoolss_5c,
17786                 false,
17787         },
17788         {
17789                 "spoolss_5d",
17790                 sizeof(struct spoolss_5d),
17791                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
17792                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
17793                 (ndr_print_function_t) ndr_print_spoolss_5d,
17794                 false,
17795         },
17796         {
17797                 "spoolss_5e",
17798                 sizeof(struct spoolss_5e),
17799                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
17800                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
17801                 (ndr_print_function_t) ndr_print_spoolss_5e,
17802                 false,
17803         },
17804         {
17805                 "spoolss_5f",
17806                 sizeof(struct spoolss_5f),
17807                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
17808                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
17809                 (ndr_print_function_t) ndr_print_spoolss_5f,
17810                 false,
17811         },
17812         { NULL, 0, NULL, NULL, NULL, false }
17813 };
17814
17815 static const char * const spoolss_endpoint_strings[] = {
17816         "ncacn_np:[\\pipe\\spoolss]",
17817 };
17818
17819 static const struct ndr_interface_string_array spoolss_endpoints = {
17820         .count  = 1,
17821         .names  = spoolss_endpoint_strings
17822 };
17823
17824 static const char * const spoolss_authservice_strings[] = {
17825         "host",
17826 };
17827
17828 static const struct ndr_interface_string_array spoolss_authservices = {
17829         .count  = 1,
17830         .names  = spoolss_authservice_strings
17831 };
17832
17833
17834 const struct ndr_interface_table ndr_table_spoolss = {
17835         .name           = "spoolss",
17836         .syntax_id      = {
17837                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
17838                 NDR_SPOOLSS_VERSION
17839         },
17840         .helpstring     = NDR_SPOOLSS_HELPSTRING,
17841         .num_calls      = 114,
17842         .calls          = spoolss_calls,
17843         .endpoints      = &spoolss_endpoints,
17844         .authservices   = &spoolss_authservices
17845 };
17846