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_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
8058 {
8059         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
8060         return NDR_ERR_SUCCESS;
8061 }
8062
8063 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
8064 {
8065         uint16_t v;
8066         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
8067         *r = v;
8068         return NDR_ERR_SUCCESS;
8069 }
8070
8071 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
8072 {
8073         const char *val = NULL;
8074
8075         switch (r) {
8076                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
8077                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
8078                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
8079                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
8080                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
8081                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
8082                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
8083                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
8084                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
8085                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
8086                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
8087                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
8088                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
8089                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
8090                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
8091                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
8092                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
8093                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
8094                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
8095                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
8096                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
8097                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
8098                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
8099                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
8100                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
8101                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
8102         }
8103         ndr_print_enum(ndr, name, "ENUM", val, r);
8104 }
8105
8106 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
8107 {
8108         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
8109         return NDR_ERR_SUCCESS;
8110 }
8111
8112 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
8113 {
8114         uint16_t v;
8115         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
8116         *r = v;
8117         return NDR_ERR_SUCCESS;
8118 }
8119
8120 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
8121 {
8122         const char *val = NULL;
8123
8124         switch (r) {
8125                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
8126                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
8127         }
8128         ndr_print_enum(ndr, name, "ENUM", val, r);
8129 }
8130
8131 static enum ndr_err_code ndr_push_spoolss_NotifyOptionsArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionsArray *r)
8132 {
8133         uint32_t cntr_fields_1;
8134         if (ndr_flags & NDR_SCALARS) {
8135                 NDR_CHECK(ndr_push_align(ndr, 4));
8136                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
8137                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
8138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
8139                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
8140                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8141                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
8142         }
8143         if (ndr_flags & NDR_BUFFERS) {
8144                 if (r->fields) {
8145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8146                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
8147                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
8148                         }
8149                 }
8150         }
8151         return NDR_ERR_SUCCESS;
8152 }
8153
8154 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionsArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionsArray *r)
8155 {
8156         uint32_t _ptr_fields;
8157         uint32_t cntr_fields_1;
8158         TALLOC_CTX *_mem_save_fields_0;
8159         TALLOC_CTX *_mem_save_fields_1;
8160         if (ndr_flags & NDR_SCALARS) {
8161                 NDR_CHECK(ndr_pull_align(ndr, 4));
8162                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
8163                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
8164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
8165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
8166                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
8168                 if (_ptr_fields) {
8169                         NDR_PULL_ALLOC(ndr, r->fields);
8170                 } else {
8171                         r->fields = NULL;
8172                 }
8173         }
8174         if (ndr_flags & NDR_BUFFERS) {
8175                 if (r->fields) {
8176                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
8177                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
8178                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
8179                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
8180                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
8181                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
8182                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
8183                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
8184                         }
8185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
8186                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
8187                 }
8188                 if (r->fields) {
8189                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
8190                 }
8191         }
8192         return NDR_ERR_SUCCESS;
8193 }
8194
8195 _PUBLIC_ void ndr_print_spoolss_NotifyOptionsArray(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionsArray *r)
8196 {
8197         uint32_t cntr_fields_1;
8198         ndr_print_struct(ndr, name, "spoolss_NotifyOptionsArray");
8199         ndr->depth++;
8200         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
8201         ndr_print_uint16(ndr, "u1", r->u1);
8202         ndr_print_uint32(ndr, "u2", r->u2);
8203         ndr_print_uint32(ndr, "u3", r->u3);
8204         ndr_print_uint32(ndr, "count", r->count);
8205         ndr_print_ptr(ndr, "fields", r->fields);
8206         ndr->depth++;
8207         if (r->fields) {
8208                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
8209                 ndr->depth++;
8210                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
8211                         char *idx_1=NULL;
8212                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
8213                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
8214                                 free(idx_1);
8215                         }
8216                 }
8217                 ndr->depth--;
8218         }
8219         ndr->depth--;
8220         ndr->depth--;
8221 }
8222
8223 static enum ndr_err_code ndr_push_spoolss_NotifyOptionsContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionsContainer *r)
8224 {
8225         uint32_t cntr_options_1;
8226         if (ndr_flags & NDR_SCALARS) {
8227                 NDR_CHECK(ndr_push_align(ndr, 4));
8228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
8229                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
8230                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8231                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->options));
8232         }
8233         if (ndr_flags & NDR_BUFFERS) {
8234                 if (r->options) {
8235                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8236                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8237                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionsArray(ndr, NDR_SCALARS, &r->options[cntr_options_1]));
8238                         }
8239                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8240                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionsArray(ndr, NDR_BUFFERS, &r->options[cntr_options_1]));
8241                         }
8242                 }
8243         }
8244         return NDR_ERR_SUCCESS;
8245 }
8246
8247 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionsContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionsContainer *r)
8248 {
8249         uint32_t _ptr_options;
8250         uint32_t cntr_options_1;
8251         TALLOC_CTX *_mem_save_options_0;
8252         TALLOC_CTX *_mem_save_options_1;
8253         if (ndr_flags & NDR_SCALARS) {
8254                 NDR_CHECK(ndr_pull_align(ndr, 4));
8255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
8256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
8257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8258                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
8259                 if (_ptr_options) {
8260                         NDR_PULL_ALLOC(ndr, r->options);
8261                 } else {
8262                         r->options = NULL;
8263                 }
8264         }
8265         if (ndr_flags & NDR_BUFFERS) {
8266                 if (r->options) {
8267                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
8268                         NDR_PULL_SET_MEM_CTX(ndr, r->options, 0);
8269                         NDR_CHECK(ndr_pull_array_size(ndr, &r->options));
8270                         NDR_PULL_ALLOC_N(ndr, r->options, ndr_get_array_size(ndr, &r->options));
8271                         _mem_save_options_1 = NDR_PULL_GET_MEM_CTX(ndr);
8272                         NDR_PULL_SET_MEM_CTX(ndr, r->options, 0);
8273                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8274                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionsArray(ndr, NDR_SCALARS, &r->options[cntr_options_1]));
8275                         }
8276                         for (cntr_options_1 = 0; cntr_options_1 < r->count; cntr_options_1++) {
8277                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionsArray(ndr, NDR_BUFFERS, &r->options[cntr_options_1]));
8278                         }
8279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_1, 0);
8280                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
8281                 }
8282                 if (r->options) {
8283                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->options, r->count));
8284                 }
8285         }
8286         return NDR_ERR_SUCCESS;
8287 }
8288
8289 _PUBLIC_ void ndr_print_spoolss_NotifyOptionsContainer(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionsContainer *r)
8290 {
8291         uint32_t cntr_options_1;
8292         ndr_print_struct(ndr, name, "spoolss_NotifyOptionsContainer");
8293         ndr->depth++;
8294         ndr_print_uint32(ndr, "version", r->version);
8295         ndr_print_uint32(ndr, "flags", r->flags);
8296         ndr_print_uint32(ndr, "count", r->count);
8297         ndr_print_ptr(ndr, "options", r->options);
8298         ndr->depth++;
8299         if (r->options) {
8300                 ndr->print(ndr, "%s: ARRAY(%d)", "options", (int)r->count);
8301                 ndr->depth++;
8302                 for (cntr_options_1=0;cntr_options_1<r->count;cntr_options_1++) {
8303                         char *idx_1=NULL;
8304                         if (asprintf(&idx_1, "[%d]", cntr_options_1) != -1) {
8305                                 ndr_print_spoolss_NotifyOptionsArray(ndr, "options", &r->options[cntr_options_1]);
8306                                 free(idx_1);
8307                         }
8308                 }
8309                 ndr->depth--;
8310         }
8311         ndr->depth--;
8312         ndr->depth--;
8313 }
8314
8315 static enum ndr_err_code ndr_push_spoolss_NotifyUTF16String(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyUTF16String *r)
8316 {
8317         if (ndr_flags & NDR_SCALARS) {
8318                 NDR_CHECK(ndr_push_align(ndr, 4));
8319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
8321         }
8322         if (ndr_flags & NDR_BUFFERS) {
8323                 if (r->string) {
8324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
8325                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
8326                 }
8327         }
8328         return NDR_ERR_SUCCESS;
8329 }
8330
8331 static enum ndr_err_code ndr_pull_spoolss_NotifyUTF16String(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyUTF16String *r)
8332 {
8333         uint32_t _ptr_string;
8334         TALLOC_CTX *_mem_save_string_0;
8335         if (ndr_flags & NDR_SCALARS) {
8336                 NDR_CHECK(ndr_pull_align(ndr, 4));
8337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8338                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
8339                 if (_ptr_string) {
8340                         NDR_PULL_ALLOC(ndr, r->string);
8341                 } else {
8342                         r->string = NULL;
8343                 }
8344         }
8345         if (ndr_flags & NDR_BUFFERS) {
8346                 if (r->string) {
8347                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
8348                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
8349                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
8350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
8351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
8352                 }
8353                 if (r->string) {
8354                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
8355                 }
8356         }
8357         return NDR_ERR_SUCCESS;
8358 }
8359
8360 _PUBLIC_ void ndr_print_spoolss_NotifyUTF16String(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyUTF16String *r)
8361 {
8362         ndr_print_struct(ndr, name, "spoolss_NotifyUTF16String");
8363         ndr->depth++;
8364         ndr_print_uint32(ndr, "size", r->size);
8365         ndr_print_ptr(ndr, "string", r->string);
8366         ndr->depth++;
8367         if (r->string) {
8368                 ndr_print_string(ndr, "string", r->string);
8369         }
8370         ndr->depth--;
8371         ndr->depth--;
8372 }
8373
8374 static enum ndr_err_code ndr_push_spoolss_NotifyDOSString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyDOSString *r)
8375 {
8376         if (ndr_flags & NDR_SCALARS) {
8377                 NDR_CHECK(ndr_push_align(ndr, 4));
8378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8379                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
8380         }
8381         if (ndr_flags & NDR_BUFFERS) {
8382                 if (r->string) {
8383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8384                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size, sizeof(uint8_t), CH_DOS));
8385                 }
8386         }
8387         return NDR_ERR_SUCCESS;
8388 }
8389
8390 static enum ndr_err_code ndr_pull_spoolss_NotifyDOSString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyDOSString *r)
8391 {
8392         uint32_t _ptr_string;
8393         TALLOC_CTX *_mem_save_string_0;
8394         if (ndr_flags & NDR_SCALARS) {
8395                 NDR_CHECK(ndr_pull_align(ndr, 4));
8396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
8398                 if (_ptr_string) {
8399                         NDR_PULL_ALLOC(ndr, r->string);
8400                 } else {
8401                         r->string = NULL;
8402                 }
8403         }
8404         if (ndr_flags & NDR_BUFFERS) {
8405                 if (r->string) {
8406                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
8407                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
8408                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
8409                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint8_t), CH_DOS));
8410                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
8411                 }
8412                 if (r->string) {
8413                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size));
8414                 }
8415         }
8416         return NDR_ERR_SUCCESS;
8417 }
8418
8419 _PUBLIC_ void ndr_print_spoolss_NotifyDOSString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyDOSString *r)
8420 {
8421         ndr_print_struct(ndr, name, "spoolss_NotifyDOSString");
8422         ndr->depth++;
8423         ndr_print_uint32(ndr, "size", r->size);
8424         ndr_print_ptr(ndr, "string", r->string);
8425         ndr->depth++;
8426         if (r->string) {
8427                 ndr_print_string(ndr, "string", r->string);
8428         }
8429         ndr->depth--;
8430         ndr->depth--;
8431 }
8432
8433 static enum ndr_err_code ndr_push_spoolss_NotifyBlobData(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyBlobData *r)
8434 {
8435         uint32_t cntr_data_0;
8436         if (ndr_flags & NDR_SCALARS) {
8437                 NDR_CHECK(ndr_push_align(ndr, 2));
8438                 for (cntr_data_0 = 0; cntr_data_0 < 8; cntr_data_0++) {
8439                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->data[cntr_data_0]));
8440                 }
8441         }
8442         if (ndr_flags & NDR_BUFFERS) {
8443         }
8444         return NDR_ERR_SUCCESS;
8445 }
8446
8447 static enum ndr_err_code ndr_pull_spoolss_NotifyBlobData(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyBlobData *r)
8448 {
8449         uint32_t cntr_data_0;
8450         if (ndr_flags & NDR_SCALARS) {
8451                 NDR_CHECK(ndr_pull_align(ndr, 2));
8452                 for (cntr_data_0 = 0; cntr_data_0 < 8; cntr_data_0++) {
8453                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->data[cntr_data_0]));
8454                 }
8455         }
8456         if (ndr_flags & NDR_BUFFERS) {
8457         }
8458         return NDR_ERR_SUCCESS;
8459 }
8460
8461 _PUBLIC_ void ndr_print_spoolss_NotifyBlobData(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyBlobData *r)
8462 {
8463         uint32_t cntr_data_0;
8464         ndr_print_struct(ndr, name, "spoolss_NotifyBlobData");
8465         ndr->depth++;
8466         ndr->print(ndr, "%s: ARRAY(%d)", "data", (int)8);
8467         ndr->depth++;
8468         for (cntr_data_0=0;cntr_data_0<8;cntr_data_0++) {
8469                 char *idx_0=NULL;
8470                 if (asprintf(&idx_0, "[%d]", cntr_data_0) != -1) {
8471                         ndr_print_uint16(ndr, "data", r->data[cntr_data_0]);
8472                         free(idx_0);
8473                 }
8474         }
8475         ndr->depth--;
8476         ndr->depth--;
8477 }
8478
8479 static enum ndr_err_code ndr_push_spoolss_NotifyBlob(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyBlob *r)
8480 {
8481         if (ndr_flags & NDR_SCALARS) {
8482                 NDR_CHECK(ndr_push_align(ndr, 4));
8483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->len));
8484                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data));
8485         }
8486         if (ndr_flags & NDR_BUFFERS) {
8487                 if (r->data) {
8488                         NDR_CHECK(ndr_push_spoolss_NotifyBlobData(ndr, NDR_SCALARS, r->data));
8489                 }
8490         }
8491         return NDR_ERR_SUCCESS;
8492 }
8493
8494 static enum ndr_err_code ndr_pull_spoolss_NotifyBlob(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyBlob *r)
8495 {
8496         uint32_t _ptr_data;
8497         TALLOC_CTX *_mem_save_data_0;
8498         if (ndr_flags & NDR_SCALARS) {
8499                 NDR_CHECK(ndr_pull_align(ndr, 4));
8500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->len));
8501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
8502                 if (_ptr_data) {
8503                         NDR_PULL_ALLOC(ndr, r->data);
8504                 } else {
8505                         r->data = NULL;
8506                 }
8507         }
8508         if (ndr_flags & NDR_BUFFERS) {
8509                 if (r->data) {
8510                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
8511                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
8512                         NDR_CHECK(ndr_pull_spoolss_NotifyBlobData(ndr, NDR_SCALARS, r->data));
8513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
8514                 }
8515         }
8516         return NDR_ERR_SUCCESS;
8517 }
8518
8519 _PUBLIC_ void ndr_print_spoolss_NotifyBlob(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyBlob *r)
8520 {
8521         ndr_print_struct(ndr, name, "spoolss_NotifyBlob");
8522         ndr->depth++;
8523         ndr_print_uint32(ndr, "len", r->len);
8524         ndr_print_ptr(ndr, "data", r->data);
8525         ndr->depth++;
8526         if (r->data) {
8527                 ndr_print_spoolss_NotifyBlobData(ndr, "data", r->data);
8528         }
8529         ndr->depth--;
8530         ndr->depth--;
8531 }
8532
8533 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
8534 {
8535         if (ndr_flags & NDR_SCALARS) {
8536                 int level = ndr_push_get_switch_value(ndr, r);
8537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8538                 switch (level) {
8539                         case 1: {
8540                                 NDR_CHECK(ndr_push_dlong(ndr, NDR_SCALARS, r->integer));
8541                         break; }
8542
8543                         case 2: {
8544                                 NDR_CHECK(ndr_push_spoolss_NotifyUTF16String(ndr, NDR_SCALARS, &r->utf16_string));
8545                         break; }
8546
8547                         case 3: {
8548                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8549                         break; }
8550
8551                         case 4: {
8552                                 NDR_CHECK(ndr_push_spoolss_NotifyBlob(ndr, NDR_SCALARS, &r->blob));
8553                         break; }
8554
8555                         case 5: {
8556                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8557                         break; }
8558
8559                         default:
8560                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8561                 }
8562         }
8563         if (ndr_flags & NDR_BUFFERS) {
8564                 int level = ndr_push_get_switch_value(ndr, r);
8565                 switch (level) {
8566                         case 1:
8567                         break;
8568
8569                         case 2:
8570                                 NDR_CHECK(ndr_push_spoolss_NotifyUTF16String(ndr, NDR_BUFFERS, &r->utf16_string));
8571                         break;
8572
8573                         case 3:
8574                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8575                         break;
8576
8577                         case 4:
8578                                 NDR_CHECK(ndr_push_spoolss_NotifyBlob(ndr, NDR_BUFFERS, &r->blob));
8579                         break;
8580
8581                         case 5:
8582                                 NDR_CHECK(ndr_push_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8583                         break;
8584
8585                         default:
8586                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8587                 }
8588         }
8589         return NDR_ERR_SUCCESS;
8590 }
8591
8592 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
8593 {
8594         int level;
8595         uint32_t _level;
8596         level = ndr_pull_get_switch_value(ndr, r);
8597         if (ndr_flags & NDR_SCALARS) {
8598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8599                 if (_level != level) {
8600                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8601                 }
8602                 switch (level) {
8603                         case 1: {
8604                                 NDR_CHECK(ndr_pull_dlong(ndr, NDR_SCALARS, &r->integer));
8605                         break; }
8606
8607                         case 2: {
8608                                 NDR_CHECK(ndr_pull_spoolss_NotifyUTF16String(ndr, NDR_SCALARS, &r->utf16_string));
8609                         break; }
8610
8611                         case 3: {
8612                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8613                         break; }
8614
8615                         case 4: {
8616                                 NDR_CHECK(ndr_pull_spoolss_NotifyBlob(ndr, NDR_SCALARS, &r->blob));
8617                         break; }
8618
8619                         case 5: {
8620                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_SCALARS, &r->ascii_string));
8621                         break; }
8622
8623                         default:
8624                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8625                 }
8626         }
8627         if (ndr_flags & NDR_BUFFERS) {
8628                 switch (level) {
8629                         case 1:
8630                         break;
8631
8632                         case 2:
8633                                 NDR_CHECK(ndr_pull_spoolss_NotifyUTF16String(ndr, NDR_BUFFERS, &r->utf16_string));
8634                         break;
8635
8636                         case 3:
8637                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8638                         break;
8639
8640                         case 4:
8641                                 NDR_CHECK(ndr_pull_spoolss_NotifyBlob(ndr, NDR_BUFFERS, &r->blob));
8642                         break;
8643
8644                         case 5:
8645                                 NDR_CHECK(ndr_pull_spoolss_NotifyDOSString(ndr, NDR_BUFFERS, &r->ascii_string));
8646                         break;
8647
8648                         default:
8649                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8650                 }
8651         }
8652         return NDR_ERR_SUCCESS;
8653 }
8654
8655 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
8656 {
8657         int level;
8658         level = ndr_print_get_switch_value(ndr, r);
8659         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
8660         switch (level) {
8661                 case 1:
8662                         ndr_print_dlong(ndr, "integer", r->integer);
8663                 break;
8664
8665                 case 2:
8666                         ndr_print_spoolss_NotifyUTF16String(ndr, "utf16_string", &r->utf16_string);
8667                 break;
8668
8669                 case 3:
8670                         ndr_print_spoolss_NotifyDOSString(ndr, "ascii_string", &r->ascii_string);
8671                 break;
8672
8673                 case 4:
8674                         ndr_print_spoolss_NotifyBlob(ndr, "blob", &r->blob);
8675                 break;
8676
8677                 case 5:
8678                         ndr_print_spoolss_NotifyDOSString(ndr, "ascii_string", &r->ascii_string);
8679                 break;
8680
8681                 default:
8682                         ndr_print_bad_level(ndr, name, level);
8683         }
8684 }
8685
8686 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
8687 {
8688         if (ndr_flags & NDR_SCALARS) {
8689                 NDR_CHECK(ndr_push_align(ndr, 4));
8690                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
8691                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
8692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->variable_type));
8693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
8694                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
8695                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
8696         }
8697         if (ndr_flags & NDR_BUFFERS) {
8698                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
8699         }
8700         return NDR_ERR_SUCCESS;
8701 }
8702
8703 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
8704 {
8705         if (ndr_flags & NDR_SCALARS) {
8706                 NDR_CHECK(ndr_pull_align(ndr, 4));
8707                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
8708                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
8709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->variable_type));
8710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
8711                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
8712                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
8713         }
8714         if (ndr_flags & NDR_BUFFERS) {
8715                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
8716         }
8717         return NDR_ERR_SUCCESS;
8718 }
8719
8720 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
8721 {
8722         ndr_print_struct(ndr, name, "spoolss_Notify");
8723         ndr->depth++;
8724         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
8725         ndr_print_spoolss_Field(ndr, "field", r->field);
8726         ndr_print_uint32(ndr, "variable_type", r->variable_type);
8727         ndr_print_uint32(ndr, "job_id", r->job_id);
8728         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
8729         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
8730         ndr->depth--;
8731 }
8732
8733 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
8734 {
8735         uint32_t cntr_notifies_0;
8736         if (ndr_flags & NDR_SCALARS) {
8737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8738                 NDR_CHECK(ndr_push_align(ndr, 4));
8739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
8740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
8741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
8742                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8743                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
8744                 }
8745         }
8746         if (ndr_flags & NDR_BUFFERS) {
8747                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8748                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
8749                 }
8750         }
8751         return NDR_ERR_SUCCESS;
8752 }
8753
8754 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
8755 {
8756         uint32_t cntr_notifies_0;
8757         TALLOC_CTX *_mem_save_notifies_0;
8758         if (ndr_flags & NDR_SCALARS) {
8759                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
8760                 NDR_CHECK(ndr_pull_align(ndr, 4));
8761                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
8762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
8763                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
8764                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
8765                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
8766                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
8767                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8768                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
8769                 }
8770                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
8771                 if (r->notifies) {
8772                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
8773                 }
8774         }
8775         if (ndr_flags & NDR_BUFFERS) {
8776                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
8777                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
8778                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
8779                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
8780                 }
8781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
8782         }
8783         return NDR_ERR_SUCCESS;
8784 }
8785
8786 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
8787 {
8788         uint32_t cntr_notifies_0;
8789         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
8790         ndr->depth++;
8791         ndr_print_uint32(ndr, "version", r->version);
8792         ndr_print_uint32(ndr, "flags", r->flags);
8793         ndr_print_uint32(ndr, "count", r->count);
8794         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
8795         ndr->depth++;
8796         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
8797                 char *idx_0=NULL;
8798                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
8799                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
8800                         free(idx_0);
8801                 }
8802         }
8803         ndr->depth--;
8804         ndr->depth--;
8805 }
8806
8807 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
8808 {
8809         if (ndr_flags & NDR_SCALARS) {
8810                 NDR_CHECK(ndr_push_align(ndr, 4));
8811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
8812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
8813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
8814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
8815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
8816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
8817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->processor));
8818         }
8819         if (ndr_flags & NDR_BUFFERS) {
8820                 if (r->client) {
8821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
8822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8823                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
8824                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8825                 }
8826                 if (r->user) {
8827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
8828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
8830                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8831                 }
8832         }
8833         return NDR_ERR_SUCCESS;
8834 }
8835
8836 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
8837 {
8838         uint32_t _ptr_client;
8839         TALLOC_CTX *_mem_save_client_0;
8840         uint32_t _ptr_user;
8841         TALLOC_CTX *_mem_save_user_0;
8842         if (ndr_flags & NDR_SCALARS) {
8843                 NDR_CHECK(ndr_pull_align(ndr, 4));
8844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
8845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
8846                 if (_ptr_client) {
8847                         NDR_PULL_ALLOC(ndr, r->client);
8848                 } else {
8849                         r->client = NULL;
8850                 }
8851                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
8852                 if (_ptr_user) {
8853                         NDR_PULL_ALLOC(ndr, r->user);
8854                 } else {
8855                         r->user = NULL;
8856                 }
8857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
8858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
8859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
8860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->processor));
8861         }
8862         if (ndr_flags & NDR_BUFFERS) {
8863                 if (r->client) {
8864                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
8865                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
8866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
8867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
8868                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
8869                                 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));
8870                         }
8871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
8872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
8873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
8874                 }
8875                 if (r->user) {
8876                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
8877                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
8878                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
8879                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
8880                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
8881                                 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));
8882                         }
8883                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
8884                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
8885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
8886                 }
8887         }
8888         return NDR_ERR_SUCCESS;
8889 }
8890
8891 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
8892 {
8893         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
8894         ndr->depth++;
8895         ndr_print_uint32(ndr, "size", r->size);
8896         ndr_print_ptr(ndr, "client", r->client);
8897         ndr->depth++;
8898         if (r->client) {
8899                 ndr_print_string(ndr, "client", r->client);
8900         }
8901         ndr->depth--;
8902         ndr_print_ptr(ndr, "user", r->user);
8903         ndr->depth++;
8904         if (r->user) {
8905                 ndr_print_string(ndr, "user", r->user);
8906         }
8907         ndr->depth--;
8908         ndr_print_uint32(ndr, "build", r->build);
8909         ndr_print_uint32(ndr, "major", r->major);
8910         ndr_print_uint32(ndr, "minor", r->minor);
8911         ndr_print_uint32(ndr, "processor", r->processor);
8912         ndr->depth--;
8913 }
8914
8915 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
8916 {
8917         if (ndr_flags & NDR_SCALARS) {
8918                 int level = ndr_push_get_switch_value(ndr, r);
8919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
8920                 switch (level) {
8921                         case 1: {
8922                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
8923                         break; }
8924
8925                         default:
8926                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8927                 }
8928         }
8929         if (ndr_flags & NDR_BUFFERS) {
8930                 int level = ndr_push_get_switch_value(ndr, r);
8931                 switch (level) {
8932                         case 1:
8933                                 if (r->level1) {
8934                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
8935                                 }
8936                         break;
8937
8938                         default:
8939                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8940                 }
8941         }
8942         return NDR_ERR_SUCCESS;
8943 }
8944
8945 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
8946 {
8947         int level;
8948         uint32_t _level;
8949         TALLOC_CTX *_mem_save_level1_0;
8950         level = ndr_pull_get_switch_value(ndr, r);
8951         if (ndr_flags & NDR_SCALARS) {
8952                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
8953                 if (_level != level) {
8954                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
8955                 }
8956                 switch (level) {
8957                         case 1: {
8958                                 uint32_t _ptr_level1;
8959                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
8960                                 if (_ptr_level1) {
8961                                         NDR_PULL_ALLOC(ndr, r->level1);
8962                                 } else {
8963                                         r->level1 = NULL;
8964                                 }
8965                         break; }
8966
8967                         default:
8968                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8969                 }
8970         }
8971         if (ndr_flags & NDR_BUFFERS) {
8972                 switch (level) {
8973                         case 1:
8974                                 if (r->level1) {
8975                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
8976                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
8977                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
8978                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
8979                                 }
8980                         break;
8981
8982                         default:
8983                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
8984                 }
8985         }
8986         return NDR_ERR_SUCCESS;
8987 }
8988
8989 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
8990 {
8991         int level;
8992         level = ndr_print_get_switch_value(ndr, r);
8993         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
8994         switch (level) {
8995                 case 1:
8996                         ndr_print_ptr(ndr, "level1", r->level1);
8997                         ndr->depth++;
8998                         if (r->level1) {
8999                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
9000                         }
9001                         ndr->depth--;
9002                 break;
9003
9004                 default:
9005                         ndr_print_bad_level(ndr, name, level);
9006         }
9007 }
9008
9009 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
9010 {
9011         if (flags & NDR_IN) {
9012                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
9013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
9014                 if (r->in.server) {
9015                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
9016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
9018                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9019                 }
9020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9021                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9022                 if (r->in.buffer) {
9023                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9024                 }
9025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9026         }
9027         if (flags & NDR_OUT) {
9028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9029                 if (r->out.info) {
9030                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
9031                 }
9032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
9033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
9034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9035         }
9036         return NDR_ERR_SUCCESS;
9037 }
9038
9039 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
9040 {
9041         uint32_t _ptr_server;
9042         uint32_t _ptr_buffer;
9043         uint32_t _ptr_info;
9044         TALLOC_CTX *_mem_save_server_0;
9045         TALLOC_CTX *_mem_save_buffer_0;
9046         TALLOC_CTX *_mem_save_info_0;
9047         if (flags & NDR_IN) {
9048                 ZERO_STRUCT(r->out);
9049
9050                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
9051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
9052                 if (_ptr_server) {
9053                         NDR_PULL_ALLOC(ndr, r->in.server);
9054                 } else {
9055                         r->in.server = NULL;
9056                 }
9057                 if (r->in.server) {
9058                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
9059                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
9060                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
9061                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
9062                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
9063                                 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));
9064                         }
9065                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
9066                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
9067                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
9068                 }
9069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9071                 if (_ptr_buffer) {
9072                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9073                 } else {
9074                         r->in.buffer = NULL;
9075                 }
9076                 if (r->in.buffer) {
9077                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9078                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9079                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9080                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9081                 }
9082                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9083         }
9084         if (flags & NDR_OUT) {
9085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9086                 if (_ptr_info) {
9087                         NDR_PULL_ALLOC(ndr, r->out.info);
9088                 } else {
9089                         r->out.info = NULL;
9090                 }
9091                 if (r->out.info) {
9092                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9093                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9094                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
9095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9096                 }
9097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
9098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
9099                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9100         }
9101         return NDR_ERR_SUCCESS;
9102 }
9103
9104 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
9105 {
9106         uint32_t cntr_info_0;
9107         if (flags & NDR_IN) {
9108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
9110         }
9111         if (flags & NDR_OUT) {
9112                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9113                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9114                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9115                 }
9116                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9117                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9118                 }
9119         }
9120         return NDR_ERR_SUCCESS;
9121 }
9122
9123 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
9124 {
9125         uint32_t cntr_info_0;
9126         TALLOC_CTX *_mem_save_info_0;
9127         if (flags & NDR_IN) {
9128                 ZERO_STRUCT(r->out);
9129
9130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
9132         }
9133         if (flags & NDR_OUT) {
9134                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
9135                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9136                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9137                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9138                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9139                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9140                 }
9141                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9142                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9143                 }
9144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9145         }
9146         return NDR_ERR_SUCCESS;
9147 }
9148
9149 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
9150 {
9151         uint32_t cntr_info_1;
9152         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
9153         ndr->depth++;
9154         if (flags & NDR_SET_VALUES) {
9155                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9156         }
9157         if (flags & NDR_IN) {
9158                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
9159                 ndr->depth++;
9160                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
9161                 ndr_print_ptr(ndr, "server", r->in.server);
9162                 ndr->depth++;
9163                 if (r->in.server) {
9164                         ndr_print_string(ndr, "server", r->in.server);
9165                 }
9166                 ndr->depth--;
9167                 ndr_print_uint32(ndr, "level", r->in.level);
9168                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
9169                 ndr->depth++;
9170                 if (r->in.buffer) {
9171                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
9172                 }
9173                 ndr->depth--;
9174                 ndr_print_uint32(ndr, "offered", r->in.offered);
9175                 ndr->depth--;
9176         }
9177         if (flags & NDR_OUT) {
9178                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
9179                 ndr->depth++;
9180                 ndr_print_ptr(ndr, "info", r->out.info);
9181                 ndr->depth++;
9182                 if (r->out.info) {
9183                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
9184                         ndr->depth++;
9185                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
9186                                 char *idx_1=NULL;
9187                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
9188                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
9189                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &r->out.info[cntr_info_1]);
9190                                         free(idx_1);
9191                                 }
9192                         }
9193                         ndr->depth--;
9194                 }
9195                 ndr->depth--;
9196                 ndr_print_uint32(ndr, "needed", r->out.needed);
9197                 ndr_print_uint32(ndr, "count", r->out.count);
9198                 ndr_print_WERROR(ndr, "result", r->out.result);
9199                 ndr->depth--;
9200         }
9201         ndr->depth--;
9202 }
9203
9204 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
9205 {
9206         if (flags & NDR_IN) {
9207                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
9208                 if (r->in.printername) {
9209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
9210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9211                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
9212                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9213                 }
9214                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
9215                 if (r->in.datatype) {
9216                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
9217                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9218                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
9219                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9220                 }
9221                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
9223         }
9224         if (flags & NDR_OUT) {
9225                 if (r->out.handle == NULL) {
9226                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9227                 }
9228                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9229                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9230         }
9231         return NDR_ERR_SUCCESS;
9232 }
9233
9234 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
9235 {
9236         uint32_t _ptr_printername;
9237         uint32_t _ptr_datatype;
9238         TALLOC_CTX *_mem_save_printername_0;
9239         TALLOC_CTX *_mem_save_datatype_0;
9240         TALLOC_CTX *_mem_save_handle_0;
9241         if (flags & NDR_IN) {
9242                 ZERO_STRUCT(r->out);
9243
9244                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
9245                 if (_ptr_printername) {
9246                         NDR_PULL_ALLOC(ndr, r->in.printername);
9247                 } else {
9248                         r->in.printername = NULL;
9249                 }
9250                 if (r->in.printername) {
9251                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
9252                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
9253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
9254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
9255                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
9256                                 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));
9257                         }
9258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
9259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
9260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
9261                 }
9262                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
9263                 if (_ptr_datatype) {
9264                         NDR_PULL_ALLOC(ndr, r->in.datatype);
9265                 } else {
9266                         r->in.datatype = NULL;
9267                 }
9268                 if (r->in.datatype) {
9269                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9270                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
9271                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
9272                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
9273                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
9274                                 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));
9275                         }
9276                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
9277                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
9278                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
9279                 }
9280                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9281                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
9282                 NDR_PULL_ALLOC(ndr, r->out.handle);
9283                 ZERO_STRUCTP(r->out.handle);
9284         }
9285         if (flags & NDR_OUT) {
9286                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9287                         NDR_PULL_ALLOC(ndr, r->out.handle);
9288                 }
9289                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9290                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
9291                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
9292                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9293                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9294         }
9295         return NDR_ERR_SUCCESS;
9296 }
9297
9298 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
9299 {
9300         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
9301         ndr->depth++;
9302         if (flags & NDR_SET_VALUES) {
9303                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9304         }
9305         if (flags & NDR_IN) {
9306                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
9307                 ndr->depth++;
9308                 ndr_print_ptr(ndr, "printername", r->in.printername);
9309                 ndr->depth++;
9310                 if (r->in.printername) {
9311                         ndr_print_string(ndr, "printername", r->in.printername);
9312                 }
9313                 ndr->depth--;
9314                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
9315                 ndr->depth++;
9316                 if (r->in.datatype) {
9317                         ndr_print_string(ndr, "datatype", r->in.datatype);
9318                 }
9319                 ndr->depth--;
9320                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
9321                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
9322                 ndr->depth--;
9323         }
9324         if (flags & NDR_OUT) {
9325                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
9326                 ndr->depth++;
9327                 ndr_print_ptr(ndr, "handle", r->out.handle);
9328                 ndr->depth++;
9329                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
9330                 ndr->depth--;
9331                 ndr_print_WERROR(ndr, "result", r->out.result);
9332                 ndr->depth--;
9333         }
9334         ndr->depth--;
9335 }
9336
9337 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
9338 {
9339         if (flags & NDR_IN) {
9340                 if (r->in.handle == NULL) {
9341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9342                 }
9343                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
9345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
9346                 if (r->in.ctr) {
9347                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
9348                 }
9349                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
9350         }
9351         if (flags & NDR_OUT) {
9352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9353         }
9354         return NDR_ERR_SUCCESS;
9355 }
9356
9357 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
9358 {
9359         uint32_t _ptr_ctr;
9360         TALLOC_CTX *_mem_save_handle_0;
9361         TALLOC_CTX *_mem_save_ctr_0;
9362         if (flags & NDR_IN) {
9363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9364                         NDR_PULL_ALLOC(ndr, r->in.handle);
9365                 }
9366                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9368                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
9371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
9372                 if (_ptr_ctr) {
9373                         NDR_PULL_ALLOC(ndr, r->in.ctr);
9374                 } else {
9375                         r->in.ctr = NULL;
9376                 }
9377                 if (r->in.ctr) {
9378                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
9379                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
9380                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
9381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
9382                 }
9383                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
9384         }
9385         if (flags & NDR_OUT) {
9386                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9387         }
9388         return NDR_ERR_SUCCESS;
9389 }
9390
9391 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
9392 {
9393         ndr_print_struct(ndr, name, "spoolss_SetJob");
9394         ndr->depth++;
9395         if (flags & NDR_SET_VALUES) {
9396                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9397         }
9398         if (flags & NDR_IN) {
9399                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
9400                 ndr->depth++;
9401                 ndr_print_ptr(ndr, "handle", r->in.handle);
9402                 ndr->depth++;
9403                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9404                 ndr->depth--;
9405                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
9406                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
9407                 ndr->depth++;
9408                 if (r->in.ctr) {
9409                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
9410                 }
9411                 ndr->depth--;
9412                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
9413                 ndr->depth--;
9414         }
9415         if (flags & NDR_OUT) {
9416                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
9417                 ndr->depth++;
9418                 ndr_print_WERROR(ndr, "result", r->out.result);
9419                 ndr->depth--;
9420         }
9421         ndr->depth--;
9422 }
9423
9424 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
9425 {
9426         if (flags & NDR_IN) {
9427                 if (r->in.handle == NULL) {
9428                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9429                 }
9430                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
9432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9433                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9434                 if (r->in.buffer) {
9435                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9436                 }
9437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9438         }
9439         if (flags & NDR_OUT) {
9440                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9441                 if (r->out.info) {
9442                         {
9443                                 struct ndr_push *_ndr_info;
9444                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
9445                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
9446                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9447                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
9448                         }
9449                 }
9450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
9451                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9452         }
9453         return NDR_ERR_SUCCESS;
9454 }
9455
9456 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
9457 {
9458         uint32_t _ptr_buffer;
9459         uint32_t _ptr_info;
9460         TALLOC_CTX *_mem_save_handle_0;
9461         TALLOC_CTX *_mem_save_buffer_0;
9462         TALLOC_CTX *_mem_save_info_0;
9463         if (flags & NDR_IN) {
9464                 ZERO_STRUCT(r->out);
9465
9466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9467                         NDR_PULL_ALLOC(ndr, r->in.handle);
9468                 }
9469                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9470                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9471                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9472                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
9474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9475                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9476                 if (_ptr_buffer) {
9477                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9478                 } else {
9479                         r->in.buffer = NULL;
9480                 }
9481                 if (r->in.buffer) {
9482                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9483                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9484                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9485                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9486                 }
9487                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9488         }
9489         if (flags & NDR_OUT) {
9490                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9491                 if (_ptr_info) {
9492                         NDR_PULL_ALLOC(ndr, r->out.info);
9493                 } else {
9494                         r->out.info = NULL;
9495                 }
9496                 if (r->out.info) {
9497                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9498                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9499                         {
9500                                 struct ndr_pull *_ndr_info;
9501                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
9502                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
9503                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9504                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
9505                         }
9506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9507                 }
9508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
9509                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9510         }
9511         return NDR_ERR_SUCCESS;
9512 }
9513
9514 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
9515 {
9516         ndr_print_struct(ndr, name, "spoolss_GetJob");
9517         ndr->depth++;
9518         if (flags & NDR_SET_VALUES) {
9519                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9520         }
9521         if (flags & NDR_IN) {
9522                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
9523                 ndr->depth++;
9524                 ndr_print_ptr(ndr, "handle", r->in.handle);
9525                 ndr->depth++;
9526                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9527                 ndr->depth--;
9528                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
9529                 ndr_print_uint32(ndr, "level", r->in.level);
9530                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
9531                 ndr->depth++;
9532                 if (r->in.buffer) {
9533                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
9534                 }
9535                 ndr->depth--;
9536                 ndr_print_uint32(ndr, "offered", r->in.offered);
9537                 ndr->depth--;
9538         }
9539         if (flags & NDR_OUT) {
9540                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
9541                 ndr->depth++;
9542                 ndr_print_ptr(ndr, "info", r->out.info);
9543                 ndr->depth++;
9544                 if (r->out.info) {
9545                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
9546                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
9547                 }
9548                 ndr->depth--;
9549                 ndr_print_uint32(ndr, "needed", r->out.needed);
9550                 ndr_print_WERROR(ndr, "result", r->out.result);
9551                 ndr->depth--;
9552         }
9553         ndr->depth--;
9554 }
9555
9556 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
9557 {
9558         if (flags & NDR_IN) {
9559                 if (r->in.handle == NULL) {
9560                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9561                 }
9562                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
9564                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
9565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9566                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9567                 if (r->in.buffer) {
9568                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9569                 }
9570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9571         }
9572         if (flags & NDR_OUT) {
9573                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9574                 if (r->out.info) {
9575                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
9576                 }
9577                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
9578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
9579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9580         }
9581         return NDR_ERR_SUCCESS;
9582 }
9583
9584 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
9585 {
9586         uint32_t _ptr_buffer;
9587         uint32_t _ptr_info;
9588         TALLOC_CTX *_mem_save_handle_0;
9589         TALLOC_CTX *_mem_save_buffer_0;
9590         TALLOC_CTX *_mem_save_info_0;
9591         if (flags & NDR_IN) {
9592                 ZERO_STRUCT(r->out);
9593
9594                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9595                         NDR_PULL_ALLOC(ndr, r->in.handle);
9596                 }
9597                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9598                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9599                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9600                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
9602                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
9603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9604                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9605                 if (_ptr_buffer) {
9606                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9607                 } else {
9608                         r->in.buffer = NULL;
9609                 }
9610                 if (r->in.buffer) {
9611                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9612                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9613                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9615                 }
9616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9617         }
9618         if (flags & NDR_OUT) {
9619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9620                 if (_ptr_info) {
9621                         NDR_PULL_ALLOC(ndr, r->out.info);
9622                 } else {
9623                         r->out.info = NULL;
9624                 }
9625                 if (r->out.info) {
9626                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9627                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9628                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
9629                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9630                 }
9631                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
9632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
9633                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9634         }
9635         return NDR_ERR_SUCCESS;
9636 }
9637
9638 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
9639 {
9640         uint32_t cntr_info_0;
9641         if (flags & NDR_IN) {
9642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
9644         }
9645         if (flags & NDR_OUT) {
9646                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9647                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9648                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9649                 }
9650                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9651                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9652                 }
9653         }
9654         return NDR_ERR_SUCCESS;
9655 }
9656
9657 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
9658 {
9659         uint32_t cntr_info_0;
9660         TALLOC_CTX *_mem_save_info_0;
9661         if (flags & NDR_IN) {
9662                 ZERO_STRUCT(r->out);
9663
9664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
9666         }
9667         if (flags & NDR_OUT) {
9668                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
9669                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9670                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9671                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9672                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
9673                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
9674                 }
9675                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
9676                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
9677                 }
9678                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9679         }
9680         return NDR_ERR_SUCCESS;
9681 }
9682
9683 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
9684 {
9685         uint32_t cntr_info_1;
9686         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
9687         ndr->depth++;
9688         if (flags & NDR_SET_VALUES) {
9689                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9690         }
9691         if (flags & NDR_IN) {
9692                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
9693                 ndr->depth++;
9694                 ndr_print_ptr(ndr, "handle", r->in.handle);
9695                 ndr->depth++;
9696                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9697                 ndr->depth--;
9698                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
9699                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
9700                 ndr_print_uint32(ndr, "level", r->in.level);
9701                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
9702                 ndr->depth++;
9703                 if (r->in.buffer) {
9704                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
9705                 }
9706                 ndr->depth--;
9707                 ndr_print_uint32(ndr, "offered", r->in.offered);
9708                 ndr->depth--;
9709         }
9710         if (flags & NDR_OUT) {
9711                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
9712                 ndr->depth++;
9713                 ndr_print_ptr(ndr, "info", r->out.info);
9714                 ndr->depth++;
9715                 if (r->out.info) {
9716                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
9717                         ndr->depth++;
9718                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
9719                                 char *idx_1=NULL;
9720                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
9721                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
9722                                         ndr_print_spoolss_JobInfo(ndr, "info", &r->out.info[cntr_info_1]);
9723                                         free(idx_1);
9724                                 }
9725                         }
9726                         ndr->depth--;
9727                 }
9728                 ndr->depth--;
9729                 ndr_print_uint32(ndr, "needed", r->out.needed);
9730                 ndr_print_uint32(ndr, "count", r->out.count);
9731                 ndr_print_WERROR(ndr, "result", r->out.result);
9732                 ndr->depth--;
9733         }
9734         ndr->depth--;
9735 }
9736
9737 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
9738 {
9739         if (flags & NDR_IN) {
9740         }
9741         if (flags & NDR_OUT) {
9742                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9743         }
9744         return NDR_ERR_SUCCESS;
9745 }
9746
9747 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
9748 {
9749         if (flags & NDR_IN) {
9750         }
9751         if (flags & NDR_OUT) {
9752                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9753         }
9754         return NDR_ERR_SUCCESS;
9755 }
9756
9757 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
9758 {
9759         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
9760         ndr->depth++;
9761         if (flags & NDR_SET_VALUES) {
9762                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9763         }
9764         if (flags & NDR_IN) {
9765                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
9766                 ndr->depth++;
9767                 ndr->depth--;
9768         }
9769         if (flags & NDR_OUT) {
9770                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
9771                 ndr->depth++;
9772                 ndr_print_WERROR(ndr, "result", r->out.result);
9773                 ndr->depth--;
9774         }
9775         ndr->depth--;
9776 }
9777
9778 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
9779 {
9780         if (flags & NDR_IN) {
9781                 if (r->in.handle == NULL) {
9782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9783                 }
9784                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9785         }
9786         if (flags & NDR_OUT) {
9787                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9788         }
9789         return NDR_ERR_SUCCESS;
9790 }
9791
9792 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
9793 {
9794         TALLOC_CTX *_mem_save_handle_0;
9795         if (flags & NDR_IN) {
9796                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9797                         NDR_PULL_ALLOC(ndr, r->in.handle);
9798                 }
9799                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9800                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9801                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9802                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9803         }
9804         if (flags & NDR_OUT) {
9805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9806         }
9807         return NDR_ERR_SUCCESS;
9808 }
9809
9810 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
9811 {
9812         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
9813         ndr->depth++;
9814         if (flags & NDR_SET_VALUES) {
9815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9816         }
9817         if (flags & NDR_IN) {
9818                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
9819                 ndr->depth++;
9820                 ndr_print_ptr(ndr, "handle", r->in.handle);
9821                 ndr->depth++;
9822                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9823                 ndr->depth--;
9824                 ndr->depth--;
9825         }
9826         if (flags & NDR_OUT) {
9827                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
9828                 ndr->depth++;
9829                 ndr_print_WERROR(ndr, "result", r->out.result);
9830                 ndr->depth--;
9831         }
9832         ndr->depth--;
9833 }
9834
9835 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
9836 {
9837         if (flags & NDR_IN) {
9838                 if (r->in.handle == NULL) {
9839                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9840                 }
9841                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9843                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
9844                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
9845                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9846                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.secdesc_ctr));
9847                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
9848         }
9849         if (flags & NDR_OUT) {
9850                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9851         }
9852         return NDR_ERR_SUCCESS;
9853 }
9854
9855 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
9856 {
9857         TALLOC_CTX *_mem_save_handle_0;
9858         if (flags & NDR_IN) {
9859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9860                         NDR_PULL_ALLOC(ndr, r->in.handle);
9861                 }
9862                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9863                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9864                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9867                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
9868                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
9869                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
9870                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.secdesc_ctr));
9871                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
9872         }
9873         if (flags & NDR_OUT) {
9874                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9875         }
9876         return NDR_ERR_SUCCESS;
9877 }
9878
9879 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
9880 {
9881         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
9882         ndr->depth++;
9883         if (flags & NDR_SET_VALUES) {
9884                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
9885         }
9886         if (flags & NDR_IN) {
9887                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
9888                 ndr->depth++;
9889                 ndr_print_ptr(ndr, "handle", r->in.handle);
9890                 ndr->depth++;
9891                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
9892                 ndr->depth--;
9893                 ndr_print_uint32(ndr, "level", r->in.level);
9894                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
9895                 ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->in.info);
9896                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
9897                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", &r->in.secdesc_ctr);
9898                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
9899                 ndr->depth--;
9900         }
9901         if (flags & NDR_OUT) {
9902                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
9903                 ndr->depth++;
9904                 ndr_print_WERROR(ndr, "result", r->out.result);
9905                 ndr->depth--;
9906         }
9907         ndr->depth--;
9908 }
9909
9910 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
9911 {
9912         if (flags & NDR_IN) {
9913                 if (r->in.handle == NULL) {
9914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
9915                 }
9916                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
9918                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
9919                 if (r->in.buffer) {
9920                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
9921                 }
9922                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
9923         }
9924         if (flags & NDR_OUT) {
9925                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
9926                 if (r->out.info) {
9927                         {
9928                                 struct ndr_push *_ndr_info;
9929                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
9930                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
9931                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9932                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
9933                         }
9934                 }
9935                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
9936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
9937         }
9938         return NDR_ERR_SUCCESS;
9939 }
9940
9941 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
9942 {
9943         uint32_t _ptr_buffer;
9944         uint32_t _ptr_info;
9945         TALLOC_CTX *_mem_save_handle_0;
9946         TALLOC_CTX *_mem_save_buffer_0;
9947         TALLOC_CTX *_mem_save_info_0;
9948         if (flags & NDR_IN) {
9949                 ZERO_STRUCT(r->out);
9950
9951                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
9952                         NDR_PULL_ALLOC(ndr, r->in.handle);
9953                 }
9954                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
9955                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
9956                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
9957                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
9958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
9959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
9960                 if (_ptr_buffer) {
9961                         NDR_PULL_ALLOC(ndr, r->in.buffer);
9962                 } else {
9963                         r->in.buffer = NULL;
9964                 }
9965                 if (r->in.buffer) {
9966                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
9967                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
9968                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
9969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
9970                 }
9971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
9972         }
9973         if (flags & NDR_OUT) {
9974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
9975                 if (_ptr_info) {
9976                         NDR_PULL_ALLOC(ndr, r->out.info);
9977                 } else {
9978                         r->out.info = NULL;
9979                 }
9980                 if (r->out.info) {
9981                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
9982                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
9983                         {
9984                                 struct ndr_pull *_ndr_info;
9985                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
9986                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
9987                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
9988                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
9989                         }
9990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
9991                 }
9992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
9993                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
9994         }
9995         return NDR_ERR_SUCCESS;
9996 }
9997
9998 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
9999 {
10000         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
10001         ndr->depth++;
10002         if (flags & NDR_SET_VALUES) {
10003                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10004         }
10005         if (flags & NDR_IN) {
10006                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
10007                 ndr->depth++;
10008                 ndr_print_ptr(ndr, "handle", r->in.handle);
10009                 ndr->depth++;
10010                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10011                 ndr->depth--;
10012                 ndr_print_uint32(ndr, "level", r->in.level);
10013                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10014                 ndr->depth++;
10015                 if (r->in.buffer) {
10016                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10017                 }
10018                 ndr->depth--;
10019                 ndr_print_uint32(ndr, "offered", r->in.offered);
10020                 ndr->depth--;
10021         }
10022         if (flags & NDR_OUT) {
10023                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
10024                 ndr->depth++;
10025                 ndr_print_ptr(ndr, "info", r->out.info);
10026                 ndr->depth++;
10027                 if (r->out.info) {
10028                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10029                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
10030                 }
10031                 ndr->depth--;
10032                 ndr_print_uint32(ndr, "needed", r->out.needed);
10033                 ndr_print_WERROR(ndr, "result", r->out.result);
10034                 ndr->depth--;
10035         }
10036         ndr->depth--;
10037 }
10038
10039 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
10040 {
10041         if (flags & NDR_IN) {
10042         }
10043         if (flags & NDR_OUT) {
10044                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10045         }
10046         return NDR_ERR_SUCCESS;
10047 }
10048
10049 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
10050 {
10051         if (flags & NDR_IN) {
10052         }
10053         if (flags & NDR_OUT) {
10054                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10055         }
10056         return NDR_ERR_SUCCESS;
10057 }
10058
10059 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
10060 {
10061         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
10062         ndr->depth++;
10063         if (flags & NDR_SET_VALUES) {
10064                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10065         }
10066         if (flags & NDR_IN) {
10067                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
10068                 ndr->depth++;
10069                 ndr->depth--;
10070         }
10071         if (flags & NDR_OUT) {
10072                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
10073                 ndr->depth++;
10074                 ndr_print_WERROR(ndr, "result", r->out.result);
10075                 ndr->depth--;
10076         }
10077         ndr->depth--;
10078 }
10079
10080 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
10081 {
10082         if (flags & NDR_IN) {
10083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10084                 if (r->in.server) {
10085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10088                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10089                 }
10090                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
10091                 if (r->in.environment) {
10092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10096                 }
10097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10099                 if (r->in.buffer) {
10100                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10101                 }
10102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10103         }
10104         if (flags & NDR_OUT) {
10105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10106                 if (r->out.info) {
10107                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
10108                 }
10109                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
10110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
10111                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10112         }
10113         return NDR_ERR_SUCCESS;
10114 }
10115
10116 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
10117 {
10118         uint32_t _ptr_server;
10119         uint32_t _ptr_environment;
10120         uint32_t _ptr_buffer;
10121         uint32_t _ptr_info;
10122         TALLOC_CTX *_mem_save_server_0;
10123         TALLOC_CTX *_mem_save_environment_0;
10124         TALLOC_CTX *_mem_save_buffer_0;
10125         TALLOC_CTX *_mem_save_info_0;
10126         if (flags & NDR_IN) {
10127                 ZERO_STRUCT(r->out);
10128
10129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10130                 if (_ptr_server) {
10131                         NDR_PULL_ALLOC(ndr, r->in.server);
10132                 } else {
10133                         r->in.server = NULL;
10134                 }
10135                 if (r->in.server) {
10136                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10137                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10138                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10139                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10140                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10141                                 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));
10142                         }
10143                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10144                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10146                 }
10147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10148                 if (_ptr_environment) {
10149                         NDR_PULL_ALLOC(ndr, r->in.environment);
10150                 } else {
10151                         r->in.environment = NULL;
10152                 }
10153                 if (r->in.environment) {
10154                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10155                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
10156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
10157                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
10158                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
10159                                 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));
10160                         }
10161                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
10162                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
10163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10164                 }
10165                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10167                 if (_ptr_buffer) {
10168                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10169                 } else {
10170                         r->in.buffer = NULL;
10171                 }
10172                 if (r->in.buffer) {
10173                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10174                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10175                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10176                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10177                 }
10178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10179         }
10180         if (flags & NDR_OUT) {
10181                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10182                 if (_ptr_info) {
10183                         NDR_PULL_ALLOC(ndr, r->out.info);
10184                 } else {
10185                         r->out.info = NULL;
10186                 }
10187                 if (r->out.info) {
10188                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10189                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10190                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
10191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10192                 }
10193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
10194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
10195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10196         }
10197         return NDR_ERR_SUCCESS;
10198 }
10199
10200 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
10201 {
10202         uint32_t cntr_info_0;
10203         if (flags & NDR_IN) {
10204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
10206         }
10207         if (flags & NDR_OUT) {
10208                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10209                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
10210                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
10211                 }
10212                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10213                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
10214                 }
10215         }
10216         return NDR_ERR_SUCCESS;
10217 }
10218
10219 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
10220 {
10221         uint32_t cntr_info_0;
10222         TALLOC_CTX *_mem_save_info_0;
10223         if (flags & NDR_IN) {
10224                 ZERO_STRUCT(r->out);
10225
10226                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
10228         }
10229         if (flags & NDR_OUT) {
10230                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
10231                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10232                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10233                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10234                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
10235                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
10236                 }
10237                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10238                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
10239                 }
10240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10241         }
10242         return NDR_ERR_SUCCESS;
10243 }
10244
10245 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
10246 {
10247         uint32_t cntr_info_1;
10248         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
10249         ndr->depth++;
10250         if (flags & NDR_SET_VALUES) {
10251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10252         }
10253         if (flags & NDR_IN) {
10254                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
10255                 ndr->depth++;
10256                 ndr_print_ptr(ndr, "server", r->in.server);
10257                 ndr->depth++;
10258                 if (r->in.server) {
10259                         ndr_print_string(ndr, "server", r->in.server);
10260                 }
10261                 ndr->depth--;
10262                 ndr_print_ptr(ndr, "environment", r->in.environment);
10263                 ndr->depth++;
10264                 if (r->in.environment) {
10265                         ndr_print_string(ndr, "environment", r->in.environment);
10266                 }
10267                 ndr->depth--;
10268                 ndr_print_uint32(ndr, "level", r->in.level);
10269                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10270                 ndr->depth++;
10271                 if (r->in.buffer) {
10272                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10273                 }
10274                 ndr->depth--;
10275                 ndr_print_uint32(ndr, "offered", r->in.offered);
10276                 ndr->depth--;
10277         }
10278         if (flags & NDR_OUT) {
10279                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
10280                 ndr->depth++;
10281                 ndr_print_ptr(ndr, "info", r->out.info);
10282                 ndr->depth++;
10283                 if (r->out.info) {
10284                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
10285                         ndr->depth++;
10286                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
10287                                 char *idx_1=NULL;
10288                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
10289                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
10290                                         ndr_print_spoolss_DriverInfo(ndr, "info", &r->out.info[cntr_info_1]);
10291                                         free(idx_1);
10292                                 }
10293                         }
10294                         ndr->depth--;
10295                 }
10296                 ndr->depth--;
10297                 ndr_print_uint32(ndr, "needed", r->out.needed);
10298                 ndr_print_uint32(ndr, "count", r->out.count);
10299                 ndr_print_WERROR(ndr, "result", r->out.result);
10300                 ndr->depth--;
10301         }
10302         ndr->depth--;
10303 }
10304
10305 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
10306 {
10307         if (flags & NDR_IN) {
10308         }
10309         if (flags & NDR_OUT) {
10310                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10311         }
10312         return NDR_ERR_SUCCESS;
10313 }
10314
10315 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
10316 {
10317         if (flags & NDR_IN) {
10318         }
10319         if (flags & NDR_OUT) {
10320                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10321         }
10322         return NDR_ERR_SUCCESS;
10323 }
10324
10325 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
10326 {
10327         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
10328         ndr->depth++;
10329         if (flags & NDR_SET_VALUES) {
10330                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10331         }
10332         if (flags & NDR_IN) {
10333                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
10334                 ndr->depth++;
10335                 ndr->depth--;
10336         }
10337         if (flags & NDR_OUT) {
10338                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
10339                 ndr->depth++;
10340                 ndr_print_WERROR(ndr, "result", r->out.result);
10341                 ndr->depth--;
10342         }
10343         ndr->depth--;
10344 }
10345
10346 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
10347 {
10348         if (flags & NDR_IN) {
10349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10350                 if (r->in.server) {
10351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10353                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10354                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10355                 }
10356                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
10357                 if (r->in.environment) {
10358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10359                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10360                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10361                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10362                 }
10363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10364                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10365                 if (r->in.buffer) {
10366                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10367                 }
10368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10369         }
10370         if (flags & NDR_OUT) {
10371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10372                 if (r->out.info) {
10373                         {
10374                                 struct ndr_push *_ndr_info;
10375                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
10376                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
10377                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
10378                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
10379                         }
10380                 }
10381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
10382                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10383         }
10384         return NDR_ERR_SUCCESS;
10385 }
10386
10387 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
10388 {
10389         uint32_t _ptr_server;
10390         uint32_t _ptr_environment;
10391         uint32_t _ptr_buffer;
10392         uint32_t _ptr_info;
10393         TALLOC_CTX *_mem_save_server_0;
10394         TALLOC_CTX *_mem_save_environment_0;
10395         TALLOC_CTX *_mem_save_buffer_0;
10396         TALLOC_CTX *_mem_save_info_0;
10397         if (flags & NDR_IN) {
10398                 ZERO_STRUCT(r->out);
10399
10400                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10401                 if (_ptr_server) {
10402                         NDR_PULL_ALLOC(ndr, r->in.server);
10403                 } else {
10404                         r->in.server = NULL;
10405                 }
10406                 if (r->in.server) {
10407                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10408                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10409                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10410                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10411                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10412                                 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));
10413                         }
10414                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10415                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10416                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10417                 }
10418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10419                 if (_ptr_environment) {
10420                         NDR_PULL_ALLOC(ndr, r->in.environment);
10421                 } else {
10422                         r->in.environment = NULL;
10423                 }
10424                 if (r->in.environment) {
10425                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10426                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
10427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
10428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
10429                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
10430                                 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));
10431                         }
10432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
10433                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
10434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10435                 }
10436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10437                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10438                 if (_ptr_buffer) {
10439                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10440                 } else {
10441                         r->in.buffer = NULL;
10442                 }
10443                 if (r->in.buffer) {
10444                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10445                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10446                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10448                 }
10449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10450         }
10451         if (flags & NDR_OUT) {
10452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10453                 if (_ptr_info) {
10454                         NDR_PULL_ALLOC(ndr, r->out.info);
10455                 } else {
10456                         r->out.info = NULL;
10457                 }
10458                 if (r->out.info) {
10459                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10460                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10461                         {
10462                                 struct ndr_pull *_ndr_info;
10463                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
10464                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
10465                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
10466                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
10467                         }
10468                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10469                 }
10470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
10471                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10472         }
10473         return NDR_ERR_SUCCESS;
10474 }
10475
10476 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
10477 {
10478         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
10479         ndr->depth++;
10480         if (flags & NDR_SET_VALUES) {
10481                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10482         }
10483         if (flags & NDR_IN) {
10484                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
10485                 ndr->depth++;
10486                 ndr_print_ptr(ndr, "server", r->in.server);
10487                 ndr->depth++;
10488                 if (r->in.server) {
10489                         ndr_print_string(ndr, "server", r->in.server);
10490                 }
10491                 ndr->depth--;
10492                 ndr_print_ptr(ndr, "environment", r->in.environment);
10493                 ndr->depth++;
10494                 if (r->in.environment) {
10495                         ndr_print_string(ndr, "environment", r->in.environment);
10496                 }
10497                 ndr->depth--;
10498                 ndr_print_uint32(ndr, "level", r->in.level);
10499                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10500                 ndr->depth++;
10501                 if (r->in.buffer) {
10502                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10503                 }
10504                 ndr->depth--;
10505                 ndr_print_uint32(ndr, "offered", r->in.offered);
10506                 ndr->depth--;
10507         }
10508         if (flags & NDR_OUT) {
10509                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
10510                 ndr->depth++;
10511                 ndr_print_ptr(ndr, "info", r->out.info);
10512                 ndr->depth++;
10513                 if (r->out.info) {
10514                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
10515                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
10516                 }
10517                 ndr->depth--;
10518                 ndr_print_uint32(ndr, "needed", r->out.needed);
10519                 ndr_print_WERROR(ndr, "result", r->out.result);
10520                 ndr->depth--;
10521         }
10522         ndr->depth--;
10523 }
10524
10525 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
10526 {
10527         if (flags & NDR_IN) {
10528                 if (r->in.handle == NULL) {
10529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10530                 }
10531                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10532                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
10533                 if (r->in.server) {
10534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10535                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
10537                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10538                 }
10539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
10540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
10542                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
10544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
10546                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10547         }
10548         if (flags & NDR_OUT) {
10549                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10550         }
10551         return NDR_ERR_SUCCESS;
10552 }
10553
10554 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
10555 {
10556         uint32_t _ptr_server;
10557         TALLOC_CTX *_mem_save_handle_0;
10558         TALLOC_CTX *_mem_save_server_0;
10559         if (flags & NDR_IN) {
10560                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10561                         NDR_PULL_ALLOC(ndr, r->in.handle);
10562                 }
10563                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10564                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10565                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10566                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
10568                 if (_ptr_server) {
10569                         NDR_PULL_ALLOC(ndr, r->in.server);
10570                 } else {
10571                         r->in.server = NULL;
10572                 }
10573                 if (r->in.server) {
10574                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
10575                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
10576                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
10577                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
10578                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
10579                                 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));
10580                         }
10581                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
10582                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
10583                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
10584                 }
10585                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
10586                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
10587                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
10588                         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));
10589                 }
10590                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
10591                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
10592                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
10593                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
10594                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
10595                         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));
10596                 }
10597                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
10598                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
10599         }
10600         if (flags & NDR_OUT) {
10601                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10602         }
10603         return NDR_ERR_SUCCESS;
10604 }
10605
10606 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
10607 {
10608         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
10609         ndr->depth++;
10610         if (flags & NDR_SET_VALUES) {
10611                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10612         }
10613         if (flags & NDR_IN) {
10614                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
10615                 ndr->depth++;
10616                 ndr_print_ptr(ndr, "handle", r->in.handle);
10617                 ndr->depth++;
10618                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
10619                 ndr->depth--;
10620                 ndr_print_ptr(ndr, "server", r->in.server);
10621                 ndr->depth++;
10622                 if (r->in.server) {
10623                         ndr_print_string(ndr, "server", r->in.server);
10624                 }
10625                 ndr->depth--;
10626                 ndr_print_string(ndr, "architecture", r->in.architecture);
10627                 ndr_print_string(ndr, "driver", r->in.driver);
10628                 ndr->depth--;
10629         }
10630         if (flags & NDR_OUT) {
10631                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
10632                 ndr->depth++;
10633                 ndr_print_WERROR(ndr, "result", r->out.result);
10634                 ndr->depth--;
10635         }
10636         ndr->depth--;
10637 }
10638
10639 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
10640 {
10641         if (flags & NDR_IN) {
10642         }
10643         if (flags & NDR_OUT) {
10644                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10645         }
10646         return NDR_ERR_SUCCESS;
10647 }
10648
10649 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
10650 {
10651         if (flags & NDR_IN) {
10652         }
10653         if (flags & NDR_OUT) {
10654                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10655         }
10656         return NDR_ERR_SUCCESS;
10657 }
10658
10659 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
10660 {
10661         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
10662         ndr->depth++;
10663         if (flags & NDR_SET_VALUES) {
10664                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10665         }
10666         if (flags & NDR_IN) {
10667                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
10668                 ndr->depth++;
10669                 ndr->depth--;
10670         }
10671         if (flags & NDR_OUT) {
10672                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
10673                 ndr->depth++;
10674                 ndr_print_WERROR(ndr, "result", r->out.result);
10675                 ndr->depth--;
10676         }
10677         ndr->depth--;
10678 }
10679
10680 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
10681 {
10682         if (flags & NDR_IN) {
10683                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
10684                 if (r->in.servername) {
10685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, 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.servername, CH_UTF16)));
10688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10689                 }
10690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
10691                 if (r->in.environment) {
10692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
10694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
10695                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
10696                 }
10697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
10699                 if (r->in.buffer) {
10700                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
10701                 }
10702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
10703         }
10704         if (flags & NDR_OUT) {
10705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
10706                 if (r->out.info) {
10707                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
10708                 }
10709                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
10710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
10711                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10712         }
10713         return NDR_ERR_SUCCESS;
10714 }
10715
10716 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
10717 {
10718         uint32_t _ptr_servername;
10719         uint32_t _ptr_environment;
10720         uint32_t _ptr_buffer;
10721         uint32_t _ptr_info;
10722         TALLOC_CTX *_mem_save_servername_0;
10723         TALLOC_CTX *_mem_save_environment_0;
10724         TALLOC_CTX *_mem_save_buffer_0;
10725         TALLOC_CTX *_mem_save_info_0;
10726         if (flags & NDR_IN) {
10727                 ZERO_STRUCT(r->out);
10728
10729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
10730                 if (_ptr_servername) {
10731                         NDR_PULL_ALLOC(ndr, r->in.servername);
10732                 } else {
10733                         r->in.servername = NULL;
10734                 }
10735                 if (r->in.servername) {
10736                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
10737                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
10738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
10739                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
10740                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
10741                                 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));
10742                         }
10743                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
10744                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
10745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
10746                 }
10747                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
10748                 if (_ptr_environment) {
10749                         NDR_PULL_ALLOC(ndr, r->in.environment);
10750                 } else {
10751                         r->in.environment = NULL;
10752                 }
10753                 if (r->in.environment) {
10754                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
10755                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
10756                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
10757                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
10758                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
10759                                 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));
10760                         }
10761                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
10762                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
10763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
10764                 }
10765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10766                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
10767                 if (_ptr_buffer) {
10768                         NDR_PULL_ALLOC(ndr, r->in.buffer);
10769                 } else {
10770                         r->in.buffer = NULL;
10771                 }
10772                 if (r->in.buffer) {
10773                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
10774                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
10775                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
10776                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
10777                 }
10778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
10779         }
10780         if (flags & NDR_OUT) {
10781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
10782                 if (_ptr_info) {
10783                         NDR_PULL_ALLOC(ndr, r->out.info);
10784                 } else {
10785                         r->out.info = NULL;
10786                 }
10787                 if (r->out.info) {
10788                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10789                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10790                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
10791                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10792                 }
10793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
10794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
10795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10796         }
10797         return NDR_ERR_SUCCESS;
10798 }
10799
10800 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
10801 {
10802         uint32_t cntr_info_0;
10803         if (flags & NDR_IN) {
10804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
10806         }
10807         if (flags & NDR_OUT) {
10808                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10809                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
10810                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
10811                 }
10812                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10813                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
10814                 }
10815         }
10816         return NDR_ERR_SUCCESS;
10817 }
10818
10819 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
10820 {
10821         uint32_t cntr_info_0;
10822         TALLOC_CTX *_mem_save_info_0;
10823         if (flags & NDR_IN) {
10824                 ZERO_STRUCT(r->out);
10825
10826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
10828         }
10829         if (flags & NDR_OUT) {
10830                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
10831                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
10832                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
10833                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10834                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
10835                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
10836                 }
10837                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
10838                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
10839                 }
10840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
10841         }
10842         return NDR_ERR_SUCCESS;
10843 }
10844
10845 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
10846 {
10847         uint32_t cntr_info_1;
10848         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
10849         ndr->depth++;
10850         if (flags & NDR_SET_VALUES) {
10851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10852         }
10853         if (flags & NDR_IN) {
10854                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
10855                 ndr->depth++;
10856                 ndr_print_ptr(ndr, "servername", r->in.servername);
10857                 ndr->depth++;
10858                 if (r->in.servername) {
10859                         ndr_print_string(ndr, "servername", r->in.servername);
10860                 }
10861                 ndr->depth--;
10862                 ndr_print_ptr(ndr, "environment", r->in.environment);
10863                 ndr->depth++;
10864                 if (r->in.environment) {
10865                         ndr_print_string(ndr, "environment", r->in.environment);
10866                 }
10867                 ndr->depth--;
10868                 ndr_print_uint32(ndr, "level", r->in.level);
10869                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
10870                 ndr->depth++;
10871                 if (r->in.buffer) {
10872                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
10873                 }
10874                 ndr->depth--;
10875                 ndr_print_uint32(ndr, "offered", r->in.offered);
10876                 ndr->depth--;
10877         }
10878         if (flags & NDR_OUT) {
10879                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
10880                 ndr->depth++;
10881                 ndr_print_ptr(ndr, "info", r->out.info);
10882                 ndr->depth++;
10883                 if (r->out.info) {
10884                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
10885                         ndr->depth++;
10886                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
10887                                 char *idx_1=NULL;
10888                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
10889                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
10890                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &r->out.info[cntr_info_1]);
10891                                         free(idx_1);
10892                                 }
10893                         }
10894                         ndr->depth--;
10895                 }
10896                 ndr->depth--;
10897                 ndr_print_uint32(ndr, "needed", r->out.needed);
10898                 ndr_print_uint32(ndr, "count", r->out.count);
10899                 ndr_print_WERROR(ndr, "result", r->out.result);
10900                 ndr->depth--;
10901         }
10902         ndr->depth--;
10903 }
10904
10905 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
10906 {
10907         if (flags & NDR_IN) {
10908         }
10909         if (flags & NDR_OUT) {
10910                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10911         }
10912         return NDR_ERR_SUCCESS;
10913 }
10914
10915 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
10916 {
10917         if (flags & NDR_IN) {
10918         }
10919         if (flags & NDR_OUT) {
10920                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10921         }
10922         return NDR_ERR_SUCCESS;
10923 }
10924
10925 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
10926 {
10927         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
10928         ndr->depth++;
10929         if (flags & NDR_SET_VALUES) {
10930                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10931         }
10932         if (flags & NDR_IN) {
10933                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
10934                 ndr->depth++;
10935                 ndr->depth--;
10936         }
10937         if (flags & NDR_OUT) {
10938                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
10939                 ndr->depth++;
10940                 ndr_print_WERROR(ndr, "result", r->out.result);
10941                 ndr->depth--;
10942         }
10943         ndr->depth--;
10944 }
10945
10946 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
10947 {
10948         if (flags & NDR_IN) {
10949                 if (r->in.handle == NULL) {
10950                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
10951                 }
10952                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
10954                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
10955                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
10956         }
10957         if (flags & NDR_OUT) {
10958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.job_id));
10959                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
10960         }
10961         return NDR_ERR_SUCCESS;
10962 }
10963
10964 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
10965 {
10966         TALLOC_CTX *_mem_save_handle_0;
10967         if (flags & NDR_IN) {
10968                 ZERO_STRUCT(r->out);
10969
10970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
10971                         NDR_PULL_ALLOC(ndr, r->in.handle);
10972                 }
10973                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
10974                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
10975                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
10976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
10977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
10978                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
10979                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
10980         }
10981         if (flags & NDR_OUT) {
10982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.job_id));
10983                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
10984         }
10985         return NDR_ERR_SUCCESS;
10986 }
10987
10988 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
10989 {
10990         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
10991         ndr->depth++;
10992         if (flags & NDR_SET_VALUES) {
10993                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
10994         }
10995         if (flags & NDR_IN) {
10996                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
10997                 ndr->depth++;
10998                 ndr_print_ptr(ndr, "handle", r->in.handle);
10999                 ndr->depth++;
11000                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11001                 ndr->depth--;
11002                 ndr_print_uint32(ndr, "level", r->in.level);
11003                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
11004                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
11005                 ndr->depth--;
11006         }
11007         if (flags & NDR_OUT) {
11008                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
11009                 ndr->depth++;
11010                 ndr_print_uint32(ndr, "job_id", r->out.job_id);
11011                 ndr_print_WERROR(ndr, "result", r->out.result);
11012                 ndr->depth--;
11013         }
11014         ndr->depth--;
11015 }
11016
11017 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
11018 {
11019         if (flags & NDR_IN) {
11020                 if (r->in.handle == NULL) {
11021                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11022                 }
11023                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11024         }
11025         if (flags & NDR_OUT) {
11026                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11027         }
11028         return NDR_ERR_SUCCESS;
11029 }
11030
11031 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
11032 {
11033         TALLOC_CTX *_mem_save_handle_0;
11034         if (flags & NDR_IN) {
11035                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11036                         NDR_PULL_ALLOC(ndr, r->in.handle);
11037                 }
11038                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11039                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11040                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11041                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11042         }
11043         if (flags & NDR_OUT) {
11044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11045         }
11046         return NDR_ERR_SUCCESS;
11047 }
11048
11049 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
11050 {
11051         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
11052         ndr->depth++;
11053         if (flags & NDR_SET_VALUES) {
11054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11055         }
11056         if (flags & NDR_IN) {
11057                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
11058                 ndr->depth++;
11059                 ndr_print_ptr(ndr, "handle", r->in.handle);
11060                 ndr->depth++;
11061                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11062                 ndr->depth--;
11063                 ndr->depth--;
11064         }
11065         if (flags & NDR_OUT) {
11066                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
11067                 ndr->depth++;
11068                 ndr_print_WERROR(ndr, "result", r->out.result);
11069                 ndr->depth--;
11070         }
11071         ndr->depth--;
11072 }
11073
11074 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
11075 {
11076         if (flags & NDR_IN) {
11077                 if (r->in.handle == NULL) {
11078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11079                 }
11080                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11081                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
11082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
11083         }
11084         if (flags & NDR_OUT) {
11085                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.num_written));
11086                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11087         }
11088         return NDR_ERR_SUCCESS;
11089 }
11090
11091 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
11092 {
11093         TALLOC_CTX *_mem_save_handle_0;
11094         if (flags & NDR_IN) {
11095                 ZERO_STRUCT(r->out);
11096
11097                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11098                         NDR_PULL_ALLOC(ndr, r->in.handle);
11099                 }
11100                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11101                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11102                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11103                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11104                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
11105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
11106         }
11107         if (flags & NDR_OUT) {
11108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.num_written));
11109                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11110         }
11111         return NDR_ERR_SUCCESS;
11112 }
11113
11114 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
11115 {
11116         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
11117         ndr->depth++;
11118         if (flags & NDR_SET_VALUES) {
11119                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11120         }
11121         if (flags & NDR_IN) {
11122                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
11123                 ndr->depth++;
11124                 ndr_print_ptr(ndr, "handle", r->in.handle);
11125                 ndr->depth++;
11126                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11127                 ndr->depth--;
11128                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
11129                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
11130                 ndr->depth--;
11131         }
11132         if (flags & NDR_OUT) {
11133                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
11134                 ndr->depth++;
11135                 ndr_print_uint32(ndr, "num_written", r->out.num_written);
11136                 ndr_print_WERROR(ndr, "result", r->out.result);
11137                 ndr->depth--;
11138         }
11139         ndr->depth--;
11140 }
11141
11142 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
11143 {
11144         if (flags & NDR_IN) {
11145                 if (r->in.handle == NULL) {
11146                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11147                 }
11148                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11149         }
11150         if (flags & NDR_OUT) {
11151                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11152         }
11153         return NDR_ERR_SUCCESS;
11154 }
11155
11156 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
11157 {
11158         TALLOC_CTX *_mem_save_handle_0;
11159         if (flags & NDR_IN) {
11160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11161                         NDR_PULL_ALLOC(ndr, r->in.handle);
11162                 }
11163                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11165                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11167         }
11168         if (flags & NDR_OUT) {
11169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11170         }
11171         return NDR_ERR_SUCCESS;
11172 }
11173
11174 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
11175 {
11176         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
11177         ndr->depth++;
11178         if (flags & NDR_SET_VALUES) {
11179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11180         }
11181         if (flags & NDR_IN) {
11182                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
11183                 ndr->depth++;
11184                 ndr_print_ptr(ndr, "handle", r->in.handle);
11185                 ndr->depth++;
11186                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11187                 ndr->depth--;
11188                 ndr->depth--;
11189         }
11190         if (flags & NDR_OUT) {
11191                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
11192                 ndr->depth++;
11193                 ndr_print_WERROR(ndr, "result", r->out.result);
11194                 ndr->depth--;
11195         }
11196         ndr->depth--;
11197 }
11198
11199 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
11200 {
11201         if (flags & NDR_IN) {
11202                 if (r->in.handle == NULL) {
11203                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11204                 }
11205                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11206         }
11207         if (flags & NDR_OUT) {
11208                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11209         }
11210         return NDR_ERR_SUCCESS;
11211 }
11212
11213 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
11214 {
11215         TALLOC_CTX *_mem_save_handle_0;
11216         if (flags & NDR_IN) {
11217                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11218                         NDR_PULL_ALLOC(ndr, r->in.handle);
11219                 }
11220                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11221                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11222                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11223                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11224         }
11225         if (flags & NDR_OUT) {
11226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11227         }
11228         return NDR_ERR_SUCCESS;
11229 }
11230
11231 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
11232 {
11233         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
11234         ndr->depth++;
11235         if (flags & NDR_SET_VALUES) {
11236                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11237         }
11238         if (flags & NDR_IN) {
11239                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
11240                 ndr->depth++;
11241                 ndr_print_ptr(ndr, "handle", r->in.handle);
11242                 ndr->depth++;
11243                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11244                 ndr->depth--;
11245                 ndr->depth--;
11246         }
11247         if (flags & NDR_OUT) {
11248                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
11249                 ndr->depth++;
11250                 ndr_print_WERROR(ndr, "result", r->out.result);
11251                 ndr->depth--;
11252         }
11253         ndr->depth--;
11254 }
11255
11256 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
11257 {
11258         if (flags & NDR_IN) {
11259                 if (r->in.handle == NULL) {
11260                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11261                 }
11262                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11263                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
11264         }
11265         if (flags & NDR_OUT) {
11266                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
11267                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.data.length));
11268                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11269         }
11270         return NDR_ERR_SUCCESS;
11271 }
11272
11273 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
11274 {
11275         TALLOC_CTX *_mem_save_handle_0;
11276         if (flags & NDR_IN) {
11277                 ZERO_STRUCT(r->out);
11278
11279                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11280                         NDR_PULL_ALLOC(ndr, r->in.handle);
11281                 }
11282                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11283                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11284                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11285                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
11287         }
11288         if (flags & NDR_OUT) {
11289                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
11290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out._data_size));
11291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11292         }
11293         return NDR_ERR_SUCCESS;
11294 }
11295
11296 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
11297 {
11298         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
11299         ndr->depth++;
11300         if (flags & NDR_SET_VALUES) {
11301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11302         }
11303         if (flags & NDR_IN) {
11304                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
11305                 ndr->depth++;
11306                 ndr_print_ptr(ndr, "handle", r->in.handle);
11307                 ndr->depth++;
11308                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11309                 ndr->depth--;
11310                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
11311                 ndr->depth--;
11312         }
11313         if (flags & NDR_OUT) {
11314                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
11315                 ndr->depth++;
11316                 ndr_print_DATA_BLOB(ndr, "data", r->out.data);
11317                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->out.data.length:r->out._data_size);
11318                 ndr_print_WERROR(ndr, "result", r->out.result);
11319                 ndr->depth--;
11320         }
11321         ndr->depth--;
11322 }
11323
11324 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
11325 {
11326         if (flags & NDR_IN) {
11327                 if (r->in.handle == NULL) {
11328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11329                 }
11330                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11331         }
11332         if (flags & NDR_OUT) {
11333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11334         }
11335         return NDR_ERR_SUCCESS;
11336 }
11337
11338 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
11339 {
11340         TALLOC_CTX *_mem_save_handle_0;
11341         if (flags & NDR_IN) {
11342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11343                         NDR_PULL_ALLOC(ndr, r->in.handle);
11344                 }
11345                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11347                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11349         }
11350         if (flags & NDR_OUT) {
11351                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11352         }
11353         return NDR_ERR_SUCCESS;
11354 }
11355
11356 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
11357 {
11358         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
11359         ndr->depth++;
11360         if (flags & NDR_SET_VALUES) {
11361                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11362         }
11363         if (flags & NDR_IN) {
11364                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
11365                 ndr->depth++;
11366                 ndr_print_ptr(ndr, "handle", r->in.handle);
11367                 ndr->depth++;
11368                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11369                 ndr->depth--;
11370                 ndr->depth--;
11371         }
11372         if (flags & NDR_OUT) {
11373                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
11374                 ndr->depth++;
11375                 ndr_print_WERROR(ndr, "result", r->out.result);
11376                 ndr->depth--;
11377         }
11378         ndr->depth--;
11379 }
11380
11381 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
11382 {
11383         if (flags & NDR_IN) {
11384         }
11385         if (flags & NDR_OUT) {
11386                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11387         }
11388         return NDR_ERR_SUCCESS;
11389 }
11390
11391 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
11392 {
11393         if (flags & NDR_IN) {
11394         }
11395         if (flags & NDR_OUT) {
11396                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11397         }
11398         return NDR_ERR_SUCCESS;
11399 }
11400
11401 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
11402 {
11403         ndr_print_struct(ndr, name, "spoolss_AddJob");
11404         ndr->depth++;
11405         if (flags & NDR_SET_VALUES) {
11406                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11407         }
11408         if (flags & NDR_IN) {
11409                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
11410                 ndr->depth++;
11411                 ndr->depth--;
11412         }
11413         if (flags & NDR_OUT) {
11414                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
11415                 ndr->depth++;
11416                 ndr_print_WERROR(ndr, "result", r->out.result);
11417                 ndr->depth--;
11418         }
11419         ndr->depth--;
11420 }
11421
11422 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
11423 {
11424         if (flags & NDR_IN) {
11425         }
11426         if (flags & NDR_OUT) {
11427                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11428         }
11429         return NDR_ERR_SUCCESS;
11430 }
11431
11432 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
11433 {
11434         if (flags & NDR_IN) {
11435         }
11436         if (flags & NDR_OUT) {
11437                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11438         }
11439         return NDR_ERR_SUCCESS;
11440 }
11441
11442 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
11443 {
11444         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
11445         ndr->depth++;
11446         if (flags & NDR_SET_VALUES) {
11447                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11448         }
11449         if (flags & NDR_IN) {
11450                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
11451                 ndr->depth++;
11452                 ndr->depth--;
11453         }
11454         if (flags & NDR_OUT) {
11455                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
11456                 ndr->depth++;
11457                 ndr_print_WERROR(ndr, "result", r->out.result);
11458                 ndr->depth--;
11459         }
11460         ndr->depth--;
11461 }
11462
11463 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
11464 {
11465         if (flags & NDR_IN) {
11466                 if (r->in.handle == NULL) {
11467                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11468                 }
11469                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11471                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11472                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11473                 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));
11474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11475         }
11476         if (flags & NDR_OUT) {
11477                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
11478                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
11479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
11480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11481         }
11482         return NDR_ERR_SUCCESS;
11483 }
11484
11485 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
11486 {
11487         TALLOC_CTX *_mem_save_handle_0;
11488         if (flags & NDR_IN) {
11489                 ZERO_STRUCT(r->out);
11490
11491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11492                         NDR_PULL_ALLOC(ndr, r->in.handle);
11493                 }
11494                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11495                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11496                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11498                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
11499                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
11500                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
11501                         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));
11502                 }
11503                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
11504                 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));
11505                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
11506         }
11507         if (flags & NDR_OUT) {
11508                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->out.type));
11509                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
11510                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
11511                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11512         }
11513         return NDR_ERR_SUCCESS;
11514 }
11515
11516 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
11517 {
11518         if (flags & NDR_IN) {
11519                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11520         }
11521         if (flags & NDR_OUT) {
11522                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
11523                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11524         }
11525         return NDR_ERR_SUCCESS;
11526 }
11527
11528 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
11529 {
11530         if (flags & NDR_IN) {
11531                 ZERO_STRUCT(r->out);
11532
11533                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
11534         }
11535         if (flags & NDR_OUT) {
11536                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
11537                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11538         }
11539         return NDR_ERR_SUCCESS;
11540 }
11541
11542 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
11543 {
11544         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
11545         ndr->depth++;
11546         if (flags & NDR_SET_VALUES) {
11547                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11548         }
11549         if (flags & NDR_IN) {
11550                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
11551                 ndr->depth++;
11552                 ndr_print_ptr(ndr, "handle", r->in.handle);
11553                 ndr->depth++;
11554                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11555                 ndr->depth--;
11556                 ndr_print_string(ndr, "value_name", r->in.value_name);
11557                 ndr_print_uint32(ndr, "offered", r->in.offered);
11558                 ndr->depth--;
11559         }
11560         if (flags & NDR_OUT) {
11561                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
11562                 ndr->depth++;
11563                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->out.type);
11564                 ndr_print_set_switch_value(ndr, &r->out.data, r->out.type);
11565                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
11566                 ndr_print_uint32(ndr, "needed", r->out.needed);
11567                 ndr_print_WERROR(ndr, "result", r->out.result);
11568                 ndr->depth--;
11569         }
11570         ndr->depth--;
11571 }
11572
11573 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
11574 {
11575         if (flags & NDR_IN) {
11576                 if (r->in.handle == NULL) {
11577                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11578                 }
11579                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
11583                 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));
11584                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11585                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
11586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
11587         }
11588         if (flags & NDR_OUT) {
11589                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11590         }
11591         return NDR_ERR_SUCCESS;
11592 }
11593
11594 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
11595 {
11596         if (flags & NDR_IN) {
11597                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
11598         }
11599         if (flags & NDR_OUT) {
11600                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
11601                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
11602         }
11603         return NDR_ERR_SUCCESS;
11604 }
11605
11606 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
11607 {
11608         TALLOC_CTX *_mem_save_handle_0;
11609         if (flags & NDR_IN) {
11610                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11611                         NDR_PULL_ALLOC(ndr, r->in.handle);
11612                 }
11613                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11614                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11615                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11617                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
11618                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
11619                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
11620                         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));
11621                 }
11622                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
11623                 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));
11624                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
11625                 {
11626                         struct ndr_pull *_ndr_data;
11627                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
11628                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
11629                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
11630                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
11631                 }
11632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
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_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
11641 {
11642         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
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_SetPrinterData");
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_print_string(ndr, "value_name", r->in.value_name);
11655                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
11656                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
11657                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
11658                 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);
11659                 ndr->depth--;
11660         }
11661         if (flags & NDR_OUT) {
11662                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
11663                 ndr->depth++;
11664                 ndr_print_WERROR(ndr, "result", r->out.result);
11665                 ndr->depth--;
11666         }
11667         ndr->depth--;
11668 }
11669
11670 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
11671 {
11672         if (flags & NDR_IN) {
11673         }
11674         if (flags & NDR_OUT) {
11675                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11676         }
11677         return NDR_ERR_SUCCESS;
11678 }
11679
11680 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
11681 {
11682         if (flags & NDR_IN) {
11683         }
11684         if (flags & NDR_OUT) {
11685                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11686         }
11687         return NDR_ERR_SUCCESS;
11688 }
11689
11690 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
11691 {
11692         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
11693         ndr->depth++;
11694         if (flags & NDR_SET_VALUES) {
11695                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11696         }
11697         if (flags & NDR_IN) {
11698                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
11699                 ndr->depth++;
11700                 ndr->depth--;
11701         }
11702         if (flags & NDR_OUT) {
11703                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
11704                 ndr->depth++;
11705                 ndr_print_WERROR(ndr, "result", r->out.result);
11706                 ndr->depth--;
11707         }
11708         ndr->depth--;
11709 }
11710
11711 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
11712 {
11713         if (flags & NDR_IN) {
11714                 if (r->in.handle == NULL) {
11715                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11716                 }
11717                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11718         }
11719         if (flags & NDR_OUT) {
11720                 if (r->out.handle == NULL) {
11721                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11722                 }
11723                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
11724                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11725         }
11726         return NDR_ERR_SUCCESS;
11727 }
11728
11729 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
11730 {
11731         TALLOC_CTX *_mem_save_handle_0;
11732         if (flags & NDR_IN) {
11733                 ZERO_STRUCT(r->out);
11734
11735                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11736                         NDR_PULL_ALLOC(ndr, r->in.handle);
11737                 }
11738                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11739                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11740                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11741                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11742                 NDR_PULL_ALLOC(ndr, r->out.handle);
11743                 *r->out.handle = *r->in.handle;
11744         }
11745         if (flags & NDR_OUT) {
11746                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11747                         NDR_PULL_ALLOC(ndr, r->out.handle);
11748                 }
11749                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11750                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
11751                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
11752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11753                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11754         }
11755         return NDR_ERR_SUCCESS;
11756 }
11757
11758 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
11759 {
11760         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
11761         ndr->depth++;
11762         if (flags & NDR_SET_VALUES) {
11763                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11764         }
11765         if (flags & NDR_IN) {
11766                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
11767                 ndr->depth++;
11768                 ndr_print_ptr(ndr, "handle", r->in.handle);
11769                 ndr->depth++;
11770                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11771                 ndr->depth--;
11772                 ndr->depth--;
11773         }
11774         if (flags & NDR_OUT) {
11775                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
11776                 ndr->depth++;
11777                 ndr_print_ptr(ndr, "handle", r->out.handle);
11778                 ndr->depth++;
11779                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
11780                 ndr->depth--;
11781                 ndr_print_WERROR(ndr, "result", r->out.result);
11782                 ndr->depth--;
11783         }
11784         ndr->depth--;
11785 }
11786
11787 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
11788 {
11789         if (flags & NDR_IN) {
11790                 if (r->in.handle == NULL) {
11791                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11792                 }
11793                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
11795                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
11796                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
11797         }
11798         if (flags & NDR_OUT) {
11799                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11800         }
11801         return NDR_ERR_SUCCESS;
11802 }
11803
11804 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
11805 {
11806         TALLOC_CTX *_mem_save_handle_0;
11807         if (flags & NDR_IN) {
11808                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11809                         NDR_PULL_ALLOC(ndr, r->in.handle);
11810                 }
11811                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11812                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11813                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
11816                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
11817                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
11818         }
11819         if (flags & NDR_OUT) {
11820                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11821         }
11822         return NDR_ERR_SUCCESS;
11823 }
11824
11825 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
11826 {
11827         ndr_print_struct(ndr, name, "spoolss_AddForm");
11828         ndr->depth++;
11829         if (flags & NDR_SET_VALUES) {
11830                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11831         }
11832         if (flags & NDR_IN) {
11833                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
11834                 ndr->depth++;
11835                 ndr_print_ptr(ndr, "handle", r->in.handle);
11836                 ndr->depth++;
11837                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11838                 ndr->depth--;
11839                 ndr_print_uint32(ndr, "level", r->in.level);
11840                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
11841                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
11842                 ndr->depth--;
11843         }
11844         if (flags & NDR_OUT) {
11845                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
11846                 ndr->depth++;
11847                 ndr_print_WERROR(ndr, "result", r->out.result);
11848                 ndr->depth--;
11849         }
11850         ndr->depth--;
11851 }
11852
11853 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
11854 {
11855         if (flags & NDR_IN) {
11856                 if (r->in.handle == NULL) {
11857                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11858                 }
11859                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
11861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
11863                 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));
11864         }
11865         if (flags & NDR_OUT) {
11866                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11867         }
11868         return NDR_ERR_SUCCESS;
11869 }
11870
11871 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
11872 {
11873         TALLOC_CTX *_mem_save_handle_0;
11874         if (flags & NDR_IN) {
11875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11876                         NDR_PULL_ALLOC(ndr, r->in.handle);
11877                 }
11878                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11882                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
11883                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
11884                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
11885                         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));
11886                 }
11887                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
11888                 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));
11889         }
11890         if (flags & NDR_OUT) {
11891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
11892         }
11893         return NDR_ERR_SUCCESS;
11894 }
11895
11896 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
11897 {
11898         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
11899         ndr->depth++;
11900         if (flags & NDR_SET_VALUES) {
11901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
11902         }
11903         if (flags & NDR_IN) {
11904                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
11905                 ndr->depth++;
11906                 ndr_print_ptr(ndr, "handle", r->in.handle);
11907                 ndr->depth++;
11908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
11909                 ndr->depth--;
11910                 ndr_print_string(ndr, "form_name", r->in.form_name);
11911                 ndr->depth--;
11912         }
11913         if (flags & NDR_OUT) {
11914                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
11915                 ndr->depth++;
11916                 ndr_print_WERROR(ndr, "result", r->out.result);
11917                 ndr->depth--;
11918         }
11919         ndr->depth--;
11920 }
11921
11922 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
11923 {
11924         if (flags & NDR_IN) {
11925                 if (r->in.handle == NULL) {
11926                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
11927                 }
11928                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11929                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
11930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
11931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
11932                 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));
11933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
11934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
11935                 if (r->in.buffer) {
11936                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
11937                 }
11938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
11939         }
11940         if (flags & NDR_OUT) {
11941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
11942                 if (r->out.info) {
11943                         {
11944                                 struct ndr_push *_ndr_info;
11945                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
11946                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
11947                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
11948                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
11949                         }
11950                 }
11951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
11952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
11953         }
11954         return NDR_ERR_SUCCESS;
11955 }
11956
11957 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
11958 {
11959         uint32_t _ptr_buffer;
11960         uint32_t _ptr_info;
11961         TALLOC_CTX *_mem_save_handle_0;
11962         TALLOC_CTX *_mem_save_buffer_0;
11963         TALLOC_CTX *_mem_save_info_0;
11964         if (flags & NDR_IN) {
11965                 ZERO_STRUCT(r->out);
11966
11967                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
11968                         NDR_PULL_ALLOC(ndr, r->in.handle);
11969                 }
11970                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
11971                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
11972                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
11973                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
11974                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
11975                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
11976                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
11977                         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));
11978                 }
11979                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
11980                 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));
11981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
11982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
11983                 if (_ptr_buffer) {
11984                         NDR_PULL_ALLOC(ndr, r->in.buffer);
11985                 } else {
11986                         r->in.buffer = NULL;
11987                 }
11988                 if (r->in.buffer) {
11989                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
11990                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
11991                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
11992                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
11993                 }
11994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
11995         }
11996         if (flags & NDR_OUT) {
11997                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
11998                 if (_ptr_info) {
11999                         NDR_PULL_ALLOC(ndr, r->out.info);
12000                 } else {
12001                         r->out.info = NULL;
12002                 }
12003                 if (r->out.info) {
12004                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12005                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12006                         {
12007                                 struct ndr_pull *_ndr_info;
12008                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
12009                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
12010                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
12011                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
12012                         }
12013                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12014                 }
12015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
12016                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12017         }
12018         return NDR_ERR_SUCCESS;
12019 }
12020
12021 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
12022 {
12023         ndr_print_struct(ndr, name, "spoolss_GetForm");
12024         ndr->depth++;
12025         if (flags & NDR_SET_VALUES) {
12026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12027         }
12028         if (flags & NDR_IN) {
12029                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
12030                 ndr->depth++;
12031                 ndr_print_ptr(ndr, "handle", r->in.handle);
12032                 ndr->depth++;
12033                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12034                 ndr->depth--;
12035                 ndr_print_string(ndr, "form_name", r->in.form_name);
12036                 ndr_print_uint32(ndr, "level", r->in.level);
12037                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12038                 ndr->depth++;
12039                 if (r->in.buffer) {
12040                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12041                 }
12042                 ndr->depth--;
12043                 ndr_print_uint32(ndr, "offered", r->in.offered);
12044                 ndr->depth--;
12045         }
12046         if (flags & NDR_OUT) {
12047                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
12048                 ndr->depth++;
12049                 ndr_print_ptr(ndr, "info", r->out.info);
12050                 ndr->depth++;
12051                 if (r->out.info) {
12052                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
12053                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
12054                 }
12055                 ndr->depth--;
12056                 ndr_print_uint32(ndr, "needed", r->out.needed);
12057                 ndr_print_WERROR(ndr, "result", r->out.result);
12058                 ndr->depth--;
12059         }
12060         ndr->depth--;
12061 }
12062
12063 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
12064 {
12065         if (flags & NDR_IN) {
12066                 if (r->in.handle == NULL) {
12067                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12068                 }
12069                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
12073                 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));
12074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12075                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
12076                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12077         }
12078         if (flags & NDR_OUT) {
12079                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12080         }
12081         return NDR_ERR_SUCCESS;
12082 }
12083
12084 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
12085 {
12086         TALLOC_CTX *_mem_save_handle_0;
12087         if (flags & NDR_IN) {
12088                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12089                         NDR_PULL_ALLOC(ndr, r->in.handle);
12090                 }
12091                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12092                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12093                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12095                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
12096                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
12097                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
12098                         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));
12099                 }
12100                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
12101                 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));
12102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12103                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
12104                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
12105         }
12106         if (flags & NDR_OUT) {
12107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12108         }
12109         return NDR_ERR_SUCCESS;
12110 }
12111
12112 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
12113 {
12114         ndr_print_struct(ndr, name, "spoolss_SetForm");
12115         ndr->depth++;
12116         if (flags & NDR_SET_VALUES) {
12117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12118         }
12119         if (flags & NDR_IN) {
12120                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
12121                 ndr->depth++;
12122                 ndr_print_ptr(ndr, "handle", r->in.handle);
12123                 ndr->depth++;
12124                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12125                 ndr->depth--;
12126                 ndr_print_string(ndr, "form_name", r->in.form_name);
12127                 ndr_print_uint32(ndr, "level", r->in.level);
12128                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
12129                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
12130                 ndr->depth--;
12131         }
12132         if (flags & NDR_OUT) {
12133                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
12134                 ndr->depth++;
12135                 ndr_print_WERROR(ndr, "result", r->out.result);
12136                 ndr->depth--;
12137         }
12138         ndr->depth--;
12139 }
12140
12141 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
12142 {
12143         if (flags & NDR_IN) {
12144                 if (r->in.handle == NULL) {
12145                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
12146                 }
12147                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12148                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12150                 if (r->in.buffer) {
12151                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12152                 }
12153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12154         }
12155         if (flags & NDR_OUT) {
12156                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12157                 if (r->out.info) {
12158                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12159                 }
12160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
12161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12162                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12163         }
12164         return NDR_ERR_SUCCESS;
12165 }
12166
12167 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
12168 {
12169         uint32_t _ptr_buffer;
12170         uint32_t _ptr_info;
12171         TALLOC_CTX *_mem_save_handle_0;
12172         TALLOC_CTX *_mem_save_buffer_0;
12173         TALLOC_CTX *_mem_save_info_0;
12174         if (flags & NDR_IN) {
12175                 ZERO_STRUCT(r->out);
12176
12177                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
12178                         NDR_PULL_ALLOC(ndr, r->in.handle);
12179                 }
12180                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
12181                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
12182                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
12183                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
12184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12186                 if (_ptr_buffer) {
12187                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12188                 } else {
12189                         r->in.buffer = NULL;
12190                 }
12191                 if (r->in.buffer) {
12192                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12193                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12194                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12196                 }
12197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12198         }
12199         if (flags & NDR_OUT) {
12200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12201                 if (_ptr_info) {
12202                         NDR_PULL_ALLOC(ndr, r->out.info);
12203                 } else {
12204                         r->out.info = NULL;
12205                 }
12206                 if (r->out.info) {
12207                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12208                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12209                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12210                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12211                 }
12212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
12213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12214                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12215         }
12216         return NDR_ERR_SUCCESS;
12217 }
12218
12219 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
12220 {
12221         uint32_t cntr_info_0;
12222         if (flags & NDR_IN) {
12223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12225         }
12226         if (flags & NDR_OUT) {
12227                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12228                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12229                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12230                 }
12231                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12232                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12233                 }
12234         }
12235         return NDR_ERR_SUCCESS;
12236 }
12237
12238 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
12239 {
12240         uint32_t cntr_info_0;
12241         TALLOC_CTX *_mem_save_info_0;
12242         if (flags & NDR_IN) {
12243                 ZERO_STRUCT(r->out);
12244
12245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12247         }
12248         if (flags & NDR_OUT) {
12249                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12250                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12251                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12252                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12253                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12254                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12255                 }
12256                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12257                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12258                 }
12259                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12260         }
12261         return NDR_ERR_SUCCESS;
12262 }
12263
12264 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
12265 {
12266         uint32_t cntr_info_1;
12267         ndr_print_struct(ndr, name, "spoolss_EnumForms");
12268         ndr->depth++;
12269         if (flags & NDR_SET_VALUES) {
12270                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12271         }
12272         if (flags & NDR_IN) {
12273                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
12274                 ndr->depth++;
12275                 ndr_print_ptr(ndr, "handle", r->in.handle);
12276                 ndr->depth++;
12277                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
12278                 ndr->depth--;
12279                 ndr_print_uint32(ndr, "level", r->in.level);
12280                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12281                 ndr->depth++;
12282                 if (r->in.buffer) {
12283                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12284                 }
12285                 ndr->depth--;
12286                 ndr_print_uint32(ndr, "offered", r->in.offered);
12287                 ndr->depth--;
12288         }
12289         if (flags & NDR_OUT) {
12290                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
12291                 ndr->depth++;
12292                 ndr_print_ptr(ndr, "info", r->out.info);
12293                 ndr->depth++;
12294                 if (r->out.info) {
12295                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12296                         ndr->depth++;
12297                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12298                                 char *idx_1=NULL;
12299                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12300                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12301                                         ndr_print_spoolss_FormInfo(ndr, "info", &r->out.info[cntr_info_1]);
12302                                         free(idx_1);
12303                                 }
12304                         }
12305                         ndr->depth--;
12306                 }
12307                 ndr->depth--;
12308                 ndr_print_uint32(ndr, "needed", r->out.needed);
12309                 ndr_print_uint32(ndr, "count", r->out.count);
12310                 ndr_print_WERROR(ndr, "result", r->out.result);
12311                 ndr->depth--;
12312         }
12313         ndr->depth--;
12314 }
12315
12316 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
12317 {
12318         if (flags & NDR_IN) {
12319                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
12320                 if (r->in.servername) {
12321                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12322                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12324                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12325                 }
12326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12328                 if (r->in.buffer) {
12329                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12330                 }
12331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12332         }
12333         if (flags & NDR_OUT) {
12334                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12335                 if (r->out.info) {
12336                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12337                 }
12338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
12339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12340                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12341         }
12342         return NDR_ERR_SUCCESS;
12343 }
12344
12345 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
12346 {
12347         uint32_t _ptr_servername;
12348         uint32_t _ptr_buffer;
12349         uint32_t _ptr_info;
12350         TALLOC_CTX *_mem_save_servername_0;
12351         TALLOC_CTX *_mem_save_buffer_0;
12352         TALLOC_CTX *_mem_save_info_0;
12353         if (flags & NDR_IN) {
12354                 ZERO_STRUCT(r->out);
12355
12356                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
12357                 if (_ptr_servername) {
12358                         NDR_PULL_ALLOC(ndr, r->in.servername);
12359                 } else {
12360                         r->in.servername = NULL;
12361                 }
12362                 if (r->in.servername) {
12363                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
12364                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
12365                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
12366                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
12367                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
12368                                 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));
12369                         }
12370                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
12371                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
12372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
12373                 }
12374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12375                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12376                 if (_ptr_buffer) {
12377                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12378                 } else {
12379                         r->in.buffer = NULL;
12380                 }
12381                 if (r->in.buffer) {
12382                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12383                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12384                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12386                 }
12387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12388         }
12389         if (flags & NDR_OUT) {
12390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12391                 if (_ptr_info) {
12392                         NDR_PULL_ALLOC(ndr, r->out.info);
12393                 } else {
12394                         r->out.info = NULL;
12395                 }
12396                 if (r->out.info) {
12397                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12398                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12399                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12401                 }
12402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
12403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12404                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12405         }
12406         return NDR_ERR_SUCCESS;
12407 }
12408
12409 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
12410 {
12411         uint32_t cntr_info_0;
12412         if (flags & NDR_IN) {
12413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12415         }
12416         if (flags & NDR_OUT) {
12417                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12418                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12419                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12420                 }
12421                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12422                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12423                 }
12424         }
12425         return NDR_ERR_SUCCESS;
12426 }
12427
12428 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
12429 {
12430         uint32_t cntr_info_0;
12431         TALLOC_CTX *_mem_save_info_0;
12432         if (flags & NDR_IN) {
12433                 ZERO_STRUCT(r->out);
12434
12435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12437         }
12438         if (flags & NDR_OUT) {
12439                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12440                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12441                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12442                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12443                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12444                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12445                 }
12446                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12447                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12448                 }
12449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12450         }
12451         return NDR_ERR_SUCCESS;
12452 }
12453
12454 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
12455 {
12456         uint32_t cntr_info_1;
12457         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
12458         ndr->depth++;
12459         if (flags & NDR_SET_VALUES) {
12460                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12461         }
12462         if (flags & NDR_IN) {
12463                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
12464                 ndr->depth++;
12465                 ndr_print_ptr(ndr, "servername", r->in.servername);
12466                 ndr->depth++;
12467                 if (r->in.servername) {
12468                         ndr_print_string(ndr, "servername", r->in.servername);
12469                 }
12470                 ndr->depth--;
12471                 ndr_print_uint32(ndr, "level", r->in.level);
12472                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12473                 ndr->depth++;
12474                 if (r->in.buffer) {
12475                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12476                 }
12477                 ndr->depth--;
12478                 ndr_print_uint32(ndr, "offered", r->in.offered);
12479                 ndr->depth--;
12480         }
12481         if (flags & NDR_OUT) {
12482                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
12483                 ndr->depth++;
12484                 ndr_print_ptr(ndr, "info", r->out.info);
12485                 ndr->depth++;
12486                 if (r->out.info) {
12487                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12488                         ndr->depth++;
12489                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12490                                 char *idx_1=NULL;
12491                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12492                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12493                                         ndr_print_spoolss_PortInfo(ndr, "info", &r->out.info[cntr_info_1]);
12494                                         free(idx_1);
12495                                 }
12496                         }
12497                         ndr->depth--;
12498                 }
12499                 ndr->depth--;
12500                 ndr_print_uint32(ndr, "needed", r->out.needed);
12501                 ndr_print_uint32(ndr, "count", r->out.count);
12502                 ndr_print_WERROR(ndr, "result", r->out.result);
12503                 ndr->depth--;
12504         }
12505         ndr->depth--;
12506 }
12507
12508 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
12509 {
12510         if (flags & NDR_IN) {
12511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
12512                 if (r->in.servername) {
12513                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12515                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
12516                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
12517                 }
12518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
12520                 if (r->in.buffer) {
12521                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
12522                 }
12523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
12524         }
12525         if (flags & NDR_OUT) {
12526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
12527                 if (r->out.info) {
12528                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
12529                 }
12530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
12531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
12532                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12533         }
12534         return NDR_ERR_SUCCESS;
12535 }
12536
12537 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
12538 {
12539         uint32_t _ptr_servername;
12540         uint32_t _ptr_buffer;
12541         uint32_t _ptr_info;
12542         TALLOC_CTX *_mem_save_servername_0;
12543         TALLOC_CTX *_mem_save_buffer_0;
12544         TALLOC_CTX *_mem_save_info_0;
12545         if (flags & NDR_IN) {
12546                 ZERO_STRUCT(r->out);
12547
12548                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
12549                 if (_ptr_servername) {
12550                         NDR_PULL_ALLOC(ndr, r->in.servername);
12551                 } else {
12552                         r->in.servername = NULL;
12553                 }
12554                 if (r->in.servername) {
12555                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
12556                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
12557                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
12558                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
12559                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
12560                                 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));
12561                         }
12562                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
12563                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
12564                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
12565                 }
12566                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
12568                 if (_ptr_buffer) {
12569                         NDR_PULL_ALLOC(ndr, r->in.buffer);
12570                 } else {
12571                         r->in.buffer = NULL;
12572                 }
12573                 if (r->in.buffer) {
12574                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
12575                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
12576                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
12577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
12578                 }
12579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
12580         }
12581         if (flags & NDR_OUT) {
12582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
12583                 if (_ptr_info) {
12584                         NDR_PULL_ALLOC(ndr, r->out.info);
12585                 } else {
12586                         r->out.info = NULL;
12587                 }
12588                 if (r->out.info) {
12589                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12590                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12591                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
12592                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12593                 }
12594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
12595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
12596                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12597         }
12598         return NDR_ERR_SUCCESS;
12599 }
12600
12601 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
12602 {
12603         uint32_t cntr_info_0;
12604         if (flags & NDR_IN) {
12605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
12606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
12607         }
12608         if (flags & NDR_OUT) {
12609                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12610                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12611                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12612                 }
12613                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12614                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12615                 }
12616         }
12617         return NDR_ERR_SUCCESS;
12618 }
12619
12620 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
12621 {
12622         uint32_t cntr_info_0;
12623         TALLOC_CTX *_mem_save_info_0;
12624         if (flags & NDR_IN) {
12625                 ZERO_STRUCT(r->out);
12626
12627                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
12628                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
12629         }
12630         if (flags & NDR_OUT) {
12631                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
12632                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
12633                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
12634                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12635                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
12636                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
12637                 }
12638                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
12639                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
12640                 }
12641                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
12642         }
12643         return NDR_ERR_SUCCESS;
12644 }
12645
12646 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
12647 {
12648         uint32_t cntr_info_1;
12649         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
12650         ndr->depth++;
12651         if (flags & NDR_SET_VALUES) {
12652                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12653         }
12654         if (flags & NDR_IN) {
12655                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
12656                 ndr->depth++;
12657                 ndr_print_ptr(ndr, "servername", r->in.servername);
12658                 ndr->depth++;
12659                 if (r->in.servername) {
12660                         ndr_print_string(ndr, "servername", r->in.servername);
12661                 }
12662                 ndr->depth--;
12663                 ndr_print_uint32(ndr, "level", r->in.level);
12664                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
12665                 ndr->depth++;
12666                 if (r->in.buffer) {
12667                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
12668                 }
12669                 ndr->depth--;
12670                 ndr_print_uint32(ndr, "offered", r->in.offered);
12671                 ndr->depth--;
12672         }
12673         if (flags & NDR_OUT) {
12674                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
12675                 ndr->depth++;
12676                 ndr_print_ptr(ndr, "info", r->out.info);
12677                 ndr->depth++;
12678                 if (r->out.info) {
12679                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)r->out.count);
12680                         ndr->depth++;
12681                         for (cntr_info_1=0;cntr_info_1<r->out.count;cntr_info_1++) {
12682                                 char *idx_1=NULL;
12683                                 if (asprintf(&idx_1, "[%d]", cntr_info_1) != -1) {
12684                                         ndr_print_set_switch_value(ndr, &r->out.info[cntr_info_1], r->in.level);
12685                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &r->out.info[cntr_info_1]);
12686                                         free(idx_1);
12687                                 }
12688                         }
12689                         ndr->depth--;
12690                 }
12691                 ndr->depth--;
12692                 ndr_print_uint32(ndr, "needed", r->out.needed);
12693                 ndr_print_uint32(ndr, "count", r->out.count);
12694                 ndr_print_WERROR(ndr, "result", r->out.result);
12695                 ndr->depth--;
12696         }
12697         ndr->depth--;
12698 }
12699
12700 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
12701 {
12702         if (flags & NDR_IN) {
12703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
12704                 if (r->in.server_name) {
12705                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
12706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
12708                         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));
12709                 }
12710                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
12711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
12712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
12713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
12714                 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));
12715         }
12716         if (flags & NDR_OUT) {
12717                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12718         }
12719         return NDR_ERR_SUCCESS;
12720 }
12721
12722 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
12723 {
12724         uint32_t _ptr_server_name;
12725         TALLOC_CTX *_mem_save_server_name_0;
12726         if (flags & NDR_IN) {
12727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
12728                 if (_ptr_server_name) {
12729                         NDR_PULL_ALLOC(ndr, r->in.server_name);
12730                 } else {
12731                         r->in.server_name = NULL;
12732                 }
12733                 if (r->in.server_name) {
12734                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12735                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
12736                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
12737                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
12738                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
12739                                 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));
12740                         }
12741                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
12742                         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));
12743                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
12744                 }
12745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
12746                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
12747                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
12748                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
12749                         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));
12750                 }
12751                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
12752                 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));
12753         }
12754         if (flags & NDR_OUT) {
12755                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12756         }
12757         return NDR_ERR_SUCCESS;
12758 }
12759
12760 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
12761 {
12762         ndr_print_struct(ndr, name, "spoolss_AddPort");
12763         ndr->depth++;
12764         if (flags & NDR_SET_VALUES) {
12765                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12766         }
12767         if (flags & NDR_IN) {
12768                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
12769                 ndr->depth++;
12770                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
12771                 ndr->depth++;
12772                 if (r->in.server_name) {
12773                         ndr_print_string(ndr, "server_name", r->in.server_name);
12774                 }
12775                 ndr->depth--;
12776                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
12777                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
12778                 ndr->depth--;
12779         }
12780         if (flags & NDR_OUT) {
12781                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
12782                 ndr->depth++;
12783                 ndr_print_WERROR(ndr, "result", r->out.result);
12784                 ndr->depth--;
12785         }
12786         ndr->depth--;
12787 }
12788
12789 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
12790 {
12791         if (flags & NDR_IN) {
12792         }
12793         if (flags & NDR_OUT) {
12794                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12795         }
12796         return NDR_ERR_SUCCESS;
12797 }
12798
12799 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
12800 {
12801         if (flags & NDR_IN) {
12802         }
12803         if (flags & NDR_OUT) {
12804                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12805         }
12806         return NDR_ERR_SUCCESS;
12807 }
12808
12809 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
12810 {
12811         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
12812         ndr->depth++;
12813         if (flags & NDR_SET_VALUES) {
12814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12815         }
12816         if (flags & NDR_IN) {
12817                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
12818                 ndr->depth++;
12819                 ndr->depth--;
12820         }
12821         if (flags & NDR_OUT) {
12822                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
12823                 ndr->depth++;
12824                 ndr_print_WERROR(ndr, "result", r->out.result);
12825                 ndr->depth--;
12826         }
12827         ndr->depth--;
12828 }
12829
12830 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
12831 {
12832         if (flags & NDR_IN) {
12833         }
12834         if (flags & NDR_OUT) {
12835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12836         }
12837         return NDR_ERR_SUCCESS;
12838 }
12839
12840 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
12841 {
12842         if (flags & NDR_IN) {
12843         }
12844         if (flags & NDR_OUT) {
12845                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12846         }
12847         return NDR_ERR_SUCCESS;
12848 }
12849
12850 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
12851 {
12852         ndr_print_struct(ndr, name, "spoolss_DeletePort");
12853         ndr->depth++;
12854         if (flags & NDR_SET_VALUES) {
12855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12856         }
12857         if (flags & NDR_IN) {
12858                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
12859                 ndr->depth++;
12860                 ndr->depth--;
12861         }
12862         if (flags & NDR_OUT) {
12863                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
12864                 ndr->depth++;
12865                 ndr_print_WERROR(ndr, "result", r->out.result);
12866                 ndr->depth--;
12867         }
12868         ndr->depth--;
12869 }
12870
12871 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
12872 {
12873         if (flags & NDR_IN) {
12874         }
12875         if (flags & NDR_OUT) {
12876                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12877         }
12878         return NDR_ERR_SUCCESS;
12879 }
12880
12881 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
12882 {
12883         if (flags & NDR_IN) {
12884         }
12885         if (flags & NDR_OUT) {
12886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12887         }
12888         return NDR_ERR_SUCCESS;
12889 }
12890
12891 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
12892 {
12893         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
12894         ndr->depth++;
12895         if (flags & NDR_SET_VALUES) {
12896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12897         }
12898         if (flags & NDR_IN) {
12899                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
12900                 ndr->depth++;
12901                 ndr->depth--;
12902         }
12903         if (flags & NDR_OUT) {
12904                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
12905                 ndr->depth++;
12906                 ndr_print_WERROR(ndr, "result", r->out.result);
12907                 ndr->depth--;
12908         }
12909         ndr->depth--;
12910 }
12911
12912 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
12913 {
12914         if (flags & NDR_IN) {
12915         }
12916         if (flags & NDR_OUT) {
12917                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12918         }
12919         return NDR_ERR_SUCCESS;
12920 }
12921
12922 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
12923 {
12924         if (flags & NDR_IN) {
12925         }
12926         if (flags & NDR_OUT) {
12927                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12928         }
12929         return NDR_ERR_SUCCESS;
12930 }
12931
12932 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
12933 {
12934         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
12935         ndr->depth++;
12936         if (flags & NDR_SET_VALUES) {
12937                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12938         }
12939         if (flags & NDR_IN) {
12940                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
12941                 ndr->depth++;
12942                 ndr->depth--;
12943         }
12944         if (flags & NDR_OUT) {
12945                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
12946                 ndr->depth++;
12947                 ndr_print_WERROR(ndr, "result", r->out.result);
12948                 ndr->depth--;
12949         }
12950         ndr->depth--;
12951 }
12952
12953 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
12954 {
12955         if (flags & NDR_IN) {
12956         }
12957         if (flags & NDR_OUT) {
12958                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
12959         }
12960         return NDR_ERR_SUCCESS;
12961 }
12962
12963 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
12964 {
12965         if (flags & NDR_IN) {
12966         }
12967         if (flags & NDR_OUT) {
12968                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
12969         }
12970         return NDR_ERR_SUCCESS;
12971 }
12972
12973 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
12974 {
12975         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
12976         ndr->depth++;
12977         if (flags & NDR_SET_VALUES) {
12978                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
12979         }
12980         if (flags & NDR_IN) {
12981                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
12982                 ndr->depth++;
12983                 ndr->depth--;
12984         }
12985         if (flags & NDR_OUT) {
12986                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
12987                 ndr->depth++;
12988                 ndr_print_WERROR(ndr, "result", r->out.result);
12989                 ndr->depth--;
12990         }
12991         ndr->depth--;
12992 }
12993
12994 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
12995 {
12996         if (flags & NDR_IN) {
12997         }
12998         if (flags & NDR_OUT) {
12999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13000         }
13001         return NDR_ERR_SUCCESS;
13002 }
13003
13004 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
13005 {
13006         if (flags & NDR_IN) {
13007         }
13008         if (flags & NDR_OUT) {
13009                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13010         }
13011         return NDR_ERR_SUCCESS;
13012 }
13013
13014 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
13015 {
13016         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
13017         ndr->depth++;
13018         if (flags & NDR_SET_VALUES) {
13019                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13020         }
13021         if (flags & NDR_IN) {
13022                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
13023                 ndr->depth++;
13024                 ndr->depth--;
13025         }
13026         if (flags & NDR_OUT) {
13027                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
13028                 ndr->depth++;
13029                 ndr_print_WERROR(ndr, "result", r->out.result);
13030                 ndr->depth--;
13031         }
13032         ndr->depth--;
13033 }
13034
13035 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
13036 {
13037         if (flags & NDR_IN) {
13038         }
13039         if (flags & NDR_OUT) {
13040                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13041         }
13042         return NDR_ERR_SUCCESS;
13043 }
13044
13045 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
13046 {
13047         if (flags & NDR_IN) {
13048         }
13049         if (flags & NDR_OUT) {
13050                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13051         }
13052         return NDR_ERR_SUCCESS;
13053 }
13054
13055 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
13056 {
13057         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
13058         ndr->depth++;
13059         if (flags & NDR_SET_VALUES) {
13060                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13061         }
13062         if (flags & NDR_IN) {
13063                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
13064                 ndr->depth++;
13065                 ndr->depth--;
13066         }
13067         if (flags & NDR_OUT) {
13068                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
13069                 ndr->depth++;
13070                 ndr_print_WERROR(ndr, "result", r->out.result);
13071                 ndr->depth--;
13072         }
13073         ndr->depth--;
13074 }
13075
13076 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
13077 {
13078         if (flags & NDR_IN) {
13079         }
13080         if (flags & NDR_OUT) {
13081                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13082         }
13083         return NDR_ERR_SUCCESS;
13084 }
13085
13086 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
13087 {
13088         if (flags & NDR_IN) {
13089         }
13090         if (flags & NDR_OUT) {
13091                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13092         }
13093         return NDR_ERR_SUCCESS;
13094 }
13095
13096 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
13097 {
13098         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
13099         ndr->depth++;
13100         if (flags & NDR_SET_VALUES) {
13101                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13102         }
13103         if (flags & NDR_IN) {
13104                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
13105                 ndr->depth++;
13106                 ndr->depth--;
13107         }
13108         if (flags & NDR_OUT) {
13109                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
13110                 ndr->depth++;
13111                 ndr_print_WERROR(ndr, "result", r->out.result);
13112                 ndr->depth--;
13113         }
13114         ndr->depth--;
13115 }
13116
13117 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
13118 {
13119         if (flags & NDR_IN) {
13120         }
13121         if (flags & NDR_OUT) {
13122                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13123         }
13124         return NDR_ERR_SUCCESS;
13125 }
13126
13127 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
13128 {
13129         if (flags & NDR_IN) {
13130         }
13131         if (flags & NDR_OUT) {
13132                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13133         }
13134         return NDR_ERR_SUCCESS;
13135 }
13136
13137 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
13138 {
13139         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
13140         ndr->depth++;
13141         if (flags & NDR_SET_VALUES) {
13142                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13143         }
13144         if (flags & NDR_IN) {
13145                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
13146                 ndr->depth++;
13147                 ndr->depth--;
13148         }
13149         if (flags & NDR_OUT) {
13150                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
13151                 ndr->depth++;
13152                 ndr_print_WERROR(ndr, "result", r->out.result);
13153                 ndr->depth--;
13154         }
13155         ndr->depth--;
13156 }
13157
13158 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
13159 {
13160         if (flags & NDR_IN) {
13161         }
13162         if (flags & NDR_OUT) {
13163                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13164         }
13165         return NDR_ERR_SUCCESS;
13166 }
13167
13168 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
13169 {
13170         if (flags & NDR_IN) {
13171         }
13172         if (flags & NDR_OUT) {
13173                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13174         }
13175         return NDR_ERR_SUCCESS;
13176 }
13177
13178 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
13179 {
13180         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
13181         ndr->depth++;
13182         if (flags & NDR_SET_VALUES) {
13183                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13184         }
13185         if (flags & NDR_IN) {
13186                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
13187                 ndr->depth++;
13188                 ndr->depth--;
13189         }
13190         if (flags & NDR_OUT) {
13191                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
13192                 ndr->depth++;
13193                 ndr_print_WERROR(ndr, "result", r->out.result);
13194                 ndr->depth--;
13195         }
13196         ndr->depth--;
13197 }
13198
13199 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
13200 {
13201         if (flags & NDR_IN) {
13202         }
13203         if (flags & NDR_OUT) {
13204                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13205         }
13206         return NDR_ERR_SUCCESS;
13207 }
13208
13209 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
13210 {
13211         if (flags & NDR_IN) {
13212         }
13213         if (flags & NDR_OUT) {
13214                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13215         }
13216         return NDR_ERR_SUCCESS;
13217 }
13218
13219 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
13220 {
13221         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
13222         ndr->depth++;
13223         if (flags & NDR_SET_VALUES) {
13224                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13225         }
13226         if (flags & NDR_IN) {
13227                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
13228                 ndr->depth++;
13229                 ndr->depth--;
13230         }
13231         if (flags & NDR_OUT) {
13232                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
13233                 ndr->depth++;
13234                 ndr_print_WERROR(ndr, "result", r->out.result);
13235                 ndr->depth--;
13236         }
13237         ndr->depth--;
13238 }
13239
13240 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
13241 {
13242         if (flags & NDR_IN) {
13243         }
13244         if (flags & NDR_OUT) {
13245                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13246         }
13247         return NDR_ERR_SUCCESS;
13248 }
13249
13250 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
13251 {
13252         if (flags & NDR_IN) {
13253         }
13254         if (flags & NDR_OUT) {
13255                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13256         }
13257         return NDR_ERR_SUCCESS;
13258 }
13259
13260 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
13261 {
13262         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
13263         ndr->depth++;
13264         if (flags & NDR_SET_VALUES) {
13265                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13266         }
13267         if (flags & NDR_IN) {
13268                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
13269                 ndr->depth++;
13270                 ndr->depth--;
13271         }
13272         if (flags & NDR_OUT) {
13273                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
13274                 ndr->depth++;
13275                 ndr_print_WERROR(ndr, "result", r->out.result);
13276                 ndr->depth--;
13277         }
13278         ndr->depth--;
13279 }
13280
13281 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
13282 {
13283         if (flags & NDR_IN) {
13284         }
13285         if (flags & NDR_OUT) {
13286                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13287         }
13288         return NDR_ERR_SUCCESS;
13289 }
13290
13291 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
13292 {
13293         if (flags & NDR_IN) {
13294         }
13295         if (flags & NDR_OUT) {
13296                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13297         }
13298         return NDR_ERR_SUCCESS;
13299 }
13300
13301 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
13302 {
13303         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
13304         ndr->depth++;
13305         if (flags & NDR_SET_VALUES) {
13306                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13307         }
13308         if (flags & NDR_IN) {
13309                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
13310                 ndr->depth++;
13311                 ndr->depth--;
13312         }
13313         if (flags & NDR_OUT) {
13314                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
13315                 ndr->depth++;
13316                 ndr_print_WERROR(ndr, "result", r->out.result);
13317                 ndr->depth--;
13318         }
13319         ndr->depth--;
13320 }
13321
13322 static enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
13323 {
13324         if (flags & NDR_IN) {
13325         }
13326         if (flags & NDR_OUT) {
13327                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13328         }
13329         return NDR_ERR_SUCCESS;
13330 }
13331
13332 static enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
13333 {
13334         if (flags & NDR_IN) {
13335         }
13336         if (flags & NDR_OUT) {
13337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13338         }
13339         return NDR_ERR_SUCCESS;
13340 }
13341
13342 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
13343 {
13344         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
13345         ndr->depth++;
13346         if (flags & NDR_SET_VALUES) {
13347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13348         }
13349         if (flags & NDR_IN) {
13350                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
13351                 ndr->depth++;
13352                 ndr->depth--;
13353         }
13354         if (flags & NDR_OUT) {
13355                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
13356                 ndr->depth++;
13357                 ndr_print_WERROR(ndr, "result", r->out.result);
13358                 ndr->depth--;
13359         }
13360         ndr->depth--;
13361 }
13362
13363 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
13364 {
13365         if (flags & NDR_IN) {
13366         }
13367         if (flags & NDR_OUT) {
13368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13369         }
13370         return NDR_ERR_SUCCESS;
13371 }
13372
13373 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
13374 {
13375         if (flags & NDR_IN) {
13376         }
13377         if (flags & NDR_OUT) {
13378                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13379         }
13380         return NDR_ERR_SUCCESS;
13381 }
13382
13383 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
13384 {
13385         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
13386         ndr->depth++;
13387         if (flags & NDR_SET_VALUES) {
13388                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13389         }
13390         if (flags & NDR_IN) {
13391                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
13392                 ndr->depth++;
13393                 ndr->depth--;
13394         }
13395         if (flags & NDR_OUT) {
13396                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
13397                 ndr->depth++;
13398                 ndr_print_WERROR(ndr, "result", r->out.result);
13399                 ndr->depth--;
13400         }
13401         ndr->depth--;
13402 }
13403
13404 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
13405 {
13406         if (flags & NDR_IN) {
13407                 if (r->in.handle == NULL) {
13408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13409                 }
13410                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
13412                 if (r->in.architecture) {
13413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
13414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
13416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
13417                 }
13418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
13419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
13420                 if (r->in.buffer) {
13421                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
13422                 }
13423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
13424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
13425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
13426         }
13427         if (flags & NDR_OUT) {
13428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
13429                 if (r->out.info) {
13430                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
13431                 }
13432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
13433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
13434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
13435                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13436         }
13437         return NDR_ERR_SUCCESS;
13438 }
13439
13440 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
13441 {
13442         uint32_t _ptr_architecture;
13443         uint32_t _ptr_buffer;
13444         uint32_t _ptr_info;
13445         TALLOC_CTX *_mem_save_handle_0;
13446         TALLOC_CTX *_mem_save_architecture_0;
13447         TALLOC_CTX *_mem_save_buffer_0;
13448         TALLOC_CTX *_mem_save_info_0;
13449         if (flags & NDR_IN) {
13450                 ZERO_STRUCT(r->out);
13451
13452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13453                         NDR_PULL_ALLOC(ndr, r->in.handle);
13454                 }
13455                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13456                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13457                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
13460                 if (_ptr_architecture) {
13461                         NDR_PULL_ALLOC(ndr, r->in.architecture);
13462                 } else {
13463                         r->in.architecture = NULL;
13464                 }
13465                 if (r->in.architecture) {
13466                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
13467                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
13468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
13469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
13470                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
13471                                 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));
13472                         }
13473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
13474                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
13475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
13476                 }
13477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
13478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
13479                 if (_ptr_buffer) {
13480                         NDR_PULL_ALLOC(ndr, r->in.buffer);
13481                 } else {
13482                         r->in.buffer = NULL;
13483                 }
13484                 if (r->in.buffer) {
13485                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
13486                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
13487                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
13488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
13489                 }
13490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
13491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
13492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
13493         }
13494         if (flags & NDR_OUT) {
13495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
13496                 if (_ptr_info) {
13497                         NDR_PULL_ALLOC(ndr, r->out.info);
13498                 } else {
13499                         r->out.info = NULL;
13500                 }
13501                 if (r->out.info) {
13502                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
13503                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
13504                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
13505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
13506                 }
13507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
13508                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.server_major_version));
13509                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.server_minor_version));
13510                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13511         }
13512         return NDR_ERR_SUCCESS;
13513 }
13514
13515 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
13516 {
13517         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
13518         ndr->depth++;
13519         if (flags & NDR_SET_VALUES) {
13520                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13521         }
13522         if (flags & NDR_IN) {
13523                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
13524                 ndr->depth++;
13525                 ndr_print_ptr(ndr, "handle", r->in.handle);
13526                 ndr->depth++;
13527                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13528                 ndr->depth--;
13529                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
13530                 ndr->depth++;
13531                 if (r->in.architecture) {
13532                         ndr_print_string(ndr, "architecture", r->in.architecture);
13533                 }
13534                 ndr->depth--;
13535                 ndr_print_uint32(ndr, "level", r->in.level);
13536                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
13537                 ndr->depth++;
13538                 if (r->in.buffer) {
13539                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
13540                 }
13541                 ndr->depth--;
13542                 ndr_print_uint32(ndr, "offered", r->in.offered);
13543                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
13544                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
13545                 ndr->depth--;
13546         }
13547         if (flags & NDR_OUT) {
13548                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
13549                 ndr->depth++;
13550                 ndr_print_ptr(ndr, "info", r->out.info);
13551                 ndr->depth++;
13552                 if (r->out.info) {
13553                         ndr_print_DATA_BLOB(ndr, "info", *r->out.info);
13554                 }
13555                 ndr->depth--;
13556                 ndr_print_uint32(ndr, "needed", r->out.needed);
13557                 ndr_print_uint32(ndr, "server_major_version", r->out.server_major_version);
13558                 ndr_print_uint32(ndr, "server_minor_version", r->out.server_minor_version);
13559                 ndr_print_WERROR(ndr, "result", r->out.result);
13560                 ndr->depth--;
13561         }
13562         ndr->depth--;
13563 }
13564
13565 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
13566 {
13567         if (flags & NDR_IN) {
13568         }
13569         if (flags & NDR_OUT) {
13570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13571         }
13572         return NDR_ERR_SUCCESS;
13573 }
13574
13575 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
13576 {
13577         if (flags & NDR_IN) {
13578         }
13579         if (flags & NDR_OUT) {
13580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13581         }
13582         return NDR_ERR_SUCCESS;
13583 }
13584
13585 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
13586 {
13587         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
13588         ndr->depth++;
13589         if (flags & NDR_SET_VALUES) {
13590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13591         }
13592         if (flags & NDR_IN) {
13593                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
13594                 ndr->depth++;
13595                 ndr->depth--;
13596         }
13597         if (flags & NDR_OUT) {
13598                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
13599                 ndr->depth++;
13600                 ndr_print_WERROR(ndr, "result", r->out.result);
13601                 ndr->depth--;
13602         }
13603         ndr->depth--;
13604 }
13605
13606 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
13607 {
13608         if (flags & NDR_IN) {
13609         }
13610         if (flags & NDR_OUT) {
13611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13612         }
13613         return NDR_ERR_SUCCESS;
13614 }
13615
13616 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
13617 {
13618         if (flags & NDR_IN) {
13619         }
13620         if (flags & NDR_OUT) {
13621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13622         }
13623         return NDR_ERR_SUCCESS;
13624 }
13625
13626 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
13627 {
13628         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
13629         ndr->depth++;
13630         if (flags & NDR_SET_VALUES) {
13631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13632         }
13633         if (flags & NDR_IN) {
13634                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
13635                 ndr->depth++;
13636                 ndr->depth--;
13637         }
13638         if (flags & NDR_OUT) {
13639                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
13640                 ndr->depth++;
13641                 ndr_print_WERROR(ndr, "result", r->out.result);
13642                 ndr->depth--;
13643         }
13644         ndr->depth--;
13645 }
13646
13647 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
13648 {
13649         if (flags & NDR_IN) {
13650                 if (r->in.handle == NULL) {
13651                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13652                 }
13653                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13654         }
13655         if (flags & NDR_OUT) {
13656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13657         }
13658         return NDR_ERR_SUCCESS;
13659 }
13660
13661 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
13662 {
13663         TALLOC_CTX *_mem_save_handle_0;
13664         if (flags & NDR_IN) {
13665                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13666                         NDR_PULL_ALLOC(ndr, r->in.handle);
13667                 }
13668                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13669                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13670                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13671                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13672         }
13673         if (flags & NDR_OUT) {
13674                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13675         }
13676         return NDR_ERR_SUCCESS;
13677 }
13678
13679 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
13680 {
13681         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
13682         ndr->depth++;
13683         if (flags & NDR_SET_VALUES) {
13684                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13685         }
13686         if (flags & NDR_IN) {
13687                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
13688                 ndr->depth++;
13689                 ndr_print_ptr(ndr, "handle", r->in.handle);
13690                 ndr->depth++;
13691                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13692                 ndr->depth--;
13693                 ndr->depth--;
13694         }
13695         if (flags & NDR_OUT) {
13696                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
13697                 ndr->depth++;
13698                 ndr_print_WERROR(ndr, "result", r->out.result);
13699                 ndr->depth--;
13700         }
13701         ndr->depth--;
13702 }
13703
13704 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
13705 {
13706         if (flags & NDR_IN) {
13707         }
13708         if (flags & NDR_OUT) {
13709                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13710         }
13711         return NDR_ERR_SUCCESS;
13712 }
13713
13714 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
13715 {
13716         if (flags & NDR_IN) {
13717         }
13718         if (flags & NDR_OUT) {
13719                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13720         }
13721         return NDR_ERR_SUCCESS;
13722 }
13723
13724 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
13725 {
13726         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
13727         ndr->depth++;
13728         if (flags & NDR_SET_VALUES) {
13729                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13730         }
13731         if (flags & NDR_IN) {
13732                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
13733                 ndr->depth++;
13734                 ndr->depth--;
13735         }
13736         if (flags & NDR_OUT) {
13737                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
13738                 ndr->depth++;
13739                 ndr_print_WERROR(ndr, "result", r->out.result);
13740                 ndr->depth--;
13741         }
13742         ndr->depth--;
13743 }
13744
13745 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
13746 {
13747         if (flags & NDR_IN) {
13748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
13749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
13750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
13751                 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));
13752                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
13753                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
13754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
13755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown2));
13756         }
13757         if (flags & NDR_OUT) {
13758                 if (r->out.handle == NULL) {
13759                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13760                 }
13761                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
13762                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13763         }
13764         return NDR_ERR_SUCCESS;
13765 }
13766
13767 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
13768 {
13769         TALLOC_CTX *_mem_save_handle_0;
13770         if (flags & NDR_IN) {
13771                 ZERO_STRUCT(r->out);
13772
13773                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
13774                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
13775                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
13776                         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));
13777                 }
13778                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
13779                 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));
13780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
13781                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
13782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
13783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown2));
13784                 NDR_PULL_ALLOC(ndr, r->out.handle);
13785                 ZERO_STRUCTP(r->out.handle);
13786         }
13787         if (flags & NDR_OUT) {
13788                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13789                         NDR_PULL_ALLOC(ndr, r->out.handle);
13790                 }
13791                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13792                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
13793                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
13794                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13795                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13796         }
13797         return NDR_ERR_SUCCESS;
13798 }
13799
13800 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
13801 {
13802         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
13803         ndr->depth++;
13804         if (flags & NDR_SET_VALUES) {
13805                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13806         }
13807         if (flags & NDR_IN) {
13808                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
13809                 ndr->depth++;
13810                 ndr_print_string(ndr, "server_name", r->in.server_name);
13811                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
13812                 ndr_print_winreg_Type(ndr, "type", r->in.type);
13813                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
13814                 ndr_print_uint32(ndr, "unknown2", r->in.unknown2);
13815                 ndr->depth--;
13816         }
13817         if (flags & NDR_OUT) {
13818                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
13819                 ndr->depth++;
13820                 ndr_print_ptr(ndr, "handle", r->out.handle);
13821                 ndr->depth++;
13822                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
13823                 ndr->depth--;
13824                 ndr_print_WERROR(ndr, "result", r->out.result);
13825                 ndr->depth--;
13826         }
13827         ndr->depth--;
13828 }
13829
13830 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
13831 {
13832         if (flags & NDR_IN) {
13833         }
13834         if (flags & NDR_OUT) {
13835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13836         }
13837         return NDR_ERR_SUCCESS;
13838 }
13839
13840 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
13841 {
13842         if (flags & NDR_IN) {
13843         }
13844         if (flags & NDR_OUT) {
13845                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13846         }
13847         return NDR_ERR_SUCCESS;
13848 }
13849
13850 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
13851 {
13852         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
13853         ndr->depth++;
13854         if (flags & NDR_SET_VALUES) {
13855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13856         }
13857         if (flags & NDR_IN) {
13858                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
13859                 ndr->depth++;
13860                 ndr->depth--;
13861         }
13862         if (flags & NDR_OUT) {
13863                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
13864                 ndr->depth++;
13865                 ndr_print_WERROR(ndr, "result", r->out.result);
13866                 ndr->depth--;
13867         }
13868         ndr->depth--;
13869 }
13870
13871 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
13872 {
13873         if (flags & NDR_IN) {
13874                 if (r->in.handle == NULL) {
13875                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13876                 }
13877                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13878         }
13879         if (flags & NDR_OUT) {
13880                 if (r->out.handle == NULL) {
13881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
13882                 }
13883                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
13884                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13885         }
13886         return NDR_ERR_SUCCESS;
13887 }
13888
13889 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
13890 {
13891         TALLOC_CTX *_mem_save_handle_0;
13892         if (flags & NDR_IN) {
13893                 ZERO_STRUCT(r->out);
13894
13895                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13896                         NDR_PULL_ALLOC(ndr, r->in.handle);
13897                 }
13898                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13899                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
13900                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
13901                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13902                 NDR_PULL_ALLOC(ndr, r->out.handle);
13903                 *r->out.handle = *r->in.handle;
13904         }
13905         if (flags & NDR_OUT) {
13906                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
13907                         NDR_PULL_ALLOC(ndr, r->out.handle);
13908                 }
13909                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
13910                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
13911                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
13912                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
13913                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13914         }
13915         return NDR_ERR_SUCCESS;
13916 }
13917
13918 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
13919 {
13920         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
13921         ndr->depth++;
13922         if (flags & NDR_SET_VALUES) {
13923                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13924         }
13925         if (flags & NDR_IN) {
13926                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
13927                 ndr->depth++;
13928                 ndr_print_ptr(ndr, "handle", r->in.handle);
13929                 ndr->depth++;
13930                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
13931                 ndr->depth--;
13932                 ndr->depth--;
13933         }
13934         if (flags & NDR_OUT) {
13935                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
13936                 ndr->depth++;
13937                 ndr_print_ptr(ndr, "handle", r->out.handle);
13938                 ndr->depth++;
13939                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
13940                 ndr->depth--;
13941                 ndr_print_WERROR(ndr, "result", r->out.result);
13942                 ndr->depth--;
13943         }
13944         ndr->depth--;
13945 }
13946
13947 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
13948 {
13949         if (flags & NDR_IN) {
13950         }
13951         if (flags & NDR_OUT) {
13952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13953         }
13954         return NDR_ERR_SUCCESS;
13955 }
13956
13957 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
13958 {
13959         if (flags & NDR_IN) {
13960         }
13961         if (flags & NDR_OUT) {
13962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
13963         }
13964         return NDR_ERR_SUCCESS;
13965 }
13966
13967 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
13968 {
13969         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
13970         ndr->depth++;
13971         if (flags & NDR_SET_VALUES) {
13972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
13973         }
13974         if (flags & NDR_IN) {
13975                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
13976                 ndr->depth++;
13977                 ndr->depth--;
13978         }
13979         if (flags & NDR_OUT) {
13980                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
13981                 ndr->depth++;
13982                 ndr_print_WERROR(ndr, "result", r->out.result);
13983                 ndr->depth--;
13984         }
13985         ndr->depth--;
13986 }
13987
13988 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
13989 {
13990         if (flags & NDR_IN) {
13991         }
13992         if (flags & NDR_OUT) {
13993                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
13994         }
13995         return NDR_ERR_SUCCESS;
13996 }
13997
13998 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
13999 {
14000         if (flags & NDR_IN) {
14001         }
14002         if (flags & NDR_OUT) {
14003                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14004         }
14005         return NDR_ERR_SUCCESS;
14006 }
14007
14008 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
14009 {
14010         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
14011         ndr->depth++;
14012         if (flags & NDR_SET_VALUES) {
14013                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14014         }
14015         if (flags & NDR_IN) {
14016                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
14017                 ndr->depth++;
14018                 ndr->depth--;
14019         }
14020         if (flags & NDR_OUT) {
14021                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
14022                 ndr->depth++;
14023                 ndr_print_WERROR(ndr, "result", r->out.result);
14024                 ndr->depth--;
14025         }
14026         ndr->depth--;
14027 }
14028
14029 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
14030 {
14031         if (flags & NDR_IN) {
14032         }
14033         if (flags & NDR_OUT) {
14034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14035         }
14036         return NDR_ERR_SUCCESS;
14037 }
14038
14039 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
14040 {
14041         if (flags & NDR_IN) {
14042         }
14043         if (flags & NDR_OUT) {
14044                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14045         }
14046         return NDR_ERR_SUCCESS;
14047 }
14048
14049 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
14050 {
14051         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
14052         ndr->depth++;
14053         if (flags & NDR_SET_VALUES) {
14054                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14055         }
14056         if (flags & NDR_IN) {
14057                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
14058                 ndr->depth++;
14059                 ndr->depth--;
14060         }
14061         if (flags & NDR_OUT) {
14062                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
14063                 ndr->depth++;
14064                 ndr_print_WERROR(ndr, "result", r->out.result);
14065                 ndr->depth--;
14066         }
14067         ndr->depth--;
14068 }
14069
14070 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
14071 {
14072         if (flags & NDR_IN) {
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 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
14081 {
14082         if (flags & NDR_IN) {
14083         }
14084         if (flags & NDR_OUT) {
14085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14086         }
14087         return NDR_ERR_SUCCESS;
14088 }
14089
14090 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
14091 {
14092         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
14093         ndr->depth++;
14094         if (flags & NDR_SET_VALUES) {
14095                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14096         }
14097         if (flags & NDR_IN) {
14098                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
14099                 ndr->depth++;
14100                 ndr->depth--;
14101         }
14102         if (flags & NDR_OUT) {
14103                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
14104                 ndr->depth++;
14105                 ndr_print_WERROR(ndr, "result", r->out.result);
14106                 ndr->depth--;
14107         }
14108         ndr->depth--;
14109 }
14110
14111 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14112 {
14113         if (flags & NDR_IN) {
14114                 if (r->in.handle == NULL) {
14115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14116                 }
14117                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.flags));
14119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
14120                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.str));
14121                 if (r->in.str) {
14122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.str, CH_UTF16)));
14123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.str, CH_UTF16)));
14125                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.str, ndr_charset_length(r->in.str, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14126                 }
14127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
14128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.t1));
14129                 if (r->in.t1) {
14130                         NDR_CHECK(ndr_push_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.t1));
14131                 }
14132         }
14133         if (flags & NDR_OUT) {
14134                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14135         }
14136         return NDR_ERR_SUCCESS;
14137 }
14138
14139 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14140 {
14141         uint32_t _ptr_str;
14142         uint32_t _ptr_t1;
14143         TALLOC_CTX *_mem_save_handle_0;
14144         TALLOC_CTX *_mem_save_str_0;
14145         TALLOC_CTX *_mem_save_t1_0;
14146         if (flags & NDR_IN) {
14147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14148                         NDR_PULL_ALLOC(ndr, r->in.handle);
14149                 }
14150                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14151                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14152                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14154                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.flags));
14155                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
14156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_str));
14157                 if (_ptr_str) {
14158                         NDR_PULL_ALLOC(ndr, r->in.str);
14159                 } else {
14160                         r->in.str = NULL;
14161                 }
14162                 if (r->in.str) {
14163                         _mem_save_str_0 = NDR_PULL_GET_MEM_CTX(ndr);
14164                         NDR_PULL_SET_MEM_CTX(ndr, r->in.str, 0);
14165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.str));
14166                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.str));
14167                         if (ndr_get_array_length(ndr, &r->in.str) > ndr_get_array_size(ndr, &r->in.str)) {
14168                                 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));
14169                         }
14170                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.str), sizeof(uint16_t)));
14171                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.str, ndr_get_array_length(ndr, &r->in.str), sizeof(uint16_t), CH_UTF16));
14172                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_str_0, 0);
14173                 }
14174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
14175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_t1));
14176                 if (_ptr_t1) {
14177                         NDR_PULL_ALLOC(ndr, r->in.t1);
14178                 } else {
14179                         r->in.t1 = NULL;
14180                 }
14181                 if (r->in.t1) {
14182                         _mem_save_t1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14183                         NDR_PULL_SET_MEM_CTX(ndr, r->in.t1, 0);
14184                         NDR_CHECK(ndr_pull_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.t1));
14185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_t1_0, 0);
14186                 }
14187         }
14188         if (flags & NDR_OUT) {
14189                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14190         }
14191         return NDR_ERR_SUCCESS;
14192 }
14193
14194 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
14195 {
14196         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14197         ndr->depth++;
14198         if (flags & NDR_SET_VALUES) {
14199                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14200         }
14201         if (flags & NDR_IN) {
14202                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14203                 ndr->depth++;
14204                 ndr_print_ptr(ndr, "handle", r->in.handle);
14205                 ndr->depth++;
14206                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14207                 ndr->depth--;
14208                 ndr_print_uint32(ndr, "flags", r->in.flags);
14209                 ndr_print_uint32(ndr, "options", r->in.options);
14210                 ndr_print_ptr(ndr, "str", r->in.str);
14211                 ndr->depth++;
14212                 if (r->in.str) {
14213                         ndr_print_string(ndr, "str", r->in.str);
14214                 }
14215                 ndr->depth--;
14216                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
14217                 ndr_print_ptr(ndr, "t1", r->in.t1);
14218                 ndr->depth++;
14219                 if (r->in.t1) {
14220                         ndr_print_spoolss_NotifyOptionsContainer(ndr, "t1", r->in.t1);
14221                 }
14222                 ndr->depth--;
14223                 ndr->depth--;
14224         }
14225         if (flags & NDR_OUT) {
14226                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
14227                 ndr->depth++;
14228                 ndr_print_WERROR(ndr, "result", r->out.result);
14229                 ndr->depth--;
14230         }
14231         ndr->depth--;
14232 }
14233
14234 static enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotification *r)
14235 {
14236         if (flags & NDR_IN) {
14237         }
14238         if (flags & NDR_OUT) {
14239                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14240         }
14241         return NDR_ERR_SUCCESS;
14242 }
14243
14244 static enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotification *r)
14245 {
14246         if (flags & NDR_IN) {
14247         }
14248         if (flags & NDR_OUT) {
14249                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14250         }
14251         return NDR_ERR_SUCCESS;
14252 }
14253
14254 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotification *r)
14255 {
14256         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotification");
14257         ndr->depth++;
14258         if (flags & NDR_SET_VALUES) {
14259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14260         }
14261         if (flags & NDR_IN) {
14262                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotification");
14263                 ndr->depth++;
14264                 ndr->depth--;
14265         }
14266         if (flags & NDR_OUT) {
14267                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotification");
14268                 ndr->depth++;
14269                 ndr_print_WERROR(ndr, "result", r->out.result);
14270                 ndr->depth--;
14271         }
14272         ndr->depth--;
14273 }
14274
14275 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14276 {
14277         if (flags & NDR_IN) {
14278                 if (r->in.handle == NULL) {
14279                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14280                 }
14281                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
14283                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.container));
14284                 if (r->in.container) {
14285                         NDR_CHECK(ndr_push_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.container));
14286                 }
14287         }
14288         if (flags & NDR_OUT) {
14289                 if (r->out.info == NULL) {
14290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14291                 }
14292                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
14293                 if (*r->out.info) {
14294                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
14295                 }
14296                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14297         }
14298         return NDR_ERR_SUCCESS;
14299 }
14300
14301 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14302 {
14303         uint32_t _ptr_container;
14304         uint32_t _ptr_info;
14305         TALLOC_CTX *_mem_save_handle_0;
14306         TALLOC_CTX *_mem_save_container_0;
14307         TALLOC_CTX *_mem_save_info_0;
14308         TALLOC_CTX *_mem_save_info_1;
14309         if (flags & NDR_IN) {
14310                 ZERO_STRUCT(r->out);
14311
14312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14313                         NDR_PULL_ALLOC(ndr, r->in.handle);
14314                 }
14315                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14317                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
14320                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_container));
14321                 if (_ptr_container) {
14322                         NDR_PULL_ALLOC(ndr, r->in.container);
14323                 } else {
14324                         r->in.container = NULL;
14325                 }
14326                 if (r->in.container) {
14327                         _mem_save_container_0 = NDR_PULL_GET_MEM_CTX(ndr);
14328                         NDR_PULL_SET_MEM_CTX(ndr, r->in.container, 0);
14329                         NDR_CHECK(ndr_pull_spoolss_NotifyOptionsContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.container));
14330                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_container_0, 0);
14331                 }
14332                 NDR_PULL_ALLOC(ndr, r->out.info);
14333                 ZERO_STRUCTP(r->out.info);
14334         }
14335         if (flags & NDR_OUT) {
14336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14337                         NDR_PULL_ALLOC(ndr, r->out.info);
14338                 }
14339                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14340                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
14341                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14342                 if (_ptr_info) {
14343                         NDR_PULL_ALLOC(ndr, *r->out.info);
14344                 } else {
14345                         *r->out.info = NULL;
14346                 }
14347                 if (*r->out.info) {
14348                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
14349                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
14350                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
14351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
14352                 }
14353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
14354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14355         }
14356         return NDR_ERR_SUCCESS;
14357 }
14358
14359 _PUBLIC_ void ndr_print_spoolss_RemoteFindNextPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindNextPrinterChangeNotifyEx *r)
14360 {
14361         ndr_print_struct(ndr, name, "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14362         ndr->depth++;
14363         if (flags & NDR_SET_VALUES) {
14364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14365         }
14366         if (flags & NDR_IN) {
14367                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14368                 ndr->depth++;
14369                 ndr_print_ptr(ndr, "handle", r->in.handle);
14370                 ndr->depth++;
14371                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14372                 ndr->depth--;
14373                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
14374                 ndr_print_ptr(ndr, "container", r->in.container);
14375                 ndr->depth++;
14376                 if (r->in.container) {
14377                         ndr_print_spoolss_NotifyOptionsContainer(ndr, "container", r->in.container);
14378                 }
14379                 ndr->depth--;
14380                 ndr->depth--;
14381         }
14382         if (flags & NDR_OUT) {
14383                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindNextPrinterChangeNotifyEx");
14384                 ndr->depth++;
14385                 ndr_print_ptr(ndr, "info", r->out.info);
14386                 ndr->depth++;
14387                 ndr_print_ptr(ndr, "info", *r->out.info);
14388                 ndr->depth++;
14389                 if (*r->out.info) {
14390                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
14391                 }
14392                 ndr->depth--;
14393                 ndr->depth--;
14394                 ndr_print_WERROR(ndr, "result", r->out.result);
14395                 ndr->depth--;
14396         }
14397         ndr->depth--;
14398 }
14399
14400 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
14401 {
14402         if (flags & NDR_IN) {
14403         }
14404         if (flags & NDR_OUT) {
14405                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14406         }
14407         return NDR_ERR_SUCCESS;
14408 }
14409
14410 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
14411 {
14412         if (flags & NDR_IN) {
14413         }
14414         if (flags & NDR_OUT) {
14415                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14416         }
14417         return NDR_ERR_SUCCESS;
14418 }
14419
14420 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
14421 {
14422         ndr_print_struct(ndr, name, "spoolss_44");
14423         ndr->depth++;
14424         if (flags & NDR_SET_VALUES) {
14425                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14426         }
14427         if (flags & NDR_IN) {
14428                 ndr_print_struct(ndr, "in", "spoolss_44");
14429                 ndr->depth++;
14430                 ndr->depth--;
14431         }
14432         if (flags & NDR_OUT) {
14433                 ndr_print_struct(ndr, "out", "spoolss_44");
14434                 ndr->depth++;
14435                 ndr_print_WERROR(ndr, "result", r->out.result);
14436                 ndr->depth--;
14437         }
14438         ndr->depth--;
14439 }
14440
14441 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
14442 {
14443         if (flags & NDR_IN) {
14444                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
14445                 if (r->in.printername) {
14446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
14449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14450                 }
14451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
14452                 if (r->in.datatype) {
14453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
14456                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14457                 }
14458                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.access_mask));
14460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14461                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
14462                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
14463         }
14464         if (flags & NDR_OUT) {
14465                 if (r->out.handle == NULL) {
14466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14467                 }
14468                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14469                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14470         }
14471         return NDR_ERR_SUCCESS;
14472 }
14473
14474 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
14475 {
14476         uint32_t _ptr_printername;
14477         uint32_t _ptr_datatype;
14478         TALLOC_CTX *_mem_save_printername_0;
14479         TALLOC_CTX *_mem_save_datatype_0;
14480         TALLOC_CTX *_mem_save_handle_0;
14481         if (flags & NDR_IN) {
14482                 ZERO_STRUCT(r->out);
14483
14484                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
14485                 if (_ptr_printername) {
14486                         NDR_PULL_ALLOC(ndr, r->in.printername);
14487                 } else {
14488                         r->in.printername = NULL;
14489                 }
14490                 if (r->in.printername) {
14491                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
14492                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
14493                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
14494                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
14495                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
14496                                 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));
14497                         }
14498                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
14499                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
14500                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
14501                 }
14502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14503                 if (_ptr_datatype) {
14504                         NDR_PULL_ALLOC(ndr, r->in.datatype);
14505                 } else {
14506                         r->in.datatype = NULL;
14507                 }
14508                 if (r->in.datatype) {
14509                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14510                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
14511                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
14512                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
14513                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
14514                                 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));
14515                         }
14516                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
14517                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
14518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14519                 }
14520                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14521                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.access_mask));
14522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14523                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
14524                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
14525                 NDR_PULL_ALLOC(ndr, r->out.handle);
14526                 ZERO_STRUCTP(r->out.handle);
14527         }
14528         if (flags & NDR_OUT) {
14529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14530                         NDR_PULL_ALLOC(ndr, r->out.handle);
14531                 }
14532                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14533                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
14534                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
14535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14537         }
14538         return NDR_ERR_SUCCESS;
14539 }
14540
14541 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
14542 {
14543         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
14544         ndr->depth++;
14545         if (flags & NDR_SET_VALUES) {
14546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14547         }
14548         if (flags & NDR_IN) {
14549                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
14550                 ndr->depth++;
14551                 ndr_print_ptr(ndr, "printername", r->in.printername);
14552                 ndr->depth++;
14553                 if (r->in.printername) {
14554                         ndr_print_string(ndr, "printername", r->in.printername);
14555                 }
14556                 ndr->depth--;
14557                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
14558                 ndr->depth++;
14559                 if (r->in.datatype) {
14560                         ndr_print_string(ndr, "datatype", r->in.datatype);
14561                 }
14562                 ndr->depth--;
14563                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
14564                 ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
14565                 ndr_print_uint32(ndr, "level", r->in.level);
14566                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
14567                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
14568                 ndr->depth--;
14569         }
14570         if (flags & NDR_OUT) {
14571                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
14572                 ndr->depth++;
14573                 ndr_print_ptr(ndr, "handle", r->out.handle);
14574                 ndr->depth++;
14575                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
14576                 ndr->depth--;
14577                 ndr_print_WERROR(ndr, "result", r->out.result);
14578                 ndr->depth--;
14579         }
14580         ndr->depth--;
14581 }
14582
14583 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
14584 {
14585         if (flags & NDR_IN) {
14586                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
14587                 if (r->in.server) {
14588                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14590                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
14591                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14592                 }
14593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
14594                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.info));
14595                 if (r->in.info) {
14596                         NDR_CHECK(ndr_push_set_switch_value(ndr, r->in.info, r->in.level));
14597                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
14598                 }
14599                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14600                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.secdesc));
14601                 if (r->in.secdesc) {
14602                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
14603                 }
14604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.ulevel));
14605                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel));
14606                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
14607         }
14608         if (flags & NDR_OUT) {
14609                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14610         }
14611         return NDR_ERR_SUCCESS;
14612 }
14613
14614 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
14615 {
14616         uint32_t _ptr_server;
14617         uint32_t _ptr_info;
14618         uint32_t _ptr_secdesc;
14619         TALLOC_CTX *_mem_save_server_0;
14620         TALLOC_CTX *_mem_save_info_0;
14621         TALLOC_CTX *_mem_save_secdesc_0;
14622         if (flags & NDR_IN) {
14623                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
14624                 if (_ptr_server) {
14625                         NDR_PULL_ALLOC(ndr, r->in.server);
14626                 } else {
14627                         r->in.server = NULL;
14628                 }
14629                 if (r->in.server) {
14630                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
14631                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
14632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
14633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
14634                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
14635                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server), ndr_get_array_length(ndr, &r->in.server));
14636                         }
14637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
14638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
14639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
14640                 }
14641                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
14642                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
14643                 if (_ptr_info) {
14644                         NDR_PULL_ALLOC(ndr, r->in.info);
14645                 } else {
14646                         r->in.info = NULL;
14647                 }
14648                 if (r->in.info) {
14649                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
14650                         NDR_PULL_SET_MEM_CTX(ndr, r->in.info, 0);
14651                         NDR_CHECK(ndr_pull_set_switch_value(ndr, r->in.info, r->in.level));
14652                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info));
14653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
14654                 }
14655                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
14656                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
14657                 if (_ptr_secdesc) {
14658                         NDR_PULL_ALLOC(ndr, r->in.secdesc);
14659                 } else {
14660                         r->in.secdesc = NULL;
14661                 }
14662                 if (r->in.secdesc) {
14663                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
14664                         NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc, 0);
14665                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc));
14666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
14667                 }
14668                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.ulevel));
14669                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel));
14670                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
14671         }
14672         if (flags & NDR_OUT) {
14673                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14674         }
14675         return NDR_ERR_SUCCESS;
14676 }
14677
14678 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
14679 {
14680         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
14681         ndr->depth++;
14682         if (flags & NDR_SET_VALUES) {
14683                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14684         }
14685         if (flags & NDR_IN) {
14686                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
14687                 ndr->depth++;
14688                 ndr_print_ptr(ndr, "server", r->in.server);
14689                 ndr->depth++;
14690                 if (r->in.server) {
14691                         ndr_print_string(ndr, "server", r->in.server);
14692                 }
14693                 ndr->depth--;
14694                 ndr_print_uint32(ndr, "level", r->in.level);
14695                 ndr_print_ptr(ndr, "info", r->in.info);
14696                 ndr->depth++;
14697                 if (r->in.info) {
14698                         ndr_print_set_switch_value(ndr, r->in.info, r->in.level);
14699                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->in.info);
14700                 }
14701                 ndr->depth--;
14702                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
14703                 ndr_print_ptr(ndr, "secdesc", r->in.secdesc);
14704                 ndr->depth++;
14705                 if (r->in.secdesc) {
14706                         ndr_print_security_descriptor(ndr, "secdesc", r->in.secdesc);
14707                 }
14708                 ndr->depth--;
14709                 ndr_print_uint32(ndr, "ulevel", r->in.ulevel);
14710                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.ulevel);
14711                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
14712                 ndr->depth--;
14713         }
14714         if (flags & NDR_OUT) {
14715                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
14716                 ndr->depth++;
14717                 ndr_print_WERROR(ndr, "result", r->out.result);
14718                 ndr->depth--;
14719         }
14720         ndr->depth--;
14721 }
14722
14723 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
14724 {
14725         if (flags & NDR_IN) {
14726         }
14727         if (flags & NDR_OUT) {
14728                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14729         }
14730         return NDR_ERR_SUCCESS;
14731 }
14732
14733 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
14734 {
14735         if (flags & NDR_IN) {
14736         }
14737         if (flags & NDR_OUT) {
14738                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14739         }
14740         return NDR_ERR_SUCCESS;
14741 }
14742
14743 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
14744 {
14745         ndr_print_struct(ndr, name, "spoolss_47");
14746         ndr->depth++;
14747         if (flags & NDR_SET_VALUES) {
14748                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14749         }
14750         if (flags & NDR_IN) {
14751                 ndr_print_struct(ndr, "in", "spoolss_47");
14752                 ndr->depth++;
14753                 ndr->depth--;
14754         }
14755         if (flags & NDR_OUT) {
14756                 ndr_print_struct(ndr, "out", "spoolss_47");
14757                 ndr->depth++;
14758                 ndr_print_WERROR(ndr, "result", r->out.result);
14759                 ndr->depth--;
14760         }
14761         ndr->depth--;
14762 }
14763
14764 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
14765 {
14766         if (flags & NDR_IN) {
14767                 if (r->in.handle == NULL) {
14768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14769                 }
14770                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
14772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
14773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
14774         }
14775         if (flags & NDR_OUT) {
14776                 if (r->out.value_name == NULL) {
14777                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14778                 }
14779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
14780                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
14781                 if (r->out.value_needed == NULL) {
14782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14783                 }
14784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
14785                 if (r->out.printerdata_type == NULL) {
14786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14787                 }
14788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
14789                 if (r->out.buffer == NULL) {
14790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14791                 }
14792                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
14793                 if (r->out.data_needed == NULL) {
14794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14795                 }
14796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
14797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14798         }
14799         return NDR_ERR_SUCCESS;
14800 }
14801
14802 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
14803 {
14804         TALLOC_CTX *_mem_save_handle_0;
14805         TALLOC_CTX *_mem_save_value_needed_0;
14806         TALLOC_CTX *_mem_save_printerdata_type_0;
14807         TALLOC_CTX *_mem_save_buffer_0;
14808         TALLOC_CTX *_mem_save_data_needed_0;
14809         if (flags & NDR_IN) {
14810                 ZERO_STRUCT(r->out);
14811
14812                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14813                         NDR_PULL_ALLOC(ndr, r->in.handle);
14814                 }
14815                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14816                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14817                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14818                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
14820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
14821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
14822                 NDR_PULL_ALLOC_N(ndr, r->out.value_name, r->in.value_offered / 2);
14823                 memset(CONST_DISCARD(struct spoolss_EnumPrinterData *,r->out.value_name), 0, (r->in.value_offered / 2) * sizeof(*r->out.value_name));
14824                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
14825                 ZERO_STRUCTP(r->out.value_needed);
14826                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
14827                 ZERO_STRUCTP(r->out.printerdata_type);
14828                 NDR_PULL_ALLOC(ndr, r->out.buffer);
14829                 ZERO_STRUCTP(r->out.buffer);
14830                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
14831                 ZERO_STRUCTP(r->out.data_needed);
14832         }
14833         if (flags & NDR_OUT) {
14834                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
14835                 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));
14836                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14837                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
14838                 }
14839                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14840                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
14841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
14842                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
14843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14844                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
14845                 }
14846                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
14847                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
14848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
14849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
14850                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14851                         NDR_PULL_ALLOC(ndr, r->out.buffer);
14852                 }
14853                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
14854                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
14855                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
14856                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
14857                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14858                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
14859                 }
14860                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
14861                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
14862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
14863                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
14864                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14865                 if (r->out.value_name) {
14866                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
14867                 }
14868         }
14869         return NDR_ERR_SUCCESS;
14870 }
14871
14872 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
14873 {
14874         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
14875         ndr->depth++;
14876         if (flags & NDR_SET_VALUES) {
14877                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14878         }
14879         if (flags & NDR_IN) {
14880                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
14881                 ndr->depth++;
14882                 ndr_print_ptr(ndr, "handle", r->in.handle);
14883                 ndr->depth++;
14884                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14885                 ndr->depth--;
14886                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
14887                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
14888                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
14889                 ndr->depth--;
14890         }
14891         if (flags & NDR_OUT) {
14892                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
14893                 ndr->depth++;
14894                 ndr_print_ptr(ndr, "value_name", r->out.value_name);
14895                 ndr->depth++;
14896                 ndr_print_string(ndr, "value_name", r->out.value_name);
14897                 ndr->depth--;
14898                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
14899                 ndr->depth++;
14900                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
14901                 ndr->depth--;
14902                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
14903                 ndr->depth++;
14904                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
14905                 ndr->depth--;
14906                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
14907                 ndr->depth++;
14908                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
14909                 ndr->depth--;
14910                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
14911                 ndr->depth++;
14912                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
14913                 ndr->depth--;
14914                 ndr_print_WERROR(ndr, "result", r->out.result);
14915                 ndr->depth--;
14916         }
14917         ndr->depth--;
14918 }
14919
14920 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
14921 {
14922         if (flags & NDR_IN) {
14923                 if (r->in.handle == NULL) {
14924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
14925                 }
14926                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, 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.value_name, CH_UTF16)));
14930                 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));
14931         }
14932         if (flags & NDR_OUT) {
14933                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14934         }
14935         return NDR_ERR_SUCCESS;
14936 }
14937
14938 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
14939 {
14940         TALLOC_CTX *_mem_save_handle_0;
14941         if (flags & NDR_IN) {
14942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
14943                         NDR_PULL_ALLOC(ndr, r->in.handle);
14944                 }
14945                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
14946                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
14947                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
14948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
14949                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
14950                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
14951                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
14952                         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));
14953                 }
14954                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
14955                 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));
14956         }
14957         if (flags & NDR_OUT) {
14958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
14959         }
14960         return NDR_ERR_SUCCESS;
14961 }
14962
14963 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
14964 {
14965         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
14966         ndr->depth++;
14967         if (flags & NDR_SET_VALUES) {
14968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
14969         }
14970         if (flags & NDR_IN) {
14971                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
14972                 ndr->depth++;
14973                 ndr_print_ptr(ndr, "handle", r->in.handle);
14974                 ndr->depth++;
14975                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
14976                 ndr->depth--;
14977                 ndr_print_string(ndr, "value_name", r->in.value_name);
14978                 ndr->depth--;
14979         }
14980         if (flags & NDR_OUT) {
14981                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
14982                 ndr->depth++;
14983                 ndr_print_WERROR(ndr, "result", r->out.result);
14984                 ndr->depth--;
14985         }
14986         ndr->depth--;
14987 }
14988
14989 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
14990 {
14991         if (flags & NDR_IN) {
14992         }
14993         if (flags & NDR_OUT) {
14994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
14995         }
14996         return NDR_ERR_SUCCESS;
14997 }
14998
14999 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
15000 {
15001         if (flags & NDR_IN) {
15002         }
15003         if (flags & NDR_OUT) {
15004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15005         }
15006         return NDR_ERR_SUCCESS;
15007 }
15008
15009 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
15010 {
15011         ndr_print_struct(ndr, name, "spoolss_4a");
15012         ndr->depth++;
15013         if (flags & NDR_SET_VALUES) {
15014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15015         }
15016         if (flags & NDR_IN) {
15017                 ndr_print_struct(ndr, "in", "spoolss_4a");
15018                 ndr->depth++;
15019                 ndr->depth--;
15020         }
15021         if (flags & NDR_OUT) {
15022                 ndr_print_struct(ndr, "out", "spoolss_4a");
15023                 ndr->depth++;
15024                 ndr_print_WERROR(ndr, "result", r->out.result);
15025                 ndr->depth--;
15026         }
15027         ndr->depth--;
15028 }
15029
15030 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
15031 {
15032         if (flags & NDR_IN) {
15033         }
15034         if (flags & NDR_OUT) {
15035                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15036         }
15037         return NDR_ERR_SUCCESS;
15038 }
15039
15040 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
15041 {
15042         if (flags & NDR_IN) {
15043         }
15044         if (flags & NDR_OUT) {
15045                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15046         }
15047         return NDR_ERR_SUCCESS;
15048 }
15049
15050 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
15051 {
15052         ndr_print_struct(ndr, name, "spoolss_4b");
15053         ndr->depth++;
15054         if (flags & NDR_SET_VALUES) {
15055                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15056         }
15057         if (flags & NDR_IN) {
15058                 ndr_print_struct(ndr, "in", "spoolss_4b");
15059                 ndr->depth++;
15060                 ndr->depth--;
15061         }
15062         if (flags & NDR_OUT) {
15063                 ndr_print_struct(ndr, "out", "spoolss_4b");
15064                 ndr->depth++;
15065                 ndr_print_WERROR(ndr, "result", r->out.result);
15066                 ndr->depth--;
15067         }
15068         ndr->depth--;
15069 }
15070
15071 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
15072 {
15073         if (flags & NDR_IN) {
15074         }
15075         if (flags & NDR_OUT) {
15076                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15077         }
15078         return NDR_ERR_SUCCESS;
15079 }
15080
15081 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
15082 {
15083         if (flags & NDR_IN) {
15084         }
15085         if (flags & NDR_OUT) {
15086                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15087         }
15088         return NDR_ERR_SUCCESS;
15089 }
15090
15091 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
15092 {
15093         ndr_print_struct(ndr, name, "spoolss_4c");
15094         ndr->depth++;
15095         if (flags & NDR_SET_VALUES) {
15096                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15097         }
15098         if (flags & NDR_IN) {
15099                 ndr_print_struct(ndr, "in", "spoolss_4c");
15100                 ndr->depth++;
15101                 ndr->depth--;
15102         }
15103         if (flags & NDR_OUT) {
15104                 ndr_print_struct(ndr, "out", "spoolss_4c");
15105                 ndr->depth++;
15106                 ndr_print_WERROR(ndr, "result", r->out.result);
15107                 ndr->depth--;
15108         }
15109         ndr->depth--;
15110 }
15111
15112 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
15113 {
15114         if (flags & NDR_IN) {
15115                 if (r->in.handle == NULL) {
15116                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15117                 }
15118                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15121                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15122                 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));
15123                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15126                 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));
15127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
15128                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
15129                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15130         }
15131         if (flags & NDR_OUT) {
15132                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15133         }
15134         return NDR_ERR_SUCCESS;
15135 }
15136
15137 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
15138 {
15139         TALLOC_CTX *_mem_save_handle_0;
15140         if (flags & NDR_IN) {
15141                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15142                         NDR_PULL_ALLOC(ndr, r->in.handle);
15143                 }
15144                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15145                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15146                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15147                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15148                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15149                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15150                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15151                         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));
15152                 }
15153                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15154                 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));
15155                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15156                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15157                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15158                         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));
15159                 }
15160                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15161                 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));
15162                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
15163                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.buffer));
15164                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15165         }
15166         if (flags & NDR_OUT) {
15167                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15168         }
15169         return NDR_ERR_SUCCESS;
15170 }
15171
15172 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
15173 {
15174         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
15175         ndr->depth++;
15176         if (flags & NDR_SET_VALUES) {
15177                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15178         }
15179         if (flags & NDR_IN) {
15180                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
15181                 ndr->depth++;
15182                 ndr_print_ptr(ndr, "handle", r->in.handle);
15183                 ndr->depth++;
15184                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15185                 ndr->depth--;
15186                 ndr_print_string(ndr, "key_name", r->in.key_name);
15187                 ndr_print_string(ndr, "value_name", r->in.value_name);
15188                 ndr_print_uint32(ndr, "type", r->in.type);
15189                 ndr_print_DATA_BLOB(ndr, "buffer", r->in.buffer);
15190                 ndr_print_uint32(ndr, "offered", r->in.offered);
15191                 ndr->depth--;
15192         }
15193         if (flags & NDR_OUT) {
15194                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
15195                 ndr->depth++;
15196                 ndr_print_WERROR(ndr, "result", r->out.result);
15197                 ndr->depth--;
15198         }
15199         ndr->depth--;
15200 }
15201
15202 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
15203 {
15204         if (flags & NDR_IN) {
15205                 if (r->in.handle == NULL) {
15206                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15207                 }
15208                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15212                 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));
15213                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15216                 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));
15217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15218         }
15219         if (flags & NDR_OUT) {
15220                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.type));
15221                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
15222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
15223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15224         }
15225         return NDR_ERR_SUCCESS;
15226 }
15227
15228 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
15229 {
15230         TALLOC_CTX *_mem_save_handle_0;
15231         if (flags & NDR_IN) {
15232                 ZERO_STRUCT(r->out);
15233
15234                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15235                         NDR_PULL_ALLOC(ndr, r->in.handle);
15236                 }
15237                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15238                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15239                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15240                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15241                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15242                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15243                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15244                         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));
15245                 }
15246                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15247                 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));
15248                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15249                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15250                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15251                         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));
15252                 }
15253                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15254                 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));
15255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15256         }
15257         if (flags & NDR_OUT) {
15258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.type));
15259                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.buffer));
15260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
15261                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15262         }
15263         return NDR_ERR_SUCCESS;
15264 }
15265
15266 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
15267 {
15268         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
15269         ndr->depth++;
15270         if (flags & NDR_SET_VALUES) {
15271                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15272         }
15273         if (flags & NDR_IN) {
15274                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
15275                 ndr->depth++;
15276                 ndr_print_ptr(ndr, "handle", r->in.handle);
15277                 ndr->depth++;
15278                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15279                 ndr->depth--;
15280                 ndr_print_string(ndr, "key_name", r->in.key_name);
15281                 ndr_print_string(ndr, "value_name", r->in.value_name);
15282                 ndr_print_uint32(ndr, "offered", r->in.offered);
15283                 ndr->depth--;
15284         }
15285         if (flags & NDR_OUT) {
15286                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
15287                 ndr->depth++;
15288                 ndr_print_uint32(ndr, "type", r->out.type);
15289                 ndr_print_DATA_BLOB(ndr, "buffer", r->out.buffer);
15290                 ndr_print_uint32(ndr, "needed", r->out.needed);
15291                 ndr_print_WERROR(ndr, "result", r->out.result);
15292                 ndr->depth--;
15293         }
15294         ndr->depth--;
15295 }
15296
15297 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
15298 {
15299         if (flags & NDR_IN) {
15300                 if (r->in.handle == NULL) {
15301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15302                 }
15303                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15307                 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));
15308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15309         }
15310         if (flags & NDR_OUT) {
15311                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
15312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
15313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.count));
15314                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15315         }
15316         return NDR_ERR_SUCCESS;
15317 }
15318
15319 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
15320 {
15321         TALLOC_CTX *_mem_save_handle_0;
15322         if (flags & NDR_IN) {
15323                 ZERO_STRUCT(r->out);
15324
15325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15326                         NDR_PULL_ALLOC(ndr, r->in.handle);
15327                 }
15328                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15329                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15330                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15332                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15333                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15334                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15335                         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));
15336                 }
15337                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15338                 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));
15339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15340         }
15341         if (flags & NDR_OUT) {
15342                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.buffer));
15343                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
15344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.count));
15345                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15346         }
15347         return NDR_ERR_SUCCESS;
15348 }
15349
15350 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
15351 {
15352         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
15353         ndr->depth++;
15354         if (flags & NDR_SET_VALUES) {
15355                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15356         }
15357         if (flags & NDR_IN) {
15358                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
15359                 ndr->depth++;
15360                 ndr_print_ptr(ndr, "handle", r->in.handle);
15361                 ndr->depth++;
15362                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15363                 ndr->depth--;
15364                 ndr_print_string(ndr, "key_name", r->in.key_name);
15365                 ndr_print_uint32(ndr, "offered", r->in.offered);
15366                 ndr->depth--;
15367         }
15368         if (flags & NDR_OUT) {
15369                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
15370                 ndr->depth++;
15371                 ndr_print_DATA_BLOB(ndr, "buffer", r->out.buffer);
15372                 ndr_print_uint32(ndr, "needed", r->out.needed);
15373                 ndr_print_uint32(ndr, "count", r->out.count);
15374                 ndr_print_WERROR(ndr, "result", r->out.result);
15375                 ndr->depth--;
15376         }
15377         ndr->depth--;
15378 }
15379
15380 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
15381 {
15382         uint32_t cntr_key_buffer_0;
15383         if (flags & NDR_IN) {
15384                 if (r->in.handle == NULL) {
15385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15386                 }
15387                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15391                 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));
15392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.needed));
15393         }
15394         if (flags & NDR_OUT) {
15395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.key_buffer_size));
15396                 for (cntr_key_buffer_0 = 0; cntr_key_buffer_0 < r->out.key_buffer_size; cntr_key_buffer_0++) {
15397                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_0]));
15398                 }
15399                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
15400                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15401         }
15402         return NDR_ERR_SUCCESS;
15403 }
15404
15405 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
15406 {
15407         uint32_t cntr_key_buffer_0;
15408         TALLOC_CTX *_mem_save_handle_0;
15409         TALLOC_CTX *_mem_save_key_buffer_0;
15410         if (flags & NDR_IN) {
15411                 ZERO_STRUCT(r->out);
15412
15413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15414                         NDR_PULL_ALLOC(ndr, r->in.handle);
15415                 }
15416                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15417                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15418                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15420                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15421                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15422                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15423                         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));
15424                 }
15425                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15426                 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));
15427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.needed));
15428         }
15429         if (flags & NDR_OUT) {
15430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.key_buffer_size));
15431                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->out.key_buffer_size);
15432                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
15433                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
15434                 for (cntr_key_buffer_0 = 0; cntr_key_buffer_0 < r->out.key_buffer_size; cntr_key_buffer_0++) {
15435                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_0]));
15436                 }
15437                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, 0);
15438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
15439                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15440         }
15441         return NDR_ERR_SUCCESS;
15442 }
15443
15444 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
15445 {
15446         uint32_t cntr_key_buffer_0;
15447         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
15448         ndr->depth++;
15449         if (flags & NDR_SET_VALUES) {
15450                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15451         }
15452         if (flags & NDR_IN) {
15453                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
15454                 ndr->depth++;
15455                 ndr_print_ptr(ndr, "handle", r->in.handle);
15456                 ndr->depth++;
15457                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15458                 ndr->depth--;
15459                 ndr_print_string(ndr, "key_name", r->in.key_name);
15460                 ndr_print_uint32(ndr, "needed", r->in.needed);
15461                 ndr->depth--;
15462         }
15463         if (flags & NDR_OUT) {
15464                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
15465                 ndr->depth++;
15466                 ndr_print_uint32(ndr, "key_buffer_size", r->out.key_buffer_size);
15467                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->out.key_buffer_size);
15468                 ndr->depth++;
15469                 for (cntr_key_buffer_0=0;cntr_key_buffer_0<r->out.key_buffer_size;cntr_key_buffer_0++) {
15470                         char *idx_0=NULL;
15471                         if (asprintf(&idx_0, "[%d]", cntr_key_buffer_0) != -1) {
15472                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_0]);
15473                                 free(idx_0);
15474                         }
15475                 }
15476                 ndr->depth--;
15477                 ndr_print_uint32(ndr, "needed", r->out.needed);
15478                 ndr_print_WERROR(ndr, "result", r->out.result);
15479                 ndr->depth--;
15480         }
15481         ndr->depth--;
15482 }
15483
15484 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
15485 {
15486         if (flags & NDR_IN) {
15487                 if (r->in.handle == NULL) {
15488                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15489                 }
15490                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15491                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
15494                 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));
15495                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15496                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
15498                 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));
15499         }
15500         if (flags & NDR_OUT) {
15501                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15502         }
15503         return NDR_ERR_SUCCESS;
15504 }
15505
15506 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
15507 {
15508         TALLOC_CTX *_mem_save_handle_0;
15509         if (flags & NDR_IN) {
15510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15511                         NDR_PULL_ALLOC(ndr, r->in.handle);
15512                 }
15513                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15514                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15515                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15517                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
15518                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
15519                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
15520                         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));
15521                 }
15522                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
15523                 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));
15524                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
15525                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
15526                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
15527                         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));
15528                 }
15529                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
15530                 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));
15531         }
15532         if (flags & NDR_OUT) {
15533                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15534         }
15535         return NDR_ERR_SUCCESS;
15536 }
15537
15538 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
15539 {
15540         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
15541         ndr->depth++;
15542         if (flags & NDR_SET_VALUES) {
15543                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15544         }
15545         if (flags & NDR_IN) {
15546                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
15547                 ndr->depth++;
15548                 ndr_print_ptr(ndr, "handle", r->in.handle);
15549                 ndr->depth++;
15550                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15551                 ndr->depth--;
15552                 ndr_print_string(ndr, "key_name", r->in.key_name);
15553                 ndr_print_string(ndr, "value_name", r->in.value_name);
15554                 ndr->depth--;
15555         }
15556         if (flags & NDR_OUT) {
15557                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
15558                 ndr->depth++;
15559                 ndr_print_WERROR(ndr, "result", r->out.result);
15560                 ndr->depth--;
15561         }
15562         ndr->depth--;
15563 }
15564
15565 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
15566 {
15567         if (flags & NDR_IN) {
15568         }
15569         if (flags & NDR_OUT) {
15570                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15571         }
15572         return NDR_ERR_SUCCESS;
15573 }
15574
15575 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
15576 {
15577         if (flags & NDR_IN) {
15578         }
15579         if (flags & NDR_OUT) {
15580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15581         }
15582         return NDR_ERR_SUCCESS;
15583 }
15584
15585 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
15586 {
15587         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
15588         ndr->depth++;
15589         if (flags & NDR_SET_VALUES) {
15590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15591         }
15592         if (flags & NDR_IN) {
15593                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
15594                 ndr->depth++;
15595                 ndr->depth--;
15596         }
15597         if (flags & NDR_OUT) {
15598                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
15599                 ndr->depth++;
15600                 ndr_print_WERROR(ndr, "result", r->out.result);
15601                 ndr->depth--;
15602         }
15603         ndr->depth--;
15604 }
15605
15606 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
15607 {
15608         if (flags & NDR_IN) {
15609         }
15610         if (flags & NDR_OUT) {
15611                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15612         }
15613         return NDR_ERR_SUCCESS;
15614 }
15615
15616 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
15617 {
15618         if (flags & NDR_IN) {
15619         }
15620         if (flags & NDR_OUT) {
15621                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15622         }
15623         return NDR_ERR_SUCCESS;
15624 }
15625
15626 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
15627 {
15628         ndr_print_struct(ndr, name, "spoolss_53");
15629         ndr->depth++;
15630         if (flags & NDR_SET_VALUES) {
15631                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15632         }
15633         if (flags & NDR_IN) {
15634                 ndr_print_struct(ndr, "in", "spoolss_53");
15635                 ndr->depth++;
15636                 ndr->depth--;
15637         }
15638         if (flags & NDR_OUT) {
15639                 ndr_print_struct(ndr, "out", "spoolss_53");
15640                 ndr->depth++;
15641                 ndr_print_WERROR(ndr, "result", r->out.result);
15642                 ndr->depth--;
15643         }
15644         ndr->depth--;
15645 }
15646
15647 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
15648 {
15649         if (flags & NDR_IN) {
15650         }
15651         if (flags & NDR_OUT) {
15652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15653         }
15654         return NDR_ERR_SUCCESS;
15655 }
15656
15657 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
15658 {
15659         if (flags & NDR_IN) {
15660         }
15661         if (flags & NDR_OUT) {
15662                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15663         }
15664         return NDR_ERR_SUCCESS;
15665 }
15666
15667 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
15668 {
15669         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
15670         ndr->depth++;
15671         if (flags & NDR_SET_VALUES) {
15672                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15673         }
15674         if (flags & NDR_IN) {
15675                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
15676                 ndr->depth++;
15677                 ndr->depth--;
15678         }
15679         if (flags & NDR_OUT) {
15680                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
15681                 ndr->depth++;
15682                 ndr_print_WERROR(ndr, "result", r->out.result);
15683                 ndr->depth--;
15684         }
15685         ndr->depth--;
15686 }
15687
15688 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
15689 {
15690         if (flags & NDR_IN) {
15691         }
15692         if (flags & NDR_OUT) {
15693                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15694         }
15695         return NDR_ERR_SUCCESS;
15696 }
15697
15698 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
15699 {
15700         if (flags & NDR_IN) {
15701         }
15702         if (flags & NDR_OUT) {
15703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15704         }
15705         return NDR_ERR_SUCCESS;
15706 }
15707
15708 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
15709 {
15710         ndr_print_struct(ndr, name, "spoolss_55");
15711         ndr->depth++;
15712         if (flags & NDR_SET_VALUES) {
15713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15714         }
15715         if (flags & NDR_IN) {
15716                 ndr_print_struct(ndr, "in", "spoolss_55");
15717                 ndr->depth++;
15718                 ndr->depth--;
15719         }
15720         if (flags & NDR_OUT) {
15721                 ndr_print_struct(ndr, "out", "spoolss_55");
15722                 ndr->depth++;
15723                 ndr_print_WERROR(ndr, "result", r->out.result);
15724                 ndr->depth--;
15725         }
15726         ndr->depth--;
15727 }
15728
15729 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
15730 {
15731         if (flags & NDR_IN) {
15732         }
15733         if (flags & NDR_OUT) {
15734                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15735         }
15736         return NDR_ERR_SUCCESS;
15737 }
15738
15739 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
15740 {
15741         if (flags & NDR_IN) {
15742         }
15743         if (flags & NDR_OUT) {
15744                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15745         }
15746         return NDR_ERR_SUCCESS;
15747 }
15748
15749 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
15750 {
15751         ndr_print_struct(ndr, name, "spoolss_56");
15752         ndr->depth++;
15753         if (flags & NDR_SET_VALUES) {
15754                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15755         }
15756         if (flags & NDR_IN) {
15757                 ndr_print_struct(ndr, "in", "spoolss_56");
15758                 ndr->depth++;
15759                 ndr->depth--;
15760         }
15761         if (flags & NDR_OUT) {
15762                 ndr_print_struct(ndr, "out", "spoolss_56");
15763                 ndr->depth++;
15764                 ndr_print_WERROR(ndr, "result", r->out.result);
15765                 ndr->depth--;
15766         }
15767         ndr->depth--;
15768 }
15769
15770 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
15771 {
15772         if (flags & NDR_IN) {
15773         }
15774         if (flags & NDR_OUT) {
15775                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15776         }
15777         return NDR_ERR_SUCCESS;
15778 }
15779
15780 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
15781 {
15782         if (flags & NDR_IN) {
15783         }
15784         if (flags & NDR_OUT) {
15785                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15786         }
15787         return NDR_ERR_SUCCESS;
15788 }
15789
15790 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
15791 {
15792         ndr_print_struct(ndr, name, "spoolss_57");
15793         ndr->depth++;
15794         if (flags & NDR_SET_VALUES) {
15795                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15796         }
15797         if (flags & NDR_IN) {
15798                 ndr_print_struct(ndr, "in", "spoolss_57");
15799                 ndr->depth++;
15800                 ndr->depth--;
15801         }
15802         if (flags & NDR_OUT) {
15803                 ndr_print_struct(ndr, "out", "spoolss_57");
15804                 ndr->depth++;
15805                 ndr_print_WERROR(ndr, "result", r->out.result);
15806                 ndr->depth--;
15807         }
15808         ndr->depth--;
15809 }
15810
15811 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
15812 {
15813         if (flags & NDR_IN) {
15814                 if (r->in.handle == NULL) {
15815                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
15816                 }
15817                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15818                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
15819                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
15821                 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));
15822                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
15823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
15824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
15825                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown1));
15826         }
15827         if (flags & NDR_OUT) {
15828                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.out_data));
15829                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.needed));
15830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->out.unknown2));
15831                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15832         }
15833         return NDR_ERR_SUCCESS;
15834 }
15835
15836 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
15837 {
15838         TALLOC_CTX *_mem_save_handle_0;
15839         if (flags & NDR_IN) {
15840                 ZERO_STRUCT(r->out);
15841
15842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
15843                         NDR_PULL_ALLOC(ndr, r->in.handle);
15844                 }
15845                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
15846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
15847                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
15848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
15849                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
15850                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
15851                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
15852                         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));
15853                 }
15854                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
15855                 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));
15856                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
15857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
15858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
15859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown1));
15860         }
15861         if (flags & NDR_OUT) {
15862                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.out_data));
15863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.needed));
15864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->out.unknown2));
15865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15866         }
15867         return NDR_ERR_SUCCESS;
15868 }
15869
15870 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
15871 {
15872         ndr_print_struct(ndr, name, "spoolss_XcvData");
15873         ndr->depth++;
15874         if (flags & NDR_SET_VALUES) {
15875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15876         }
15877         if (flags & NDR_IN) {
15878                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
15879                 ndr->depth++;
15880                 ndr_print_ptr(ndr, "handle", r->in.handle);
15881                 ndr->depth++;
15882                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
15883                 ndr->depth--;
15884                 ndr_print_string(ndr, "function_name", r->in.function_name);
15885                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
15886                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
15887                 ndr_print_uint32(ndr, "offered", r->in.offered);
15888                 ndr_print_uint32(ndr, "unknown1", r->in.unknown1);
15889                 ndr->depth--;
15890         }
15891         if (flags & NDR_OUT) {
15892                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
15893                 ndr->depth++;
15894                 ndr_print_DATA_BLOB(ndr, "out_data", r->out.out_data);
15895                 ndr_print_uint32(ndr, "needed", r->out.needed);
15896                 ndr_print_uint32(ndr, "unknown2", r->out.unknown2);
15897                 ndr_print_WERROR(ndr, "result", r->out.result);
15898                 ndr->depth--;
15899         }
15900         ndr->depth--;
15901 }
15902
15903 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
15904 {
15905         if (flags & NDR_IN) {
15906         }
15907         if (flags & NDR_OUT) {
15908                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15909         }
15910         return NDR_ERR_SUCCESS;
15911 }
15912
15913 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
15914 {
15915         if (flags & NDR_IN) {
15916         }
15917         if (flags & NDR_OUT) {
15918                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15919         }
15920         return NDR_ERR_SUCCESS;
15921 }
15922
15923 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
15924 {
15925         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
15926         ndr->depth++;
15927         if (flags & NDR_SET_VALUES) {
15928                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15929         }
15930         if (flags & NDR_IN) {
15931                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
15932                 ndr->depth++;
15933                 ndr->depth--;
15934         }
15935         if (flags & NDR_OUT) {
15936                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
15937                 ndr->depth++;
15938                 ndr_print_WERROR(ndr, "result", r->out.result);
15939                 ndr->depth--;
15940         }
15941         ndr->depth--;
15942 }
15943
15944 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
15945 {
15946         if (flags & NDR_IN) {
15947         }
15948         if (flags & NDR_OUT) {
15949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15950         }
15951         return NDR_ERR_SUCCESS;
15952 }
15953
15954 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
15955 {
15956         if (flags & NDR_IN) {
15957         }
15958         if (flags & NDR_OUT) {
15959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
15960         }
15961         return NDR_ERR_SUCCESS;
15962 }
15963
15964 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
15965 {
15966         ndr_print_struct(ndr, name, "spoolss_5a");
15967         ndr->depth++;
15968         if (flags & NDR_SET_VALUES) {
15969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
15970         }
15971         if (flags & NDR_IN) {
15972                 ndr_print_struct(ndr, "in", "spoolss_5a");
15973                 ndr->depth++;
15974                 ndr->depth--;
15975         }
15976         if (flags & NDR_OUT) {
15977                 ndr_print_struct(ndr, "out", "spoolss_5a");
15978                 ndr->depth++;
15979                 ndr_print_WERROR(ndr, "result", r->out.result);
15980                 ndr->depth--;
15981         }
15982         ndr->depth--;
15983 }
15984
15985 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
15986 {
15987         if (flags & NDR_IN) {
15988         }
15989         if (flags & NDR_OUT) {
15990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
15991         }
15992         return NDR_ERR_SUCCESS;
15993 }
15994
15995 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
15996 {
15997         if (flags & NDR_IN) {
15998         }
15999         if (flags & NDR_OUT) {
16000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16001         }
16002         return NDR_ERR_SUCCESS;
16003 }
16004
16005 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
16006 {
16007         ndr_print_struct(ndr, name, "spoolss_5b");
16008         ndr->depth++;
16009         if (flags & NDR_SET_VALUES) {
16010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16011         }
16012         if (flags & NDR_IN) {
16013                 ndr_print_struct(ndr, "in", "spoolss_5b");
16014                 ndr->depth++;
16015                 ndr->depth--;
16016         }
16017         if (flags & NDR_OUT) {
16018                 ndr_print_struct(ndr, "out", "spoolss_5b");
16019                 ndr->depth++;
16020                 ndr_print_WERROR(ndr, "result", r->out.result);
16021                 ndr->depth--;
16022         }
16023         ndr->depth--;
16024 }
16025
16026 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
16027 {
16028         if (flags & NDR_IN) {
16029         }
16030         if (flags & NDR_OUT) {
16031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16032         }
16033         return NDR_ERR_SUCCESS;
16034 }
16035
16036 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
16037 {
16038         if (flags & NDR_IN) {
16039         }
16040         if (flags & NDR_OUT) {
16041                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16042         }
16043         return NDR_ERR_SUCCESS;
16044 }
16045
16046 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
16047 {
16048         ndr_print_struct(ndr, name, "spoolss_5c");
16049         ndr->depth++;
16050         if (flags & NDR_SET_VALUES) {
16051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16052         }
16053         if (flags & NDR_IN) {
16054                 ndr_print_struct(ndr, "in", "spoolss_5c");
16055                 ndr->depth++;
16056                 ndr->depth--;
16057         }
16058         if (flags & NDR_OUT) {
16059                 ndr_print_struct(ndr, "out", "spoolss_5c");
16060                 ndr->depth++;
16061                 ndr_print_WERROR(ndr, "result", r->out.result);
16062                 ndr->depth--;
16063         }
16064         ndr->depth--;
16065 }
16066
16067 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
16068 {
16069         if (flags & NDR_IN) {
16070         }
16071         if (flags & NDR_OUT) {
16072                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16073         }
16074         return NDR_ERR_SUCCESS;
16075 }
16076
16077 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
16078 {
16079         if (flags & NDR_IN) {
16080         }
16081         if (flags & NDR_OUT) {
16082                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16083         }
16084         return NDR_ERR_SUCCESS;
16085 }
16086
16087 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
16088 {
16089         ndr_print_struct(ndr, name, "spoolss_5d");
16090         ndr->depth++;
16091         if (flags & NDR_SET_VALUES) {
16092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16093         }
16094         if (flags & NDR_IN) {
16095                 ndr_print_struct(ndr, "in", "spoolss_5d");
16096                 ndr->depth++;
16097                 ndr->depth--;
16098         }
16099         if (flags & NDR_OUT) {
16100                 ndr_print_struct(ndr, "out", "spoolss_5d");
16101                 ndr->depth++;
16102                 ndr_print_WERROR(ndr, "result", r->out.result);
16103                 ndr->depth--;
16104         }
16105         ndr->depth--;
16106 }
16107
16108 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
16109 {
16110         if (flags & NDR_IN) {
16111         }
16112         if (flags & NDR_OUT) {
16113                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16114         }
16115         return NDR_ERR_SUCCESS;
16116 }
16117
16118 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
16119 {
16120         if (flags & NDR_IN) {
16121         }
16122         if (flags & NDR_OUT) {
16123                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16124         }
16125         return NDR_ERR_SUCCESS;
16126 }
16127
16128 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
16129 {
16130         ndr_print_struct(ndr, name, "spoolss_5e");
16131         ndr->depth++;
16132         if (flags & NDR_SET_VALUES) {
16133                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16134         }
16135         if (flags & NDR_IN) {
16136                 ndr_print_struct(ndr, "in", "spoolss_5e");
16137                 ndr->depth++;
16138                 ndr->depth--;
16139         }
16140         if (flags & NDR_OUT) {
16141                 ndr_print_struct(ndr, "out", "spoolss_5e");
16142                 ndr->depth++;
16143                 ndr_print_WERROR(ndr, "result", r->out.result);
16144                 ndr->depth--;
16145         }
16146         ndr->depth--;
16147 }
16148
16149 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
16150 {
16151         if (flags & NDR_IN) {
16152         }
16153         if (flags & NDR_OUT) {
16154                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
16155         }
16156         return NDR_ERR_SUCCESS;
16157 }
16158
16159 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
16160 {
16161         if (flags & NDR_IN) {
16162         }
16163         if (flags & NDR_OUT) {
16164                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
16165         }
16166         return NDR_ERR_SUCCESS;
16167 }
16168
16169 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
16170 {
16171         ndr_print_struct(ndr, name, "spoolss_5f");
16172         ndr->depth++;
16173         if (flags & NDR_SET_VALUES) {
16174                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
16175         }
16176         if (flags & NDR_IN) {
16177                 ndr_print_struct(ndr, "in", "spoolss_5f");
16178                 ndr->depth++;
16179                 ndr->depth--;
16180         }
16181         if (flags & NDR_OUT) {
16182                 ndr_print_struct(ndr, "out", "spoolss_5f");
16183                 ndr->depth++;
16184                 ndr_print_WERROR(ndr, "result", r->out.result);
16185                 ndr->depth--;
16186         }
16187         ndr->depth--;
16188 }
16189
16190 static const struct ndr_interface_call spoolss_calls[] = {
16191         {
16192                 "spoolss_EnumPrinters",
16193                 sizeof(struct spoolss_EnumPrinters),
16194                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
16195                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
16196                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
16197                 false,
16198         },
16199         {
16200                 "spoolss_OpenPrinter",
16201                 sizeof(struct spoolss_OpenPrinter),
16202                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
16203                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
16204                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
16205                 false,
16206         },
16207         {
16208                 "spoolss_SetJob",
16209                 sizeof(struct spoolss_SetJob),
16210                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
16211                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
16212                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
16213                 false,
16214         },
16215         {
16216                 "spoolss_GetJob",
16217                 sizeof(struct spoolss_GetJob),
16218                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
16219                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
16220                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
16221                 false,
16222         },
16223         {
16224                 "spoolss_EnumJobs",
16225                 sizeof(struct spoolss_EnumJobs),
16226                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
16227                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
16228                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
16229                 false,
16230         },
16231         {
16232                 "spoolss_AddPrinter",
16233                 sizeof(struct spoolss_AddPrinter),
16234                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
16235                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
16236                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
16237                 false,
16238         },
16239         {
16240                 "spoolss_DeletePrinter",
16241                 sizeof(struct spoolss_DeletePrinter),
16242                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
16243                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
16244                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
16245                 false,
16246         },
16247         {
16248                 "spoolss_SetPrinter",
16249                 sizeof(struct spoolss_SetPrinter),
16250                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
16251                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
16252                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
16253                 false,
16254         },
16255         {
16256                 "spoolss_GetPrinter",
16257                 sizeof(struct spoolss_GetPrinter),
16258                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
16259                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
16260                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
16261                 false,
16262         },
16263         {
16264                 "spoolss_AddPrinterDriver",
16265                 sizeof(struct spoolss_AddPrinterDriver),
16266                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
16267                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
16268                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
16269                 false,
16270         },
16271         {
16272                 "spoolss_EnumPrinterDrivers",
16273                 sizeof(struct spoolss_EnumPrinterDrivers),
16274                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
16275                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
16276                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
16277                 false,
16278         },
16279         {
16280                 "spoolss_GetPrinterDriver",
16281                 sizeof(struct spoolss_GetPrinterDriver),
16282                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
16283                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
16284                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
16285                 false,
16286         },
16287         {
16288                 "spoolss_GetPrinterDriverDirectory",
16289                 sizeof(struct spoolss_GetPrinterDriverDirectory),
16290                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
16291                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
16292                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
16293                 false,
16294         },
16295         {
16296                 "spoolss_DeletePrinterDriver",
16297                 sizeof(struct spoolss_DeletePrinterDriver),
16298                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
16299                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
16300                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
16301                 false,
16302         },
16303         {
16304                 "spoolss_AddPrintProcessor",
16305                 sizeof(struct spoolss_AddPrintProcessor),
16306                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
16307                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
16308                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
16309                 false,
16310         },
16311         {
16312                 "spoolss_EnumPrintProcessors",
16313                 sizeof(struct spoolss_EnumPrintProcessors),
16314                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
16315                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
16316                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
16317                 false,
16318         },
16319         {
16320                 "spoolss_GetPrintProcessorDirectory",
16321                 sizeof(struct spoolss_GetPrintProcessorDirectory),
16322                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
16323                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
16324                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
16325                 false,
16326         },
16327         {
16328                 "spoolss_StartDocPrinter",
16329                 sizeof(struct spoolss_StartDocPrinter),
16330                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
16331                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
16332                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
16333                 false,
16334         },
16335         {
16336                 "spoolss_StartPagePrinter",
16337                 sizeof(struct spoolss_StartPagePrinter),
16338                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
16339                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
16340                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
16341                 false,
16342         },
16343         {
16344                 "spoolss_WritePrinter",
16345                 sizeof(struct spoolss_WritePrinter),
16346                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
16347                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
16348                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
16349                 false,
16350         },
16351         {
16352                 "spoolss_EndPagePrinter",
16353                 sizeof(struct spoolss_EndPagePrinter),
16354                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
16355                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
16356                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
16357                 false,
16358         },
16359         {
16360                 "spoolss_AbortPrinter",
16361                 sizeof(struct spoolss_AbortPrinter),
16362                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
16363                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
16364                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
16365                 false,
16366         },
16367         {
16368                 "spoolss_ReadPrinter",
16369                 sizeof(struct spoolss_ReadPrinter),
16370                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
16371                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
16372                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
16373                 false,
16374         },
16375         {
16376                 "spoolss_EndDocPrinter",
16377                 sizeof(struct spoolss_EndDocPrinter),
16378                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
16379                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
16380                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
16381                 false,
16382         },
16383         {
16384                 "spoolss_AddJob",
16385                 sizeof(struct spoolss_AddJob),
16386                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
16387                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
16388                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
16389                 false,
16390         },
16391         {
16392                 "spoolss_ScheduleJob",
16393                 sizeof(struct spoolss_ScheduleJob),
16394                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
16395                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
16396                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
16397                 false,
16398         },
16399         {
16400                 "spoolss_GetPrinterData",
16401                 sizeof(struct spoolss_GetPrinterData),
16402                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
16403                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
16404                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
16405                 false,
16406         },
16407         {
16408                 "spoolss_SetPrinterData",
16409                 sizeof(struct spoolss_SetPrinterData),
16410                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
16411                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
16412                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
16413                 false,
16414         },
16415         {
16416                 "spoolss_WaitForPrinterChange",
16417                 sizeof(struct spoolss_WaitForPrinterChange),
16418                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
16419                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
16420                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
16421                 false,
16422         },
16423         {
16424                 "spoolss_ClosePrinter",
16425                 sizeof(struct spoolss_ClosePrinter),
16426                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
16427                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
16428                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
16429                 false,
16430         },
16431         {
16432                 "spoolss_AddForm",
16433                 sizeof(struct spoolss_AddForm),
16434                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
16435                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
16436                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
16437                 false,
16438         },
16439         {
16440                 "spoolss_DeleteForm",
16441                 sizeof(struct spoolss_DeleteForm),
16442                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
16443                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
16444                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
16445                 false,
16446         },
16447         {
16448                 "spoolss_GetForm",
16449                 sizeof(struct spoolss_GetForm),
16450                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
16451                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
16452                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
16453                 false,
16454         },
16455         {
16456                 "spoolss_SetForm",
16457                 sizeof(struct spoolss_SetForm),
16458                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
16459                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
16460                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
16461                 false,
16462         },
16463         {
16464                 "spoolss_EnumForms",
16465                 sizeof(struct spoolss_EnumForms),
16466                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
16467                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
16468                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
16469                 false,
16470         },
16471         {
16472                 "spoolss_EnumPorts",
16473                 sizeof(struct spoolss_EnumPorts),
16474                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
16475                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
16476                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
16477                 false,
16478         },
16479         {
16480                 "spoolss_EnumMonitors",
16481                 sizeof(struct spoolss_EnumMonitors),
16482                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
16483                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
16484                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
16485                 false,
16486         },
16487         {
16488                 "spoolss_AddPort",
16489                 sizeof(struct spoolss_AddPort),
16490                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
16491                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
16492                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
16493                 false,
16494         },
16495         {
16496                 "spoolss_ConfigurePort",
16497                 sizeof(struct spoolss_ConfigurePort),
16498                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
16499                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
16500                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
16501                 false,
16502         },
16503         {
16504                 "spoolss_DeletePort",
16505                 sizeof(struct spoolss_DeletePort),
16506                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
16507                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
16508                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
16509                 false,
16510         },
16511         {
16512                 "spoolss_CreatePrinterIC",
16513                 sizeof(struct spoolss_CreatePrinterIC),
16514                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
16515                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
16516                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
16517                 false,
16518         },
16519         {
16520                 "spoolss_PlayGDIScriptOnPrinterIC",
16521                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
16522                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
16523                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
16524                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
16525                 false,
16526         },
16527         {
16528                 "spoolss_DeletePrinterIC",
16529                 sizeof(struct spoolss_DeletePrinterIC),
16530                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
16531                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
16532                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
16533                 false,
16534         },
16535         {
16536                 "spoolss_AddPrinterConnection",
16537                 sizeof(struct spoolss_AddPrinterConnection),
16538                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
16539                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
16540                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
16541                 false,
16542         },
16543         {
16544                 "spoolss_DeletePrinterConnection",
16545                 sizeof(struct spoolss_DeletePrinterConnection),
16546                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
16547                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
16548                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
16549                 false,
16550         },
16551         {
16552                 "spoolss_PrinterMessageBox",
16553                 sizeof(struct spoolss_PrinterMessageBox),
16554                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
16555                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
16556                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
16557                 false,
16558         },
16559         {
16560                 "spoolss_AddMonitor",
16561                 sizeof(struct spoolss_AddMonitor),
16562                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
16563                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
16564                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
16565                 false,
16566         },
16567         {
16568                 "spoolss_DeleteMonitor",
16569                 sizeof(struct spoolss_DeleteMonitor),
16570                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
16571                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
16572                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
16573                 false,
16574         },
16575         {
16576                 "spoolss_DeletePrintProcessor",
16577                 sizeof(struct spoolss_DeletePrintProcessor),
16578                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
16579                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
16580                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
16581                 false,
16582         },
16583         {
16584                 "spoolss_AddPrintProvidor",
16585                 sizeof(struct spoolss_AddPrintProvidor),
16586                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
16587                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
16588                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
16589                 false,
16590         },
16591         {
16592                 "spoolss_DeletePrintProvidor",
16593                 sizeof(struct spoolss_DeletePrintProvidor),
16594                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
16595                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
16596                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
16597                 false,
16598         },
16599         {
16600                 "spoolss_EnumPrintProcDataTypes",
16601                 sizeof(struct spoolss_EnumPrintProcDataTypes),
16602                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
16603                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
16604                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
16605                 false,
16606         },
16607         {
16608                 "spoolss_ResetPrinter",
16609                 sizeof(struct spoolss_ResetPrinter),
16610                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
16611                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
16612                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
16613                 false,
16614         },
16615         {
16616                 "spoolss_GetPrinterDriver2",
16617                 sizeof(struct spoolss_GetPrinterDriver2),
16618                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
16619                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
16620                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
16621                 false,
16622         },
16623         {
16624                 "spoolss_FindFirstPrinterChangeNotification",
16625                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
16626                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
16627                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
16628                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
16629                 false,
16630         },
16631         {
16632                 "spoolss_FindNextPrinterChangeNotification",
16633                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
16634                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
16635                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
16636                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
16637                 false,
16638         },
16639         {
16640                 "spoolss_FindClosePrinterNotify",
16641                 sizeof(struct spoolss_FindClosePrinterNotify),
16642                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
16643                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
16644                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
16645                 false,
16646         },
16647         {
16648                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
16649                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
16650                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
16651                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
16652                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
16653                 false,
16654         },
16655         {
16656                 "spoolss_ReplyOpenPrinter",
16657                 sizeof(struct spoolss_ReplyOpenPrinter),
16658                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
16659                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
16660                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
16661                 false,
16662         },
16663         {
16664                 "spoolss_RouterReplyPrinter",
16665                 sizeof(struct spoolss_RouterReplyPrinter),
16666                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
16667                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
16668                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
16669                 false,
16670         },
16671         {
16672                 "spoolss_ReplyClosePrinter",
16673                 sizeof(struct spoolss_ReplyClosePrinter),
16674                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
16675                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
16676                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
16677                 false,
16678         },
16679         {
16680                 "spoolss_AddPortEx",
16681                 sizeof(struct spoolss_AddPortEx),
16682                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
16683                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
16684                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
16685                 false,
16686         },
16687         {
16688                 "spoolss_RouterFindFirstPrinterChangeNotification",
16689                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
16690                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
16691                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
16692                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
16693                 false,
16694         },
16695         {
16696                 "spoolss_SpoolerInit",
16697                 sizeof(struct spoolss_SpoolerInit),
16698                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
16699                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
16700                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
16701                 false,
16702         },
16703         {
16704                 "spoolss_ResetPrinterEx",
16705                 sizeof(struct spoolss_ResetPrinterEx),
16706                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
16707                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
16708                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
16709                 false,
16710         },
16711         {
16712                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
16713                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
16714                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
16715                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
16716                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
16717                 false,
16718         },
16719         {
16720                 "spoolss_RouterRefreshPrinterChangeNotification",
16721                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotification),
16722                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotification,
16723                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotification,
16724                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotification,
16725                 false,
16726         },
16727         {
16728                 "spoolss_RemoteFindNextPrinterChangeNotifyEx",
16729                 sizeof(struct spoolss_RemoteFindNextPrinterChangeNotifyEx),
16730                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindNextPrinterChangeNotifyEx,
16731                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindNextPrinterChangeNotifyEx,
16732                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindNextPrinterChangeNotifyEx,
16733                 false,
16734         },
16735         {
16736                 "spoolss_44",
16737                 sizeof(struct spoolss_44),
16738                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
16739                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
16740                 (ndr_print_function_t) ndr_print_spoolss_44,
16741                 false,
16742         },
16743         {
16744                 "spoolss_OpenPrinterEx",
16745                 sizeof(struct spoolss_OpenPrinterEx),
16746                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
16747                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
16748                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
16749                 false,
16750         },
16751         {
16752                 "spoolss_AddPrinterEx",
16753                 sizeof(struct spoolss_AddPrinterEx),
16754                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
16755                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
16756                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
16757                 false,
16758         },
16759         {
16760                 "spoolss_47",
16761                 sizeof(struct spoolss_47),
16762                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
16763                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
16764                 (ndr_print_function_t) ndr_print_spoolss_47,
16765                 false,
16766         },
16767         {
16768                 "spoolss_EnumPrinterData",
16769                 sizeof(struct spoolss_EnumPrinterData),
16770                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
16771                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
16772                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
16773                 false,
16774         },
16775         {
16776                 "spoolss_DeletePrinterData",
16777                 sizeof(struct spoolss_DeletePrinterData),
16778                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
16779                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
16780                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
16781                 false,
16782         },
16783         {
16784                 "spoolss_4a",
16785                 sizeof(struct spoolss_4a),
16786                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
16787                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
16788                 (ndr_print_function_t) ndr_print_spoolss_4a,
16789                 false,
16790         },
16791         {
16792                 "spoolss_4b",
16793                 sizeof(struct spoolss_4b),
16794                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
16795                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
16796                 (ndr_print_function_t) ndr_print_spoolss_4b,
16797                 false,
16798         },
16799         {
16800                 "spoolss_4c",
16801                 sizeof(struct spoolss_4c),
16802                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
16803                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
16804                 (ndr_print_function_t) ndr_print_spoolss_4c,
16805                 false,
16806         },
16807         {
16808                 "spoolss_SetPrinterDataEx",
16809                 sizeof(struct spoolss_SetPrinterDataEx),
16810                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
16811                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
16812                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
16813                 false,
16814         },
16815         {
16816                 "spoolss_GetPrinterDataEx",
16817                 sizeof(struct spoolss_GetPrinterDataEx),
16818                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
16819                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
16820                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
16821                 false,
16822         },
16823         {
16824                 "spoolss_EnumPrinterDataEx",
16825                 sizeof(struct spoolss_EnumPrinterDataEx),
16826                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
16827                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
16828                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
16829                 false,
16830         },
16831         {
16832                 "spoolss_EnumPrinterKey",
16833                 sizeof(struct spoolss_EnumPrinterKey),
16834                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
16835                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
16836                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
16837                 false,
16838         },
16839         {
16840                 "spoolss_DeletePrinterDataEx",
16841                 sizeof(struct spoolss_DeletePrinterDataEx),
16842                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
16843                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
16844                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
16845                 false,
16846         },
16847         {
16848                 "spoolss_DeletePrinterKey",
16849                 sizeof(struct spoolss_DeletePrinterKey),
16850                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
16851                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
16852                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
16853                 false,
16854         },
16855         {
16856                 "spoolss_53",
16857                 sizeof(struct spoolss_53),
16858                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
16859                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
16860                 (ndr_print_function_t) ndr_print_spoolss_53,
16861                 false,
16862         },
16863         {
16864                 "spoolss_DeletePrinterDriverEx",
16865                 sizeof(struct spoolss_DeletePrinterDriverEx),
16866                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
16867                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
16868                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
16869                 false,
16870         },
16871         {
16872                 "spoolss_55",
16873                 sizeof(struct spoolss_55),
16874                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
16875                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
16876                 (ndr_print_function_t) ndr_print_spoolss_55,
16877                 false,
16878         },
16879         {
16880                 "spoolss_56",
16881                 sizeof(struct spoolss_56),
16882                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
16883                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
16884                 (ndr_print_function_t) ndr_print_spoolss_56,
16885                 false,
16886         },
16887         {
16888                 "spoolss_57",
16889                 sizeof(struct spoolss_57),
16890                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
16891                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
16892                 (ndr_print_function_t) ndr_print_spoolss_57,
16893                 false,
16894         },
16895         {
16896                 "spoolss_XcvData",
16897                 sizeof(struct spoolss_XcvData),
16898                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
16899                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
16900                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
16901                 false,
16902         },
16903         {
16904                 "spoolss_AddPrinterDriverEx",
16905                 sizeof(struct spoolss_AddPrinterDriverEx),
16906                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
16907                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
16908                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
16909                 false,
16910         },
16911         {
16912                 "spoolss_5a",
16913                 sizeof(struct spoolss_5a),
16914                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
16915                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
16916                 (ndr_print_function_t) ndr_print_spoolss_5a,
16917                 false,
16918         },
16919         {
16920                 "spoolss_5b",
16921                 sizeof(struct spoolss_5b),
16922                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
16923                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
16924                 (ndr_print_function_t) ndr_print_spoolss_5b,
16925                 false,
16926         },
16927         {
16928                 "spoolss_5c",
16929                 sizeof(struct spoolss_5c),
16930                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
16931                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
16932                 (ndr_print_function_t) ndr_print_spoolss_5c,
16933                 false,
16934         },
16935         {
16936                 "spoolss_5d",
16937                 sizeof(struct spoolss_5d),
16938                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
16939                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
16940                 (ndr_print_function_t) ndr_print_spoolss_5d,
16941                 false,
16942         },
16943         {
16944                 "spoolss_5e",
16945                 sizeof(struct spoolss_5e),
16946                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
16947                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
16948                 (ndr_print_function_t) ndr_print_spoolss_5e,
16949                 false,
16950         },
16951         {
16952                 "spoolss_5f",
16953                 sizeof(struct spoolss_5f),
16954                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
16955                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
16956                 (ndr_print_function_t) ndr_print_spoolss_5f,
16957                 false,
16958         },
16959         { NULL, 0, NULL, NULL, NULL, false }
16960 };
16961
16962 static const char * const spoolss_endpoint_strings[] = {
16963         "ncacn_np:[\\pipe\\spoolss]",
16964 };
16965
16966 static const struct ndr_interface_string_array spoolss_endpoints = {
16967         .count  = 1,
16968         .names  = spoolss_endpoint_strings
16969 };
16970
16971 static const char * const spoolss_authservice_strings[] = {
16972         "host",
16973 };
16974
16975 static const struct ndr_interface_string_array spoolss_authservices = {
16976         .count  = 1,
16977         .names  = spoolss_authservice_strings
16978 };
16979
16980
16981 const struct ndr_interface_table ndr_table_spoolss = {
16982         .name           = "spoolss",
16983         .syntax_id      = {
16984                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
16985                 NDR_SPOOLSS_VERSION
16986         },
16987         .helpstring     = NDR_SPOOLSS_HELPSTRING,
16988         .num_calls      = 114,
16989         .calls          = spoolss_calls,
16990         .endpoints      = &spoolss_endpoints,
16991         .authservices   = &spoolss_authservices
16992 };
16993