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 uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
 697 {
 698         if (!devmode) return 0;
 699         return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
 700 }
 701
 702 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
 703 {
 704         if (!r) {
 705                 return 4;
 706         }
 707
 708         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
 709 }
 710
 711 /* hand marshall as pidl cannot (yet) generate a relative pointer to a fixed array of
 712  * structs */
 713
 714 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo101(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo101 *r)
 715 {
 716         uint32_t cntr_file_info_1;
 717         if (ndr_flags & NDR_SCALARS) {
 718                 NDR_CHECK(ndr_push_align(ndr, 8));
 719                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
 720                 {
 721                         uint32_t _flags_save_string = ndr->flags;
 722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 723                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
 724                         ndr->flags = _flags_save_string;
 725                 }
 726                 {
 727                         uint32_t _flags_save_string = ndr->flags;
 728                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 729                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
 730                         ndr->flags = _flags_save_string;
 731                 }
 732                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_info));
 733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
 734                 {
 735                         uint32_t _flags_save_string = ndr->flags;
 736                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 737                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
 738                         ndr->flags = _flags_save_string;
 739                 }
 740                 {
 741                         uint32_t _flags_save_string = ndr->flags;
 742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 743                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
 744                         ndr->flags = _flags_save_string;
 745                 }
 746                 {
 747                         uint32_t _flags_save_string_array = ndr->flags;
 748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 749                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
 750                         ndr->flags = _flags_save_string_array;
 751                 }
 752                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
 753                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
 754                 {
 755                         uint32_t _flags_save_string = ndr->flags;
 756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 757                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
 758                         ndr->flags = _flags_save_string;
 759                 }
 760                 {
 761                         uint32_t _flags_save_string = ndr->flags;
 762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 763                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
 764                         ndr->flags = _flags_save_string;
 765                 }
 766                 {
 767                         uint32_t _flags_save_string = ndr->flags;
 768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
 776                         ndr->flags = _flags_save_string;
 777                 }
 778         }
 779         if (ndr_flags & NDR_BUFFERS) {
 780                 {
 781                         uint32_t _flags_save_string = ndr->flags;
 782                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 783                         if (r->driver_name) {
 784                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
 785                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
 786                         }
 787                         ndr->flags = _flags_save_string;
 788                 }
 789                 {
 790                         uint32_t _flags_save_string = ndr->flags;
 791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 792                         if (r->architecture) {
 793                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
 794                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
 795                         }
 796                         ndr->flags = _flags_save_string;
 797                 }
 798                 if (r->file_info) {
 799                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_info));
 800 #if 0
 801                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
 802 #endif
 803                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
 804                                 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
 805                         }
 806                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
 807                                 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
 808                         }
 809                 }
 810                 {
 811                         uint32_t _flags_save_string = ndr->flags;
 812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 813                         if (r->monitor_name) {
 814                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
 815                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
 816                         }
 817                         ndr->flags = _flags_save_string;
 818                 }
 819                 {
 820                         uint32_t _flags_save_string = ndr->flags;
 821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 822                         if (r->default_datatype) {
 823                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
 824                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
 825                         }
 826                         ndr->flags = _flags_save_string;
 827                 }
 828                 {
 829                         uint32_t _flags_save_string_array = ndr->flags;
 830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 831                         if (r->previous_names) {
 832                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
 833                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
 834                         }
 835                         ndr->flags = _flags_save_string_array;
 836                 }
 837                 {
 838                         uint32_t _flags_save_string = ndr->flags;
 839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 840                         if (r->manufacturer_name) {
 841                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
 842                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
 843                         }
 844                         ndr->flags = _flags_save_string;
 845                 }
 846                 {
 847                         uint32_t _flags_save_string = ndr->flags;
 848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 849                         if (r->manufacturer_url) {
 850                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
 851                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
 852                         }
 853                         ndr->flags = _flags_save_string;
 854                 }
 855                 {
 856                         uint32_t _flags_save_string = ndr->flags;
 857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 858                         if (r->hardware_id) {
 859                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
 860                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
 861                         }
 862                         ndr->flags = _flags_save_string;
 863                 }
 864                 {
 865                         uint32_t _flags_save_string = ndr->flags;
 866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 867                         if (r->provider) {
 868                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
 869                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
 870                         }
 871                         ndr->flags = _flags_save_string;
 872                 }
 873         }
 874         return NDR_ERR_SUCCESS;
 875 }
 876
 877 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r)
 878 {
 879         uint32_t _ptr_driver_name;
 880         TALLOC_CTX *_mem_save_driver_name_0;
 881         uint32_t _ptr_architecture;
 882         TALLOC_CTX *_mem_save_architecture_0;
 883         uint32_t _ptr_file_info;
 884         uint32_t cntr_file_info_1;
 885         TALLOC_CTX *_mem_save_file_info_0;
 886         TALLOC_CTX *_mem_save_file_info_1;
 887         uint32_t _ptr_monitor_name;
 888         TALLOC_CTX *_mem_save_monitor_name_0;
 889         uint32_t _ptr_default_datatype;
 890         TALLOC_CTX *_mem_save_default_datatype_0;
 891         uint32_t _ptr_previous_names;
 892         TALLOC_CTX *_mem_save_previous_names_0;
 893         uint32_t _ptr_manufacturer_name;
 894         TALLOC_CTX *_mem_save_manufacturer_name_0;
 895         uint32_t _ptr_manufacturer_url;
 896         TALLOC_CTX *_mem_save_manufacturer_url_0;
 897         uint32_t _ptr_hardware_id;
 898         TALLOC_CTX *_mem_save_hardware_id_0;
 899         uint32_t _ptr_provider;
 900         TALLOC_CTX *_mem_save_provider_0;
 901         if (ndr_flags & NDR_SCALARS) {
 902                 NDR_CHECK(ndr_pull_align(ndr, 8));
 903                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
 904                 {
 905                         uint32_t _flags_save_string = ndr->flags;
 906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
 908                         if (_ptr_driver_name) {
 909                                 NDR_PULL_ALLOC(ndr, r->driver_name);
 910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
 911                         } else {
 912                                 r->driver_name = NULL;
 913                         }
 914                         ndr->flags = _flags_save_string;
 915                 }
 916                 {
 917                         uint32_t _flags_save_string = ndr->flags;
 918                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 919                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
 920                         if (_ptr_architecture) {
 921                                 NDR_PULL_ALLOC(ndr, r->architecture);
 922                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
 923                         } else {
 924                                 r->architecture = NULL;
 925                         }
 926                         ndr->flags = _flags_save_string;
 927                 }
 928                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_info));
 929                 if (_ptr_file_info) {
 930                         NDR_PULL_ALLOC(ndr, r->file_info);
 931                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_info, _ptr_file_info));
 932                 } else {
 933                         r->file_info = NULL;
 934                 }
 935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_count));
 936                 {
 937                         uint32_t _flags_save_string = ndr->flags;
 938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 939                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
 940                         if (_ptr_monitor_name) {
 941                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
 942                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
 943                         } else {
 944                                 r->monitor_name = NULL;
 945                         }
 946                         ndr->flags = _flags_save_string;
 947                 }
 948                 {
 949                         uint32_t _flags_save_string = ndr->flags;
 950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 951                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
 952                         if (_ptr_default_datatype) {
 953                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
 954                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
 955                         } else {
 956                                 r->default_datatype = NULL;
 957                         }
 958                         ndr->flags = _flags_save_string;
 959                 }
 960                 {
 961                         uint32_t _flags_save_string_array = ndr->flags;
 962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 963                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
 964                         if (_ptr_previous_names) {
 965                                 NDR_PULL_ALLOC(ndr, r->previous_names);
 966                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
 967                         } else {
 968                                 r->previous_names = NULL;
 969                         }
 970                         ndr->flags = _flags_save_string_array;
 971                 }
 972                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
 973                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
 974                 {
 975                         uint32_t _flags_save_string = ndr->flags;
 976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 977                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
 978                         if (_ptr_manufacturer_name) {
 979                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
 980                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
 981                         } else {
 982                                 r->manufacturer_name = NULL;
 983                         }
 984                         ndr->flags = _flags_save_string;
 985                 }
 986                 {
 987                         uint32_t _flags_save_string = ndr->flags;
 988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 989                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
 990                         if (_ptr_manufacturer_url) {
 991                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
 992                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
 993                         } else {
 994                                 r->manufacturer_url = NULL;
 995                         }
 996                         ndr->flags = _flags_save_string;
 997                 }
 998                 {
 999                         uint32_t _flags_save_string = ndr->flags;
1000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1001                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
1002                         if (_ptr_hardware_id) {
1003                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
1004                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
1005                         } else {
1006                                 r->hardware_id = NULL;
1007                         }
1008                         ndr->flags = _flags_save_string;
1009                 }
1010                 {
1011                         uint32_t _flags_save_string = ndr->flags;
1012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1013                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
1014                         if (_ptr_provider) {
1015                                 NDR_PULL_ALLOC(ndr, r->provider);
1016                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
1017                         } else {
1018                                 r->provider = NULL;
1019                         }
1020                         ndr->flags = _flags_save_string;
1021                 }
1022         }
1023         if (ndr_flags & NDR_BUFFERS) {
1024                 {
1025                         uint32_t _flags_save_string = ndr->flags;
1026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1027                         if (r->driver_name) {
1028                                 uint32_t _relative_save_offset;
1029                                 _relative_save_offset = ndr->offset;
1030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
1031                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1032                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
1033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
1034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
1035                                 ndr->offset = _relative_save_offset;
1036                         }
1037                         ndr->flags = _flags_save_string;
1038                 }
1039                 {
1040                         uint32_t _flags_save_string = ndr->flags;
1041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1042                         if (r->architecture) {
1043                                 uint32_t _relative_save_offset;
1044                                 _relative_save_offset = ndr->offset;
1045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
1046                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
1047                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
1048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
1049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
1050                                 ndr->offset = _relative_save_offset;
1051                         }
1052                         ndr->flags = _flags_save_string;
1053                 }
1054                 if (r->file_info) {
1055                         uint32_t _relative_save_offset;
1056                         _relative_save_offset = ndr->offset;
1057                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
1058                         _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1059                         NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1060 #if 0
1061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
1062 #else
1063                         NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
1064 #endif
1065                         NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
1066                         _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1067                         NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1068                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1069                                 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
1070                         }
1071                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1072                                 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
1073                         }
1074                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
1075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
1076                         ndr->offset = _relative_save_offset;
1077                 }
1078                 {
1079                         uint32_t _flags_save_string = ndr->flags;
1080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1081                         if (r->monitor_name) {
1082                                 uint32_t _relative_save_offset;
1083                                 _relative_save_offset = ndr->offset;
1084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
1085                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1086                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
1087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
1088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
1089                                 ndr->offset = _relative_save_offset;
1090                         }
1091                         ndr->flags = _flags_save_string;
1092                 }
1093                 {
1094                         uint32_t _flags_save_string = ndr->flags;
1095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1096                         if (r->default_datatype) {
1097                                 uint32_t _relative_save_offset;
1098                                 _relative_save_offset = ndr->offset;
1099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
1100                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1101                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
1102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
1103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
1104                                 ndr->offset = _relative_save_offset;
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                         if (r->previous_names) {
1112                                 uint32_t _relative_save_offset;
1113                                 _relative_save_offset = ndr->offset;
1114                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
1115                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1116                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
1117                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
1118                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
1119                                 ndr->offset = _relative_save_offset;
1120                         }
1121                         ndr->flags = _flags_save_string_array;
1122                 }
1123                 {
1124                         uint32_t _flags_save_string = ndr->flags;
1125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1126                         if (r->manufacturer_name) {
1127                                 uint32_t _relative_save_offset;
1128                                 _relative_save_offset = ndr->offset;
1129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1130                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1131                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1134                                 ndr->offset = _relative_save_offset;
1135                         }
1136                         ndr->flags = _flags_save_string;
1137                 }
1138                 {
1139                         uint32_t _flags_save_string = ndr->flags;
1140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1141                         if (r->manufacturer_url) {
1142                                 uint32_t _relative_save_offset;
1143                                 _relative_save_offset = ndr->offset;
1144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1145                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1146                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1147                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1149                                 ndr->offset = _relative_save_offset;
1150                         }
1151                         ndr->flags = _flags_save_string;
1152                 }
1153                 {
1154                         uint32_t _flags_save_string = ndr->flags;
1155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1156                         if (r->hardware_id) {
1157                                 uint32_t _relative_save_offset;
1158                                 _relative_save_offset = ndr->offset;
1159                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1160                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1161                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1162                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1163                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1164                                 ndr->offset = _relative_save_offset;
1165                         }
1166                         ndr->flags = _flags_save_string;
1167                 }
1168                 {
1169                         uint32_t _flags_save_string = ndr->flags;
1170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1171                         if (r->provider) {
1172                                 uint32_t _relative_save_offset;
1173                                 _relative_save_offset = ndr->offset;
1174                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1175                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1176                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1177                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1178                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1179                                 ndr->offset = _relative_save_offset;
1180                         }
1181                         ndr->flags = _flags_save_string;
1182                 }
1183                 if (r->file_info) {
1184                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1185                 }
1186         }
1187         return NDR_ERR_SUCCESS;
1188 }
1189
1190 void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, const union spoolss_Field *r)
1191 {
1192         int level;
1193         level = ndr_print_get_switch_value(ndr, r);
1194         ndr_print_union(ndr, name, level, "spoolss_Field");
1195         switch (level) {
1196                 case PRINTER_NOTIFY_TYPE:
1197                         ndr_print_spoolss_PrintNotifyField(ndr, "field", r->field);
1198                 break;
1199
1200                 case JOB_NOTIFY_TYPE:
1201                         ndr_print_spoolss_JobNotifyField(ndr, "field", r->field);
1202                 break;
1203
1204                 default:
1205                         ndr_print_uint16(ndr, "field", r->field);
1206                 break;
1207
1208         }
1209 }
1210