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