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