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(CONST_DISCARD(struct spoolss_ReadPrinter *,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         }
11669         if (flags & NDR_OUT) {
11670                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11671         }
11672         return NDR_ERR_SUCCESS;
11673 }
11674
11675 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
11676 {
11677         if (flags & NDR_IN) {
11678         }
11679         if (flags & NDR_OUT) {
11680                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11681         }
11682         return NDR_ERR_SUCCESS;
11683 }
11684
11685 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
11686 {
11687         ndr_print_struct(ndr, name, "spoolss_AddJob");
11688         ndr->depth++;
11689         if (flags & NDR_SET_VALUES) {
11690                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11691         }
11692         if (flags & NDR_IN) {
11693                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
11694                 ndr->depth++;
11695                 ndr->depth--;
11696         }
11697         if (flags & NDR_OUT) {
11698                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
11699                 ndr->depth++;
11700                 ndr_print_WERROR(ndr, "result", r->out.result);
11701                 ndr->depth--;
11702         }
11703         ndr->depth--;
11704 }
11705
11706 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
11707 {
11708         if (flags & NDR_IN) {
11709         }
11710         if (flags & NDR_OUT) {
11711                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11712         }
11713         return NDR_ERR_SUCCESS;
11714 }
11715
11716 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
11717 {
11718         if (flags & NDR_IN) {
11719         }
11720         if (flags & NDR_OUT) {
11721                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11722         }
11723         return NDR_ERR_SUCCESS;
11724 }
11725
11726 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
11727 {
11728         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
11729         ndr->depth++;
11730         if (flags & NDR_SET_VALUES) {
11731                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11732         }
11733         if (flags & NDR_IN) {
11734                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
11735                 ndr->depth++;
11736                 ndr->depth--;
11737         }
11738         if (flags & NDR_OUT) {
11739                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
11740                 ndr->depth++;
11741                 ndr_print_WERROR(ndr, "result", r->out.result);
11742                 ndr->depth--;
11743         }
11744         ndr->depth--;
11745 }
11746
11747 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
11748 {
11749         if (flags & NDR_IN) {
11750                 if (r->in.handle == NULL) {
11751                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11752                 }
11753                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11757                 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));
11758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11759         }
11760         if (flags & NDR_OUT) {
11761                 if (r->out.type == NULL) {
11762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11763                 }
11764                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
11765                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
11766                 if (r->out.needed == NULL) {
11767                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11768                 }
11769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
11770                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11771         }
11772         return NDR_ERR_SUCCESS;
11773 }
11774
11775 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
11776 {
11777         TALLOC_CTX *_mem_save_handle_0;
11778         TALLOC_CTX *_mem_save_type_0;
11779         TALLOC_CTX *_mem_save_needed_0;
11780         if (flags & NDR_IN) {
11781                 ZERO_STRUCT(r->out);
11782
11783                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11784                         NDR_PULL_ALLOC(ndr, r->in.handle);
11785                 }
11786                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11787                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11788                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11789                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11790                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
11791                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
11792                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
11793                         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));
11794                 }
11795                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
11796                 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));
11797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
11798                 NDR_PULL_ALLOC(ndr, r->out.type);
11799                 ZERO_STRUCTP(r->out.type);
11800                 NDR_PULL_ALLOC(ndr, r->out.needed);
11801                 ZERO_STRUCTP(r->out.needed);
11802         }
11803         if (flags & NDR_OUT) {
11804                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11805                         NDR_PULL_ALLOC(ndr, r->out.type);
11806                 }
11807                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
11808                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
11809                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
11810                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
11811                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
11812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11813                         NDR_PULL_ALLOC(ndr, r->out.needed);
11814                 }
11815                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
11816                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
11817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
11818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
11819                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11820         }
11821         return NDR_ERR_SUCCESS;
11822 }
11823
11824 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
11825 {
11826         if (flags & NDR_IN) {
11827                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11828         }
11829         if (flags & NDR_OUT) {
11830                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
11831                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11832         }
11833         return NDR_ERR_SUCCESS;
11834 }
11835
11836 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
11837 {
11838         if (flags & NDR_IN) {
11839                 ZERO_STRUCT(r->out);
11840
11841                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
11842         }
11843         if (flags & NDR_OUT) {
11844                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
11845                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11846         }
11847         return NDR_ERR_SUCCESS;
11848 }
11849
11850 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
11851 {
11852         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
11853         ndr->depth++;
11854         if (flags & NDR_SET_VALUES) {
11855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11856         }
11857         if (flags & NDR_IN) {
11858                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
11859                 ndr->depth++;
11860                 ndr_print_ptr(ndr, "handle", r->in.handle);
11861                 ndr->depth++;
11862                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11863                 ndr->depth--;
11864                 ndr_print_string(ndr, "value_name", r->in.value_name);
11865                 ndr_print_uint32(ndr, "offered", r->in.offered);
11866                 ndr->depth--;
11867         }
11868         if (flags & NDR_OUT) {
11869                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
11870                 ndr->depth++;
11871                 ndr_print_ptr(ndr, "type", r->out.type);
11872                 ndr->depth++;
11873                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
11874                 ndr->depth--;
11875                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
11876                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
11877                 ndr_print_ptr(ndr, "needed", r->out.needed);
11878                 ndr->depth++;
11879                 ndr_print_uint32(ndr, "needed", *r->out.needed);
11880                 ndr->depth--;
11881                 ndr_print_WERROR(ndr, "result", r->out.result);
11882                 ndr->depth--;
11883         }
11884         ndr->depth--;
11885 }
11886
11887 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
11888 {
11889         if (flags & NDR_IN) {
11890                 if (r->in.handle == NULL) {
11891                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11892                 }
11893                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11897                 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));
11898                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11899                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
11900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
11901         }
11902         if (flags & NDR_OUT) {
11903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11904         }
11905         return NDR_ERR_SUCCESS;
11906 }
11907
11908 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
11909 {
11910         if (flags & NDR_IN) {
11911                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11912         }
11913         if (flags & NDR_OUT) {
11914                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
11915                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11916         }
11917         return NDR_ERR_SUCCESS;
11918 }
11919
11920 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
11921 {
11922         TALLOC_CTX *_mem_save_handle_0;
11923         if (flags & NDR_IN) {
11924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11925                         NDR_PULL_ALLOC(ndr, r->in.handle);
11926                 }
11927                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11929                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11931                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
11932                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
11933                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
11934                         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));
11935                 }
11936                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
11937                 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));
11938                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
11939                 {
11940                         struct ndr_pull *_ndr_data;
11941                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
11942                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
11943                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
11944                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
11945                 }
11946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
11947         }
11948         if (flags & NDR_OUT) {
11949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11950         }
11951         return NDR_ERR_SUCCESS;
11952 }
11953
11954 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
11955 {
11956         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
11957         ndr->depth++;
11958         if (flags & NDR_SET_VALUES) {
11959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11960         }
11961         if (flags & NDR_IN) {
11962                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
11963                 ndr->depth++;
11964                 ndr_print_ptr(ndr, "handle", r->in.handle);
11965                 ndr->depth++;
11966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11967                 ndr->depth--;
11968                 ndr_print_string(ndr, "value_name", r->in.value_name);
11969                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
11970                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
11971                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
11972                 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);
11973                 ndr->depth--;
11974         }
11975         if (flags & NDR_OUT) {
11976                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
11977                 ndr->depth++;
11978                 ndr_print_WERROR(ndr, "result", r->out.result);
11979                 ndr->depth--;
11980         }
11981         ndr->depth--;
11982 }
11983
11984 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
11985 {
11986         if (flags & NDR_IN) {
11987         }
11988         if (flags & NDR_OUT) {
11989                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11990         }
11991         return NDR_ERR_SUCCESS;
11992 }
11993
11994 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
11995 {
11996         if (flags & NDR_IN) {
11997         }
11998         if (flags & NDR_OUT) {
11999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12000         }
12001         return NDR_ERR_SUCCESS;
12002 }
12003
12004 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
12005 {
12006         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
12007         ndr->depth++;
12008         if (flags & NDR_SET_VALUES) {
12009                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12010         }
12011         if (flags & NDR_IN) {
12012                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
12013                 ndr->depth++;
12014                 ndr->depth--;
12015         }
12016         if (flags & NDR_OUT) {
12017                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
12018                 ndr->depth++;
12019                 ndr_print_WERROR(ndr, "result", r->out.result);
12020                 ndr->depth--;
12021         }
12022         ndr->depth--;
12023 }
12024
12025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
12026 {
12027         if (flags & NDR_IN) {
12028                 if (r->in.handle == NULL) {
12029                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12030                 }
12031                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12032         }
12033         if (flags & NDR_OUT) {
12034                 if (r->out.handle == NULL) {
12035                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12036                 }
12037                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
12038                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12039         }
12040         return NDR_ERR_SUCCESS;
12041 }
12042
12043 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
12044 {
12045         TALLOC_CTX *_mem_save_handle_0;
12046         if (flags & NDR_IN) {
12047                 ZERO_STRUCT(r->out);
12048
12049                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12050                         NDR_PULL_ALLOC(ndr, r->in.handle);
12051                 }
12052                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12053                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12054                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12055                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12056                 NDR_PULL_ALLOC(ndr, r->out.handle);
12057                 *r->out.handle = *r->in.handle;
12058         }
12059         if (flags & NDR_OUT) {
12060                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12061                         NDR_PULL_ALLOC(ndr, r->out.handle);
12062                 }
12063                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12064                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
12065                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
12066                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12067                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12068         }
12069         return NDR_ERR_SUCCESS;
12070 }
12071
12072 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
12073 {
12074         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
12075         ndr->depth++;
12076         if (flags & NDR_SET_VALUES) {
12077                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12078         }
12079         if (flags & NDR_IN) {
12080                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
12081                 ndr->depth++;
12082                 ndr_print_ptr(ndr, "handle", r->in.handle);
12083                 ndr->depth++;
12084                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12085                 ndr->depth--;
12086                 ndr->depth--;
12087         }
12088         if (flags & NDR_OUT) {
12089                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
12090                 ndr->depth++;
12091                 ndr_print_ptr(ndr, "handle", r->out.handle);
12092                 ndr->depth++;
12093                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
12094                 ndr->depth--;
12095                 ndr_print_WERROR(ndr, "result", r->out.result);
12096                 ndr->depth--;
12097         }
12098         ndr->depth--;
12099 }
12100
12101 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
12102 {
12103         if (flags & NDR_IN) {
12104                 if (r->in.handle == NULL) {
12105                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12106                 }
12107                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12109                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
12110                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12111         }
12112         if (flags & NDR_OUT) {
12113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12114         }
12115         return NDR_ERR_SUCCESS;
12116 }
12117
12118 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
12119 {
12120         TALLOC_CTX *_mem_save_handle_0;
12121         if (flags & NDR_IN) {
12122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12123                         NDR_PULL_ALLOC(ndr, r->in.handle);
12124                 }
12125                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12126                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12127                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12129                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12130                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
12131                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12132         }
12133         if (flags & NDR_OUT) {
12134                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12135         }
12136         return NDR_ERR_SUCCESS;
12137 }
12138
12139 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
12140 {
12141         ndr_print_struct(ndr, name, "spoolss_AddForm");
12142         ndr->depth++;
12143         if (flags & NDR_SET_VALUES) {
12144                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12145         }
12146         if (flags & NDR_IN) {
12147                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
12148                 ndr->depth++;
12149                 ndr_print_ptr(ndr, "handle", r->in.handle);
12150                 ndr->depth++;
12151                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12152                 ndr->depth--;
12153                 ndr_print_uint32(ndr, "level", r->in.level);
12154                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
12155                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
12156                 ndr->depth--;
12157         }
12158         if (flags & NDR_OUT) {
12159                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
12160                 ndr->depth++;
12161                 ndr_print_WERROR(ndr, "result", r->out.result);
12162                 ndr->depth--;
12163         }
12164         ndr->depth--;
12165 }
12166
12167 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
12168 {
12169         if (flags & NDR_IN) {
12170                 if (r->in.handle == NULL) {
12171                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12172                 }
12173                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12177                 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));
12178         }
12179         if (flags & NDR_OUT) {
12180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12181         }
12182         return NDR_ERR_SUCCESS;
12183 }
12184
12185 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
12186 {
12187         TALLOC_CTX *_mem_save_handle_0;
12188         if (flags & NDR_IN) {
12189                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12190                         NDR_PULL_ALLOC(ndr, r->in.handle);
12191                 }
12192                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12193                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12194                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12196                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12197                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12198                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12199                         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));
12200                 }
12201                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12202                 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));
12203         }
12204         if (flags & NDR_OUT) {
12205                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12206         }
12207         return NDR_ERR_SUCCESS;
12208 }
12209
12210 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
12211 {
12212         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
12213         ndr->depth++;
12214         if (flags & NDR_SET_VALUES) {
12215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12216         }
12217         if (flags & NDR_IN) {
12218                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
12219                 ndr->depth++;
12220                 ndr_print_ptr(ndr, "handle", r->in.handle);
12221                 ndr->depth++;
12222                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12223                 ndr->depth--;
12224                 ndr_print_string(ndr, "form_name", r->in.form_name);
12225                 ndr->depth--;
12226         }
12227         if (flags & NDR_OUT) {
12228                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
12229                 ndr->depth++;
12230                 ndr_print_WERROR(ndr, "result", r->out.result);
12231                 ndr->depth--;
12232         }
12233         ndr->depth--;
12234 }
12235
12236 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
12237 {
12238         if (flags & NDR_IN) {
12239                 if (r->in.handle == NULL) {
12240                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12241                 }
12242                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12246                 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));
12247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12249                 if (r->in.buffer) {
12250                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12251                 }
12252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12253         }
12254         if (flags & NDR_OUT) {
12255                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12256                 if (r->out.info) {
12257                         {
12258                                 struct ndr_push *_ndr_info;
12259                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12260                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
12261                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12262                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12263                         }
12264                 }
12265                 if (r->out.needed == NULL) {
12266                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12267                 }
12268                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12269                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12270         }
12271         return NDR_ERR_SUCCESS;
12272 }
12273
12274 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
12275 {
12276         uint32_t _ptr_buffer;
12277         uint32_t _ptr_info;
12278         TALLOC_CTX *_mem_save_handle_0;
12279         TALLOC_CTX *_mem_save_buffer_0;
12280         TALLOC_CTX *_mem_save_info_0;
12281         TALLOC_CTX *_mem_save_needed_0;
12282         if (flags & NDR_IN) {
12283                 ZERO_STRUCT(r->out);
12284
12285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12286                         NDR_PULL_ALLOC(ndr, r->in.handle);
12287                 }
12288                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12289                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12290                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12292                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12293                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12294                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12295                         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));
12296                 }
12297                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12298                 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));
12299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12301                 if (_ptr_buffer) {
12302                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12303                 } else {
12304                         r->in.buffer = NULL;
12305                 }
12306                 if (r->in.buffer) {
12307                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12308                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12309                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12311                 }
12312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12313                 NDR_PULL_ALLOC(ndr, r->out.needed);
12314                 ZERO_STRUCTP(r->out.needed);
12315         }
12316         if (flags & NDR_OUT) {
12317                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12318                 if (_ptr_info) {
12319                         NDR_PULL_ALLOC(ndr, r->out.info);
12320                 } else {
12321                         r->out.info = NULL;
12322                 }
12323                 if (r->out.info) {
12324                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12325                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12326                         {
12327                                 struct ndr_pull *_ndr_info;
12328                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12329                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
12330                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12331                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12332                         }
12333                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12334                 }
12335                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12336                         NDR_PULL_ALLOC(ndr, r->out.needed);
12337                 }
12338                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12339                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12341                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12342                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12343         }
12344         return NDR_ERR_SUCCESS;
12345 }
12346
12347 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
12348 {
12349         ndr_print_struct(ndr, name, "spoolss_GetForm");
12350         ndr->depth++;
12351         if (flags & NDR_SET_VALUES) {
12352                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12353         }
12354         if (flags & NDR_IN) {
12355                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
12356                 ndr->depth++;
12357                 ndr_print_ptr(ndr, "handle", r->in.handle);
12358                 ndr->depth++;
12359                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12360                 ndr->depth--;
12361                 ndr_print_string(ndr, "form_name", r->in.form_name);
12362                 ndr_print_uint32(ndr, "level", r->in.level);
12363                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12364                 ndr->depth++;
12365                 if (r->in.buffer) {
12366                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12367                 }
12368                 ndr->depth--;
12369                 ndr_print_uint32(ndr, "offered", r->in.offered);
12370                 ndr->depth--;
12371         }
12372         if (flags & NDR_OUT) {
12373                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
12374                 ndr->depth++;
12375                 ndr_print_ptr(ndr, "info", r->out.info);
12376                 ndr->depth++;
12377                 if (r->out.info) {
12378                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
12379                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
12380                 }
12381                 ndr->depth--;
12382                 ndr_print_ptr(ndr, "needed", r->out.needed);
12383                 ndr->depth++;
12384                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12385                 ndr->depth--;
12386                 ndr_print_WERROR(ndr, "result", r->out.result);
12387                 ndr->depth--;
12388         }
12389         ndr->depth--;
12390 }
12391
12392 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
12393 {
12394         if (flags & NDR_IN) {
12395                 if (r->in.handle == NULL) {
12396                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12397                 }
12398                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12402                 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));
12403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12404                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
12405                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12406         }
12407         if (flags & NDR_OUT) {
12408                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12409         }
12410         return NDR_ERR_SUCCESS;
12411 }
12412
12413 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
12414 {
12415         TALLOC_CTX *_mem_save_handle_0;
12416         if (flags & NDR_IN) {
12417                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12418                         NDR_PULL_ALLOC(ndr, r->in.handle);
12419                 }
12420                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12421                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12422                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12424                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12425                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12426                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12427                         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));
12428                 }
12429                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12430                 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));
12431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12432                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
12433                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12434         }
12435         if (flags & NDR_OUT) {
12436                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12437         }
12438         return NDR_ERR_SUCCESS;
12439 }
12440
12441 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
12442 {
12443         ndr_print_struct(ndr, name, "spoolss_SetForm");
12444         ndr->depth++;
12445         if (flags & NDR_SET_VALUES) {
12446                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12447         }
12448         if (flags & NDR_IN) {
12449                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
12450                 ndr->depth++;
12451                 ndr_print_ptr(ndr, "handle", r->in.handle);
12452                 ndr->depth++;
12453                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12454                 ndr->depth--;
12455                 ndr_print_string(ndr, "form_name", r->in.form_name);
12456                 ndr_print_uint32(ndr, "level", r->in.level);
12457                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
12458                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
12459                 ndr->depth--;
12460         }
12461         if (flags & NDR_OUT) {
12462                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
12463                 ndr->depth++;
12464                 ndr_print_WERROR(ndr, "result", r->out.result);
12465                 ndr->depth--;
12466         }
12467         ndr->depth--;
12468 }
12469
12470 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
12471 {
12472         if (flags & NDR_IN) {
12473                 if (r->in.handle == NULL) {
12474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12475                 }
12476                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12478                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12479                 if (r->in.buffer) {
12480                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12481                 }
12482                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12483         }
12484         if (flags & NDR_OUT) {
12485                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12486                 if (r->out.info) {
12487                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12488                 }
12489                 if (r->out.needed == NULL) {
12490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12491                 }
12492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12495         }
12496         return NDR_ERR_SUCCESS;
12497 }
12498
12499 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
12500 {
12501         uint32_t _ptr_buffer;
12502         uint32_t _ptr_info;
12503         TALLOC_CTX *_mem_save_handle_0;
12504         TALLOC_CTX *_mem_save_buffer_0;
12505         TALLOC_CTX *_mem_save_info_0;
12506         TALLOC_CTX *_mem_save_needed_0;
12507         if (flags & NDR_IN) {
12508                 ZERO_STRUCT(r->out);
12509
12510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12511                         NDR_PULL_ALLOC(ndr, r->in.handle);
12512                 }
12513                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12514                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12515                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12519                 if (_ptr_buffer) {
12520                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12521                 } else {
12522                         r->in.buffer = NULL;
12523                 }
12524                 if (r->in.buffer) {
12525                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12526                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12527                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12528                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12529                 }
12530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12531                 NDR_PULL_ALLOC(ndr, r->out.needed);
12532                 ZERO_STRUCTP(r->out.needed);
12533         }
12534         if (flags & NDR_OUT) {
12535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12536                 if (_ptr_info) {
12537                         NDR_PULL_ALLOC(ndr, r->out.info);
12538                 } else {
12539                         r->out.info = NULL;
12540                 }
12541                 if (r->out.info) {
12542                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12543                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12544                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12546                 }
12547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12548                         NDR_PULL_ALLOC(ndr, r->out.needed);
12549                 }
12550                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12556         }
12557         return NDR_ERR_SUCCESS;
12558 }
12559
12560 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
12561 {
12562         uint32_t cntr_info_0;
12563         if (flags & NDR_IN) {
12564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12566         }
12567         if (flags & NDR_OUT) {
12568                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12569                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12570                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12571                 }
12572                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12573                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12574                 }
12575         }
12576         return NDR_ERR_SUCCESS;
12577 }
12578
12579 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
12580 {
12581         uint32_t cntr_info_0;
12582         TALLOC_CTX *_mem_save_info_0;
12583         if (flags & NDR_IN) {
12584                 ZERO_STRUCT(r->out);
12585
12586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12588         }
12589         if (flags & NDR_OUT) {
12590                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12591                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12592                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12593                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12594                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12595                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12596                 }
12597                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12598                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12599                 }
12600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12601         }
12602         return NDR_ERR_SUCCESS;
12603 }
12604
12605 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
12606 {
12607         uint32_t cntr_info_1;
12608         ndr_print_struct(ndr, name, "spoolss_EnumForms");
12609         ndr->depth++;
12610         if (flags & NDR_SET_VALUES) {
12611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12612         }
12613         if (flags & NDR_IN) {
12614                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
12615                 ndr->depth++;
12616                 ndr_print_ptr(ndr, "handle", r->in.handle);
12617                 ndr->depth++;
12618                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12619                 ndr->depth--;
12620                 ndr_print_uint32(ndr, "level", r->in.level);
12621                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12622                 ndr->depth++;
12623                 if (r->in.buffer) {
12624                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12625                 }
12626                 ndr->depth--;
12627                 ndr_print_uint32(ndr, "offered", r->in.offered);
12628                 ndr->depth--;
12629         }
12630         if (flags & NDR_OUT) {
12631                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
12632                 ndr->depth++;
12633                 ndr_print_ptr(ndr, "info", r->out.info);
12634                 ndr->depth++;
12635                 if (r->out.info) {
12636                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12637                         ndr->depth++;
12638                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12639                                 char *idx_1=NULL;
12640                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12641                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12642                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
12643                                         free(idx_1);
12644                                 }
12645                         }
12646                         ndr->depth--;
12647                 }
12648                 ndr->depth--;
12649                 ndr_print_ptr(ndr, "needed", r->out.needed);
12650                 ndr->depth++;
12651                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12652                 ndr->depth--;
12653                 ndr_print_uint32(ndr, "count", r->out.count);
12654                 ndr_print_WERROR(ndr, "result", r->out.result);
12655                 ndr->depth--;
12656         }
12657         ndr->depth--;
12658 }
12659
12660 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
12661 {
12662         if (flags & NDR_IN) {
12663                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
12664                 if (r->in.servername) {
12665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12666                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12668                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12669                 }
12670                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12671                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12672                 if (r->in.buffer) {
12673                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12674                 }
12675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12676         }
12677         if (flags & NDR_OUT) {
12678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12679                 if (r->out.info) {
12680                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12681                 }
12682                 if (r->out.needed == NULL) {
12683                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12684                 }
12685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12687                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12688         }
12689         return NDR_ERR_SUCCESS;
12690 }
12691
12692 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
12693 {
12694         uint32_t _ptr_servername;
12695         uint32_t _ptr_buffer;
12696         uint32_t _ptr_info;
12697         TALLOC_CTX *_mem_save_servername_0;
12698         TALLOC_CTX *_mem_save_buffer_0;
12699         TALLOC_CTX *_mem_save_info_0;
12700         TALLOC_CTX *_mem_save_needed_0;
12701         if (flags & NDR_IN) {
12702                 ZERO_STRUCT(r->out);
12703
12704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
12705                 if (_ptr_servername) {
12706                         NDR_PULL_ALLOC(ndr, r->in.servername);
12707                 } else {
12708                         r->in.servername = NULL;
12709                 }
12710                 if (r->in.servername) {
12711                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
12712                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
12713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
12714                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
12715                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
12716                                 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));
12717                         }
12718                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
12719                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
12720                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
12721                 }
12722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12723                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12724                 if (_ptr_buffer) {
12725                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12726                 } else {
12727                         r->in.buffer = NULL;
12728                 }
12729                 if (r->in.buffer) {
12730                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12731                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12732                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12734                 }
12735                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12736                 NDR_PULL_ALLOC(ndr, r->out.needed);
12737                 ZERO_STRUCTP(r->out.needed);
12738         }
12739         if (flags & NDR_OUT) {
12740                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12741                 if (_ptr_info) {
12742                         NDR_PULL_ALLOC(ndr, r->out.info);
12743                 } else {
12744                         r->out.info = NULL;
12745                 }
12746                 if (r->out.info) {
12747                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12748                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12749                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12750                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12751                 }
12752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12753                         NDR_PULL_ALLOC(ndr, r->out.needed);
12754                 }
12755                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12756                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12759                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12760                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12761         }
12762         return NDR_ERR_SUCCESS;
12763 }
12764
12765 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
12766 {
12767         uint32_t cntr_info_0;
12768         if (flags & NDR_IN) {
12769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12771         }
12772         if (flags & NDR_OUT) {
12773                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12774                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12775                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12776                 }
12777                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12778                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12779                 }
12780         }
12781         return NDR_ERR_SUCCESS;
12782 }
12783
12784 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
12785 {
12786         uint32_t cntr_info_0;
12787         TALLOC_CTX *_mem_save_info_0;
12788         if (flags & NDR_IN) {
12789                 ZERO_STRUCT(r->out);
12790
12791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12793         }
12794         if (flags & NDR_OUT) {
12795                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12796                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12797                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12798                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12799                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12800                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12801                 }
12802                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12803                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12804                 }
12805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12806         }
12807         return NDR_ERR_SUCCESS;
12808 }
12809
12810 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
12811 {
12812         uint32_t cntr_info_1;
12813         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
12814         ndr->depth++;
12815         if (flags & NDR_SET_VALUES) {
12816                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12817         }
12818         if (flags & NDR_IN) {
12819                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
12820                 ndr->depth++;
12821                 ndr_print_ptr(ndr, "servername", r->in.servername);
12822                 ndr->depth++;
12823                 if (r->in.servername) {
12824                         ndr_print_string(ndr, "servername", r->in.servername);
12825                 }
12826                 ndr->depth--;
12827                 ndr_print_uint32(ndr, "level", r->in.level);
12828                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12829                 ndr->depth++;
12830                 if (r->in.buffer) {
12831                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12832                 }
12833                 ndr->depth--;
12834                 ndr_print_uint32(ndr, "offered", r->in.offered);
12835                 ndr->depth--;
12836         }
12837         if (flags & NDR_OUT) {
12838                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
12839                 ndr->depth++;
12840                 ndr_print_ptr(ndr, "info", r->out.info);
12841                 ndr->depth++;
12842                 if (r->out.info) {
12843                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12844                         ndr->depth++;
12845                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12846                                 char *idx_1=NULL;
12847                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12848                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12849                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
12850                                         free(idx_1);
12851                                 }
12852                         }
12853                         ndr->depth--;
12854                 }
12855                 ndr->depth--;
12856                 ndr_print_ptr(ndr, "needed", r->out.needed);
12857                 ndr->depth++;
12858                 ndr_print_uint32(ndr, "needed", *r->out.needed);
12859                 ndr->depth--;
12860                 ndr_print_uint32(ndr, "count", r->out.count);
12861                 ndr_print_WERROR(ndr, "result", r->out.result);
12862                 ndr->depth--;
12863         }
12864         ndr->depth--;
12865 }
12866
12867 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
12868 {
12869         if (flags & NDR_IN) {
12870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
12871                 if (r->in.servername) {
12872                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12873                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12874                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12875                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12876                 }
12877                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12878                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12879                 if (r->in.buffer) {
12880                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12881                 }
12882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12883         }
12884         if (flags & NDR_OUT) {
12885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12886                 if (r->out.info) {
12887                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12888                 }
12889                 if (r->out.needed == NULL) {
12890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12891                 }
12892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
12893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12894                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12895         }
12896         return NDR_ERR_SUCCESS;
12897 }
12898
12899 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
12900 {
12901         uint32_t _ptr_servername;
12902         uint32_t _ptr_buffer;
12903         uint32_t _ptr_info;
12904         TALLOC_CTX *_mem_save_servername_0;
12905         TALLOC_CTX *_mem_save_buffer_0;
12906         TALLOC_CTX *_mem_save_info_0;
12907         TALLOC_CTX *_mem_save_needed_0;
12908         if (flags & NDR_IN) {
12909                 ZERO_STRUCT(r->out);
12910
12911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
12912                 if (_ptr_servername) {
12913                         NDR_PULL_ALLOC(ndr, r->in.servername);
12914                 } else {
12915                         r->in.servername = NULL;
12916                 }
12917                 if (r->in.servername) {
12918                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
12919                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
12920                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
12921                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
12922                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
12923                                 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));
12924                         }
12925                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
12926                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
12927                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
12928                 }
12929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12931                 if (_ptr_buffer) {
12932                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12933                 } else {
12934                         r->in.buffer = NULL;
12935                 }
12936                 if (r->in.buffer) {
12937                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12938                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12939                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12941                 }
12942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12943                 NDR_PULL_ALLOC(ndr, r->out.needed);
12944                 ZERO_STRUCTP(r->out.needed);
12945         }
12946         if (flags & NDR_OUT) {
12947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12948                 if (_ptr_info) {
12949                         NDR_PULL_ALLOC(ndr, r->out.info);
12950                 } else {
12951                         r->out.info = NULL;
12952                 }
12953                 if (r->out.info) {
12954                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12955                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12956                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12958                 }
12959                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12960                         NDR_PULL_ALLOC(ndr, r->out.needed);
12961                 }
12962                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
12963                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
12964                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
12965                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
12966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12968         }
12969         return NDR_ERR_SUCCESS;
12970 }
12971
12972 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
12973 {
12974         uint32_t cntr_info_0;
12975         if (flags & NDR_IN) {
12976                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12977                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12978         }
12979         if (flags & NDR_OUT) {
12980                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12981                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12982                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12983                 }
12984                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12985                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12986                 }
12987         }
12988         return NDR_ERR_SUCCESS;
12989 }
12990
12991 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
12992 {
12993         uint32_t cntr_info_0;
12994         TALLOC_CTX *_mem_save_info_0;
12995         if (flags & NDR_IN) {
12996                 ZERO_STRUCT(r->out);
12997
12998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
13000         }
13001         if (flags & NDR_OUT) {
13002                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
13003                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13004                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13005                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13006                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
13007                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
13008                 }
13009                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
13010                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
13011                 }
13012                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13013         }
13014         return NDR_ERR_SUCCESS;
13015 }
13016
13017 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
13018 {
13019         uint32_t cntr_info_1;
13020         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
13021         ndr->depth++;
13022         if (flags & NDR_SET_VALUES) {
13023                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13024         }
13025         if (flags & NDR_IN) {
13026                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
13027                 ndr->depth++;
13028                 ndr_print_ptr(ndr, "servername", r->in.servername);
13029                 ndr->depth++;
13030                 if (r->in.servername) {
13031                         ndr_print_string(ndr, "servername", r->in.servername);
13032                 }
13033                 ndr->depth--;
13034                 ndr_print_uint32(ndr, "level", r->in.level);
13035                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13036                 ndr->depth++;
13037                 if (r->in.buffer) {
13038                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13039                 }
13040                 ndr->depth--;
13041                 ndr_print_uint32(ndr, "offered", r->in.offered);
13042                 ndr->depth--;
13043         }
13044         if (flags & NDR_OUT) {
13045                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
13046                 ndr->depth++;
13047                 ndr_print_ptr(ndr, "info", r->out.info);
13048                 ndr->depth++;
13049                 if (r->out.info) {
13050                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
13051                         ndr->depth++;
13052                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
13053                                 char *idx_1=NULL;
13054                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
13055                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
13056                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
13057                                         free(idx_1);
13058                                 }
13059                         }
13060                         ndr->depth--;
13061                 }
13062                 ndr->depth--;
13063                 ndr_print_ptr(ndr, "needed", r->out.needed);
13064                 ndr->depth++;
13065                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13066                 ndr->depth--;
13067                 ndr_print_uint32(ndr, "count", r->out.count);
13068                 ndr_print_WERROR(ndr, "result", r->out.result);
13069                 ndr->depth--;
13070         }
13071         ndr->depth--;
13072 }
13073
13074 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
13075 {
13076         if (flags & NDR_IN) {
13077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
13078                 if (r->in.server_name) {
13079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
13080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
13082                         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));
13083                 }
13084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
13085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
13086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
13088                 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));
13089         }
13090         if (flags & NDR_OUT) {
13091                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13092         }
13093         return NDR_ERR_SUCCESS;
13094 }
13095
13096 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
13097 {
13098         uint32_t _ptr_server_name;
13099         TALLOC_CTX *_mem_save_server_name_0;
13100         if (flags & NDR_IN) {
13101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
13102                 if (_ptr_server_name) {
13103                         NDR_PULL_ALLOC(ndr, r->in.server_name);
13104                 } else {
13105                         r->in.server_name = NULL;
13106                 }
13107                 if (r->in.server_name) {
13108                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13109                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
13110                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
13111                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
13112                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
13113                                 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));
13114                         }
13115                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
13116                         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));
13117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
13118                 }
13119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
13120                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
13121                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
13122                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
13123                         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));
13124                 }
13125                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
13126                 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));
13127         }
13128         if (flags & NDR_OUT) {
13129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13130         }
13131         return NDR_ERR_SUCCESS;
13132 }
13133
13134 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
13135 {
13136         ndr_print_struct(ndr, name, "spoolss_AddPort");
13137         ndr->depth++;
13138         if (flags & NDR_SET_VALUES) {
13139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13140         }
13141         if (flags & NDR_IN) {
13142                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
13143                 ndr->depth++;
13144                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
13145                 ndr->depth++;
13146                 if (r->in.server_name) {
13147                         ndr_print_string(ndr, "server_name", r->in.server_name);
13148                 }
13149                 ndr->depth--;
13150                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
13151                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
13152                 ndr->depth--;
13153         }
13154         if (flags & NDR_OUT) {
13155                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
13156                 ndr->depth++;
13157                 ndr_print_WERROR(ndr, "result", r->out.result);
13158                 ndr->depth--;
13159         }
13160         ndr->depth--;
13161 }
13162
13163 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
13164 {
13165         if (flags & NDR_IN) {
13166         }
13167         if (flags & NDR_OUT) {
13168                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13169         }
13170         return NDR_ERR_SUCCESS;
13171 }
13172
13173 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
13174 {
13175         if (flags & NDR_IN) {
13176         }
13177         if (flags & NDR_OUT) {
13178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13179         }
13180         return NDR_ERR_SUCCESS;
13181 }
13182
13183 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
13184 {
13185         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
13186         ndr->depth++;
13187         if (flags & NDR_SET_VALUES) {
13188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13189         }
13190         if (flags & NDR_IN) {
13191                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
13192                 ndr->depth++;
13193                 ndr->depth--;
13194         }
13195         if (flags & NDR_OUT) {
13196                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
13197                 ndr->depth++;
13198                 ndr_print_WERROR(ndr, "result", r->out.result);
13199                 ndr->depth--;
13200         }
13201         ndr->depth--;
13202 }
13203
13204 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
13205 {
13206         if (flags & NDR_IN) {
13207         }
13208         if (flags & NDR_OUT) {
13209                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13210         }
13211         return NDR_ERR_SUCCESS;
13212 }
13213
13214 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
13215 {
13216         if (flags & NDR_IN) {
13217         }
13218         if (flags & NDR_OUT) {
13219                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13220         }
13221         return NDR_ERR_SUCCESS;
13222 }
13223
13224 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
13225 {
13226         ndr_print_struct(ndr, name, "spoolss_DeletePort");
13227         ndr->depth++;
13228         if (flags & NDR_SET_VALUES) {
13229                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13230         }
13231         if (flags & NDR_IN) {
13232                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
13233                 ndr->depth++;
13234                 ndr->depth--;
13235         }
13236         if (flags & NDR_OUT) {
13237                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
13238                 ndr->depth++;
13239                 ndr_print_WERROR(ndr, "result", r->out.result);
13240                 ndr->depth--;
13241         }
13242         ndr->depth--;
13243 }
13244
13245 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
13246 {
13247         if (flags & NDR_IN) {
13248         }
13249         if (flags & NDR_OUT) {
13250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13251         }
13252         return NDR_ERR_SUCCESS;
13253 }
13254
13255 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
13256 {
13257         if (flags & NDR_IN) {
13258         }
13259         if (flags & NDR_OUT) {
13260                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13261         }
13262         return NDR_ERR_SUCCESS;
13263 }
13264
13265 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
13266 {
13267         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
13268         ndr->depth++;
13269         if (flags & NDR_SET_VALUES) {
13270                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13271         }
13272         if (flags & NDR_IN) {
13273                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
13274                 ndr->depth++;
13275                 ndr->depth--;
13276         }
13277         if (flags & NDR_OUT) {
13278                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
13279                 ndr->depth++;
13280                 ndr_print_WERROR(ndr, "result", r->out.result);
13281                 ndr->depth--;
13282         }
13283         ndr->depth--;
13284 }
13285
13286 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
13287 {
13288         if (flags & NDR_IN) {
13289         }
13290         if (flags & NDR_OUT) {
13291                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13292         }
13293         return NDR_ERR_SUCCESS;
13294 }
13295
13296 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
13297 {
13298         if (flags & NDR_IN) {
13299         }
13300         if (flags & NDR_OUT) {
13301                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13302         }
13303         return NDR_ERR_SUCCESS;
13304 }
13305
13306 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
13307 {
13308         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
13309         ndr->depth++;
13310         if (flags & NDR_SET_VALUES) {
13311                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13312         }
13313         if (flags & NDR_IN) {
13314                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
13315                 ndr->depth++;
13316                 ndr->depth--;
13317         }
13318         if (flags & NDR_OUT) {
13319                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
13320                 ndr->depth++;
13321                 ndr_print_WERROR(ndr, "result", r->out.result);
13322                 ndr->depth--;
13323         }
13324         ndr->depth--;
13325 }
13326
13327 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
13328 {
13329         if (flags & NDR_IN) {
13330         }
13331         if (flags & NDR_OUT) {
13332                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13333         }
13334         return NDR_ERR_SUCCESS;
13335 }
13336
13337 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
13338 {
13339         if (flags & NDR_IN) {
13340         }
13341         if (flags & NDR_OUT) {
13342                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13343         }
13344         return NDR_ERR_SUCCESS;
13345 }
13346
13347 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
13348 {
13349         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
13350         ndr->depth++;
13351         if (flags & NDR_SET_VALUES) {
13352                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13353         }
13354         if (flags & NDR_IN) {
13355                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
13356                 ndr->depth++;
13357                 ndr->depth--;
13358         }
13359         if (flags & NDR_OUT) {
13360                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
13361                 ndr->depth++;
13362                 ndr_print_WERROR(ndr, "result", r->out.result);
13363                 ndr->depth--;
13364         }
13365         ndr->depth--;
13366 }
13367
13368 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
13369 {
13370         if (flags & NDR_IN) {
13371         }
13372         if (flags & NDR_OUT) {
13373                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13374         }
13375         return NDR_ERR_SUCCESS;
13376 }
13377
13378 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
13379 {
13380         if (flags & NDR_IN) {
13381         }
13382         if (flags & NDR_OUT) {
13383                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13384         }
13385         return NDR_ERR_SUCCESS;
13386 }
13387
13388 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
13389 {
13390         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
13391         ndr->depth++;
13392         if (flags & NDR_SET_VALUES) {
13393                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13394         }
13395         if (flags & NDR_IN) {
13396                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
13397                 ndr->depth++;
13398                 ndr->depth--;
13399         }
13400         if (flags & NDR_OUT) {
13401                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
13402                 ndr->depth++;
13403                 ndr_print_WERROR(ndr, "result", r->out.result);
13404                 ndr->depth--;
13405         }
13406         ndr->depth--;
13407 }
13408
13409 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
13410 {
13411         if (flags & NDR_IN) {
13412         }
13413         if (flags & NDR_OUT) {
13414                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13415         }
13416         return NDR_ERR_SUCCESS;
13417 }
13418
13419 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
13420 {
13421         if (flags & NDR_IN) {
13422         }
13423         if (flags & NDR_OUT) {
13424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13425         }
13426         return NDR_ERR_SUCCESS;
13427 }
13428
13429 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
13430 {
13431         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
13432         ndr->depth++;
13433         if (flags & NDR_SET_VALUES) {
13434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13435         }
13436         if (flags & NDR_IN) {
13437                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
13438                 ndr->depth++;
13439                 ndr->depth--;
13440         }
13441         if (flags & NDR_OUT) {
13442                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
13443                 ndr->depth++;
13444                 ndr_print_WERROR(ndr, "result", r->out.result);
13445                 ndr->depth--;
13446         }
13447         ndr->depth--;
13448 }
13449
13450 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
13451 {
13452         if (flags & NDR_IN) {
13453         }
13454         if (flags & NDR_OUT) {
13455                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13456         }
13457         return NDR_ERR_SUCCESS;
13458 }
13459
13460 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
13461 {
13462         if (flags & NDR_IN) {
13463         }
13464         if (flags & NDR_OUT) {
13465                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13466         }
13467         return NDR_ERR_SUCCESS;
13468 }
13469
13470 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
13471 {
13472         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
13473         ndr->depth++;
13474         if (flags & NDR_SET_VALUES) {
13475                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13476         }
13477         if (flags & NDR_IN) {
13478                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
13479                 ndr->depth++;
13480                 ndr->depth--;
13481         }
13482         if (flags & NDR_OUT) {
13483                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
13484                 ndr->depth++;
13485                 ndr_print_WERROR(ndr, "result", r->out.result);
13486                 ndr->depth--;
13487         }
13488         ndr->depth--;
13489 }
13490
13491 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
13492 {
13493         if (flags & NDR_IN) {
13494         }
13495         if (flags & NDR_OUT) {
13496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13497         }
13498         return NDR_ERR_SUCCESS;
13499 }
13500
13501 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
13502 {
13503         if (flags & NDR_IN) {
13504         }
13505         if (flags & NDR_OUT) {
13506                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13507         }
13508         return NDR_ERR_SUCCESS;
13509 }
13510
13511 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
13512 {
13513         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
13514         ndr->depth++;
13515         if (flags & NDR_SET_VALUES) {
13516                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13517         }
13518         if (flags & NDR_IN) {
13519                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
13520                 ndr->depth++;
13521                 ndr->depth--;
13522         }
13523         if (flags & NDR_OUT) {
13524                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
13525                 ndr->depth++;
13526                 ndr_print_WERROR(ndr, "result", r->out.result);
13527                 ndr->depth--;
13528         }
13529         ndr->depth--;
13530 }
13531
13532 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
13533 {
13534         if (flags & NDR_IN) {
13535         }
13536         if (flags & NDR_OUT) {
13537                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13538         }
13539         return NDR_ERR_SUCCESS;
13540 }
13541
13542 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
13543 {
13544         if (flags & NDR_IN) {
13545         }
13546         if (flags & NDR_OUT) {
13547                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13548         }
13549         return NDR_ERR_SUCCESS;
13550 }
13551
13552 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
13553 {
13554         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
13555         ndr->depth++;
13556         if (flags & NDR_SET_VALUES) {
13557                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13558         }
13559         if (flags & NDR_IN) {
13560                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
13561                 ndr->depth++;
13562                 ndr->depth--;
13563         }
13564         if (flags & NDR_OUT) {
13565                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
13566                 ndr->depth++;
13567                 ndr_print_WERROR(ndr, "result", r->out.result);
13568                 ndr->depth--;
13569         }
13570         ndr->depth--;
13571 }
13572
13573 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
13574 {
13575         if (flags & NDR_IN) {
13576         }
13577         if (flags & NDR_OUT) {
13578                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13579         }
13580         return NDR_ERR_SUCCESS;
13581 }
13582
13583 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
13584 {
13585         if (flags & NDR_IN) {
13586         }
13587         if (flags & NDR_OUT) {
13588                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13589         }
13590         return NDR_ERR_SUCCESS;
13591 }
13592
13593 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
13594 {
13595         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
13596         ndr->depth++;
13597         if (flags & NDR_SET_VALUES) {
13598                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13599         }
13600         if (flags & NDR_IN) {
13601                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
13602                 ndr->depth++;
13603                 ndr->depth--;
13604         }
13605         if (flags & NDR_OUT) {
13606                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
13607                 ndr->depth++;
13608                 ndr_print_WERROR(ndr, "result", r->out.result);
13609                 ndr->depth--;
13610         }
13611         ndr->depth--;
13612 }
13613
13614 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
13615 {
13616         if (flags & NDR_IN) {
13617         }
13618         if (flags & NDR_OUT) {
13619                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13620         }
13621         return NDR_ERR_SUCCESS;
13622 }
13623
13624 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
13625 {
13626         if (flags & NDR_IN) {
13627         }
13628         if (flags & NDR_OUT) {
13629                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13630         }
13631         return NDR_ERR_SUCCESS;
13632 }
13633
13634 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
13635 {
13636         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
13637         ndr->depth++;
13638         if (flags & NDR_SET_VALUES) {
13639                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13640         }
13641         if (flags & NDR_IN) {
13642                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
13643                 ndr->depth++;
13644                 ndr->depth--;
13645         }
13646         if (flags & NDR_OUT) {
13647                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
13648                 ndr->depth++;
13649                 ndr_print_WERROR(ndr, "result", r->out.result);
13650                 ndr->depth--;
13651         }
13652         ndr->depth--;
13653 }
13654
13655 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
13656 {
13657         if (flags & NDR_IN) {
13658         }
13659         if (flags & NDR_OUT) {
13660                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13661         }
13662         return NDR_ERR_SUCCESS;
13663 }
13664
13665 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
13666 {
13667         if (flags & NDR_IN) {
13668         }
13669         if (flags & NDR_OUT) {
13670                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13671         }
13672         return NDR_ERR_SUCCESS;
13673 }
13674
13675 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
13676 {
13677         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
13678         ndr->depth++;
13679         if (flags & NDR_SET_VALUES) {
13680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13681         }
13682         if (flags & NDR_IN) {
13683                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
13684                 ndr->depth++;
13685                 ndr->depth--;
13686         }
13687         if (flags & NDR_OUT) {
13688                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
13689                 ndr->depth++;
13690                 ndr_print_WERROR(ndr, "result", r->out.result);
13691                 ndr->depth--;
13692         }
13693         ndr->depth--;
13694 }
13695
13696 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
13697 {
13698         if (flags & NDR_IN) {
13699         }
13700         if (flags & NDR_OUT) {
13701                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13702         }
13703         return NDR_ERR_SUCCESS;
13704 }
13705
13706 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
13707 {
13708         if (flags & NDR_IN) {
13709         }
13710         if (flags & NDR_OUT) {
13711                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13712         }
13713         return NDR_ERR_SUCCESS;
13714 }
13715
13716 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
13717 {
13718         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
13719         ndr->depth++;
13720         if (flags & NDR_SET_VALUES) {
13721                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13722         }
13723         if (flags & NDR_IN) {
13724                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
13725                 ndr->depth++;
13726                 ndr->depth--;
13727         }
13728         if (flags & NDR_OUT) {
13729                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
13730                 ndr->depth++;
13731                 ndr_print_WERROR(ndr, "result", r->out.result);
13732                 ndr->depth--;
13733         }
13734         ndr->depth--;
13735 }
13736
13737 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
13738 {
13739         if (flags & NDR_IN) {
13740         }
13741         if (flags & NDR_OUT) {
13742                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13743         }
13744         return NDR_ERR_SUCCESS;
13745 }
13746
13747 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
13748 {
13749         if (flags & NDR_IN) {
13750         }
13751         if (flags & NDR_OUT) {
13752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13753         }
13754         return NDR_ERR_SUCCESS;
13755 }
13756
13757 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
13758 {
13759         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
13760         ndr->depth++;
13761         if (flags & NDR_SET_VALUES) {
13762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13763         }
13764         if (flags & NDR_IN) {
13765                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
13766                 ndr->depth++;
13767                 ndr->depth--;
13768         }
13769         if (flags & NDR_OUT) {
13770                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
13771                 ndr->depth++;
13772                 ndr_print_WERROR(ndr, "result", r->out.result);
13773                 ndr->depth--;
13774         }
13775         ndr->depth--;
13776 }
13777
13778 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
13779 {
13780         if (flags & NDR_IN) {
13781                 if (r->in.handle == NULL) {
13782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13783                 }
13784                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
13786                 if (r->in.architecture) {
13787                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
13788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
13790                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13791                 }
13792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13793                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13794                 if (r->in.buffer) {
13795                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13796                 }
13797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
13799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
13800         }
13801         if (flags & NDR_OUT) {
13802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13803                 if (r->out.info) {
13804                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
13805                 }
13806                 if (r->out.needed == NULL) {
13807                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13808                 }
13809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
13810                 if (r->out.server_major_version == NULL) {
13811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13812                 }
13813                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
13814                 if (r->out.server_minor_version == NULL) {
13815                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13816                 }
13817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
13818                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13819         }
13820         return NDR_ERR_SUCCESS;
13821 }
13822
13823 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
13824 {
13825         uint32_t _ptr_architecture;
13826         uint32_t _ptr_buffer;
13827         uint32_t _ptr_info;
13828         TALLOC_CTX *_mem_save_handle_0;
13829         TALLOC_CTX *_mem_save_architecture_0;
13830         TALLOC_CTX *_mem_save_buffer_0;
13831         TALLOC_CTX *_mem_save_info_0;
13832         TALLOC_CTX *_mem_save_needed_0;
13833         TALLOC_CTX *_mem_save_server_major_version_0;
13834         TALLOC_CTX *_mem_save_server_minor_version_0;
13835         if (flags & NDR_IN) {
13836                 ZERO_STRUCT(r->out);
13837
13838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13839                         NDR_PULL_ALLOC(ndr, r->in.handle);
13840                 }
13841                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13842                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13843                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13846                 if (_ptr_architecture) {
13847                         NDR_PULL_ALLOC(ndr, r->in.architecture);
13848                 } else {
13849                         r->in.architecture = NULL;
13850                 }
13851                 if (r->in.architecture) {
13852                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13853                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
13854                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
13855                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
13856                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
13857                                 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));
13858                         }
13859                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
13860                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
13861                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13862                 }
13863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13865                 if (_ptr_buffer) {
13866                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13867                 } else {
13868                         r->in.buffer = NULL;
13869                 }
13870                 if (r->in.buffer) {
13871                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13872                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13873                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13875                 }
13876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13877                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
13878                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
13879                 NDR_PULL_ALLOC(ndr, r->out.needed);
13880                 ZERO_STRUCTP(r->out.needed);
13881                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
13882                 ZERO_STRUCTP(r->out.server_major_version);
13883                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
13884                 ZERO_STRUCTP(r->out.server_minor_version);
13885         }
13886         if (flags & NDR_OUT) {
13887                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13888                 if (_ptr_info) {
13889                         NDR_PULL_ALLOC(ndr, r->out.info);
13890                 } else {
13891                         r->out.info = NULL;
13892                 }
13893                 if (r->out.info) {
13894                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13895                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13896                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
13897                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13898                 }
13899                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13900                         NDR_PULL_ALLOC(ndr, r->out.needed);
13901                 }
13902                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
13903                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
13904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
13905                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
13906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13907                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
13908                 }
13909                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
13910                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
13911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
13912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
13913                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13914                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
13915                 }
13916                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
13917                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
13918                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
13919                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
13920                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13921         }
13922         return NDR_ERR_SUCCESS;
13923 }
13924
13925 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
13926 {
13927         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
13928         ndr->depth++;
13929         if (flags & NDR_SET_VALUES) {
13930                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13931         }
13932         if (flags & NDR_IN) {
13933                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
13934                 ndr->depth++;
13935                 ndr_print_ptr(ndr, "handle", r->in.handle);
13936                 ndr->depth++;
13937                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13938                 ndr->depth--;
13939                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
13940                 ndr->depth++;
13941                 if (r->in.architecture) {
13942                         ndr_print_string(ndr, "architecture", r->in.architecture);
13943                 }
13944                 ndr->depth--;
13945                 ndr_print_uint32(ndr, "level", r->in.level);
13946                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13947                 ndr->depth++;
13948                 if (r->in.buffer) {
13949                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13950                 }
13951                 ndr->depth--;
13952                 ndr_print_uint32(ndr, "offered", r->in.offered);
13953                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
13954                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
13955                 ndr->depth--;
13956         }
13957         if (flags & NDR_OUT) {
13958                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
13959                 ndr->depth++;
13960                 ndr_print_ptr(ndr, "info", r->out.info);
13961                 ndr->depth++;
13962                 if (r->out.info) {
13963                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
13964                 }
13965                 ndr->depth--;
13966                 ndr_print_ptr(ndr, "needed", r->out.needed);
13967                 ndr->depth++;
13968                 ndr_print_uint32(ndr, "needed", *r->out.needed);
13969                 ndr->depth--;
13970                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
13971                 ndr->depth++;
13972                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
13973                 ndr->depth--;
13974                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
13975                 ndr->depth++;
13976                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
13977                 ndr->depth--;
13978                 ndr_print_WERROR(ndr, "result", r->out.result);
13979                 ndr->depth--;
13980         }
13981         ndr->depth--;
13982 }
13983
13984 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
13985 {
13986         if (flags & NDR_IN) {
13987         }
13988         if (flags & NDR_OUT) {
13989                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13990         }
13991         return NDR_ERR_SUCCESS;
13992 }
13993
13994 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
13995 {
13996         if (flags & NDR_IN) {
13997         }
13998         if (flags & NDR_OUT) {
13999                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14000         }
14001         return NDR_ERR_SUCCESS;
14002 }
14003
14004 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
14005 {
14006         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
14007         ndr->depth++;
14008         if (flags & NDR_SET_VALUES) {
14009                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14010         }
14011         if (flags & NDR_IN) {
14012                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
14013                 ndr->depth++;
14014                 ndr->depth--;
14015         }
14016         if (flags & NDR_OUT) {
14017                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
14018                 ndr->depth++;
14019                 ndr_print_WERROR(ndr, "result", r->out.result);
14020                 ndr->depth--;
14021         }
14022         ndr->depth--;
14023 }
14024
14025 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
14026 {
14027         if (flags & NDR_IN) {
14028         }
14029         if (flags & NDR_OUT) {
14030                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14031         }
14032         return NDR_ERR_SUCCESS;
14033 }
14034
14035 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
14036 {
14037         if (flags & NDR_IN) {
14038         }
14039         if (flags & NDR_OUT) {
14040                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14041         }
14042         return NDR_ERR_SUCCESS;
14043 }
14044
14045 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
14046 {
14047         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
14048         ndr->depth++;
14049         if (flags & NDR_SET_VALUES) {
14050                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14051         }
14052         if (flags & NDR_IN) {
14053                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
14054                 ndr->depth++;
14055                 ndr->depth--;
14056         }
14057         if (flags & NDR_OUT) {
14058                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
14059                 ndr->depth++;
14060                 ndr_print_WERROR(ndr, "result", r->out.result);
14061                 ndr->depth--;
14062         }
14063         ndr->depth--;
14064 }
14065
14066 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
14067 {
14068         if (flags & NDR_IN) {
14069                 if (r->in.handle == NULL) {
14070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14071                 }
14072                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14073         }
14074         if (flags & NDR_OUT) {
14075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14076         }
14077         return NDR_ERR_SUCCESS;
14078 }
14079
14080 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
14081 {
14082         TALLOC_CTX *_mem_save_handle_0;
14083         if (flags & NDR_IN) {
14084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14085                         NDR_PULL_ALLOC(ndr, r->in.handle);
14086                 }
14087                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14088                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14089                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14090                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14091         }
14092         if (flags & NDR_OUT) {
14093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14094         }
14095         return NDR_ERR_SUCCESS;
14096 }
14097
14098 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
14099 {
14100         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
14101         ndr->depth++;
14102         if (flags & NDR_SET_VALUES) {
14103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14104         }
14105         if (flags & NDR_IN) {
14106                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
14107                 ndr->depth++;
14108                 ndr_print_ptr(ndr, "handle", r->in.handle);
14109                 ndr->depth++;
14110                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14111                 ndr->depth--;
14112                 ndr->depth--;
14113         }
14114         if (flags & NDR_OUT) {
14115                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
14116                 ndr->depth++;
14117                 ndr_print_WERROR(ndr, "result", r->out.result);
14118                 ndr->depth--;
14119         }
14120         ndr->depth--;
14121 }
14122
14123 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
14124 {
14125         if (flags & NDR_IN) {
14126         }
14127         if (flags & NDR_OUT) {
14128                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14129         }
14130         return NDR_ERR_SUCCESS;
14131 }
14132
14133 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
14134 {
14135         if (flags & NDR_IN) {
14136         }
14137         if (flags & NDR_OUT) {
14138                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14139         }
14140         return NDR_ERR_SUCCESS;
14141 }
14142
14143 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
14144 {
14145         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
14146         ndr->depth++;
14147         if (flags & NDR_SET_VALUES) {
14148                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14149         }
14150         if (flags & NDR_IN) {
14151                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
14152                 ndr->depth++;
14153                 ndr->depth--;
14154         }
14155         if (flags & NDR_OUT) {
14156                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
14157                 ndr->depth++;
14158                 ndr_print_WERROR(ndr, "result", r->out.result);
14159                 ndr->depth--;
14160         }
14161         ndr->depth--;
14162 }
14163
14164 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
14165 {
14166         if (flags & NDR_IN) {
14167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
14168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
14170                 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));
14171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
14172                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
14173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
14174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
14175         }
14176         if (flags & NDR_OUT) {
14177                 if (r->out.handle == NULL) {
14178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14179                 }
14180                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14181                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14182         }
14183         return NDR_ERR_SUCCESS;
14184 }
14185
14186 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
14187 {
14188         TALLOC_CTX *_mem_save_handle_0;
14189         if (flags & NDR_IN) {
14190                 ZERO_STRUCT(r->out);
14191
14192                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
14193                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
14194                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
14195                         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));
14196                 }
14197                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
14198                 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));
14199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
14200                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
14201                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
14202                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
14203                 NDR_PULL_ALLOC(ndr, r->out.handle);
14204                 ZERO_STRUCTP(r->out.handle);
14205         }
14206         if (flags & NDR_OUT) {
14207                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14208                         NDR_PULL_ALLOC(ndr, r->out.handle);
14209                 }
14210                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14211                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14212                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14213                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14214                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14215         }
14216         return NDR_ERR_SUCCESS;
14217 }
14218
14219 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
14220 {
14221         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
14222         ndr->depth++;
14223         if (flags & NDR_SET_VALUES) {
14224                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14225         }
14226         if (flags & NDR_IN) {
14227                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
14228                 ndr->depth++;
14229                 ndr_print_string(ndr, "server_name", r->in.server_name);
14230                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
14231                 ndr_print_winreg_Type(ndr, "type", r->in.type);
14232                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
14233                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
14234                 ndr->depth--;
14235         }
14236         if (flags & NDR_OUT) {
14237                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
14238                 ndr->depth++;
14239                 ndr_print_ptr(ndr, "handle", r->out.handle);
14240                 ndr->depth++;
14241                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14242                 ndr->depth--;
14243                 ndr_print_WERROR(ndr, "result", r->out.result);
14244                 ndr->depth--;
14245         }
14246         ndr->depth--;
14247 }
14248
14249 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
14250 {
14251         if (flags & NDR_IN) {
14252                 if (r->in.handle == NULL) {
14253                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14254                 }
14255                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14256                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
14257                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
14258                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
14259                 if (r->in.buffer) {
14260                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
14261                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
14262                 }
14263         }
14264         if (flags & NDR_OUT) {
14265                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14266         }
14267         return NDR_ERR_SUCCESS;
14268 }
14269
14270 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
14271 {
14272         uint32_t _ptr_buffer;
14273         TALLOC_CTX *_mem_save_handle_0;
14274         TALLOC_CTX *_mem_save_buffer_0;
14275         if (flags & NDR_IN) {
14276                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14277                         NDR_PULL_ALLOC(ndr, r->in.handle);
14278                 }
14279                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14280                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14281                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14282                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14283                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
14284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
14285                 if (r->in.bufsize > 512) {
14286                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
14287                 }
14288                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
14289                 if (_ptr_buffer) {
14290                         NDR_PULL_ALLOC(ndr, r->in.buffer);
14291                 } else {
14292                         r->in.buffer = NULL;
14293                 }
14294                 if (r->in.buffer) {
14295                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14296                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
14297                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
14298                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
14299                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
14300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
14301                 }
14302                 if (r->in.buffer) {
14303                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
14304                 }
14305         }
14306         if (flags & NDR_OUT) {
14307                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14308         }
14309         return NDR_ERR_SUCCESS;
14310 }
14311
14312 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
14313 {
14314         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
14315         ndr->depth++;
14316         if (flags & NDR_SET_VALUES) {
14317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14318         }
14319         if (flags & NDR_IN) {
14320                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
14321                 ndr->depth++;
14322                 ndr_print_ptr(ndr, "handle", r->in.handle);
14323                 ndr->depth++;
14324                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14325                 ndr->depth--;
14326                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
14327                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
14328                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
14329                 ndr->depth++;
14330                 if (r->in.buffer) {
14331                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
14332                 }
14333                 ndr->depth--;
14334                 ndr->depth--;
14335         }
14336         if (flags & NDR_OUT) {
14337                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
14338                 ndr->depth++;
14339                 ndr_print_WERROR(ndr, "result", r->out.result);
14340                 ndr->depth--;
14341         }
14342         ndr->depth--;
14343 }
14344
14345 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
14346 {
14347         if (flags & NDR_IN) {
14348                 if (r->in.handle == NULL) {
14349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14350                 }
14351                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14352         }
14353         if (flags & NDR_OUT) {
14354                 if (r->out.handle == NULL) {
14355                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14356                 }
14357                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14358                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14359         }
14360         return NDR_ERR_SUCCESS;
14361 }
14362
14363 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
14364 {
14365         TALLOC_CTX *_mem_save_handle_0;
14366         if (flags & NDR_IN) {
14367                 ZERO_STRUCT(r->out);
14368
14369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14370                         NDR_PULL_ALLOC(ndr, r->in.handle);
14371                 }
14372                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14373                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14374                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14376                 NDR_PULL_ALLOC(ndr, r->out.handle);
14377                 *r->out.handle = *r->in.handle;
14378         }
14379         if (flags & NDR_OUT) {
14380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14381                         NDR_PULL_ALLOC(ndr, r->out.handle);
14382                 }
14383                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14384                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14385                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14388         }
14389         return NDR_ERR_SUCCESS;
14390 }
14391
14392 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
14393 {
14394         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
14395         ndr->depth++;
14396         if (flags & NDR_SET_VALUES) {
14397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14398         }
14399         if (flags & NDR_IN) {
14400                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
14401                 ndr->depth++;
14402                 ndr_print_ptr(ndr, "handle", r->in.handle);
14403                 ndr->depth++;
14404                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14405                 ndr->depth--;
14406                 ndr->depth--;
14407         }
14408         if (flags & NDR_OUT) {
14409                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
14410                 ndr->depth++;
14411                 ndr_print_ptr(ndr, "handle", r->out.handle);
14412                 ndr->depth++;
14413                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14414                 ndr->depth--;
14415                 ndr_print_WERROR(ndr, "result", r->out.result);
14416                 ndr->depth--;
14417         }
14418         ndr->depth--;
14419 }
14420
14421 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
14422 {
14423         if (flags & NDR_IN) {
14424         }
14425         if (flags & NDR_OUT) {
14426                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14427         }
14428         return NDR_ERR_SUCCESS;
14429 }
14430
14431 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
14432 {
14433         if (flags & NDR_IN) {
14434         }
14435         if (flags & NDR_OUT) {
14436                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14437         }
14438         return NDR_ERR_SUCCESS;
14439 }
14440
14441 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
14442 {
14443         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
14444         ndr->depth++;
14445         if (flags & NDR_SET_VALUES) {
14446                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14447         }
14448         if (flags & NDR_IN) {
14449                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
14450                 ndr->depth++;
14451                 ndr->depth--;
14452         }
14453         if (flags & NDR_OUT) {
14454                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
14455                 ndr->depth++;
14456                 ndr_print_WERROR(ndr, "result", r->out.result);
14457                 ndr->depth--;
14458         }
14459         ndr->depth--;
14460 }
14461
14462 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14463 {
14464         if (flags & NDR_IN) {
14465         }
14466         if (flags & NDR_OUT) {
14467                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14468         }
14469         return NDR_ERR_SUCCESS;
14470 }
14471
14472 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14473 {
14474         if (flags & NDR_IN) {
14475         }
14476         if (flags & NDR_OUT) {
14477                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14478         }
14479         return NDR_ERR_SUCCESS;
14480 }
14481
14482 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14483 {
14484         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
14485         ndr->depth++;
14486         if (flags & NDR_SET_VALUES) {
14487                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14488         }
14489         if (flags & NDR_IN) {
14490                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
14491                 ndr->depth++;
14492                 ndr->depth--;
14493         }
14494         if (flags & NDR_OUT) {
14495                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
14496                 ndr->depth++;
14497                 ndr_print_WERROR(ndr, "result", r->out.result);
14498                 ndr->depth--;
14499         }
14500         ndr->depth--;
14501 }
14502
14503 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
14504 {
14505         if (flags & NDR_IN) {
14506         }
14507         if (flags & NDR_OUT) {
14508                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14509         }
14510         return NDR_ERR_SUCCESS;
14511 }
14512
14513 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
14514 {
14515         if (flags & NDR_IN) {
14516         }
14517         if (flags & NDR_OUT) {
14518                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14519         }
14520         return NDR_ERR_SUCCESS;
14521 }
14522
14523 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
14524 {
14525         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
14526         ndr->depth++;
14527         if (flags & NDR_SET_VALUES) {
14528                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14529         }
14530         if (flags & NDR_IN) {
14531                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
14532                 ndr->depth++;
14533                 ndr->depth--;
14534         }
14535         if (flags & NDR_OUT) {
14536                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
14537                 ndr->depth++;
14538                 ndr_print_WERROR(ndr, "result", r->out.result);
14539                 ndr->depth--;
14540         }
14541         ndr->depth--;
14542 }
14543
14544 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
14545 {
14546         if (flags & NDR_IN) {
14547         }
14548         if (flags & NDR_OUT) {
14549                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14550         }
14551         return NDR_ERR_SUCCESS;
14552 }
14553
14554 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
14555 {
14556         if (flags & NDR_IN) {
14557         }
14558         if (flags & NDR_OUT) {
14559                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14560         }
14561         return NDR_ERR_SUCCESS;
14562 }
14563
14564 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
14565 {
14566         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
14567         ndr->depth++;
14568         if (flags & NDR_SET_VALUES) {
14569                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14570         }
14571         if (flags & NDR_IN) {
14572                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
14573                 ndr->depth++;
14574                 ndr->depth--;
14575         }
14576         if (flags & NDR_OUT) {
14577                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
14578                 ndr->depth++;
14579                 ndr_print_WERROR(ndr, "result", r->out.result);
14580                 ndr->depth--;
14581         }
14582         ndr->depth--;
14583 }
14584
14585 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14586 {
14587         if (flags & NDR_IN) {
14588                 if (r->in.handle == NULL) {
14589                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14590                 }
14591                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
14593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
14594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.str));
14595                 if (r->in.str) {
14596                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.str, CH_UTF16)));
14597                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14598                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.str, CH_UTF16)));
14599                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.str, ndr_charset_length(r->in.str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14600                 }
14601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
14602                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.t1));
14603                 if (r->in.t1) {
14604                         NDR_CHECK(ndr_push_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.t1));
14605                 }
14606         }
14607         if (flags & NDR_OUT) {
14608                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14609         }
14610         return NDR_ERR_SUCCESS;
14611 }
14612
14613 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14614 {
14615         uint32_t _ptr_str;
14616         uint32_t _ptr_t1;
14617         TALLOC_CTX *_mem_save_handle_0;
14618         TALLOC_CTX *_mem_save_str_0;
14619         TALLOC_CTX *_mem_save_t1_0;
14620         if (flags & NDR_IN) {
14621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14622                         NDR_PULL_ALLOC(ndr, r->in.handle);
14623                 }
14624                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14625                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14626                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
14629                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
14630                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
14631                 if (_ptr_str) {
14632                         NDR_PULL_ALLOC(ndr, r->in.str);
14633                 } else {
14634                         r->in.str = NULL;
14635                 }
14636                 if (r->in.str) {
14637                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
14638                         NDR_PULL_SET_MEM_CTX(ndr, r->in.str, 0);
14639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.str));
14640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.str));
14641                         if (ndr_get_array_length(ndr, &r->in.str) > ndr_get_array_size(ndr, &r->in.str)) {
14642                                 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));
14643                         }
14644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.str), sizeof(uint16_t)));
14645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.str, ndr_get_array_length(ndr, &r->in.str), sizeof(uint16_t), CH_UTF16));
14646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
14647                 }
14648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
14649                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_t1));
14650                 if (_ptr_t1) {
14651                         NDR_PULL_ALLOC(ndr, r->in.t1);
14652                 } else {
14653                         r->in.t1 = NULL;
14654                 }
14655                 if (r->in.t1) {
14656                         _mem_save_t1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14657                         NDR_PULL_SET_MEM_CTX(ndr, r->in.t1, 0);
14658                         NDR_CHECK(ndr_pull_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.t1));
14659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_t1_0, 0);
14660                 }
14661         }
14662         if (flags & NDR_OUT) {
14663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14664         }
14665         return NDR_ERR_SUCCESS;
14666 }
14667
14668 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14669 {
14670         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14671         ndr->depth++;
14672         if (flags & NDR_SET_VALUES) {
14673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14674         }
14675         if (flags & NDR_IN) {
14676                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14677                 ndr->depth++;
14678                 ndr_print_ptr(ndr, "handle", r->in.handle);
14679                 ndr->depth++;
14680                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14681                 ndr->depth--;
14682                 ndr_print_uint32(ndr, "flags", r->in.flags);
14683                 ndr_print_uint32(ndr, "options", r->in.options);
14684                 ndr_print_ptr(ndr, "str", r->in.str);
14685                 ndr->depth++;
14686                 if (r->in.str) {
14687                         ndr_print_string(ndr, "str", r->in.str);
14688                 }
14689                 ndr->depth--;
14690                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
14691                 ndr_print_ptr(ndr, "t1", r->in.t1);
14692                 ndr->depth++;
14693                 if (r->in.t1) {
14694                         ndr_print_spoolss_NotifyOptionsContainer(ndr, "t1", r->in.t1);
14695                 }
14696                 ndr->depth--;
14697                 ndr->depth--;
14698         }
14699         if (flags & NDR_OUT) {
14700                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14701                 ndr->depth++;
14702                 ndr_print_WERROR(ndr, "result", r->out.result);
14703                 ndr->depth--;
14704         }
14705         ndr->depth--;
14706 }
14707
14708 static enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotification *r)
14709 {
14710         if (flags & NDR_IN) {
14711         }
14712         if (flags & NDR_OUT) {
14713                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14714         }
14715         return NDR_ERR_SUCCESS;
14716 }
14717
14718 static enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotification *r)
14719 {
14720         if (flags & NDR_IN) {
14721         }
14722         if (flags & NDR_OUT) {
14723                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14724         }
14725         return NDR_ERR_SUCCESS;
14726 }
14727
14728 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotification *r)
14729 {
14730         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotification");
14731         ndr->depth++;
14732         if (flags & NDR_SET_VALUES) {
14733                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14734         }
14735         if (flags & NDR_IN) {
14736                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotification");
14737                 ndr->depth++;
14738                 ndr->depth--;
14739         }
14740         if (flags & NDR_OUT) {
14741                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotification");
14742                 ndr->depth++;
14743                 ndr_print_WERROR(ndr, "result", r->out.result);
14744                 ndr->depth--;
14745         }
14746         ndr->depth--;
14747 }
14748
14749 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14750 {
14751         if (flags & NDR_IN) {
14752                 if (r->in.handle == NULL) {
14753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14754                 }
14755                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
14757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.container));
14758                 if (r->in.container) {
14759                         NDR_CHECK(ndr_push_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.container));
14760                 }
14761         }
14762         if (flags & NDR_OUT) {
14763                 if (r->out.info == NULL) {
14764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14765                 }
14766                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
14767                 if (*r->out.info) {
14768                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
14769                 }
14770                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14771         }
14772         return NDR_ERR_SUCCESS;
14773 }
14774
14775 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14776 {
14777         uint32_t _ptr_container;
14778         uint32_t _ptr_info;
14779         TALLOC_CTX *_mem_save_handle_0;
14780         TALLOC_CTX *_mem_save_container_0;
14781         TALLOC_CTX *_mem_save_info_0;
14782         TALLOC_CTX *_mem_save_info_1;
14783         if (flags & NDR_IN) {
14784                 ZERO_STRUCT(r->out);
14785
14786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14787                         NDR_PULL_ALLOC(ndr, r->in.handle);
14788                 }
14789                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14791                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
14794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_container));
14795                 if (_ptr_container) {
14796                         NDR_PULL_ALLOC(ndr, r->in.container);
14797                 } else {
14798                         r->in.container = NULL;
14799                 }
14800                 if (r->in.container) {
14801                         _mem_save_container_0 = NDR_PULL_GET_MEM_CTX(ndr);
14802                         NDR_PULL_SET_MEM_CTX(ndr, r->in.container, 0);
14803                         NDR_CHECK(ndr_pull_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.container));
14804                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_container_0, 0);
14805                 }
14806                 NDR_PULL_ALLOC(ndr, r->out.info);
14807                 ZERO_STRUCTP(r->out.info);
14808         }
14809         if (flags & NDR_OUT) {
14810                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14811                         NDR_PULL_ALLOC(ndr, r->out.info);
14812                 }
14813                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14814                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14815                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14816                 if (_ptr_info) {
14817                         NDR_PULL_ALLOC(ndr, *r->out.info);
14818                 } else {
14819                         *r->out.info = NULL;
14820                 }
14821                 if (*r->out.info) {
14822                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
14823                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
14824                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
14825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
14826                 }
14827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14828                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14829         }
14830         return NDR_ERR_SUCCESS;
14831 }
14832
14833 _PUBLIC_ void ndr_print_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14834 {
14835         ndr_print_struct(ndr, name, "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14836         ndr->depth++;
14837         if (flags & NDR_SET_VALUES) {
14838                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14839         }
14840         if (flags & NDR_IN) {
14841                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14842                 ndr->depth++;
14843                 ndr_print_ptr(ndr, "handle", r->in.handle);
14844                 ndr->depth++;
14845                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14846                 ndr->depth--;
14847                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
14848                 ndr_print_ptr(ndr, "container", r->in.container);
14849                 ndr->depth++;
14850                 if (r->in.container) {
14851                         ndr_print_spoolss_NotifyOptionsContainer(ndr, "container", r->in.container);
14852                 }
14853                 ndr->depth--;
14854                 ndr->depth--;
14855         }
14856         if (flags & NDR_OUT) {
14857                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14858                 ndr->depth++;
14859                 ndr_print_ptr(ndr, "info", r->out.info);
14860                 ndr->depth++;
14861                 ndr_print_ptr(ndr, "info", *r->out.info);
14862                 ndr->depth++;
14863                 if (*r->out.info) {
14864                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
14865                 }
14866                 ndr->depth--;
14867                 ndr->depth--;
14868                 ndr_print_WERROR(ndr, "result", r->out.result);
14869                 ndr->depth--;
14870         }
14871         ndr->depth--;
14872 }
14873
14874 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
14875 {
14876         if (flags & NDR_IN) {
14877         }
14878         if (flags & NDR_OUT) {
14879                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14880         }
14881         return NDR_ERR_SUCCESS;
14882 }
14883
14884 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
14885 {
14886         if (flags & NDR_IN) {
14887         }
14888         if (flags & NDR_OUT) {
14889                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14890         }
14891         return NDR_ERR_SUCCESS;
14892 }
14893
14894 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
14895 {
14896         ndr_print_struct(ndr, name, "spoolss_44");
14897         ndr->depth++;
14898         if (flags & NDR_SET_VALUES) {
14899                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14900         }
14901         if (flags & NDR_IN) {
14902                 ndr_print_struct(ndr, "in", "spoolss_44");
14903                 ndr->depth++;
14904                 ndr->depth--;
14905         }
14906         if (flags & NDR_OUT) {
14907                 ndr_print_struct(ndr, "out", "spoolss_44");
14908                 ndr->depth++;
14909                 ndr_print_WERROR(ndr, "result", r->out.result);
14910                 ndr->depth--;
14911         }
14912         ndr->depth--;
14913 }
14914
14915 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
14916 {
14917         if (flags & NDR_IN) {
14918                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
14919                 if (r->in.printername) {
14920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14923                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14924                 }
14925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
14926                 if (r->in.datatype) {
14927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14931                 }
14932                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
14934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14935                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
14936                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
14937         }
14938         if (flags & NDR_OUT) {
14939                 if (r->out.handle == NULL) {
14940                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14941                 }
14942                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14943                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14944         }
14945         return NDR_ERR_SUCCESS;
14946 }
14947
14948 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
14949 {
14950         uint32_t _ptr_printername;
14951         uint32_t _ptr_datatype;
14952         TALLOC_CTX *_mem_save_printername_0;
14953         TALLOC_CTX *_mem_save_datatype_0;
14954         TALLOC_CTX *_mem_save_handle_0;
14955         if (flags & NDR_IN) {
14956                 ZERO_STRUCT(r->out);
14957
14958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
14959                 if (_ptr_printername) {
14960                         NDR_PULL_ALLOC(ndr, r->in.printername);
14961                 } else {
14962                         r->in.printername = NULL;
14963                 }
14964                 if (r->in.printername) {
14965                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14966                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
14967                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
14968                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
14969                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
14970                                 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));
14971                         }
14972                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
14973                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
14974                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
14975                 }
14976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14977                 if (_ptr_datatype) {
14978                         NDR_PULL_ALLOC(ndr, r->in.datatype);
14979                 } else {
14980                         r->in.datatype = NULL;
14981                 }
14982                 if (r->in.datatype) {
14983                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14984                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
14985                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
14986                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
14987                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
14988                                 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));
14989                         }
14990                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
14991                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
14992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14993                 }
14994                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
14996                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14997                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
14998                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
14999                 NDR_PULL_ALLOC(ndr, r->out.handle);
15000                 ZERO_STRUCTP(r->out.handle);
15001         }
15002         if (flags & NDR_OUT) {
15003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15004                         NDR_PULL_ALLOC(ndr, r->out.handle);
15005                 }
15006                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
15008                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
15009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15011         }
15012         return NDR_ERR_SUCCESS;
15013 }
15014
15015 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
15016 {
15017         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
15018         ndr->depth++;
15019         if (flags & NDR_SET_VALUES) {
15020                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15021         }
15022         if (flags & NDR_IN) {
15023                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
15024                 ndr->depth++;
15025                 ndr_print_ptr(ndr, "printername", r->in.printername);
15026                 ndr->depth++;
15027                 if (r->in.printername) {
15028                         ndr_print_string(ndr, "printername", r->in.printername);
15029                 }
15030                 ndr->depth--;
15031                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
15032                 ndr->depth++;
15033                 if (r->in.datatype) {
15034                         ndr_print_string(ndr, "datatype", r->in.datatype);
15035                 }
15036                 ndr->depth--;
15037                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
15038                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
15039                 ndr_print_uint32(ndr, "level", r->in.level);
15040                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
15041                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
15042                 ndr->depth--;
15043         }
15044         if (flags & NDR_OUT) {
15045                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
15046                 ndr->depth++;
15047                 ndr_print_ptr(ndr, "handle", r->out.handle);
15048                 ndr->depth++;
15049                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
15050                 ndr->depth--;
15051                 ndr_print_WERROR(ndr, "result", r->out.result);
15052                 ndr->depth--;
15053         }
15054         ndr->depth--;
15055 }
15056
15057 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
15058 {
15059         if (flags & NDR_IN) {
15060                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
15061                 if (r->in.server) {
15062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
15065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15066                 }
15067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
15068                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
15069                 if (r->in.info) {
15070                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
15071                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15072                 }
15073                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));
15075                 if (r->in.secdesc) {
15076                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
15077                 }
15078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.ulevel));
15079                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel));
15080                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
15081         }
15082         if (flags & NDR_OUT) {
15083                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15084         }
15085         return NDR_ERR_SUCCESS;
15086 }
15087
15088 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
15089 {
15090         uint32_t _ptr_server;
15091         uint32_t _ptr_info;
15092         uint32_t _ptr_secdesc;
15093         TALLOC_CTX *_mem_save_server_0;
15094         TALLOC_CTX *_mem_save_info_0;
15095         TALLOC_CTX *_mem_save_secdesc_0;
15096         if (flags & NDR_IN) {
15097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
15098                 if (_ptr_server) {
15099                         NDR_PULL_ALLOC(ndr, r->in.server);
15100                 } else {
15101                         r->in.server = NULL;
15102                 }
15103                 if (r->in.server) {
15104                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
15105                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
15106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
15107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
15108                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
15109                                 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));
15110                         }
15111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
15112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
15113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
15114                 }
15115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
15116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
15117                 if (_ptr_info) {
15118                         NDR_PULL_ALLOC(ndr, r->in.info);
15119                 } else {
15120                         r->in.info = NULL;
15121                 }
15122                 if (r->in.info) {
15123                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
15124                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
15125                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
15126                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
15127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
15128                 }
15129                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
15130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
15131                 if (_ptr_secdesc) {
15132                         NDR_PULL_ALLOC(ndr, r->in.secdesc);
15133                 } else {
15134                         r->in.secdesc = NULL;
15135                 }
15136                 if (r->in.secdesc) {
15137                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
15138                         NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);
15139                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
15140                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
15141                 }
15142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.ulevel));
15143                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel));
15144                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
15145         }
15146         if (flags & NDR_OUT) {
15147                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15148         }
15149         return NDR_ERR_SUCCESS;
15150 }
15151
15152 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
15153 {
15154         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
15155         ndr->depth++;
15156         if (flags & NDR_SET_VALUES) {
15157                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15158         }
15159         if (flags & NDR_IN) {
15160                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
15161                 ndr->depth++;
15162                 ndr_print_ptr(ndr, "server", r->in.server);
15163                 ndr->depth++;
15164                 if (r->in.server) {
15165                         ndr_print_string(ndr, "server", r->in.server);
15166                 }
15167                 ndr->depth--;
15168                 ndr_print_uint32(ndr, "level", r->in.level);
15169                 ndr_print_ptr(ndr, "info", r->in.info);
15170                 ndr->depth++;
15171                 if (r->in.info) {
15172                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
15173                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->in.info);
15174                 }
15175                 ndr->depth--;
15176                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
15177                 ndr_print_ptr(ndr, "secdesc", r->in.secdesc);
15178                 ndr->depth++;
15179                 if (r->in.secdesc) {
15180                         ndr_print_security_descriptor(ndr, "secdesc", r->in.secdesc);
15181                 }
15182                 ndr->depth--;
15183                 ndr_print_uint32(ndr, "ulevel", r->in.ulevel);
15184                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel);
15185                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
15186                 ndr->depth--;
15187         }
15188         if (flags & NDR_OUT) {
15189                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
15190                 ndr->depth++;
15191                 ndr_print_WERROR(ndr, "result", r->out.result);
15192                 ndr->depth--;
15193         }
15194         ndr->depth--;
15195 }
15196
15197 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
15198 {
15199         if (flags & NDR_IN) {
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_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
15208 {
15209         if (flags & NDR_IN) {
15210         }
15211         if (flags & NDR_OUT) {
15212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15213         }
15214         return NDR_ERR_SUCCESS;
15215 }
15216
15217 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
15218 {
15219         ndr_print_struct(ndr, name, "spoolss_47");
15220         ndr->depth++;
15221         if (flags & NDR_SET_VALUES) {
15222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15223         }
15224         if (flags & NDR_IN) {
15225                 ndr_print_struct(ndr, "in", "spoolss_47");
15226                 ndr->depth++;
15227                 ndr->depth--;
15228         }
15229         if (flags & NDR_OUT) {
15230                 ndr_print_struct(ndr, "out", "spoolss_47");
15231                 ndr->depth++;
15232                 ndr_print_WERROR(ndr, "result", r->out.result);
15233                 ndr->depth--;
15234         }
15235         ndr->depth--;
15236 }
15237
15238 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
15239 {
15240         if (flags & NDR_IN) {
15241                 if (r->in.handle == NULL) {
15242                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15243                 }
15244                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
15246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
15247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
15248         }
15249         if (flags & NDR_OUT) {
15250                 if (r->out.value_name == NULL) {
15251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15252                 }
15253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
15254                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
15255                 if (r->out.value_needed == NULL) {
15256                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15257                 }
15258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
15259                 if (r->out.printerdata_type == NULL) {
15260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15261                 }
15262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
15263                 if (r->out.buffer == NULL) {
15264                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15265                 }
15266                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
15267                 if (r->out.data_needed == NULL) {
15268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15269                 }
15270                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
15271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15272         }
15273         return NDR_ERR_SUCCESS;
15274 }
15275
15276 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
15277 {
15278         TALLOC_CTX *_mem_save_handle_0;
15279         TALLOC_CTX *_mem_save_value_needed_0;
15280         TALLOC_CTX *_mem_save_printerdata_type_0;
15281         TALLOC_CTX *_mem_save_buffer_0;
15282         TALLOC_CTX *_mem_save_data_needed_0;
15283         if (flags & NDR_IN) {
15284                 ZERO_STRUCT(r->out);
15285
15286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15287                         NDR_PULL_ALLOC(ndr, r->in.handle);
15288                 }
15289                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15290                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15291                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15293                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
15294                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
15295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
15296                 NDR_PULL_ALLOC_N(ndr, r->out.value_name, r->in.value_offered / 2);
15297                 memset(CONST_DISCARD(struct spoolss_EnumPrinterData *,r->out.value_name), 0, (r->in.value_offered / 2) * sizeof(*r->out.value_name));
15298                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
15299                 ZERO_STRUCTP(r->out.value_needed);
15300                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
15301                 ZERO_STRUCTP(r->out.printerdata_type);
15302                 NDR_PULL_ALLOC(ndr, r->out.buffer);
15303                 ZERO_STRUCTP(r->out.buffer);
15304                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
15305                 ZERO_STRUCTP(r->out.data_needed);
15306         }
15307         if (flags & NDR_OUT) {
15308                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
15309                 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));
15310                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15311                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
15312                 }
15313                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15314                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
15315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
15316                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
15317                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15318                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
15319                 }
15320                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15321                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
15322                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
15323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
15324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15325                         NDR_PULL_ALLOC(ndr, r->out.buffer);
15326                 }
15327                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15328                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
15329                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
15330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
15331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15332                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
15333                 }
15334                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15335                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
15336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
15337                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
15338                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15339                 if (r->out.value_name) {
15340                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
15341                 }
15342         }
15343         return NDR_ERR_SUCCESS;
15344 }
15345
15346 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
15347 {
15348         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
15349         ndr->depth++;
15350         if (flags & NDR_SET_VALUES) {
15351                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15352         }
15353         if (flags & NDR_IN) {
15354                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
15355                 ndr->depth++;
15356                 ndr_print_ptr(ndr, "handle", r->in.handle);
15357                 ndr->depth++;
15358                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15359                 ndr->depth--;
15360                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
15361                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
15362                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
15363                 ndr->depth--;
15364         }
15365         if (flags & NDR_OUT) {
15366                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
15367                 ndr->depth++;
15368                 ndr_print_ptr(ndr, "value_name", r->out.value_name);
15369                 ndr->depth++;
15370                 ndr_print_string(ndr, "value_name", r->out.value_name);
15371                 ndr->depth--;
15372                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
15373                 ndr->depth++;
15374                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
15375                 ndr->depth--;
15376                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
15377                 ndr->depth++;
15378                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
15379                 ndr->depth--;
15380                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
15381                 ndr->depth++;
15382                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
15383                 ndr->depth--;
15384                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
15385                 ndr->depth++;
15386                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
15387                 ndr->depth--;
15388                 ndr_print_WERROR(ndr, "result", r->out.result);
15389                 ndr->depth--;
15390         }
15391         ndr->depth--;
15392 }
15393
15394 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
15395 {
15396         if (flags & NDR_IN) {
15397                 if (r->in.handle == NULL) {
15398                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15399                 }
15400                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15404                 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));
15405         }
15406         if (flags & NDR_OUT) {
15407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15408         }
15409         return NDR_ERR_SUCCESS;
15410 }
15411
15412 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
15413 {
15414         TALLOC_CTX *_mem_save_handle_0;
15415         if (flags & NDR_IN) {
15416                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15417                         NDR_PULL_ALLOC(ndr, r->in.handle);
15418                 }
15419                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15420                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15421                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15422                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15423                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15424                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15425                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15426                         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));
15427                 }
15428                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15429                 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));
15430         }
15431         if (flags & NDR_OUT) {
15432                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15433         }
15434         return NDR_ERR_SUCCESS;
15435 }
15436
15437 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
15438 {
15439         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
15440         ndr->depth++;
15441         if (flags & NDR_SET_VALUES) {
15442                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15443         }
15444         if (flags & NDR_IN) {
15445                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
15446                 ndr->depth++;
15447                 ndr_print_ptr(ndr, "handle", r->in.handle);
15448                 ndr->depth++;
15449                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15450                 ndr->depth--;
15451                 ndr_print_string(ndr, "value_name", r->in.value_name);
15452                 ndr->depth--;
15453         }
15454         if (flags & NDR_OUT) {
15455                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
15456                 ndr->depth++;
15457                 ndr_print_WERROR(ndr, "result", r->out.result);
15458                 ndr->depth--;
15459         }
15460         ndr->depth--;
15461 }
15462
15463 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
15464 {
15465         if (flags & NDR_IN) {
15466         }
15467         if (flags & NDR_OUT) {
15468                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15469         }
15470         return NDR_ERR_SUCCESS;
15471 }
15472
15473 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
15474 {
15475         if (flags & NDR_IN) {
15476         }
15477         if (flags & NDR_OUT) {
15478                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15479         }
15480         return NDR_ERR_SUCCESS;
15481 }
15482
15483 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
15484 {
15485         ndr_print_struct(ndr, name, "spoolss_4a");
15486         ndr->depth++;
15487         if (flags & NDR_SET_VALUES) {
15488                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15489         }
15490         if (flags & NDR_IN) {
15491                 ndr_print_struct(ndr, "in", "spoolss_4a");
15492                 ndr->depth++;
15493                 ndr->depth--;
15494         }
15495         if (flags & NDR_OUT) {
15496                 ndr_print_struct(ndr, "out", "spoolss_4a");
15497                 ndr->depth++;
15498                 ndr_print_WERROR(ndr, "result", r->out.result);
15499                 ndr->depth--;
15500         }
15501         ndr->depth--;
15502 }
15503
15504 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
15505 {
15506         if (flags & NDR_IN) {
15507         }
15508         if (flags & NDR_OUT) {
15509                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15510         }
15511         return NDR_ERR_SUCCESS;
15512 }
15513
15514 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
15515 {
15516         if (flags & NDR_IN) {
15517         }
15518         if (flags & NDR_OUT) {
15519                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15520         }
15521         return NDR_ERR_SUCCESS;
15522 }
15523
15524 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
15525 {
15526         ndr_print_struct(ndr, name, "spoolss_4b");
15527         ndr->depth++;
15528         if (flags & NDR_SET_VALUES) {
15529                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15530         }
15531         if (flags & NDR_IN) {
15532                 ndr_print_struct(ndr, "in", "spoolss_4b");
15533                 ndr->depth++;
15534                 ndr->depth--;
15535         }
15536         if (flags & NDR_OUT) {
15537                 ndr_print_struct(ndr, "out", "spoolss_4b");
15538                 ndr->depth++;
15539                 ndr_print_WERROR(ndr, "result", r->out.result);
15540                 ndr->depth--;
15541         }
15542         ndr->depth--;
15543 }
15544
15545 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
15546 {
15547         if (flags & NDR_IN) {
15548         }
15549         if (flags & NDR_OUT) {
15550                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15551         }
15552         return NDR_ERR_SUCCESS;
15553 }
15554
15555 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
15556 {
15557         if (flags & NDR_IN) {
15558         }
15559         if (flags & NDR_OUT) {
15560                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15561         }
15562         return NDR_ERR_SUCCESS;
15563 }
15564
15565 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
15566 {
15567         ndr_print_struct(ndr, name, "spoolss_4c");
15568         ndr->depth++;
15569         if (flags & NDR_SET_VALUES) {
15570                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15571         }
15572         if (flags & NDR_IN) {
15573                 ndr_print_struct(ndr, "in", "spoolss_4c");
15574                 ndr->depth++;
15575                 ndr->depth--;
15576         }
15577         if (flags & NDR_OUT) {
15578                 ndr_print_struct(ndr, "out", "spoolss_4c");
15579                 ndr->depth++;
15580                 ndr_print_WERROR(ndr, "result", r->out.result);
15581                 ndr->depth--;
15582         }
15583         ndr->depth--;
15584 }
15585
15586 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
15587 {
15588         if (flags & NDR_IN) {
15589                 if (r->in.handle == NULL) {
15590                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15591                 }
15592                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15596                 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));
15597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15600                 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));
15601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
15602                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15604         }
15605         if (flags & NDR_OUT) {
15606                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15607         }
15608         return NDR_ERR_SUCCESS;
15609 }
15610
15611 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
15612 {
15613         TALLOC_CTX *_mem_save_handle_0;
15614         if (flags & NDR_IN) {
15615                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15616                         NDR_PULL_ALLOC(ndr, r->in.handle);
15617                 }
15618                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15619                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15620                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15621                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15622                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15623                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15624                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15625                         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));
15626                 }
15627                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15628                 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));
15629                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15630                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15631                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15632                         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));
15633                 }
15634                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15635                 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));
15636                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
15637                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.buffer));
15638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15639         }
15640         if (flags & NDR_OUT) {
15641                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15642         }
15643         return NDR_ERR_SUCCESS;
15644 }
15645
15646 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
15647 {
15648         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
15649         ndr->depth++;
15650         if (flags & NDR_SET_VALUES) {
15651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15652         }
15653         if (flags & NDR_IN) {
15654                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
15655                 ndr->depth++;
15656                 ndr_print_ptr(ndr, "handle", r->in.handle);
15657                 ndr->depth++;
15658                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15659                 ndr->depth--;
15660                 ndr_print_string(ndr, "key_name", r->in.key_name);
15661                 ndr_print_string(ndr, "value_name", r->in.value_name);
15662                 ndr_print_uint32(ndr, "type", r->in.type);
15663                 ndr_print_DATA_BLOB(ndr, "buffer", r->in.buffer);
15664                 ndr_print_uint32(ndr, "offered", r->in.offered);
15665                 ndr->depth--;
15666         }
15667         if (flags & NDR_OUT) {
15668                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
15669                 ndr->depth++;
15670                 ndr_print_WERROR(ndr, "result", r->out.result);
15671                 ndr->depth--;
15672         }
15673         ndr->depth--;
15674 }
15675
15676 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
15677 {
15678         if (flags & NDR_IN) {
15679                 if (r->in.handle == NULL) {
15680                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15681                 }
15682                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15686                 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));
15687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15690                 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));
15691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15692         }
15693         if (flags & NDR_OUT) {
15694                 if (r->out.type == NULL) {
15695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15696                 }
15697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
15698                 if (r->out.buffer == NULL) {
15699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15700                 }
15701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15702                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
15703                 if (r->out.needed == NULL) {
15704                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15705                 }
15706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15707                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15708         }
15709         return NDR_ERR_SUCCESS;
15710 }
15711
15712 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
15713 {
15714         TALLOC_CTX *_mem_save_handle_0;
15715         TALLOC_CTX *_mem_save_type_0;
15716         TALLOC_CTX *_mem_save_needed_0;
15717         if (flags & NDR_IN) {
15718                 ZERO_STRUCT(r->out);
15719
15720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15721                         NDR_PULL_ALLOC(ndr, r->in.handle);
15722                 }
15723                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15724                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15725                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15727                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15728                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15729                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15730                         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));
15731                 }
15732                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15733                 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));
15734                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15735                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15736                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15737                         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));
15738                 }
15739                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15740                 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));
15741                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15742                 NDR_PULL_ALLOC(ndr, r->out.type);
15743                 ZERO_STRUCTP(r->out.type);
15744                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
15745                 memset(CONST_DISCARD(struct spoolss_GetPrinterDataEx *,r->out.buffer), 0, (r->in.offered) * sizeof(*r->out.buffer));
15746                 NDR_PULL_ALLOC(ndr, r->out.needed);
15747                 ZERO_STRUCTP(r->out.needed);
15748         }
15749         if (flags & NDR_OUT) {
15750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15751                         NDR_PULL_ALLOC(ndr, r->out.type);
15752                 }
15753                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
15754                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
15755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
15756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
15757                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
15758                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15759                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
15760                 }
15761                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
15762                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15763                         NDR_PULL_ALLOC(ndr, r->out.needed);
15764                 }
15765                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15766                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15767                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15768                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15769                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15770                 if (r->out.buffer) {
15771                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
15772                 }
15773         }
15774         return NDR_ERR_SUCCESS;
15775 }
15776
15777 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
15778 {
15779         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
15780         ndr->depth++;
15781         if (flags & NDR_SET_VALUES) {
15782                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15783         }
15784         if (flags & NDR_IN) {
15785                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
15786                 ndr->depth++;
15787                 ndr_print_ptr(ndr, "handle", r->in.handle);
15788                 ndr->depth++;
15789                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15790                 ndr->depth--;
15791                 ndr_print_string(ndr, "key_name", r->in.key_name);
15792                 ndr_print_string(ndr, "value_name", r->in.value_name);
15793                 ndr_print_uint32(ndr, "offered", r->in.offered);
15794                 ndr->depth--;
15795         }
15796         if (flags & NDR_OUT) {
15797                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
15798                 ndr->depth++;
15799                 ndr_print_ptr(ndr, "type", r->out.type);
15800                 ndr->depth++;
15801                 ndr_print_uint32(ndr, "type", *r->out.type);
15802                 ndr->depth--;
15803                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
15804                 ndr->depth++;
15805                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
15806                 ndr->depth--;
15807                 ndr_print_ptr(ndr, "needed", r->out.needed);
15808                 ndr->depth++;
15809                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15810                 ndr->depth--;
15811                 ndr_print_WERROR(ndr, "result", r->out.result);
15812                 ndr->depth--;
15813         }
15814         ndr->depth--;
15815 }
15816
15817 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
15818 {
15819         if (flags & NDR_IN) {
15820                 if (r->in.handle == NULL) {
15821                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15822                 }
15823                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15826                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15827                 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));
15828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15829         }
15830         if (flags & NDR_OUT) {
15831                 if (r->out.buffer == NULL) {
15832                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15833                 }
15834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15835                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
15836                 if (r->out.needed == NULL) {
15837                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15838                 }
15839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15840                 if (r->out.count == NULL) {
15841                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15842                 }
15843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
15844                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15845         }
15846         return NDR_ERR_SUCCESS;
15847 }
15848
15849 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
15850 {
15851         TALLOC_CTX *_mem_save_handle_0;
15852         TALLOC_CTX *_mem_save_needed_0;
15853         TALLOC_CTX *_mem_save_count_0;
15854         if (flags & NDR_IN) {
15855                 ZERO_STRUCT(r->out);
15856
15857                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15858                         NDR_PULL_ALLOC(ndr, r->in.handle);
15859                 }
15860                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15861                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15862                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15863                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15864                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15865                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15866                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15867                         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));
15868                 }
15869                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15870                 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));
15871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15872                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
15873                 memset(CONST_DISCARD(struct spoolss_EnumPrinterDataEx *,r->out.buffer), 0, (r->in.offered) * sizeof(*r->out.buffer));
15874                 NDR_PULL_ALLOC(ndr, r->out.needed);
15875                 ZERO_STRUCTP(r->out.needed);
15876                 NDR_PULL_ALLOC(ndr, r->out.count);
15877                 ZERO_STRUCTP(r->out.count);
15878         }
15879         if (flags & NDR_OUT) {
15880                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
15881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15882                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
15883                 }
15884                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
15885                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15886                         NDR_PULL_ALLOC(ndr, r->out.needed);
15887                 }
15888                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
15889                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
15890                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
15891                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
15892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15893                         NDR_PULL_ALLOC(ndr, r->out.count);
15894                 }
15895                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
15896                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
15897                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
15898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
15899                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15900                 if (r->out.buffer) {
15901                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
15902                 }
15903         }
15904         return NDR_ERR_SUCCESS;
15905 }
15906
15907 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
15908 {
15909         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
15910         ndr->depth++;
15911         if (flags & NDR_SET_VALUES) {
15912                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15913         }
15914         if (flags & NDR_IN) {
15915                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
15916                 ndr->depth++;
15917                 ndr_print_ptr(ndr, "handle", r->in.handle);
15918                 ndr->depth++;
15919                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15920                 ndr->depth--;
15921                 ndr_print_string(ndr, "key_name", r->in.key_name);
15922                 ndr_print_uint32(ndr, "offered", r->in.offered);
15923                 ndr->depth--;
15924         }
15925         if (flags & NDR_OUT) {
15926                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
15927                 ndr->depth++;
15928                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
15929                 ndr->depth++;
15930                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
15931                 ndr->depth--;
15932                 ndr_print_ptr(ndr, "needed", r->out.needed);
15933                 ndr->depth++;
15934                 ndr_print_uint32(ndr, "needed", *r->out.needed);
15935                 ndr->depth--;
15936                 ndr_print_ptr(ndr, "count", r->out.count);
15937                 ndr->depth++;
15938                 ndr_print_uint32(ndr, "count", *r->out.count);
15939                 ndr->depth--;
15940                 ndr_print_WERROR(ndr, "result", r->out.result);
15941                 ndr->depth--;
15942         }
15943         ndr->depth--;
15944 }
15945
15946 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
15947 {
15948         uint32_t cntr_key_buffer_1;
15949         if (flags & NDR_IN) {
15950                 if (r->in.handle == NULL) {
15951                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15952                 }
15953                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15957                 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));
15958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
15959         }
15960         if (flags & NDR_OUT) {
15961                 if (r->out.key_buffer == NULL) {
15962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15963                 }
15964                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
15965                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
15966                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
15967                 }
15968                 if (r->out.needed == NULL) {
15969                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15970                 }
15971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
15972                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15973         }
15974         return NDR_ERR_SUCCESS;
15975 }
15976
15977 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
15978 {
15979         uint32_t cntr_key_buffer_1;
15980         TALLOC_CTX *_mem_save_handle_0;
15981         TALLOC_CTX *_mem_save_key_buffer_1;
15982         TALLOC_CTX *_mem_save_needed_0;
15983         if (flags & NDR_IN) {
15984                 ZERO_STRUCT(r->out);
15985
15986                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15987                         NDR_PULL_ALLOC(ndr, r->in.handle);
15988                 }
15989                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15990                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15991                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15992                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15993                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15994                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15995                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15996                         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));
15997                 }
15998                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15999                 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));
16000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
16001                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
16002                 memset(CONST_DISCARD(struct spoolss_EnumPrinterKey *,r->out.key_buffer), 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
16003                 NDR_PULL_ALLOC(ndr, r->out.needed);
16004                 ZERO_STRUCTP(r->out.needed);
16005         }
16006         if (flags & NDR_OUT) {
16007                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
16008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16009                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
16010                 }
16011                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
16012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
16013                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
16014                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
16015                 }
16016                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
16017                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16018                         NDR_PULL_ALLOC(ndr, r->out.needed);
16019                 }
16020                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16021                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16023                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16024                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16025                 if (r->out.key_buffer) {
16026                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
16027                 }
16028         }
16029         return NDR_ERR_SUCCESS;
16030 }
16031
16032 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
16033 {
16034         uint32_t cntr_key_buffer_1;
16035         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
16036         ndr->depth++;
16037         if (flags & NDR_SET_VALUES) {
16038                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16039         }
16040         if (flags & NDR_IN) {
16041                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
16042                 ndr->depth++;
16043                 ndr_print_ptr(ndr, "handle", r->in.handle);
16044                 ndr->depth++;
16045                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16046                 ndr->depth--;
16047                 ndr_print_string(ndr, "key_name", r->in.key_name);
16048                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
16049                 ndr->depth--;
16050         }
16051         if (flags & NDR_OUT) {
16052                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
16053                 ndr->depth++;
16054                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
16055                 ndr->depth++;
16056                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
16057                 ndr->depth++;
16058                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
16059                         char *idx_1=NULL;
16060                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
16061                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
16062                                 free(idx_1);
16063                         }
16064                 }
16065                 ndr->depth--;
16066                 ndr->depth--;
16067                 ndr_print_ptr(ndr, "needed", r->out.needed);
16068                 ndr->depth++;
16069                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16070                 ndr->depth--;
16071                 ndr_print_WERROR(ndr, "result", r->out.result);
16072                 ndr->depth--;
16073         }
16074         ndr->depth--;
16075 }
16076
16077 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
16078 {
16079         if (flags & NDR_IN) {
16080                 if (r->in.handle == NULL) {
16081                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16082                 }
16083                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16087                 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));
16088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
16089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
16091                 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));
16092         }
16093         if (flags & NDR_OUT) {
16094                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16095         }
16096         return NDR_ERR_SUCCESS;
16097 }
16098
16099 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
16100 {
16101         TALLOC_CTX *_mem_save_handle_0;
16102         if (flags & NDR_IN) {
16103                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16104                         NDR_PULL_ALLOC(ndr, r->in.handle);
16105                 }
16106                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16107                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16108                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16109                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16110                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
16111                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
16112                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
16113                         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));
16114                 }
16115                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
16116                 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));
16117                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
16118                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
16119                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
16120                         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));
16121                 }
16122                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
16123                 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));
16124         }
16125         if (flags & NDR_OUT) {
16126                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16127         }
16128         return NDR_ERR_SUCCESS;
16129 }
16130
16131 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
16132 {
16133         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
16134         ndr->depth++;
16135         if (flags & NDR_SET_VALUES) {
16136                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16137         }
16138         if (flags & NDR_IN) {
16139                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
16140                 ndr->depth++;
16141                 ndr_print_ptr(ndr, "handle", r->in.handle);
16142                 ndr->depth++;
16143                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16144                 ndr->depth--;
16145                 ndr_print_string(ndr, "key_name", r->in.key_name);
16146                 ndr_print_string(ndr, "value_name", r->in.value_name);
16147                 ndr->depth--;
16148         }
16149         if (flags & NDR_OUT) {
16150                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
16151                 ndr->depth++;
16152                 ndr_print_WERROR(ndr, "result", r->out.result);
16153                 ndr->depth--;
16154         }
16155         ndr->depth--;
16156 }
16157
16158 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
16159 {
16160         if (flags & NDR_IN) {
16161                 if (r->in.handle == NULL) {
16162                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16163                 }
16164                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16167                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
16168                 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));
16169         }
16170         if (flags & NDR_OUT) {
16171                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16172         }
16173         return NDR_ERR_SUCCESS;
16174 }
16175
16176 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
16177 {
16178         TALLOC_CTX *_mem_save_handle_0;
16179         if (flags & NDR_IN) {
16180                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16181                         NDR_PULL_ALLOC(ndr, r->in.handle);
16182                 }
16183                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16184                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16185                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16186                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16187                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
16188                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
16189                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
16190                         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));
16191                 }
16192                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
16193                 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));
16194         }
16195         if (flags & NDR_OUT) {
16196                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16197         }
16198         return NDR_ERR_SUCCESS;
16199 }
16200
16201 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
16202 {
16203         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
16204         ndr->depth++;
16205         if (flags & NDR_SET_VALUES) {
16206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16207         }
16208         if (flags & NDR_IN) {
16209                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
16210                 ndr->depth++;
16211                 ndr_print_ptr(ndr, "handle", r->in.handle);
16212                 ndr->depth++;
16213                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16214                 ndr->depth--;
16215                 ndr_print_string(ndr, "key_name", r->in.key_name);
16216                 ndr->depth--;
16217         }
16218         if (flags & NDR_OUT) {
16219                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
16220                 ndr->depth++;
16221                 ndr_print_WERROR(ndr, "result", r->out.result);
16222                 ndr->depth--;
16223         }
16224         ndr->depth--;
16225 }
16226
16227 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
16228 {
16229         if (flags & NDR_IN) {
16230         }
16231         if (flags & NDR_OUT) {
16232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16233         }
16234         return NDR_ERR_SUCCESS;
16235 }
16236
16237 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
16238 {
16239         if (flags & NDR_IN) {
16240         }
16241         if (flags & NDR_OUT) {
16242                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16243         }
16244         return NDR_ERR_SUCCESS;
16245 }
16246
16247 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
16248 {
16249         ndr_print_struct(ndr, name, "spoolss_53");
16250         ndr->depth++;
16251         if (flags & NDR_SET_VALUES) {
16252                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16253         }
16254         if (flags & NDR_IN) {
16255                 ndr_print_struct(ndr, "in", "spoolss_53");
16256                 ndr->depth++;
16257                 ndr->depth--;
16258         }
16259         if (flags & NDR_OUT) {
16260                 ndr_print_struct(ndr, "out", "spoolss_53");
16261                 ndr->depth++;
16262                 ndr_print_WERROR(ndr, "result", r->out.result);
16263                 ndr->depth--;
16264         }
16265         ndr->depth--;
16266 }
16267
16268 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
16269 {
16270         if (flags & NDR_IN) {
16271                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
16272                 if (r->in.server) {
16273                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16274                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16275                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
16276                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16277                 }
16278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16280                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
16281                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
16285                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
16286                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
16287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
16288         }
16289         if (flags & NDR_OUT) {
16290                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16291         }
16292         return NDR_ERR_SUCCESS;
16293 }
16294
16295 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
16296 {
16297         uint32_t _ptr_server;
16298         TALLOC_CTX *_mem_save_server_0;
16299         if (flags & NDR_IN) {
16300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
16301                 if (_ptr_server) {
16302                         NDR_PULL_ALLOC(ndr, r->in.server);
16303                 } else {
16304                         r->in.server = NULL;
16305                 }
16306                 if (r->in.server) {
16307                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
16308                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
16309                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
16310                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
16311                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
16312                                 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));
16313                         }
16314                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
16315                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
16316                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
16317                 }
16318                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
16319                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
16320                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
16321                         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));
16322                 }
16323                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
16324                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
16325                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
16326                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
16327                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
16328                         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));
16329                 }
16330                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
16331                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
16332                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
16333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
16334         }
16335         if (flags & NDR_OUT) {
16336                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16337         }
16338         return NDR_ERR_SUCCESS;
16339 }
16340
16341 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
16342 {
16343         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
16344         ndr->depth++;
16345         if (flags & NDR_SET_VALUES) {
16346                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16347         }
16348         if (flags & NDR_IN) {
16349                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
16350                 ndr->depth++;
16351                 ndr_print_ptr(ndr, "server", r->in.server);
16352                 ndr->depth++;
16353                 if (r->in.server) {
16354                         ndr_print_string(ndr, "server", r->in.server);
16355                 }
16356                 ndr->depth--;
16357                 ndr_print_string(ndr, "architecture", r->in.architecture);
16358                 ndr_print_string(ndr, "driver", r->in.driver);
16359                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
16360                 ndr_print_uint32(ndr, "version", r->in.version);
16361                 ndr->depth--;
16362         }
16363         if (flags & NDR_OUT) {
16364                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
16365                 ndr->depth++;
16366                 ndr_print_WERROR(ndr, "result", r->out.result);
16367                 ndr->depth--;
16368         }
16369         ndr->depth--;
16370 }
16371
16372 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
16373 {
16374         if (flags & NDR_IN) {
16375         }
16376         if (flags & NDR_OUT) {
16377                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16378         }
16379         return NDR_ERR_SUCCESS;
16380 }
16381
16382 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
16383 {
16384         if (flags & NDR_IN) {
16385         }
16386         if (flags & NDR_OUT) {
16387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16388         }
16389         return NDR_ERR_SUCCESS;
16390 }
16391
16392 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
16393 {
16394         ndr_print_struct(ndr, name, "spoolss_55");
16395         ndr->depth++;
16396         if (flags & NDR_SET_VALUES) {
16397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16398         }
16399         if (flags & NDR_IN) {
16400                 ndr_print_struct(ndr, "in", "spoolss_55");
16401                 ndr->depth++;
16402                 ndr->depth--;
16403         }
16404         if (flags & NDR_OUT) {
16405                 ndr_print_struct(ndr, "out", "spoolss_55");
16406                 ndr->depth++;
16407                 ndr_print_WERROR(ndr, "result", r->out.result);
16408                 ndr->depth--;
16409         }
16410         ndr->depth--;
16411 }
16412
16413 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
16414 {
16415         if (flags & NDR_IN) {
16416         }
16417         if (flags & NDR_OUT) {
16418                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16419         }
16420         return NDR_ERR_SUCCESS;
16421 }
16422
16423 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
16424 {
16425         if (flags & NDR_IN) {
16426         }
16427         if (flags & NDR_OUT) {
16428                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16429         }
16430         return NDR_ERR_SUCCESS;
16431 }
16432
16433 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
16434 {
16435         ndr_print_struct(ndr, name, "spoolss_56");
16436         ndr->depth++;
16437         if (flags & NDR_SET_VALUES) {
16438                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16439         }
16440         if (flags & NDR_IN) {
16441                 ndr_print_struct(ndr, "in", "spoolss_56");
16442                 ndr->depth++;
16443                 ndr->depth--;
16444         }
16445         if (flags & NDR_OUT) {
16446                 ndr_print_struct(ndr, "out", "spoolss_56");
16447                 ndr->depth++;
16448                 ndr_print_WERROR(ndr, "result", r->out.result);
16449                 ndr->depth--;
16450         }
16451         ndr->depth--;
16452 }
16453
16454 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
16455 {
16456         if (flags & NDR_IN) {
16457         }
16458         if (flags & NDR_OUT) {
16459                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16460         }
16461         return NDR_ERR_SUCCESS;
16462 }
16463
16464 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
16465 {
16466         if (flags & NDR_IN) {
16467         }
16468         if (flags & NDR_OUT) {
16469                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16470         }
16471         return NDR_ERR_SUCCESS;
16472 }
16473
16474 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
16475 {
16476         ndr_print_struct(ndr, name, "spoolss_57");
16477         ndr->depth++;
16478         if (flags & NDR_SET_VALUES) {
16479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16480         }
16481         if (flags & NDR_IN) {
16482                 ndr_print_struct(ndr, "in", "spoolss_57");
16483                 ndr->depth++;
16484                 ndr->depth--;
16485         }
16486         if (flags & NDR_OUT) {
16487                 ndr_print_struct(ndr, "out", "spoolss_57");
16488                 ndr->depth++;
16489                 ndr_print_WERROR(ndr, "result", r->out.result);
16490                 ndr->depth--;
16491         }
16492         ndr->depth--;
16493 }
16494
16495 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
16496 {
16497         if (flags & NDR_IN) {
16498                 if (r->in.handle == NULL) {
16499                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16500                 }
16501                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
16503                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
16504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
16505                 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));
16506                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
16507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
16508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
16509                 if (r->in.status_code == NULL) {
16510                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16511                 }
16512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
16513         }
16514         if (flags & NDR_OUT) {
16515                 if (r->out.out_data == NULL) {
16516                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16517                 }
16518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
16519                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
16520                 if (r->out.needed == NULL) {
16521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16522                 }
16523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
16524                 if (r->out.status_code == NULL) {
16525                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
16526                 }
16527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
16528                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16529         }
16530         return NDR_ERR_SUCCESS;
16531 }
16532
16533 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
16534 {
16535         TALLOC_CTX *_mem_save_handle_0;
16536         TALLOC_CTX *_mem_save_needed_0;
16537         TALLOC_CTX *_mem_save_status_code_0;
16538         if (flags & NDR_IN) {
16539                 ZERO_STRUCT(r->out);
16540
16541                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16542                         NDR_PULL_ALLOC(ndr, r->in.handle);
16543                 }
16544                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
16545                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
16546                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
16547                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
16548                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
16549                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
16550                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
16551                         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));
16552                 }
16553                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
16554                 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));
16555                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
16556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
16557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
16558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16559                         NDR_PULL_ALLOC(ndr, r->in.status_code);
16560                 }
16561                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
16562                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
16563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
16564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
16565                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
16566                 memset(CONST_DISCARD(struct spoolss_XcvData *,r->out.out_data), 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
16567                 NDR_PULL_ALLOC(ndr, r->out.needed);
16568                 ZERO_STRUCTP(r->out.needed);
16569                 NDR_PULL_ALLOC(ndr, r->out.status_code);
16570                 *r->out.status_code = *r->in.status_code;
16571         }
16572         if (flags & NDR_OUT) {
16573                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
16574                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16575                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
16576                 }
16577                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
16578                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16579                         NDR_PULL_ALLOC(ndr, r->out.needed);
16580                 }
16581                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
16582                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
16583                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
16584                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
16585                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
16586                         NDR_PULL_ALLOC(ndr, r->out.status_code);
16587                 }
16588                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
16589                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
16590                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
16591                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
16592                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16593                 if (r->out.out_data) {
16594                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
16595                 }
16596         }
16597         return NDR_ERR_SUCCESS;
16598 }
16599
16600 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
16601 {
16602         ndr_print_struct(ndr, name, "spoolss_XcvData");
16603         ndr->depth++;
16604         if (flags & NDR_SET_VALUES) {
16605                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16606         }
16607         if (flags & NDR_IN) {
16608                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
16609                 ndr->depth++;
16610                 ndr_print_ptr(ndr, "handle", r->in.handle);
16611                 ndr->depth++;
16612                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
16613                 ndr->depth--;
16614                 ndr_print_string(ndr, "function_name", r->in.function_name);
16615                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
16616                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
16617                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
16618                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
16619                 ndr->depth++;
16620                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
16621                 ndr->depth--;
16622                 ndr->depth--;
16623         }
16624         if (flags & NDR_OUT) {
16625                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
16626                 ndr->depth++;
16627                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
16628                 ndr->depth++;
16629                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
16630                 ndr->depth--;
16631                 ndr_print_ptr(ndr, "needed", r->out.needed);
16632                 ndr->depth++;
16633                 ndr_print_uint32(ndr, "needed", *r->out.needed);
16634                 ndr->depth--;
16635                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
16636                 ndr->depth++;
16637                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
16638                 ndr->depth--;
16639                 ndr_print_WERROR(ndr, "result", r->out.result);
16640                 ndr->depth--;
16641         }
16642         ndr->depth--;
16643 }
16644
16645 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
16646 {
16647         if (flags & NDR_IN) {
16648         }
16649         if (flags & NDR_OUT) {
16650                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16651         }
16652         return NDR_ERR_SUCCESS;
16653 }
16654
16655 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
16656 {
16657         if (flags & NDR_IN) {
16658         }
16659         if (flags & NDR_OUT) {
16660                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16661         }
16662         return NDR_ERR_SUCCESS;
16663 }
16664
16665 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
16666 {
16667         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
16668         ndr->depth++;
16669         if (flags & NDR_SET_VALUES) {
16670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16671         }
16672         if (flags & NDR_IN) {
16673                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
16674                 ndr->depth++;
16675                 ndr->depth--;
16676         }
16677         if (flags & NDR_OUT) {
16678                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
16679                 ndr->depth++;
16680                 ndr_print_WERROR(ndr, "result", r->out.result);
16681                 ndr->depth--;
16682         }
16683         ndr->depth--;
16684 }
16685
16686 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
16687 {
16688         if (flags & NDR_IN) {
16689         }
16690         if (flags & NDR_OUT) {
16691                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16692         }
16693         return NDR_ERR_SUCCESS;
16694 }
16695
16696 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
16697 {
16698         if (flags & NDR_IN) {
16699         }
16700         if (flags & NDR_OUT) {
16701                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16702         }
16703         return NDR_ERR_SUCCESS;
16704 }
16705
16706 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
16707 {
16708         ndr_print_struct(ndr, name, "spoolss_5a");
16709         ndr->depth++;
16710         if (flags & NDR_SET_VALUES) {
16711                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16712         }
16713         if (flags & NDR_IN) {
16714                 ndr_print_struct(ndr, "in", "spoolss_5a");
16715                 ndr->depth++;
16716                 ndr->depth--;
16717         }
16718         if (flags & NDR_OUT) {
16719                 ndr_print_struct(ndr, "out", "spoolss_5a");
16720                 ndr->depth++;
16721                 ndr_print_WERROR(ndr, "result", r->out.result);
16722                 ndr->depth--;
16723         }
16724         ndr->depth--;
16725 }
16726
16727 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
16728 {
16729         if (flags & NDR_IN) {
16730         }
16731         if (flags & NDR_OUT) {
16732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16733         }
16734         return NDR_ERR_SUCCESS;
16735 }
16736
16737 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
16738 {
16739         if (flags & NDR_IN) {
16740         }
16741         if (flags & NDR_OUT) {
16742                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16743         }
16744         return NDR_ERR_SUCCESS;
16745 }
16746
16747 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
16748 {
16749         ndr_print_struct(ndr, name, "spoolss_5b");
16750         ndr->depth++;
16751         if (flags & NDR_SET_VALUES) {
16752                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16753         }
16754         if (flags & NDR_IN) {
16755                 ndr_print_struct(ndr, "in", "spoolss_5b");
16756                 ndr->depth++;
16757                 ndr->depth--;
16758         }
16759         if (flags & NDR_OUT) {
16760                 ndr_print_struct(ndr, "out", "spoolss_5b");
16761                 ndr->depth++;
16762                 ndr_print_WERROR(ndr, "result", r->out.result);
16763                 ndr->depth--;
16764         }
16765         ndr->depth--;
16766 }
16767
16768 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
16769 {
16770         if (flags & NDR_IN) {
16771         }
16772         if (flags & NDR_OUT) {
16773                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16774         }
16775         return NDR_ERR_SUCCESS;
16776 }
16777
16778 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
16779 {
16780         if (flags & NDR_IN) {
16781         }
16782         if (flags & NDR_OUT) {
16783                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16784         }
16785         return NDR_ERR_SUCCESS;
16786 }
16787
16788 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
16789 {
16790         ndr_print_struct(ndr, name, "spoolss_5c");
16791         ndr->depth++;
16792         if (flags & NDR_SET_VALUES) {
16793                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16794         }
16795         if (flags & NDR_IN) {
16796                 ndr_print_struct(ndr, "in", "spoolss_5c");
16797                 ndr->depth++;
16798                 ndr->depth--;
16799         }
16800         if (flags & NDR_OUT) {
16801                 ndr_print_struct(ndr, "out", "spoolss_5c");
16802                 ndr->depth++;
16803                 ndr_print_WERROR(ndr, "result", r->out.result);
16804                 ndr->depth--;
16805         }
16806         ndr->depth--;
16807 }
16808
16809 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
16810 {
16811         if (flags & NDR_IN) {
16812         }
16813         if (flags & NDR_OUT) {
16814                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16815         }
16816         return NDR_ERR_SUCCESS;
16817 }
16818
16819 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
16820 {
16821         if (flags & NDR_IN) {
16822         }
16823         if (flags & NDR_OUT) {
16824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16825         }
16826         return NDR_ERR_SUCCESS;
16827 }
16828
16829 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
16830 {
16831         ndr_print_struct(ndr, name, "spoolss_5d");
16832         ndr->depth++;
16833         if (flags & NDR_SET_VALUES) {
16834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16835         }
16836         if (flags & NDR_IN) {
16837                 ndr_print_struct(ndr, "in", "spoolss_5d");
16838                 ndr->depth++;
16839                 ndr->depth--;
16840         }
16841         if (flags & NDR_OUT) {
16842                 ndr_print_struct(ndr, "out", "spoolss_5d");
16843                 ndr->depth++;
16844                 ndr_print_WERROR(ndr, "result", r->out.result);
16845                 ndr->depth--;
16846         }
16847         ndr->depth--;
16848 }
16849
16850 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
16851 {
16852         if (flags & NDR_IN) {
16853         }
16854         if (flags & NDR_OUT) {
16855                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16856         }
16857         return NDR_ERR_SUCCESS;
16858 }
16859
16860 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
16861 {
16862         if (flags & NDR_IN) {
16863         }
16864         if (flags & NDR_OUT) {
16865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16866         }
16867         return NDR_ERR_SUCCESS;
16868 }
16869
16870 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
16871 {
16872         ndr_print_struct(ndr, name, "spoolss_5e");
16873         ndr->depth++;
16874         if (flags & NDR_SET_VALUES) {
16875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16876         }
16877         if (flags & NDR_IN) {
16878                 ndr_print_struct(ndr, "in", "spoolss_5e");
16879                 ndr->depth++;
16880                 ndr->depth--;
16881         }
16882         if (flags & NDR_OUT) {
16883                 ndr_print_struct(ndr, "out", "spoolss_5e");
16884                 ndr->depth++;
16885                 ndr_print_WERROR(ndr, "result", r->out.result);
16886                 ndr->depth--;
16887         }
16888         ndr->depth--;
16889 }
16890
16891 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
16892 {
16893         if (flags & NDR_IN) {
16894         }
16895         if (flags & NDR_OUT) {
16896                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16897         }
16898         return NDR_ERR_SUCCESS;
16899 }
16900
16901 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
16902 {
16903         if (flags & NDR_IN) {
16904         }
16905         if (flags & NDR_OUT) {
16906                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16907         }
16908         return NDR_ERR_SUCCESS;
16909 }
16910
16911 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
16912 {
16913         ndr_print_struct(ndr, name, "spoolss_5f");
16914         ndr->depth++;
16915         if (flags & NDR_SET_VALUES) {
16916                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16917         }
16918         if (flags & NDR_IN) {
16919                 ndr_print_struct(ndr, "in", "spoolss_5f");
16920                 ndr->depth++;
16921                 ndr->depth--;
16922         }
16923         if (flags & NDR_OUT) {
16924                 ndr_print_struct(ndr, "out", "spoolss_5f");
16925                 ndr->depth++;
16926                 ndr_print_WERROR(ndr, "result", r->out.result);
16927                 ndr->depth--;
16928         }
16929         ndr->depth--;
16930 }
16931
16932 static const struct ndr_interface_call spoolss_calls[] = {
16933         {
16934                 "spoolss_EnumPrinters",
16935                 sizeof(struct spoolss_EnumPrinters),
16936                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
16937                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
16938                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
16939                 false,
16940         },
16941         {
16942                 "spoolss_OpenPrinter",
16943                 sizeof(struct spoolss_OpenPrinter),
16944                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
16945                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
16946                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
16947                 false,
16948         },
16949         {
16950                 "spoolss_SetJob",
16951                 sizeof(struct spoolss_SetJob),
16952                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
16953                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
16954                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
16955                 false,
16956         },
16957         {
16958                 "spoolss_GetJob",
16959                 sizeof(struct spoolss_GetJob),
16960                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
16961                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
16962                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
16963                 false,
16964         },
16965         {
16966                 "spoolss_EnumJobs",
16967                 sizeof(struct spoolss_EnumJobs),
16968                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
16969                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
16970                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
16971                 false,
16972         },
16973         {
16974                 "spoolss_AddPrinter",
16975                 sizeof(struct spoolss_AddPrinter),
16976                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
16977                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
16978                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
16979                 false,
16980         },
16981         {
16982                 "spoolss_DeletePrinter",
16983                 sizeof(struct spoolss_DeletePrinter),
16984                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
16985                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
16986                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
16987                 false,
16988         },
16989         {
16990                 "spoolss_SetPrinter",
16991                 sizeof(struct spoolss_SetPrinter),
16992                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
16993                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
16994                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
16995                 false,
16996         },
16997         {
16998                 "spoolss_GetPrinter",
16999                 sizeof(struct spoolss_GetPrinter),
17000                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
17001                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
17002                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
17003                 false,
17004         },
17005         {
17006                 "spoolss_AddPrinterDriver",
17007                 sizeof(struct spoolss_AddPrinterDriver),
17008                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
17009                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
17010                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
17011                 false,
17012         },
17013         {
17014                 "spoolss_EnumPrinterDrivers",
17015                 sizeof(struct spoolss_EnumPrinterDrivers),
17016                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
17017                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
17018                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
17019                 false,
17020         },
17021         {
17022                 "spoolss_GetPrinterDriver",
17023                 sizeof(struct spoolss_GetPrinterDriver),
17024                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
17025                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
17026                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
17027                 false,
17028         },
17029         {
17030                 "spoolss_GetPrinterDriverDirectory",
17031                 sizeof(struct spoolss_GetPrinterDriverDirectory),
17032                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
17033                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
17034                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
17035                 false,
17036         },
17037         {
17038                 "spoolss_DeletePrinterDriver",
17039                 sizeof(struct spoolss_DeletePrinterDriver),
17040                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
17041                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
17042                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
17043                 false,
17044         },
17045         {
17046                 "spoolss_AddPrintProcessor",
17047                 sizeof(struct spoolss_AddPrintProcessor),
17048                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
17049                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
17050                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
17051                 false,
17052         },
17053         {
17054                 "spoolss_EnumPrintProcessors",
17055                 sizeof(struct spoolss_EnumPrintProcessors),
17056                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
17057                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
17058                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
17059                 false,
17060         },
17061         {
17062                 "spoolss_GetPrintProcessorDirectory",
17063                 sizeof(struct spoolss_GetPrintProcessorDirectory),
17064                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
17065                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
17066                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
17067                 false,
17068         },
17069         {
17070                 "spoolss_StartDocPrinter",
17071                 sizeof(struct spoolss_StartDocPrinter),
17072                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
17073                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
17074                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
17075                 false,
17076         },
17077         {
17078                 "spoolss_StartPagePrinter",
17079                 sizeof(struct spoolss_StartPagePrinter),
17080                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
17081                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
17082                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
17083                 false,
17084         },
17085         {
17086                 "spoolss_WritePrinter",
17087                 sizeof(struct spoolss_WritePrinter),
17088                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
17089                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
17090                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
17091                 false,
17092         },
17093         {
17094                 "spoolss_EndPagePrinter",
17095                 sizeof(struct spoolss_EndPagePrinter),
17096                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
17097                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
17098                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
17099                 false,
17100         },
17101         {
17102                 "spoolss_AbortPrinter",
17103                 sizeof(struct spoolss_AbortPrinter),
17104                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
17105                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
17106                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
17107                 false,
17108         },
17109         {
17110                 "spoolss_ReadPrinter",
17111                 sizeof(struct spoolss_ReadPrinter),
17112                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
17113                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
17114                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
17115                 false,
17116         },
17117         {
17118                 "spoolss_EndDocPrinter",
17119                 sizeof(struct spoolss_EndDocPrinter),
17120                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
17121                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
17122                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
17123                 false,
17124         },
17125         {
17126                 "spoolss_AddJob",
17127                 sizeof(struct spoolss_AddJob),
17128                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
17129                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
17130                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
17131                 false,
17132         },
17133         {
17134                 "spoolss_ScheduleJob",
17135                 sizeof(struct spoolss_ScheduleJob),
17136                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
17137                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
17138                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
17139                 false,
17140         },
17141         {
17142                 "spoolss_GetPrinterData",
17143                 sizeof(struct spoolss_GetPrinterData),
17144                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
17145                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
17146                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
17147                 false,
17148         },
17149         {
17150                 "spoolss_SetPrinterData",
17151                 sizeof(struct spoolss_SetPrinterData),
17152                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
17153                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
17154                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
17155                 false,
17156         },
17157         {
17158                 "spoolss_WaitForPrinterChange",
17159                 sizeof(struct spoolss_WaitForPrinterChange),
17160                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
17161                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
17162                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
17163                 false,
17164         },
17165         {
17166                 "spoolss_ClosePrinter",
17167                 sizeof(struct spoolss_ClosePrinter),
17168                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
17169                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
17170                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
17171                 false,
17172         },
17173         {
17174                 "spoolss_AddForm",
17175                 sizeof(struct spoolss_AddForm),
17176                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
17177                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
17178                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
17179                 false,
17180         },
17181         {
17182                 "spoolss_DeleteForm",
17183                 sizeof(struct spoolss_DeleteForm),
17184                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
17185                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
17186                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
17187                 false,
17188         },
17189         {
17190                 "spoolss_GetForm",
17191                 sizeof(struct spoolss_GetForm),
17192                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
17193                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
17194                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
17195                 false,
17196         },
17197         {
17198                 "spoolss_SetForm",
17199                 sizeof(struct spoolss_SetForm),
17200                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
17201                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
17202                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
17203                 false,
17204         },
17205         {
17206                 "spoolss_EnumForms",
17207                 sizeof(struct spoolss_EnumForms),
17208                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
17209                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
17210                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
17211                 false,
17212         },
17213         {
17214                 "spoolss_EnumPorts",
17215                 sizeof(struct spoolss_EnumPorts),
17216                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
17217                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
17218                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
17219                 false,
17220         },
17221         {
17222                 "spoolss_EnumMonitors",
17223                 sizeof(struct spoolss_EnumMonitors),
17224                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
17225                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
17226                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
17227                 false,
17228         },
17229         {
17230                 "spoolss_AddPort",
17231                 sizeof(struct spoolss_AddPort),
17232                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
17233                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
17234                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
17235                 false,
17236         },
17237         {
17238                 "spoolss_ConfigurePort",
17239                 sizeof(struct spoolss_ConfigurePort),
17240                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
17241                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
17242                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
17243                 false,
17244         },
17245         {
17246                 "spoolss_DeletePort",
17247                 sizeof(struct spoolss_DeletePort),
17248                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
17249                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
17250                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
17251                 false,
17252         },
17253         {
17254                 "spoolss_CreatePrinterIC",
17255                 sizeof(struct spoolss_CreatePrinterIC),
17256                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
17257                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
17258                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
17259                 false,
17260         },
17261         {
17262                 "spoolss_PlayGDIScriptOnPrinterIC",
17263                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
17264                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
17265                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
17266                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
17267                 false,
17268         },
17269         {
17270                 "spoolss_DeletePrinterIC",
17271                 sizeof(struct spoolss_DeletePrinterIC),
17272                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
17273                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
17274                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
17275                 false,
17276         },
17277         {
17278                 "spoolss_AddPrinterConnection",
17279                 sizeof(struct spoolss_AddPrinterConnection),
17280                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
17281                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
17282                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
17283                 false,
17284         },
17285         {
17286                 "spoolss_DeletePrinterConnection",
17287                 sizeof(struct spoolss_DeletePrinterConnection),
17288                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
17289                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
17290                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
17291                 false,
17292         },
17293         {
17294                 "spoolss_PrinterMessageBox",
17295                 sizeof(struct spoolss_PrinterMessageBox),
17296                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
17297                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
17298                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
17299                 false,
17300         },
17301         {
17302                 "spoolss_AddMonitor",
17303                 sizeof(struct spoolss_AddMonitor),
17304                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
17305                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
17306                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
17307                 false,
17308         },
17309         {
17310                 "spoolss_DeleteMonitor",
17311                 sizeof(struct spoolss_DeleteMonitor),
17312                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
17313                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
17314                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
17315                 false,
17316         },
17317         {
17318                 "spoolss_DeletePrintProcessor",
17319                 sizeof(struct spoolss_DeletePrintProcessor),
17320                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
17321                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
17322                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
17323                 false,
17324         },
17325         {
17326                 "spoolss_AddPrintProvidor",
17327                 sizeof(struct spoolss_AddPrintProvidor),
17328                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
17329                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
17330                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
17331                 false,
17332         },
17333         {
17334                 "spoolss_DeletePrintProvidor",
17335                 sizeof(struct spoolss_DeletePrintProvidor),
17336                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
17337                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
17338                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
17339                 false,
17340         },
17341         {
17342                 "spoolss_EnumPrintProcDataTypes",
17343                 sizeof(struct spoolss_EnumPrintProcDataTypes),
17344                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
17345                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
17346                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
17347                 false,
17348         },
17349         {
17350                 "spoolss_ResetPrinter",
17351                 sizeof(struct spoolss_ResetPrinter),
17352                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
17353                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
17354                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
17355                 false,
17356         },
17357         {
17358                 "spoolss_GetPrinterDriver2",
17359                 sizeof(struct spoolss_GetPrinterDriver2),
17360                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
17361                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
17362                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
17363                 false,
17364         },
17365         {
17366                 "spoolss_FindFirstPrinterChangeNotification",
17367                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
17368                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
17369                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
17370                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
17371                 false,
17372         },
17373         {
17374                 "spoolss_FindNextPrinterChangeNotification",
17375                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
17376                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
17377                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
17378                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
17379                 false,
17380         },
17381         {
17382                 "spoolss_FindClosePrinterNotify",
17383                 sizeof(struct spoolss_FindClosePrinterNotify),
17384                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
17385                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
17386                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
17387                 false,
17388         },
17389         {
17390                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
17391                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
17392                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
17393                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
17394                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
17395                 false,
17396         },
17397         {
17398                 "spoolss_ReplyOpenPrinter",
17399                 sizeof(struct spoolss_ReplyOpenPrinter),
17400                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
17401                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
17402                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
17403                 false,
17404         },
17405         {
17406                 "spoolss_RouterReplyPrinter",
17407                 sizeof(struct spoolss_RouterReplyPrinter),
17408                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
17409                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
17410                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
17411                 false,
17412         },
17413         {
17414                 "spoolss_ReplyClosePrinter",
17415                 sizeof(struct spoolss_ReplyClosePrinter),
17416                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
17417                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
17418                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
17419                 false,
17420         },
17421         {
17422                 "spoolss_AddPortEx",
17423                 sizeof(struct spoolss_AddPortEx),
17424                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
17425                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
17426                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
17427                 false,
17428         },
17429         {
17430                 "spoolss_RouterFindFirstPrinterChangeNotification",
17431                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
17432                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
17433                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
17434                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
17435                 false,
17436         },
17437         {
17438                 "spoolss_SpoolerInit",
17439                 sizeof(struct spoolss_SpoolerInit),
17440                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
17441                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
17442                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
17443                 false,
17444         },
17445         {
17446                 "spoolss_ResetPrinterEx",
17447                 sizeof(struct spoolss_ResetPrinterEx),
17448                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
17449                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
17450                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
17451                 false,
17452         },
17453         {
17454                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
17455                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
17456                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
17457                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
17458                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
17459                 false,
17460         },
17461         {
17462                 "spoolss_RouterRefreshPrinterChangeNotification",
17463                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotification),
17464                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotification,
17465                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotification,
17466                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotification,
17467                 false,
17468         },
17469         {
17470                 "spoolss_RemoteFindNextPrinterChangeNotifyEx",
17471                 sizeof(struct spoolss_RemoteFindNextPrinterChangeNotifyEx),
17472                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindNextPrinterChangeNotifyEx,
17473                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindNextPrinterChangeNotifyEx,
17474                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindNextPrinterChangeNotifyEx,
17475                 false,
17476         },
17477         {
17478                 "spoolss_44",
17479                 sizeof(struct spoolss_44),
17480                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
17481                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
17482                 (ndr_print_function_t) ndr_print_spoolss_44,
17483                 false,
17484         },
17485         {
17486                 "spoolss_OpenPrinterEx",
17487                 sizeof(struct spoolss_OpenPrinterEx),
17488                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
17489                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
17490                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
17491                 false,
17492         },
17493         {
17494                 "spoolss_AddPrinterEx",
17495                 sizeof(struct spoolss_AddPrinterEx),
17496                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
17497                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
17498                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
17499                 false,
17500         },
17501         {
17502                 "spoolss_47",
17503                 sizeof(struct spoolss_47),
17504                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
17505                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
17506                 (ndr_print_function_t) ndr_print_spoolss_47,
17507                 false,
17508         },
17509         {
17510                 "spoolss_EnumPrinterData",
17511                 sizeof(struct spoolss_EnumPrinterData),
17512                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
17513                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
17514                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
17515                 false,
17516         },
17517         {
17518                 "spoolss_DeletePrinterData",
17519                 sizeof(struct spoolss_DeletePrinterData),
17520                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
17521                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
17522                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
17523                 false,
17524         },
17525         {
17526                 "spoolss_4a",
17527                 sizeof(struct spoolss_4a),
17528                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
17529                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
17530                 (ndr_print_function_t) ndr_print_spoolss_4a,
17531                 false,
17532         },
17533         {
17534                 "spoolss_4b",
17535                 sizeof(struct spoolss_4b),
17536                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
17537                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
17538                 (ndr_print_function_t) ndr_print_spoolss_4b,
17539                 false,
17540         },
17541         {
17542                 "spoolss_4c",
17543                 sizeof(struct spoolss_4c),
17544                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
17545                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
17546                 (ndr_print_function_t) ndr_print_spoolss_4c,
17547                 false,
17548         },
17549         {
17550                 "spoolss_SetPrinterDataEx",
17551                 sizeof(struct spoolss_SetPrinterDataEx),
17552                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
17553                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
17554                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
17555                 false,
17556         },
17557         {
17558                 "spoolss_GetPrinterDataEx",
17559                 sizeof(struct spoolss_GetPrinterDataEx),
17560                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
17561                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
17562                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
17563                 false,
17564         },
17565         {
17566                 "spoolss_EnumPrinterDataEx",
17567                 sizeof(struct spoolss_EnumPrinterDataEx),
17568                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
17569                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
17570                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
17571                 false,
17572         },
17573         {
17574                 "spoolss_EnumPrinterKey",
17575                 sizeof(struct spoolss_EnumPrinterKey),
17576                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
17577                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
17578                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
17579                 false,
17580         },
17581         {
17582                 "spoolss_DeletePrinterDataEx",
17583                 sizeof(struct spoolss_DeletePrinterDataEx),
17584                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
17585                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
17586                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
17587                 false,
17588         },
17589         {
17590                 "spoolss_DeletePrinterKey",
17591                 sizeof(struct spoolss_DeletePrinterKey),
17592                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
17593                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
17594                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
17595                 false,
17596         },
17597         {
17598                 "spoolss_53",
17599                 sizeof(struct spoolss_53),
17600                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
17601                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
17602                 (ndr_print_function_t) ndr_print_spoolss_53,
17603                 false,
17604         },
17605         {
17606                 "spoolss_DeletePrinterDriverEx",
17607                 sizeof(struct spoolss_DeletePrinterDriverEx),
17608                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
17609                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
17610                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
17611                 false,
17612         },
17613         {
17614                 "spoolss_55",
17615                 sizeof(struct spoolss_55),
17616                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
17617                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
17618                 (ndr_print_function_t) ndr_print_spoolss_55,
17619                 false,
17620         },
17621         {
17622                 "spoolss_56",
17623                 sizeof(struct spoolss_56),
17624                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
17625                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
17626                 (ndr_print_function_t) ndr_print_spoolss_56,
17627                 false,
17628         },
17629         {
17630                 "spoolss_57",
17631                 sizeof(struct spoolss_57),
17632                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
17633                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
17634                 (ndr_print_function_t) ndr_print_spoolss_57,
17635                 false,
17636         },
17637         {
17638                 "spoolss_XcvData",
17639                 sizeof(struct spoolss_XcvData),
17640                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
17641                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
17642                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
17643                 false,
17644         },
17645         {
17646                 "spoolss_AddPrinterDriverEx",
17647                 sizeof(struct spoolss_AddPrinterDriverEx),
17648                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
17649                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
17650                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
17651                 false,
17652         },
17653         {
17654                 "spoolss_5a",
17655                 sizeof(struct spoolss_5a),
17656                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
17657                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
17658                 (ndr_print_function_t) ndr_print_spoolss_5a,
17659                 false,
17660         },
17661         {
17662                 "spoolss_5b",
17663                 sizeof(struct spoolss_5b),
17664                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
17665                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
17666                 (ndr_print_function_t) ndr_print_spoolss_5b,
17667                 false,
17668         },
17669         {
17670                 "spoolss_5c",
17671                 sizeof(struct spoolss_5c),
17672                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
17673                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
17674                 (ndr_print_function_t) ndr_print_spoolss_5c,
17675                 false,
17676         },
17677         {
17678                 "spoolss_5d",
17679                 sizeof(struct spoolss_5d),
17680                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
17681                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
17682                 (ndr_print_function_t) ndr_print_spoolss_5d,
17683                 false,
17684         },
17685         {
17686                 "spoolss_5e",
17687                 sizeof(struct spoolss_5e),
17688                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
17689                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
17690                 (ndr_print_function_t) ndr_print_spoolss_5e,
17691                 false,
17692         },
17693         {
17694                 "spoolss_5f",
17695                 sizeof(struct spoolss_5f),
17696                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
17697                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
17698                 (ndr_print_function_t) ndr_print_spoolss_5f,
17699                 false,
17700         },
17701         { NULL, 0, NULL, NULL, NULL, false }
17702 };
17703
17704 static const char * const spoolss_endpoint_strings[] = {
17705         "ncacn_np:[\\pipe\\spoolss]",
17706 };
17707
17708 static const struct ndr_interface_string_array spoolss_endpoints = {
17709         .count  = 1,
17710         .names  = spoolss_endpoint_strings
17711 };
17712
17713 static const char * const spoolss_authservice_strings[] = {
17714         "host",
17715 };
17716
17717 static const struct ndr_interface_string_array spoolss_authservices = {
17718         .count  = 1,
17719         .names  = spoolss_authservice_strings
17720 };
17721
17722
17723 const struct ndr_interface_table ndr_table_spoolss = {
17724         .name           = "spoolss",
17725         .syntax_id      = {
17726                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
17727                 NDR_SPOOLSS_VERSION
17728         },
17729         .helpstring     = NDR_SPOOLSS_HELPSTRING,
17730         .num_calls      = 114,
17731         .calls          = spoolss_calls,
17732         .endpoints      = &spoolss_endpoints,
17733         .authservices   = &spoolss_authservices
17734 };
17735