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