librpc/ndr/ndr_spoolss_buf.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    routines for marshalling/unmarshalling spoolss subcontext buffer structures
   5
   6    Copyright (C) Andrew Tridgell 2003
   7    Copyright (C) Tim Potter 2003
   8    Copyright (C) Guenther Deschner 2009
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24
  25 #include "includes.h"
  26 #include "librpc/gen_ndr/ndr_spoolss.h"
  27 #include "librpc/gen_ndr/ndr_security.h"
  28 #if (_SAMBA_BUILD_ >= 4)
  29 #include "param/param.h"
  30 #endif
  31
  32 #define NDR_SPOOLSS_PUSH_ENUM_IN(fn) do { \
  33         if (!r->in.buffer && r->in.offered != 0) {\
  34                 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
  35                         "SPOOLSS Buffer: r->in.offered[%u] but there's no buffer",\
  36                         (unsigned)r->in.offered);\
  37         } else if (r->in.buffer && r->in.buffer->length != r->in.offered) {\
  38                 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
  39                         "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of r->in.buffer[%u]",\
  40                         (unsigned)r->in.offered, (unsigned)r->in.buffer->length);\
  41         }\
  42         _r.in.level     = r->in.level;\
  43         _r.in.buffer    = r->in.buffer;\
  44         _r.in.offered   = r->in.offered;\
  45         NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
  46 } while(0)
  47
  48 #define NDR_SPOOLSS_PUSH_ENUM_OUT(fn) do { \
  49         struct ndr_push *_ndr_info;\
  50         _r.in.level     = r->in.level;\
  51         _r.in.buffer    = r->in.buffer;\
  52         _r.in.offered   = r->in.offered;\
  53         _r.out.info     = NULL;\
  54         _r.out.needed   = r->out.needed;\
  55         _r.out.count    = r->out.count;\
  56         _r.out.result   = r->out.result;\
  57         if (r->out.info && *r->out.info && !r->in.buffer) {\
  58                 return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
  59                         "SPOOLSS Buffer: *r->out.info but there's no r->in.buffer");\
  60         }\
  61         if (r->in.buffer) {\
  62                 DATA_BLOB _data_blob_info;\
  63                 _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);\
  64                 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
  65                 _ndr_info->flags= ndr->flags;\
  66                 if (r->out.info) {\
  67                         struct ndr_push *_subndr_info;\
  68                         struct __##fn __r;\
  69                         __r.in.level    = r->in.level;\
  70                         __r.in.count    = *r->out.count;\
  71                         __r.out.info    = *r->out.info;\
  72                         NDR_CHECK(ndr_push_subcontext_start(_ndr_info, &_subndr_info, 0, r->in.offered));\
  73                         NDR_CHECK(ndr_push___##fn(_subndr_info, flags, &__r)); \
  74                         NDR_CHECK(ndr_push_subcontext_end(_ndr_info, _subndr_info, 0, r->in.offered));\
  75                 }\
  76                 if (r->in.offered > _ndr_info->offset) {\
  77                         uint32_t _padding_len = r->in.offered - _ndr_info->offset;\
  78                         NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));\
  79                 } else if (r->in.offered < _ndr_info->offset) {\
  80                         return ndr_push_error(ndr, NDR_ERR_BUFSIZE,\
  81                                 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]!",\
  82                                 (unsigned)r->in.offered, (unsigned)_ndr_info->offset);\
  83                 }\
  84                 _data_blob_info = ndr_push_blob(_ndr_info);\
  85                 _r.out.info     = &_data_blob_info;\
  86         }\
  87         NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
  88 } while(0)
  89
  90 #define NDR_SPOOLSS_PUSH_ENUM(fn,in,out) do { \
  91         struct _##fn _r;\
  92         if (flags & NDR_IN) {\
  93                 in;\
  94                 NDR_SPOOLSS_PUSH_ENUM_IN(fn);\
  95         }\
  96         if (flags & NDR_OUT) {\
  97                 out;\
  98                 NDR_SPOOLSS_PUSH_ENUM_OUT(fn);\
  99         }\
 100 } while(0)
 101
 102 #define NDR_SPOOLSS_PULL_ENUM_IN(fn) do { \
 103         ZERO_STRUCT(r->out);\
 104         NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
 105         r->in.level     = _r.in.level;\
 106         r->in.buffer    = _r.in.buffer;\
 107         r->in.offered   = _r.in.offered;\
 108         r->out.needed   = _r.out.needed;\
 109         r->out.count    = _r.out.count;\
 110         if (!r->in.buffer && r->in.offered != 0) {\
 111                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
 112                         "SPOOLSS Buffer: r->in.offered[%u] but there's no buffer",\
 113                         (unsigned)r->in.offered);\
 114         } else if (r->in.buffer && r->in.buffer->length != r->in.offered) {\
 115                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
 116                         "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of r->in.buffer[%u]",\
 117                         (unsigned)r->in.offered, (unsigned)r->in.buffer->length);\
 118         }\
 119         NDR_PULL_ALLOC(ndr, r->out.info);\
 120         ZERO_STRUCTP(r->out.info);\
 121 } while(0)
 122
 123 #define NDR_SPOOLSS_PULL_ENUM_OUT(fn) do { \
 124         _r.in.level     = r->in.level;\
 125         _r.in.buffer    = r->in.buffer;\
 126         _r.in.offered   = r->in.offered;\
 127         _r.out.needed   = r->out.needed;\
 128         _r.out.count    = r->out.count;\
 129         NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
 130         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {\
 131                 NDR_PULL_ALLOC(ndr, r->out.info);\
 132         }\
 133         *r->out.info = NULL;\
 134         r->out.needed   = _r.out.needed;\
 135         r->out.count    = _r.out.count;\
 136         r->out.result   = _r.out.result;\
 137         if (_r.out.info) {\
 138                 struct ndr_pull *_ndr_info;\
 139                 NDR_PULL_ALLOC(ndr, *r->out.info);\
 140                 _ndr_info = ndr_pull_init_blob(_r.out.info, *r->out.info, ndr->iconv_convenience);\
 141                 NDR_ERR_HAVE_NO_MEMORY(_ndr_info);\
 142                 _ndr_info->flags= ndr->flags;\
 143                 if (r->in.offered != _ndr_info->data_size) {\
 144                         return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,\
 145                                 "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",\
 146                                 (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);\
 147                 }\
 148                 if (*r->out.needed <= _ndr_info->data_size) {\
 149                         struct __##fn __r;\
 150                         __r.in.level    = r->in.level;\
 151                         __r.in.count    = *r->out.count;\
 152                         __r.out.info    = NULL;\
 153                         NDR_CHECK(ndr_pull___##fn(_ndr_info, flags, &__r));\
 154                         *r->out.info    = __r.out.info;\
 155                 }\
 156         }\
 157 } while(0)
 158
 159 #define NDR_SPOOLSS_PULL_ENUM(fn,in,out) do { \
 160         struct _##fn _r;\
 161         if (flags & NDR_IN) {\
 162                 out;\
 163                 NDR_SPOOLSS_PULL_ENUM_IN(fn);\
 164                 in;\
 165         }\
 166         if (flags & NDR_OUT) {\
 167                 out;\
 168                 NDR_SPOOLSS_PULL_ENUM_OUT(fn);\
 169         }\
 170 } while(0)
 171
 172 #define _NDR_CHECK_UINT32(call) do {\
 173         enum ndr_err_code _ndr_err; \
 174         _ndr_err = call; \
 175         if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
 176                 return 0; \
 177         }\
 178 } while (0)
 179
 180 /* TODO: set _ndr_info->flags correct */
 181 #define NDR_SPOOLSS_SIZE_ENUM_LEVEL(fn) do { \
 182         struct __##fn __r;\
 183         DATA_BLOB _data_blob_info;\
 184         struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
 185         if (!_ndr_info) return 0;\
 186         _ndr_info->flags|=LIBNDR_FLAG_NO_NDR_SIZE;\
 187         __r.in.level    = level;\
 188         __r.in.count    = count;\
 189         __r.out.info    = info;\
 190         _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
 191         _data_blob_info = ndr_push_blob(_ndr_info);\
 192         return _data_blob_info.length;\
 193 } while(0)
 194
 195 /* TODO: set _ndr_info->flags correct */
 196 #define NDR_SPOOLSS_SIZE_ENUM(fn) do { \
 197         struct __##fn __r;\
 198         DATA_BLOB _data_blob_info;\
 199         struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx, iconv_convenience);\
 200         if (!_ndr_info) return 0;\
 201         _ndr_info->flags|=LIBNDR_FLAG_NO_NDR_SIZE;\
 202         __r.in.count    = count;\
 203         __r.out.info    = info;\
 204         _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
 205         _data_blob_info = ndr_push_blob(_ndr_info);\
 206         return _data_blob_info.length;\
 207 } while(0)
 208
 209
 210 /*
 211   spoolss_EnumPrinters
 212 */
 213 enum ndr_err_code ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinters *r)
 214 {
 215         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
 216                 _r.in.flags     = r->in.flags;
 217                 _r.in.server    = r->in.server;
 218         },{
 219                 _r.in.flags     = r->in.flags;
 220                 _r.in.server    = r->in.server;
 221         });
 222         return NDR_ERR_SUCCESS;
 223 }
 224
 225 enum ndr_err_code ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
 226 {
 227         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
 228                 r->in.flags     = _r.in.flags;
 229                 r->in.server    = _r.in.server;
 230         },{
 231                 _r.in.flags     = r->in.flags;
 232                 _r.in.server    = r->in.server;
 233         });
 234         return NDR_ERR_SUCCESS;
 235 }
 236
 237 uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info)
 238 {
 239         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinters);
 240 }
 241
 242 /*
 243   spoolss_EnumJobs
 244 */
 245 enum ndr_err_code ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct spoolss_EnumJobs *r)
 246 {
 247         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
 248                 _r.in.handle    = r->in.handle;
 249                 _r.in.firstjob  = r->in.firstjob;
 250                 _r.in.numjobs   = r->in.numjobs;
 251         },{
 252                 _r.in.handle    = r->in.handle;
 253                 _r.in.firstjob  = r->in.firstjob;
 254                 _r.in.numjobs   = r->in.numjobs;
 255         });
 256         return NDR_ERR_SUCCESS;
 257 }
 258
 259 enum ndr_err_code ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
 260 {
 261         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
 262                 r->in.handle    = _r.in.handle;
 263                 r->in.firstjob  = _r.in.firstjob;
 264                 r->in.numjobs   = _r.in.numjobs;
 265         },{
 266                 _r.in.handle    = r->in.handle;
 267                 _r.in.firstjob  = r->in.firstjob;
 268                 _r.in.numjobs   = r->in.numjobs;
 269         });
 270         return NDR_ERR_SUCCESS;
 271 }
 272
 273 uint32_t ndr_size_spoolss_EnumJobs_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_JobInfo *info)
 274 {
 275         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumJobs);
 276 }
 277
 278 /*
 279   spoolss_EnumPrinterDrivers
 280 */
 281 enum ndr_err_code ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDrivers *r)
 282 {
 283         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
 284                 _r.in.server            = r->in.server;
 285                 _r.in.environment       = r->in.environment;
 286         },{
 287                 _r.in.server            = r->in.server;
 288                 _r.in.environment       = r->in.environment;
 289         });
 290         return NDR_ERR_SUCCESS;
 291 }
 292
 293 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 294 {
 295         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
 296                 r->in.server            = _r.in.server;
 297                 r->in.environment       = _r.in.environment;
 298         },{
 299                 _r.in.server            = r->in.server;
 300                 _r.in.environment       = r->in.environment;
 301         });
 302         return NDR_ERR_SUCCESS;
 303 }
 304
 305 uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_DriverInfo *info)
 306 {
 307         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrinterDrivers);
 308 }
 309
 310 /*
 311   spoolss_EnumForms
 312 */
 313 enum ndr_err_code ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct spoolss_EnumForms *r)
 314 {
 315         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
 316                 _r.in.handle    = r->in.handle;
 317         },{
 318                 _r.in.handle    = r->in.handle;
 319         });
 320         return NDR_ERR_SUCCESS;
 321 }
 322
 323 enum ndr_err_code ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
 324 {
 325         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
 326                 r->in.handle    = _r.in.handle;
 327         },{
 328                 _r.in.handle    = r->in.handle;
 329         });
 330         return NDR_ERR_SUCCESS;
 331 }
 332
 333 uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_FormInfo *info)
 334 {
 335         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumForms);
 336 }
 337
 338 /*
 339   spoolss_EnumPorts
 340 */
 341 enum ndr_err_code ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct spoolss_EnumPorts *r)
 342 {
 343         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
 344                 _r.in.servername= r->in.servername;
 345         },{
 346                 _r.in.servername= r->in.servername;
 347         });
 348         return NDR_ERR_SUCCESS;
 349 }
 350
 351 enum ndr_err_code ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
 352 {
 353         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
 354                 r->in.servername= _r.in.servername;
 355         },{
 356                 _r.in.servername= r->in.servername;
 357         });
 358         return NDR_ERR_SUCCESS;
 359 }
 360
 361 uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_PortInfo *info)
 362 {
 363         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPorts);
 364 }
 365
 366 /*
 367   spoolss_EnumMonitors
 368 */
 369 enum ndr_err_code ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct spoolss_EnumMonitors *r)
 370 {
 371         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
 372                 _r.in.servername= r->in.servername;
 373         },{
 374                 _r.in.servername= r->in.servername;
 375         });
 376         return NDR_ERR_SUCCESS;
 377 }
 378
 379 enum ndr_err_code ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
 380 {
 381         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
 382                 r->in.servername= _r.in.servername;
 383         },{
 384                 _r.in.servername= r->in.servername;
 385         });
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info)
 390 {
 391         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumMonitors);
 392 }
 393
 394 /*
 395   spoolss_EnumPrintProcessors
 396 */
 397 enum ndr_err_code ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcessors *r)
 398 {
 399         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
 400                 _r.in.servername        = r->in.servername;
 401                 _r.in.environment       = r->in.environment;
 402         },{
 403                 _r.in.servername        = r->in.servername;
 404                 _r.in.environment       = r->in.environment;
 405         });
 406         return NDR_ERR_SUCCESS;
 407 }
 408
 409 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 410 {
 411         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
 412                 r->in.servername        = _r.in.servername;
 413                 r->in.environment       = _r.in.environment;
 414         },{
 415                 _r.in.servername        = r->in.servername;
 416                 _r.in.environment       = r->in.environment;
 417         });
 418         return NDR_ERR_SUCCESS;
 419 }
 420
 421 uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
 422                                                    uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
 423 {
 424         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcessors);
 425 }
 426
 427 /*
 428   spoolss_EnumPrintProcessors
 429 */
 430 enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
 431 {
 432         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcDataTypes,{
 433                 _r.in.servername                = r->in.servername;
 434                 _r.in.print_processor_name      = r->in.print_processor_name;
 435         },{
 436                 _r.in.servername                = r->in.servername;
 437                 _r.in.print_processor_name      = r->in.print_processor_name;
 438         });
 439         return NDR_ERR_SUCCESS;
 440 }
 441
 442 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
 443 {
 444         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcDataTypes,{
 445                 r->in.servername                = _r.in.servername;
 446                 r->in.print_processor_name      = _r.in.print_processor_name;
 447         },{
 448                 _r.in.servername                = r->in.servername;
 449                 _r.in.print_processor_name      = r->in.print_processor_name;
 450         });
 451         return NDR_ERR_SUCCESS;
 452 }
 453
 454 uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
 455                                                       uint32_t level, uint32_t count, union spoolss_PrintProcDataTypesInfo *info)
 456 {
 457         NDR_SPOOLSS_SIZE_ENUM_LEVEL(spoolss_EnumPrintProcDataTypes);
 458 }
 459
 460 /*
 461   spoolss_EnumPrinterDataEx
 462 */
 463
 464 enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
 465 {
 466         struct _spoolss_EnumPrinterDataEx _r;
 467         if (flags & NDR_IN) {
 468                 _r.in.handle    = r->in.handle;
 469                 _r.in.key_name  = r->in.key_name;
 470                 _r.in.offered   = r->in.offered;
 471                 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 472         }
 473         if (flags & NDR_OUT) {
 474                 struct ndr_push *_ndr_info;
 475                 _r.in.handle    = r->in.handle;
 476                 _r.in.key_name  = r->in.key_name;
 477                 _r.in.offered   = r->in.offered;
 478                 _r.out.count    = r->out.count;
 479                 _r.out.needed   = r->out.needed;
 480                 _r.out.result   = r->out.result;
 481                 _r.out.info     = data_blob(NULL, 0);
 482                 if (r->in.offered >= *r->out.needed) {
 483                         struct __spoolss_EnumPrinterDataEx __r;
 484                         _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 485                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 486                         _ndr_info->flags= ndr->flags;
 487                         __r.in.count    = *r->out.count;
 488                         __r.out.info    = *r->out.info;
 489                         NDR_CHECK(ndr_push___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
 490                         if (r->in.offered > _ndr_info->offset) {
 491                                 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
 492                                 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
 493                         }
 494                         _r.out.info = ndr_push_blob(_ndr_info);
 495                 }
 496                 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 497         }
 498         return NDR_ERR_SUCCESS;
 499 }
 500
 501 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
 502 {
 503         struct _spoolss_EnumPrinterDataEx _r;
 504         if (flags & NDR_IN) {
 505                 _r.in.handle    = r->in.handle;
 506                 _r.in.key_name  = r->in.key_name;
 507                 ZERO_STRUCT(r->out);
 508                 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 509                 r->in.handle    = _r.in.handle;
 510                 r->in.key_name  = _r.in.key_name;
 511                 r->in.offered   = _r.in.offered;
 512                 r->out.needed   = _r.out.needed;
 513                 r->out.count    = _r.out.count;
 514                 NDR_PULL_ALLOC(ndr, r->out.info);
 515                 ZERO_STRUCTP(r->out.info);
 516         }
 517         if (flags & NDR_OUT) {
 518                 _r.in.handle    = r->in.handle;
 519                 _r.in.key_name  = r->in.key_name;
 520                 _r.in.offered   = r->in.offered;
 521                 _r.out.count    = r->out.count;
 522                 _r.out.needed   = r->out.needed;
 523                 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 525                         NDR_PULL_ALLOC(ndr, r->out.info);
 526                 }
 527                 *r->out.info    = NULL;
 528                 r->out.needed   = _r.out.needed;
 529                 r->out.count    = _r.out.count;
 530                 r->out.result   = _r.out.result;
 531                 if (_r.out.info.length) {
 532                         struct ndr_pull *_ndr_info;
 533                         NDR_PULL_ALLOC(ndr, *r->out.info);
 534                         _ndr_info = ndr_pull_init_blob(&_r.out.info, *r->out.info, ndr->iconv_convenience);
 535                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 536                         _ndr_info->flags= ndr->flags;
 537                         if (r->in.offered != _ndr_info->data_size) {
 538                                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
 539                                         "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",
 540                                         (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);
 541                         }
 542                         if (*r->out.needed <= _ndr_info->data_size) {
 543                                 struct __spoolss_EnumPrinterDataEx __r;
 544                                 __r.in.count    = *r->out.count;
 545                                 __r.out.info    = NULL;
 546                                 NDR_CHECK(ndr_pull___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
 547                                 *r->out.info    = __r.out.info;
 548                         }
 549                 }
 550         }
 551         return NDR_ERR_SUCCESS;
 552 }
 553
 554 uint32_t ndr_size_spoolss_EnumPrinterDataEx_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
 555                                                  uint32_t count, struct spoolss_PrinterEnumValues *info)
 556 {
 557         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDataEx);
 558 }
 559
 560 /*
 561   spoolss_GetPrinterData
 562 */
 563 enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
 564 {
 565         struct _spoolss_GetPrinterData _r;
 566         if (flags & NDR_IN) {
 567                 _r.in.handle    = r->in.handle;
 568                 _r.in.value_name= r->in.value_name;
 569                 _r.in.offered   = r->in.offered;
 570                 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
 571         }
 572         if (flags & NDR_OUT) {
 573                 struct ndr_push *_ndr_info;
 574                 DATA_BLOB blob = data_blob(NULL, 0);
 575                 _r.in.handle    = r->in.handle;
 576                 _r.in.value_name= r->in.value_name;
 577                 _r.in.offered   = r->in.offered;
 578                 _r.out.type     = r->out.type;
 579                 _r.out.data     = &blob;
 580                 _r.out.needed   = r->out.needed;
 581                 _r.out.result   = r->out.result;
 582                 {
 583                         struct __spoolss_GetPrinterData __r;
 584                         DATA_BLOB _blob;
 585                         _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 586                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 587                         _ndr_info->flags= ndr->flags;
 588                         __r.in.type     = *r->out.type;
 589                         __r.out.data    = r->out.data;
 590                         NDR_CHECK(ndr_push___spoolss_GetPrinterData(_ndr_info, flags, &__r));
 591                         if (r->in.offered > _ndr_info->offset) {
 592                                 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
 593                                 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
 594                         }
 595                         _blob = ndr_push_blob(_ndr_info);
 596                         _r.out.data = &_blob;
 597                 }
 598                 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
 599         }
 600         return NDR_ERR_SUCCESS;
 601 }
 602
 603 enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
 604 {
 605         struct _spoolss_GetPrinterData _r;
 606         if (flags & NDR_IN) {
 607                 DATA_BLOB blob = data_blob(NULL,0);
 608                 ZERO_STRUCT(r->out);
 609
 610                 _r.in.handle    = r->in.handle;
 611                 _r.in.value_name= r->in.value_name;
 612                 _r.in.offered   = r->in.offered;
 613                 _r.out.type     = r->out.type;
 614                 _r.out.data     = &blob;
 615                 _r.out.needed   = r->out.needed;
 616                 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
 617                 r->in.handle    = _r.in.handle;
 618                 r->in.value_name= _r.in.value_name;
 619                 r->in.offered   = _r.in.offered;
 620                 r->out.needed   = _r.out.needed;
 621         }
 622         if (flags & NDR_OUT) {
 623                 DATA_BLOB blob = data_blob_talloc(ndr,NULL,0);
 624                 _r.in.handle    = r->in.handle;
 625                 _r.in.value_name= r->in.value_name;
 626                 _r.in.offered   = r->in.offered;
 627                 _r.out.type     = r->out.type;
 628                 _r.out.data     = &blob;
 629                 _r.out.needed   = r->out.needed;
 630                 _r.out.result   = r->out.result;
 631                 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
 632                 r->out.type     = _r.out.type;
 633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 634                         NDR_PULL_ALLOC(ndr, r->out.data);
 635                 }
 636                 ZERO_STRUCTP(r->out.data);
 637                 r->out.needed   = _r.out.needed;
 638                 r->out.result   = _r.out.result;
 639                 if (_r.out.data && _r.out.data->length != r->in.offered) {
 640                         return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
 641                                 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]",
 642                                 (unsigned)r->in.offered, (unsigned)_r.out.data->length);
 643                 }
 644                 if (_r.out.data && _r.out.data->length > 0 && *r->out.needed <= _r.out.data->length) {
 645                         struct __spoolss_GetPrinterData __r;
 646                         struct ndr_pull *_ndr_data = ndr_pull_init_blob(_r.out.data, ndr, ndr->iconv_convenience);
 647                         NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
 648                         _ndr_data->flags= ndr->flags;
 649                         __r.in.type     = *r->out.type;
 650                         __r.out.data    = r->out.data;
 651                         NDR_CHECK(ndr_pull___spoolss_GetPrinterData(_ndr_data, flags, &__r));
 652                         r->out.data     = __r.out.data;
 653                 } else {
 654                         *r->out.type    = REG_NONE;
 655                 }
 656         }
 657         return NDR_ERR_SUCCESS;
 658 }
 659
 660 /*
 661   spoolss_SetPrinterData
 662 */
 663 enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
 664 {
 665         struct _spoolss_SetPrinterData _r;
 666         if (flags & NDR_IN) {
 667                 struct ndr_push *_ndr_data;
 668                 struct __spoolss_SetPrinterData __r;
 669                 DATA_BLOB _data_blob_data;
 670
 671                 _ndr_data = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 672                 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
 673                 _ndr_data->flags= ndr->flags;
 674
 675                 __r.in.type     = r->in.type;
 676                 __r.out.data    = discard_const_p(union spoolss_PrinterData, &r->in.data);
 677                 NDR_CHECK(ndr_push___spoolss_SetPrinterData(_ndr_data, NDR_OUT, &__r));
 678                 _data_blob_data = ndr_push_blob(_ndr_data);
 679
 680                 _r.in.handle    = r->in.handle;
 681                 _r.in.value_name= r->in.value_name;
 682                 _r.in.type      = r->in.type;
 683                 _r.in.data      = _data_blob_data;
 684                 _r.in._offered  = _data_blob_data.length;
 685                 _r.out.result   = r->out.result;
 686                 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
 687         }
 688         if (flags & NDR_OUT) {
 689                 _r.in.handle    = r->in.handle;
 690                 _r.in.value_name= r->in.value_name;
 691                 _r.in.type      = r->in.type;
 692                 _r.in.data      = data_blob(NULL,0),
 693                 _r.in._offered  = r->in._offered;
 694                 _r.out.result   = r->out.result;
 695                 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
 696         }
 697         return NDR_ERR_SUCCESS;
 698 }
 699
 700 /*
 701   spoolss_GetPrinterDataEx
 702 */
 703 enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
 704 {
 705         struct _spoolss_GetPrinterDataEx _r;
 706         if (flags & NDR_IN) {
 707                 _r.in.handle    = r->in.handle;
 708                 _r.in.key_name  = r->in.key_name;
 709                 _r.in.value_name= r->in.value_name;
 710                 _r.in.offered   = r->in.offered;
 711                 NDR_CHECK(ndr_push__spoolss_GetPrinterDataEx(ndr, flags, &_r));
 712         }
 713         if (flags & NDR_OUT) {
 714                 struct ndr_push *_ndr_info;
 715                 DATA_BLOB blob = data_blob(NULL, 0);
 716                 _r.in.handle    = r->in.handle;
 717                 _r.in.key_name  = r->in.key_name;
 718                 _r.in.value_name= r->in.value_name;
 719                 _r.in.offered   = r->in.offered;
 720                 _r.out.type     = r->out.type;
 721                 _r.out.data     = &blob;
 722                 _r.out.needed   = r->out.needed;
 723                 _r.out.result   = r->out.result;
 724                 {
 725                         struct __spoolss_GetPrinterDataEx __r;
 726                         DATA_BLOB _blob;
 727                         _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 728                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 729                         _ndr_info->flags= ndr->flags;
 730                         __r.in.type     = *r->out.type;
 731                         __r.out.data    = r->out.data;
 732                         NDR_CHECK(ndr_push___spoolss_GetPrinterDataEx(_ndr_info, flags, &__r));
 733                         if (r->in.offered > _ndr_info->offset) {
 734                                 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
 735                                 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
 736                         }
 737                         _blob = ndr_push_blob(_ndr_info);
 738                         _r.out.data = &_blob;
 739                 }
 740                 NDR_CHECK(ndr_push__spoolss_GetPrinterDataEx(ndr, flags, &_r));
 741         }
 742         return NDR_ERR_SUCCESS;
 743 }
 744
 745 enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
 746 {
 747         struct _spoolss_GetPrinterDataEx _r;
 748         if (flags & NDR_IN) {
 749                 DATA_BLOB blob = data_blob(NULL,0);
 750                 ZERO_STRUCT(r->out);
 751
 752                 _r.in.handle    = r->in.handle;
 753                 _r.in.key_name  = r->in.key_name;
 754                 _r.in.value_name= r->in.value_name;
 755                 _r.in.offered   = r->in.offered;
 756                 _r.out.type     = r->out.type;
 757                 _r.out.data     = &blob;
 758                 _r.out.needed   = r->out.needed;
 759                 NDR_CHECK(ndr_pull__spoolss_GetPrinterDataEx(ndr, flags, &_r));
 760                 r->in.handle    = _r.in.handle;
 761                 r->in.key_name  = _r.in.key_name;
 762                 r->in.value_name= _r.in.value_name;
 763                 r->in.offered   = _r.in.offered;
 764                 r->out.needed   = _r.out.needed;
 765         }
 766         if (flags & NDR_OUT) {
 767                 DATA_BLOB blob = data_blob_talloc(ndr,NULL,0);
 768                 _r.in.handle    = r->in.handle;
 769                 _r.in.key_name  = r->in.key_name;
 770                 _r.in.value_name= r->in.value_name;
 771                 _r.in.offered   = r->in.offered;
 772                 _r.out.type     = r->out.type;
 773                 _r.out.data     = &blob;
 774                 _r.out.needed   = r->out.needed;
 775                 _r.out.result   = r->out.result;
 776                 NDR_CHECK(ndr_pull__spoolss_GetPrinterDataEx(ndr, flags, &_r));
 777                 r->out.type     = _r.out.type;
 778                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 779                         NDR_PULL_ALLOC(ndr, r->out.data);
 780                 }
 781                 ZERO_STRUCTP(r->out.data);
 782                 r->out.needed   = _r.out.needed;
 783                 r->out.result   = _r.out.result;
 784                 if (_r.out.data && _r.out.data->length != r->in.offered) {
 785                         return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
 786                                 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]",
 787                                 (unsigned)r->in.offered, (unsigned)_r.out.data->length);
 788                 }
 789                 if (_r.out.data && _r.out.data->length > 0 && *r->out.needed <= _r.out.data->length) {
 790                         struct __spoolss_GetPrinterDataEx __r;
 791                         struct ndr_pull *_ndr_data = ndr_pull_init_blob(_r.out.data, ndr, ndr->iconv_convenience);
 792                         NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
 793                         _ndr_data->flags= ndr->flags;
 794                         __r.in.type     = *r->out.type;
 795                         __r.out.data    = r->out.data;
 796                         NDR_CHECK(ndr_pull___spoolss_GetPrinterDataEx(_ndr_data, flags, &__r));
 797                         r->out.data     = __r.out.data;
 798                 } else {
 799                         *r->out.type    = REG_NONE;
 800                 }
 801         }
 802         return NDR_ERR_SUCCESS;
 803 }
 804
 805 /*
 806   spoolss_SetPrinterDataEx
 807 */
 808 enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
 809 {
 810         struct _spoolss_SetPrinterDataEx _r;
 811         if (flags & NDR_IN) {
 812                 struct ndr_push *_ndr_data;
 813                 struct __spoolss_SetPrinterDataEx __r;
 814                 DATA_BLOB _data_blob_data;
 815
 816                 _ndr_data = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 817                 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
 818                 _ndr_data->flags= ndr->flags;
 819
 820                 __r.in.type     = r->in.type;
 821                 __r.out.data    = discard_const_p(union spoolss_PrinterData, &r->in.data);
 822                 NDR_CHECK(ndr_push___spoolss_SetPrinterDataEx(_ndr_data, NDR_OUT, &__r));
 823                 _data_blob_data = ndr_push_blob(_ndr_data);
 824
 825                 _r.in.handle    = r->in.handle;
 826                 _r.in.key_name  = r->in.key_name;
 827                 _r.in.value_name= r->in.value_name;
 828                 _r.in.type      = r->in.type;
 829                 _r.in.data      = _data_blob_data;
 830                 _r.in._offered  = _data_blob_data.length;
 831                 _r.out.result   = r->out.result;
 832                 NDR_CHECK(ndr_push__spoolss_SetPrinterDataEx(ndr, flags, &_r));
 833         }
 834         if (flags & NDR_OUT) {
 835                 _r.in.handle    = r->in.handle;
 836                 _r.in.key_name  = r->in.key_name;
 837                 _r.in.value_name= r->in.value_name;
 838                 _r.in.type      = r->in.type;
 839                 _r.in.data      = data_blob(NULL,0),
 840                 _r.in._offered  = r->in._offered;
 841                 _r.out.result   = r->out.result;
 842                 NDR_CHECK(ndr_push__spoolss_SetPrinterDataEx(ndr, flags, &_r));
 843         }
 844         return NDR_ERR_SUCCESS;
 845 }
 846
 847 uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
 848 {
 849         if (!devmode) return 0;
 850         return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
 851 }
 852
 853 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
 854 {
 855         if (!r) {
 856                 return 4;
 857         }
 858
 859         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
 860 }
 861
 862 /* hand marshall as pidl cannot (yet) generate a relative pointer to a fixed array of
 863  * structs */
 864
 865 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo101(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo101 *r)
 866 {
 867         uint32_t cntr_file_info_1;
 868         if (ndr_flags & NDR_SCALARS) {
 869                 NDR_CHECK(ndr_push_align(ndr, 8));
 870                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
 871                 {
 872                         uint32_t _flags_save_string = ndr->flags;
 873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
 875                         ndr->flags = _flags_save_string;
 876                 }
 877                 {
 878                         uint32_t _flags_save_string = ndr->flags;
 879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 880                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
 881                         ndr->flags = _flags_save_string;
 882                 }
 883                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_info));
 884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
 885                 {
 886                         uint32_t _flags_save_string = ndr->flags;
 887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 888                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
 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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
 895                         ndr->flags = _flags_save_string;
 896                 }
 897                 {
 898                         uint32_t _flags_save_string_array = ndr->flags;
 899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 900                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
 901                         ndr->flags = _flags_save_string_array;
 902                 }
 903                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
 904                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
 905                 {
 906                         uint32_t _flags_save_string = ndr->flags;
 907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 908                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
 909                         ndr->flags = _flags_save_string;
 910                 }
 911                 {
 912                         uint32_t _flags_save_string = ndr->flags;
 913                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 914                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
 915                         ndr->flags = _flags_save_string;
 916                 }
 917                 {
 918                         uint32_t _flags_save_string = ndr->flags;
 919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 920                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
 921                         ndr->flags = _flags_save_string;
 922                 }
 923                 {
 924                         uint32_t _flags_save_string = ndr->flags;
 925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
 927                         ndr->flags = _flags_save_string;
 928                 }
 929                 NDR_CHECK(ndr_push_trailer_align(ndr, 8));
 930         }
 931         if (ndr_flags & NDR_BUFFERS) {
 932                 {
 933                         uint32_t _flags_save_string = ndr->flags;
 934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 935                         if (r->driver_name) {
 936                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->driver_name));
 937                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
 938                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->driver_name));
 939                         }
 940                         ndr->flags = _flags_save_string;
 941                 }
 942                 {
 943                         uint32_t _flags_save_string = ndr->flags;
 944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 945                         if (r->architecture) {
 946                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->architecture));
 947                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
 948                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->architecture));
 949                         }
 950                         ndr->flags = _flags_save_string;
 951                 }
 952                 if (r->file_info) {
 953                         NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->file_info));
 954 #if 0
 955                         NDR_CHECK(ndr_push_uint3264(ndr, NDR_SCALARS, r->file_count));
 956 #endif
 957                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
 958                                 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
 959                         }
 960                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
 961                                 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
 962                         }
 963                         NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->file_info));
 964                 }
 965                 {
 966                         uint32_t _flags_save_string = ndr->flags;
 967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 968                         if (r->monitor_name) {
 969                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->monitor_name));
 970                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
 971                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->monitor_name));
 972                         }
 973                         ndr->flags = _flags_save_string;
 974                 }
 975                 {
 976                         uint32_t _flags_save_string = ndr->flags;
 977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 978                         if (r->default_datatype) {
 979                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->default_datatype));
 980                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
 981                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->default_datatype));
 982                         }
 983                         ndr->flags = _flags_save_string;
 984                 }
 985                 {
 986                         uint32_t _flags_save_string_array = ndr->flags;
 987                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 988                         if (r->previous_names) {
 989                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->previous_names));
 990                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
 991                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->previous_names));
 992                         }
 993                         ndr->flags = _flags_save_string_array;
 994                 }
 995                 {
 996                         uint32_t _flags_save_string = ndr->flags;
 997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 998                         if (r->manufacturer_name) {
 999                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_name));
1000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
1001                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_name));
1002                         }
1003                         ndr->flags = _flags_save_string;
1004                 }
1005                 {
1006                         uint32_t _flags_save_string = ndr->flags;
1007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1008                         if (r->manufacturer_url) {
1009                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->manufacturer_url));
1010                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
1011                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->manufacturer_url));
1012                         }
1013                         ndr->flags = _flags_save_string;
1014                 }
1015                 {
1016                         uint32_t _flags_save_string = ndr->flags;
1017                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1018                         if (r->hardware_id) {
1019                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->hardware_id));
1020                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
1021                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->hardware_id));
1022                         }
1023                         ndr->flags = _flags_save_string;
1024                 }
1025                 {
1026                         uint32_t _flags_save_string = ndr->flags;
1027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1028                         if (r->provider) {
1029                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->provider));
1030                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
1031                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->provider));
1032                         }
1033                         ndr->flags = _flags_save_string;
1034                 }
1035         }
1036         return NDR_ERR_SUCCESS;
1037 }
1038
1039 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r)
1040 {
1041         uint32_t _ptr_driver_name;
1042         TALLOC_CTX *_mem_save_driver_name_0;
1043         uint32_t _ptr_architecture;
1044         TALLOC_CTX *_mem_save_architecture_0;
1045         uint32_t _ptr_file_info;
1046         uint32_t cntr_file_info_1;
1047         TALLOC_CTX *_mem_save_file_info_0;
1048         TALLOC_CTX *_mem_save_file_info_1;
1049         uint32_t _ptr_monitor_name;
1050         TALLOC_CTX *_mem_save_monitor_name_0;
1051         uint32_t _ptr_default_datatype;
1052         TALLOC_CTX *_mem_save_default_datatype_0;
1053         uint32_t _ptr_previous_names;
1054         TALLOC_CTX *_mem_save_previous_names_0;
1055         uint32_t _ptr_manufacturer_name;
1056         TALLOC_CTX *_mem_save_manufacturer_name_0;
1057         uint32_t _ptr_manufacturer_url;
1058         TALLOC_CTX *_mem_save_manufacturer_url_0;
1059         uint32_t _ptr_hardware_id;
1060         TALLOC_CTX *_mem_save_hardware_id_0;
1061         uint32_t _ptr_provider;
1062         TALLOC_CTX *_mem_save_provider_0;
1063         if (ndr_flags & NDR_SCALARS) {
1064                 NDR_CHECK(ndr_pull_align(ndr, 8));
1065                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
1066                 {
1067                         uint32_t _flags_save_string = ndr->flags;
1068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1069                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
1070                         if (_ptr_driver_name) {
1071                                 NDR_PULL_ALLOC(ndr, r->driver_name);
1072                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
1073                         } else {
1074                                 r->driver_name = NULL;
1075                         }
1076                         ndr->flags = _flags_save_string;
1077                 }
1078                 {
1079                         uint32_t _flags_save_string = ndr->flags;
1080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1081                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
1082                         if (_ptr_architecture) {
1083                                 NDR_PULL_ALLOC(ndr, r->architecture);
1084                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
1085                         } else {
1086                                 r->architecture = NULL;
1087                         }
1088                         ndr->flags = _flags_save_string;
1089                 }
1090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_info));
1091                 if (_ptr_file_info) {
1092                         NDR_PULL_ALLOC(ndr, r->file_info);
1093                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_info, _ptr_file_info));
1094                 } else {
1095                         r->file_info = NULL;
1096                 }
1097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_count));
1098                 {
1099                         uint32_t _flags_save_string = ndr->flags;
1100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1101                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
1102                         if (_ptr_monitor_name) {
1103                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
1104                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
1105                         } else {
1106                                 r->monitor_name = NULL;
1107                         }
1108                         ndr->flags = _flags_save_string;
1109                 }
1110                 {
1111                         uint32_t _flags_save_string = ndr->flags;
1112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1113                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
1114                         if (_ptr_default_datatype) {
1115                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
1116                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
1117                         } else {
1118                                 r->default_datatype = NULL;
1119                         }
1120                         ndr->flags = _flags_save_string;
1121                 }
1122                 {
1123                         uint32_t _flags_save_string_array = ndr->flags;
1124                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1125                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
1126                         if (_ptr_previous_names) {
1127                                 NDR_PULL_ALLOC(ndr, r->previous_names);
1128                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
1129                         } else {
1130                                 r->previous_names = NULL;
1131                         }
1132                         ndr->flags = _flags_save_string_array;
1133                 }
1134                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
1135                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
1136                 {
1137                         uint32_t _flags_save_string = ndr->flags;
1138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1139                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
1140                         if (_ptr_manufacturer_name) {
1141                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
1142                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
1143                         } else {
1144                                 r->manufacturer_name = NULL;
1145                         }
1146                         ndr->flags = _flags_save_string;
1147                 }
1148                 {
1149                         uint32_t _flags_save_string = ndr->flags;
1150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1151                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
1152                         if (_ptr_manufacturer_url) {
1153                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
1154                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
1155                         } else {
1156                                 r->manufacturer_url = NULL;
1157                         }
1158                         ndr->flags = _flags_save_string;
1159                 }
1160                 {
1161                         uint32_t _flags_save_string = ndr->flags;
1162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1163                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
1164                         if (_ptr_hardware_id) {
1165                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
1166                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
1167                         } else {
1168                                 r->hardware_id = NULL;
1169                         }
1170                         ndr->flags = _flags_save_string;
1171                 }
1172                 {
1173                         uint32_t _flags_save_string = ndr->flags;
1174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1175                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
1176                         if (_ptr_provider) {
1177                                 NDR_PULL_ALLOC(ndr, r->provider);
1178                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
1179                         } else {
1180                                 r->provider = NULL;
1181                         }
1182                         ndr->flags = _flags_save_string;
1183                 }
1184                 NDR_CHECK(ndr_pull_trailer_align(ndr, 8));
1185         }
1186         if (ndr_flags & NDR_BUFFERS) {
1187                 {
1188                         uint32_t _flags_save_string = ndr->flags;
1189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1190                         if (r->driver_name) {
1191                                 uint32_t _relative_save_offset;
1192                                 _relative_save_offset = ndr->offset;
1193                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
1194                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1195                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
1196                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
1197                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
1198                                 if (ndr->offset > ndr->relative_highest_offset) {
1199                                         ndr->relative_highest_offset = ndr->offset;
1200                                 }
1201                                 ndr->offset = _relative_save_offset;
1202                         }
1203                         ndr->flags = _flags_save_string;
1204                 }
1205                 {
1206                         uint32_t _flags_save_string = ndr->flags;
1207                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1208                         if (r->architecture) {
1209                                 uint32_t _relative_save_offset;
1210                                 _relative_save_offset = ndr->offset;
1211                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
1212                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
1213                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
1214                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
1215                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
1216                                 if (ndr->offset > ndr->relative_highest_offset) {
1217                                         ndr->relative_highest_offset = ndr->offset;
1218                                 }
1219                                 ndr->offset = _relative_save_offset;
1220                         }
1221                         ndr->flags = _flags_save_string;
1222                 }
1223                 if (r->file_info) {
1224                         uint32_t _relative_save_offset;
1225                         _relative_save_offset = ndr->offset;
1226                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
1227                         _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1228                         NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1229 #if 0
1230                         NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
1231 #else
1232                         NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
1233 #endif
1234                         NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
1235                         _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1236                         NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1237                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1238                                 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
1239                         }
1240                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1241                                 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
1242                         }
1243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
1244                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
1245                         if (ndr->offset > ndr->relative_highest_offset) {
1246                                 ndr->relative_highest_offset = ndr->offset;
1247                         }
1248                         ndr->offset = _relative_save_offset;
1249                 }
1250                 {
1251                         uint32_t _flags_save_string = ndr->flags;
1252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1253                         if (r->monitor_name) {
1254                                 uint32_t _relative_save_offset;
1255                                 _relative_save_offset = ndr->offset;
1256                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
1257                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1258                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
1259                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
1260                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
1261                                 if (ndr->offset > ndr->relative_highest_offset) {
1262                                         ndr->relative_highest_offset = ndr->offset;
1263                                 }
1264                                 ndr->offset = _relative_save_offset;
1265                         }
1266                         ndr->flags = _flags_save_string;
1267                 }
1268                 {
1269                         uint32_t _flags_save_string = ndr->flags;
1270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1271                         if (r->default_datatype) {
1272                                 uint32_t _relative_save_offset;
1273                                 _relative_save_offset = ndr->offset;
1274                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
1275                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1276                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
1277                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
1278                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
1279                                 if (ndr->offset > ndr->relative_highest_offset) {
1280                                         ndr->relative_highest_offset = ndr->offset;
1281                                 }
1282                                 ndr->offset = _relative_save_offset;
1283                         }
1284                         ndr->flags = _flags_save_string;
1285                 }
1286                 {
1287                         uint32_t _flags_save_string_array = ndr->flags;
1288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1289                         if (r->previous_names) {
1290                                 uint32_t _relative_save_offset;
1291                                 _relative_save_offset = ndr->offset;
1292                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
1293                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1294                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
1295                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
1296                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
1297                                 if (ndr->offset > ndr->relative_highest_offset) {
1298                                         ndr->relative_highest_offset = ndr->offset;
1299                                 }
1300                                 ndr->offset = _relative_save_offset;
1301                         }
1302                         ndr->flags = _flags_save_string_array;
1303                 }
1304                 {
1305                         uint32_t _flags_save_string = ndr->flags;
1306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1307                         if (r->manufacturer_name) {
1308                                 uint32_t _relative_save_offset;
1309                                 _relative_save_offset = ndr->offset;
1310                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1311                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1312                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1313                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1314                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1315                                 if (ndr->offset > ndr->relative_highest_offset) {
1316                                         ndr->relative_highest_offset = ndr->offset;
1317                                 }
1318                                 ndr->offset = _relative_save_offset;
1319                         }
1320                         ndr->flags = _flags_save_string;
1321                 }
1322                 {
1323                         uint32_t _flags_save_string = ndr->flags;
1324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1325                         if (r->manufacturer_url) {
1326                                 uint32_t _relative_save_offset;
1327                                 _relative_save_offset = ndr->offset;
1328                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1329                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1330                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1331                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1332                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1333                                 if (ndr->offset > ndr->relative_highest_offset) {
1334                                         ndr->relative_highest_offset = ndr->offset;
1335                                 }
1336                                 ndr->offset = _relative_save_offset;
1337                         }
1338                         ndr->flags = _flags_save_string;
1339                 }
1340                 {
1341                         uint32_t _flags_save_string = ndr->flags;
1342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1343                         if (r->hardware_id) {
1344                                 uint32_t _relative_save_offset;
1345                                 _relative_save_offset = ndr->offset;
1346                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1347                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1348                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1349                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1350                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1351                                 if (ndr->offset > ndr->relative_highest_offset) {
1352                                         ndr->relative_highest_offset = ndr->offset;
1353                                 }
1354                                 ndr->offset = _relative_save_offset;
1355                         }
1356                         ndr->flags = _flags_save_string;
1357                 }
1358                 {
1359                         uint32_t _flags_save_string = ndr->flags;
1360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1361                         if (r->provider) {
1362                                 uint32_t _relative_save_offset;
1363                                 _relative_save_offset = ndr->offset;
1364                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1365                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1366                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1367                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1368                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1369                                 if (ndr->offset > ndr->relative_highest_offset) {
1370                                         ndr->relative_highest_offset = ndr->offset;
1371                                 }
1372                                 ndr->offset = _relative_save_offset;
1373                         }
1374                         ndr->flags = _flags_save_string;
1375                 }
1376                 if (r->file_info) {
1377                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1378                 }
1379         }
1380         return NDR_ERR_SUCCESS;
1381 }
1382
1383 void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r)
1384 {
1385         int level;
1386         level = ndr_print_get_switch_value(ndr, r);
1387         ndr_print_union(ndr, name, level, "spoolss_Field");
1388         switch (level) {
1389                 case PRINTER_NOTIFY_TYPE:
1390                         ndr_print_spoolss_PrintNotifyField(ndr, "field", r->field);
1391                 break;
1392
1393                 case JOB_NOTIFY_TYPE:
1394                         ndr_print_spoolss_JobNotifyField(ndr, "field", r->field);
1395                 break;
1396
1397                 default:
1398                         ndr_print_uint16(ndr, "field", r->field);
1399                 break;
1400
1401         }
1402 }
1403
1404 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
1405 {
1406         if (!r) {
1407                 return 0;
1408         }
1409         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
1410 }
1411
1412 void ndr_print_spoolss_security_descriptor(struct ndr_print *ndr, const char *name, const struct security_descriptor *r)
1413 {
1414         ndr_print_security_descriptor(ndr, name, r);
1415 }
1416
1417 enum ndr_err_code ndr_pull_spoolss_security_descriptor(struct ndr_pull *ndr, int ndr_flags, struct security_descriptor *r)
1418 {
1419         uint32_t _flags_save_STRUCT = ndr->flags;
1420         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_NO_RELATIVE_REVERSE);
1421         NDR_CHECK(ndr_pull_security_descriptor(ndr, ndr_flags, r));
1422         ndr->flags = _flags_save_STRUCT;
1423         return NDR_ERR_SUCCESS;
1424 }
1425
1426 enum ndr_err_code ndr_push_spoolss_security_descriptor(struct ndr_push *ndr, int ndr_flags, const struct security_descriptor *r)
1427 {
1428         {
1429                 uint32_t _flags_save_STRUCT = ndr->flags;
1430                 ndr_set_flags(&ndr->flags, LIBNDR_FLAG_LITTLE_ENDIAN|LIBNDR_FLAG_NO_RELATIVE_REVERSE);
1431                 if (ndr_flags & NDR_SCALARS) {
1432                         NDR_CHECK(ndr_push_align(ndr, 5));
1433                         NDR_CHECK(ndr_push_security_descriptor_revision(ndr, NDR_SCALARS, r->revision));
1434                         NDR_CHECK(ndr_push_security_descriptor_type(ndr, NDR_SCALARS, r->type));
1435                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->owner_sid));
1436                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->group_sid));
1437                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sacl));
1438                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dacl));
1439                         NDR_CHECK(ndr_push_trailer_align(ndr, 5));
1440                 }
1441                 if (ndr_flags & NDR_BUFFERS) {
1442                         if (r->sacl) {
1443                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->sacl));
1444                                 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->sacl));
1445                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->sacl));
1446                         }
1447                         if (r->dacl) {
1448                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->dacl));
1449                                 NDR_CHECK(ndr_push_security_acl(ndr, NDR_SCALARS|NDR_BUFFERS, r->dacl));
1450                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->dacl));
1451                         }
1452                         if (r->owner_sid) {
1453                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->owner_sid));
1454                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->owner_sid));
1455                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->owner_sid));
1456                         }
1457                         if (r->group_sid) {
1458                                 NDR_CHECK(ndr_push_relative_ptr2_start(ndr, r->group_sid));
1459                                 NDR_CHECK(ndr_push_dom_sid(ndr, NDR_SCALARS, r->group_sid));
1460                                 NDR_CHECK(ndr_push_relative_ptr2_end(ndr, r->group_sid));
1461                         }
1462                 }
1463                 ndr->flags = _flags_save_STRUCT;
1464         }
1465         return NDR_ERR_SUCCESS;
1466 }