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(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 /*
 191   spoolss_EnumPrinters
 192 */
 193 enum ndr_err_code ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinters *r)
 194 {
 195         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
 196                 _r.in.flags     = r->in.flags;
 197                 _r.in.server    = r->in.server;
 198         },{
 199                 _r.in.flags     = r->in.flags;
 200                 _r.in.server    = r->in.server;
 201         });
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 enum ndr_err_code ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
 206 {
 207         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
 208                 r->in.flags     = _r.in.flags;
 209                 r->in.server    = _r.in.server;
 210         },{
 211                 _r.in.flags     = r->in.flags;
 212                 _r.in.server    = r->in.server;
 213         });
 214         return NDR_ERR_SUCCESS;
 215 }
 216
 217 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)
 218 {
 219         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinters);
 220 }
 221
 222 /*
 223   spoolss_EnumJobs
 224 */
 225 enum ndr_err_code ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct spoolss_EnumJobs *r)
 226 {
 227         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
 228                 _r.in.handle    = r->in.handle;
 229                 _r.in.firstjob  = r->in.firstjob;
 230                 _r.in.numjobs   = r->in.numjobs;
 231         },{
 232                 _r.in.handle    = r->in.handle;
 233                 _r.in.firstjob  = r->in.firstjob;
 234                 _r.in.numjobs   = r->in.numjobs;
 235         });
 236         return NDR_ERR_SUCCESS;
 237 }
 238
 239 enum ndr_err_code ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
 240 {
 241         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
 242                 r->in.handle    = _r.in.handle;
 243                 r->in.firstjob  = _r.in.firstjob;
 244                 r->in.numjobs   = _r.in.numjobs;
 245         },{
 246                 _r.in.handle    = r->in.handle;
 247                 _r.in.firstjob  = r->in.firstjob;
 248                 _r.in.numjobs   = r->in.numjobs;
 249         });
 250         return NDR_ERR_SUCCESS;
 251 }
 252
 253 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)
 254 {
 255         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumJobs);
 256 }
 257
 258 /*
 259   spoolss_EnumPrinterDrivers
 260 */
 261 enum ndr_err_code ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDrivers *r)
 262 {
 263         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
 264                 _r.in.server            = r->in.server;
 265                 _r.in.environment       = r->in.environment;
 266         },{
 267                 _r.in.server            = r->in.server;
 268                 _r.in.environment       = r->in.environment;
 269         });
 270         return NDR_ERR_SUCCESS;
 271 }
 272
 273 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 274 {
 275         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
 276                 r->in.server            = _r.in.server;
 277                 r->in.environment       = _r.in.environment;
 278         },{
 279                 _r.in.server            = r->in.server;
 280                 _r.in.environment       = r->in.environment;
 281         });
 282         return NDR_ERR_SUCCESS;
 283 }
 284
 285 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)
 286 {
 287         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDrivers);
 288 }
 289
 290 /*
 291   spoolss_EnumForms
 292 */
 293 enum ndr_err_code ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct spoolss_EnumForms *r)
 294 {
 295         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
 296                 _r.in.handle    = r->in.handle;
 297         },{
 298                 _r.in.handle    = r->in.handle;
 299         });
 300         return NDR_ERR_SUCCESS;
 301 }
 302
 303 enum ndr_err_code ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
 304 {
 305         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
 306                 r->in.handle    = _r.in.handle;
 307         },{
 308                 _r.in.handle    = r->in.handle;
 309         });
 310         return NDR_ERR_SUCCESS;
 311 }
 312
 313 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)
 314 {
 315         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumForms);
 316 }
 317
 318 /*
 319   spoolss_EnumPorts
 320 */
 321 enum ndr_err_code ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct spoolss_EnumPorts *r)
 322 {
 323         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
 324                 _r.in.servername= r->in.servername;
 325         },{
 326                 _r.in.servername= r->in.servername;
 327         });
 328         return NDR_ERR_SUCCESS;
 329 }
 330
 331 enum ndr_err_code ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
 332 {
 333         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
 334                 r->in.servername= _r.in.servername;
 335         },{
 336                 _r.in.servername= r->in.servername;
 337         });
 338         return NDR_ERR_SUCCESS;
 339 }
 340
 341 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)
 342 {
 343         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPorts);
 344 }
 345
 346 /*
 347   spoolss_EnumMonitors
 348 */
 349 enum ndr_err_code ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct spoolss_EnumMonitors *r)
 350 {
 351         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
 352                 _r.in.servername= r->in.servername;
 353         },{
 354                 _r.in.servername= r->in.servername;
 355         });
 356         return NDR_ERR_SUCCESS;
 357 }
 358
 359 enum ndr_err_code ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
 360 {
 361         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
 362                 r->in.servername= _r.in.servername;
 363         },{
 364                 _r.in.servername= r->in.servername;
 365         });
 366         return NDR_ERR_SUCCESS;
 367 }
 368
 369 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)
 370 {
 371         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumMonitors);
 372 }
 373
 374 /*
 375   spoolss_EnumPrintProcessors
 376 */
 377 enum ndr_err_code ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcessors *r)
 378 {
 379         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
 380                 _r.in.servername        = r->in.servername;
 381                 _r.in.environment       = r->in.environment;
 382         },{
 383                 _r.in.servername        = r->in.servername;
 384                 _r.in.environment       = r->in.environment;
 385         });
 386         return NDR_ERR_SUCCESS;
 387 }
 388
 389 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 390 {
 391         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
 392                 r->in.servername        = _r.in.servername;
 393                 r->in.environment       = _r.in.environment;
 394         },{
 395                 _r.in.servername        = r->in.servername;
 396                 _r.in.environment       = r->in.environment;
 397         });
 398         return NDR_ERR_SUCCESS;
 399 }
 400
 401 uint32_t ndr_size_spoolss_EnumPrintProcessors_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
 402                                                    uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
 403 {
 404         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrintProcessors);
 405 }
 406
 407 /*
 408   spoolss_EnumPrintProcessors
 409 */
 410 enum ndr_err_code ndr_push_spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
 411 {
 412         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcDataTypes,{
 413                 _r.in.servername                = r->in.servername;
 414                 _r.in.print_processor_name      = r->in.print_processor_name;
 415         },{
 416                 _r.in.servername                = r->in.servername;
 417                 _r.in.print_processor_name      = r->in.print_processor_name;
 418         });
 419         return NDR_ERR_SUCCESS;
 420 }
 421
 422 enum ndr_err_code ndr_pull_spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcDataTypes *r)
 423 {
 424         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcDataTypes,{
 425                 r->in.servername                = _r.in.servername;
 426                 r->in.print_processor_name      = _r.in.print_processor_name;
 427         },{
 428                 _r.in.servername                = r->in.servername;
 429                 _r.in.print_processor_name      = r->in.print_processor_name;
 430         });
 431         return NDR_ERR_SUCCESS;
 432 }
 433
 434 uint32_t ndr_size_spoolss_EnumPrintProcDataTypes_info(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience,
 435                                                       uint32_t level, uint32_t count, union spoolss_PrintProcDataTypesInfo *info)
 436 {
 437         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrintProcDataTypes);
 438 }
 439
 440 /*
 441   spoolss_EnumPrinterDataEx
 442 */
 443
 444 enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
 445 {
 446         struct _spoolss_EnumPrinterDataEx _r;
 447         if (flags & NDR_IN) {
 448                 _r.in.handle    = r->in.handle;
 449                 _r.in.key_name  = r->in.key_name;
 450                 _r.in.offered   = r->in.offered;
 451                 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 452         }
 453         if (flags & NDR_OUT) {
 454                 struct ndr_push *_ndr_info;
 455                 _r.in.handle    = r->in.handle;
 456                 _r.in.key_name  = r->in.key_name;
 457                 _r.in.offered   = r->in.offered;
 458                 _r.out.count    = r->out.count;
 459                 _r.out.needed   = r->out.needed;
 460                 _r.out.result   = r->out.result;
 461                 _r.out.info     = data_blob(NULL, 0);
 462                 if (r->in.offered >= *r->out.needed) {
 463                         struct __spoolss_EnumPrinterDataEx __r;
 464                         _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 465                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 466                         _ndr_info->flags= ndr->flags;
 467                         __r.in.count    = *r->out.count;
 468                         __r.out.info    = *r->out.info;
 469                         NDR_CHECK(ndr_push___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
 470                         if (r->in.offered > _ndr_info->offset) {
 471                                 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
 472                                 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
 473                         }
 474                         _r.out.info = ndr_push_blob(_ndr_info);
 475                 }
 476                 NDR_CHECK(ndr_push__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 477         }
 478         return NDR_ERR_SUCCESS;
 479 }
 480
 481 enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
 482 {
 483         struct _spoolss_EnumPrinterDataEx _r;
 484         if (flags & NDR_IN) {
 485                 _r.in.handle    = r->in.handle;
 486                 _r.in.key_name  = r->in.key_name;
 487                 ZERO_STRUCT(r->out);
 488                 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 489                 r->in.handle    = _r.in.handle;
 490                 r->in.key_name  = _r.in.key_name;
 491                 r->in.offered   = _r.in.offered;
 492                 r->out.needed   = _r.out.needed;
 493                 r->out.count    = _r.out.count;
 494                 NDR_PULL_ALLOC(ndr, r->out.info);
 495                 ZERO_STRUCTP(r->out.info);
 496         }
 497         if (flags & NDR_OUT) {
 498                 _r.in.handle    = r->in.handle;
 499                 _r.in.key_name  = r->in.key_name;
 500                 _r.in.offered   = r->in.offered;
 501                 _r.out.count    = r->out.count;
 502                 _r.out.needed   = r->out.needed;
 503                 NDR_CHECK(ndr_pull__spoolss_EnumPrinterDataEx(ndr, flags, &_r));
 504                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 505                         NDR_PULL_ALLOC(ndr, r->out.info);
 506                 }
 507                 *r->out.info    = NULL;
 508                 r->out.needed   = _r.out.needed;
 509                 r->out.count    = _r.out.count;
 510                 r->out.result   = _r.out.result;
 511                 if (_r.out.info.length) {
 512                         struct ndr_pull *_ndr_info;
 513                         NDR_PULL_ALLOC(ndr, *r->out.info);
 514                         _ndr_info = ndr_pull_init_blob(&_r.out.info, *r->out.info, ndr->iconv_convenience);
 515                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 516                         _ndr_info->flags= ndr->flags;
 517                         if (r->in.offered != _ndr_info->data_size) {
 518                                 return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
 519                                         "SPOOLSS Buffer: offered[%u] doesn't match length of buffer[%u]",
 520                                         (unsigned)r->in.offered, (unsigned)_ndr_info->data_size);
 521                         }
 522                         if (*r->out.needed <= _ndr_info->data_size) {
 523                                 struct __spoolss_EnumPrinterDataEx __r;
 524                                 __r.in.count    = *r->out.count;
 525                                 __r.out.info    = NULL;
 526                                 NDR_CHECK(ndr_pull___spoolss_EnumPrinterDataEx(_ndr_info, flags, &__r));
 527                                 *r->out.info    = __r.out.info;
 528                         }
 529                 }
 530         }
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 /*
 535   spoolss_GetPrinterData
 536 */
 537 enum ndr_err_code ndr_push_spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterData *r)
 538 {
 539         struct _spoolss_GetPrinterData _r;
 540         if (flags & NDR_IN) {
 541                 _r.in.handle    = r->in.handle;
 542                 _r.in.value_name= r->in.value_name;
 543                 _r.in.offered   = r->in.offered;
 544                 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
 545         }
 546         if (flags & NDR_OUT) {
 547                 struct ndr_push *_ndr_info;
 548                 DATA_BLOB blob = data_blob(NULL, 0);
 549                 _r.in.handle    = r->in.handle;
 550                 _r.in.value_name= r->in.value_name;
 551                 _r.in.offered   = r->in.offered;
 552                 _r.out.type     = r->out.type;
 553                 _r.out.data     = &blob;
 554                 _r.out.needed   = r->out.needed;
 555                 _r.out.result   = r->out.result;
 556                 {
 557                         struct __spoolss_GetPrinterData __r;
 558                         DATA_BLOB _blob;
 559                         _ndr_info = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 560                         NDR_ERR_HAVE_NO_MEMORY(_ndr_info);
 561                         _ndr_info->flags= ndr->flags;
 562                         __r.in.type     = *r->out.type;
 563                         __r.out.data    = r->out.data;
 564                         NDR_CHECK(ndr_push___spoolss_GetPrinterData(_ndr_info, flags, &__r));
 565                         if (r->in.offered > _ndr_info->offset) {
 566                                 uint32_t _padding_len = r->in.offered - _ndr_info->offset;
 567                                 NDR_CHECK(ndr_push_zero(_ndr_info, _padding_len));
 568                         }
 569                         _blob = ndr_push_blob(_ndr_info);
 570                         _r.out.data = &_blob;
 571                 }
 572                 NDR_CHECK(ndr_push__spoolss_GetPrinterData(ndr, flags, &_r));
 573         }
 574         return NDR_ERR_SUCCESS;
 575 }
 576
 577 enum ndr_err_code ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
 578 {
 579         struct _spoolss_GetPrinterData _r;
 580         if (flags & NDR_IN) {
 581                 DATA_BLOB blob = data_blob(NULL,0);
 582                 ZERO_STRUCT(r->out);
 583
 584                 _r.in.handle    = r->in.handle;
 585                 _r.in.value_name= r->in.value_name;
 586                 _r.in.offered   = r->in.offered;
 587                 _r.out.type     = r->out.type;
 588                 _r.out.data     = &blob;
 589                 _r.out.needed   = r->out.needed;
 590                 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
 591                 r->in.handle    = _r.in.handle;
 592                 r->in.value_name= _r.in.value_name;
 593                 r->in.offered   = _r.in.offered;
 594                 r->out.needed   = _r.out.needed;
 595         }
 596         if (flags & NDR_OUT) {
 597                 DATA_BLOB blob = data_blob_talloc(ndr,NULL,0);
 598                 _r.in.handle    = r->in.handle;
 599                 _r.in.value_name= r->in.value_name;
 600                 _r.in.offered   = r->in.offered;
 601                 _r.out.type     = r->out.type;
 602                 _r.out.data     = &blob;
 603                 _r.out.needed   = r->out.needed;
 604                 _r.out.result   = r->out.result;
 605                 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
 606                 r->out.type     = _r.out.type;
 607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
 608                         NDR_PULL_ALLOC(ndr, r->out.data);
 609                 }
 610                 ZERO_STRUCTP(r->out.data);
 611                 r->out.needed   = _r.out.needed;
 612                 r->out.result   = _r.out.result;
 613                 if (_r.out.data && _r.out.data->length != r->in.offered) {
 614                         return ndr_pull_error(ndr, NDR_ERR_BUFSIZE,
 615                                 "SPOOLSS Buffer: r->in.offered[%u] doesn't match length of out buffer[%u]",
 616                                 (unsigned)r->in.offered, (unsigned)_r.out.data->length);
 617                 }
 618                 if (_r.out.data && _r.out.data->length > 0 && *r->out.needed <= _r.out.data->length) {
 619                         struct __spoolss_GetPrinterData __r;
 620                         struct ndr_pull *_ndr_data = ndr_pull_init_blob(_r.out.data, ndr, ndr->iconv_convenience);
 621                         NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
 622                         _ndr_data->flags= ndr->flags;
 623                         __r.in.type     = *r->out.type;
 624                         __r.out.data    = r->out.data;
 625                         NDR_CHECK(ndr_pull___spoolss_GetPrinterData(_ndr_data, flags, &__r));
 626                         r->out.data     = __r.out.data;
 627                 } else {
 628                         *r->out.type    = REG_NONE;
 629                 }
 630         }
 631         return NDR_ERR_SUCCESS;
 632 }
 633
 634 /*
 635   spoolss_SetPrinterData
 636 */
 637 enum ndr_err_code ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterData *r)
 638 {
 639         struct _spoolss_SetPrinterData _r;
 640         if (flags & NDR_IN) {
 641                 struct ndr_push *_ndr_data;
 642                 struct __spoolss_SetPrinterData __r;
 643                 DATA_BLOB _data_blob_data;
 644
 645                 _ndr_data = ndr_push_init_ctx(ndr, ndr->iconv_convenience);
 646                 NDR_ERR_HAVE_NO_MEMORY(_ndr_data);
 647                 _ndr_data->flags= ndr->flags;
 648
 649                 __r.in.type     = r->in.type;
 650                 __r.out.data    = discard_const_p(union spoolss_PrinterData, &r->in.data);
 651                 NDR_CHECK(ndr_push___spoolss_SetPrinterData(_ndr_data, NDR_OUT, &__r));
 652                 _data_blob_data = ndr_push_blob(_ndr_data);
 653
 654                 _r.in.handle    = r->in.handle;
 655                 _r.in.value_name= r->in.value_name;
 656                 _r.in.type      = r->in.type;
 657                 _r.in.data      = _data_blob_data;
 658                 _r.in._offered  = _data_blob_data.length;
 659                 _r.out.result   = r->out.result;
 660                 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
 661         }
 662         if (flags & NDR_OUT) {
 663                 _r.in.handle    = r->in.handle;
 664                 _r.in.value_name= r->in.value_name;
 665                 _r.in.type      = r->in.type;
 666                 _r.in.data      = data_blob(NULL,0),
 667                 _r.in._offered  = r->in._offered;
 668                 _r.out.result   = r->out.result;
 669                 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
 670         }
 671         return NDR_ERR_SUCCESS;
 672 }
 673
 674 uint32_t _ndr_size_spoolss_DeviceMode(struct spoolss_DeviceMode *devmode, struct smb_iconv_convenience *ic, uint32_t flags)
 675 {
 676         if (!devmode) return 0;
 677         return ndr_size_spoolss_DeviceMode(devmode,ic,flags);
 678 }
 679
 680 _PUBLIC_ size_t ndr_size_spoolss_StringArray(const struct spoolss_StringArray *r, struct smb_iconv_convenience *ic, int flags)
 681 {
 682         if (!r) {
 683                 return 4;
 684         }
 685
 686         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_StringArray, ic);
 687 }
 688
 689 /* hand marshall as pidl cannot (yet) generate a relative pointer to a fixed array of
 690  * structs */
 691
 692 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo101(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo101 *r)
 693 {
 694         uint32_t cntr_file_info_1;
 695         if (ndr_flags & NDR_SCALARS) {
 696                 NDR_CHECK(ndr_push_align(ndr, 8));
 697                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
 698                 {
 699                         uint32_t _flags_save_string = ndr->flags;
 700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 701                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
 702                         ndr->flags = _flags_save_string;
 703                 }
 704                 {
 705                         uint32_t _flags_save_string = ndr->flags;
 706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 707                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
 708                         ndr->flags = _flags_save_string;
 709                 }
 710                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_info));
 711                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
 712                 {
 713                         uint32_t _flags_save_string = ndr->flags;
 714                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 715                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
 716                         ndr->flags = _flags_save_string;
 717                 }
 718                 {
 719                         uint32_t _flags_save_string = ndr->flags;
 720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 721                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
 722                         ndr->flags = _flags_save_string;
 723                 }
 724                 {
 725                         uint32_t _flags_save_string_array = ndr->flags;
 726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 727                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
 728                         ndr->flags = _flags_save_string_array;
 729                 }
 730                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
 731                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
 732                 {
 733                         uint32_t _flags_save_string = ndr->flags;
 734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 735                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
 736                         ndr->flags = _flags_save_string;
 737                 }
 738                 {
 739                         uint32_t _flags_save_string = ndr->flags;
 740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 741                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
 742                         ndr->flags = _flags_save_string;
 743                 }
 744                 {
 745                         uint32_t _flags_save_string = ndr->flags;
 746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 747                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
 748                         ndr->flags = _flags_save_string;
 749                 }
 750                 {
 751                         uint32_t _flags_save_string = ndr->flags;
 752                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 753                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
 754                         ndr->flags = _flags_save_string;
 755                 }
 756         }
 757         if (ndr_flags & NDR_BUFFERS) {
 758                 {
 759                         uint32_t _flags_save_string = ndr->flags;
 760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 761                         if (r->driver_name) {
 762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
 763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
 764                         }
 765                         ndr->flags = _flags_save_string;
 766                 }
 767                 {
 768                         uint32_t _flags_save_string = ndr->flags;
 769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 770                         if (r->architecture) {
 771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
 772                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
 773                         }
 774                         ndr->flags = _flags_save_string;
 775                 }
 776                 if (r->file_info) {
 777                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_info));
 778 #if 0
 779                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_count));
 780 #endif
 781                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
 782                                 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
 783                         }
 784                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
 785                                 NDR_CHECK(ndr_push_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
 786                         }
 787                 }
 788                 {
 789                         uint32_t _flags_save_string = ndr->flags;
 790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 791                         if (r->monitor_name) {
 792                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
 793                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
 794                         }
 795                         ndr->flags = _flags_save_string;
 796                 }
 797                 {
 798                         uint32_t _flags_save_string = ndr->flags;
 799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 800                         if (r->default_datatype) {
 801                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
 802                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
 803                         }
 804                         ndr->flags = _flags_save_string;
 805                 }
 806                 {
 807                         uint32_t _flags_save_string_array = ndr->flags;
 808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 809                         if (r->previous_names) {
 810                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
 811                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
 812                         }
 813                         ndr->flags = _flags_save_string_array;
 814                 }
 815                 {
 816                         uint32_t _flags_save_string = ndr->flags;
 817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 818                         if (r->manufacturer_name) {
 819                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
 820                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
 821                         }
 822                         ndr->flags = _flags_save_string;
 823                 }
 824                 {
 825                         uint32_t _flags_save_string = ndr->flags;
 826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 827                         if (r->manufacturer_url) {
 828                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
 829                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
 830                         }
 831                         ndr->flags = _flags_save_string;
 832                 }
 833                 {
 834                         uint32_t _flags_save_string = ndr->flags;
 835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 836                         if (r->hardware_id) {
 837                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
 838                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
 839                         }
 840                         ndr->flags = _flags_save_string;
 841                 }
 842                 {
 843                         uint32_t _flags_save_string = ndr->flags;
 844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 845                         if (r->provider) {
 846                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
 847                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
 848                         }
 849                         ndr->flags = _flags_save_string;
 850                 }
 851         }
 852         return NDR_ERR_SUCCESS;
 853 }
 854
 855 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo101(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo101 *r)
 856 {
 857         uint32_t _ptr_driver_name;
 858         TALLOC_CTX *_mem_save_driver_name_0;
 859         uint32_t _ptr_architecture;
 860         TALLOC_CTX *_mem_save_architecture_0;
 861         uint32_t _ptr_file_info;
 862         uint32_t cntr_file_info_1;
 863         TALLOC_CTX *_mem_save_file_info_0;
 864         TALLOC_CTX *_mem_save_file_info_1;
 865         uint32_t _ptr_monitor_name;
 866         TALLOC_CTX *_mem_save_monitor_name_0;
 867         uint32_t _ptr_default_datatype;
 868         TALLOC_CTX *_mem_save_default_datatype_0;
 869         uint32_t _ptr_previous_names;
 870         TALLOC_CTX *_mem_save_previous_names_0;
 871         uint32_t _ptr_manufacturer_name;
 872         TALLOC_CTX *_mem_save_manufacturer_name_0;
 873         uint32_t _ptr_manufacturer_url;
 874         TALLOC_CTX *_mem_save_manufacturer_url_0;
 875         uint32_t _ptr_hardware_id;
 876         TALLOC_CTX *_mem_save_hardware_id_0;
 877         uint32_t _ptr_provider;
 878         TALLOC_CTX *_mem_save_provider_0;
 879         if (ndr_flags & NDR_SCALARS) {
 880                 NDR_CHECK(ndr_pull_align(ndr, 8));
 881                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
 882                 {
 883                         uint32_t _flags_save_string = ndr->flags;
 884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 885                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
 886                         if (_ptr_driver_name) {
 887                                 NDR_PULL_ALLOC(ndr, r->driver_name);
 888                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
 889                         } else {
 890                                 r->driver_name = NULL;
 891                         }
 892                         ndr->flags = _flags_save_string;
 893                 }
 894                 {
 895                         uint32_t _flags_save_string = ndr->flags;
 896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 897                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
 898                         if (_ptr_architecture) {
 899                                 NDR_PULL_ALLOC(ndr, r->architecture);
 900                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
 901                         } else {
 902                                 r->architecture = NULL;
 903                         }
 904                         ndr->flags = _flags_save_string;
 905                 }
 906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_info));
 907                 if (_ptr_file_info) {
 908                         NDR_PULL_ALLOC(ndr, r->file_info);
 909                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_info, _ptr_file_info));
 910                 } else {
 911                         r->file_info = NULL;
 912                 }
 913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_count));
 914                 {
 915                         uint32_t _flags_save_string = ndr->flags;
 916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 917                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
 918                         if (_ptr_monitor_name) {
 919                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
 920                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
 921                         } else {
 922                                 r->monitor_name = NULL;
 923                         }
 924                         ndr->flags = _flags_save_string;
 925                 }
 926                 {
 927                         uint32_t _flags_save_string = ndr->flags;
 928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 929                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
 930                         if (_ptr_default_datatype) {
 931                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
 932                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
 933                         } else {
 934                                 r->default_datatype = NULL;
 935                         }
 936                         ndr->flags = _flags_save_string;
 937                 }
 938                 {
 939                         uint32_t _flags_save_string_array = ndr->flags;
 940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 941                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
 942                         if (_ptr_previous_names) {
 943                                 NDR_PULL_ALLOC(ndr, r->previous_names);
 944                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
 945                         } else {
 946                                 r->previous_names = NULL;
 947                         }
 948                         ndr->flags = _flags_save_string_array;
 949                 }
 950                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
 951                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
 952                 {
 953                         uint32_t _flags_save_string = ndr->flags;
 954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 955                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
 956                         if (_ptr_manufacturer_name) {
 957                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
 958                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
 959                         } else {
 960                                 r->manufacturer_name = NULL;
 961                         }
 962                         ndr->flags = _flags_save_string;
 963                 }
 964                 {
 965                         uint32_t _flags_save_string = ndr->flags;
 966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 967                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
 968                         if (_ptr_manufacturer_url) {
 969                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
 970                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
 971                         } else {
 972                                 r->manufacturer_url = NULL;
 973                         }
 974                         ndr->flags = _flags_save_string;
 975                 }
 976                 {
 977                         uint32_t _flags_save_string = ndr->flags;
 978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 979                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
 980                         if (_ptr_hardware_id) {
 981                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
 982                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
 983                         } else {
 984                                 r->hardware_id = NULL;
 985                         }
 986                         ndr->flags = _flags_save_string;
 987                 }
 988                 {
 989                         uint32_t _flags_save_string = ndr->flags;
 990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 991                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
 992                         if (_ptr_provider) {
 993                                 NDR_PULL_ALLOC(ndr, r->provider);
 994                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
 995                         } else {
 996                                 r->provider = NULL;
 997                         }
 998                         ndr->flags = _flags_save_string;
 999                 }
1000         }
1001         if (ndr_flags & NDR_BUFFERS) {
1002                 {
1003                         uint32_t _flags_save_string = ndr->flags;
1004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1005                         if (r->driver_name) {
1006                                 uint32_t _relative_save_offset;
1007                                 _relative_save_offset = ndr->offset;
1008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
1009                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1010                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
1011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
1012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
1013                                 ndr->offset = _relative_save_offset;
1014                         }
1015                         ndr->flags = _flags_save_string;
1016                 }
1017                 {
1018                         uint32_t _flags_save_string = ndr->flags;
1019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1020                         if (r->architecture) {
1021                                 uint32_t _relative_save_offset;
1022                                 _relative_save_offset = ndr->offset;
1023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
1024                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
1025                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
1026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
1027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
1028                                 ndr->offset = _relative_save_offset;
1029                         }
1030                         ndr->flags = _flags_save_string;
1031                 }
1032                 if (r->file_info) {
1033                         uint32_t _relative_save_offset;
1034                         _relative_save_offset = ndr->offset;
1035                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_info));
1036                         _mem_save_file_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1037                         NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1038 #if 0
1039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->file_info));
1040 #else
1041                         NDR_CHECK(ndr_token_store(ndr, &ndr->array_size_list, &r->file_info, r->file_count));
1042 #endif
1043                         NDR_PULL_ALLOC_N(ndr, r->file_info, ndr_get_array_size(ndr, &r->file_info));
1044                         _mem_save_file_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
1045                         NDR_PULL_SET_MEM_CTX(ndr, r->file_info, 0);
1046                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1047                                 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_SCALARS, &r->file_info[cntr_file_info_1]));
1048                         }
1049                         for (cntr_file_info_1 = 0; cntr_file_info_1 < r->file_count; cntr_file_info_1++) {
1050                                 NDR_CHECK(ndr_pull_spoolss_DriverFileInfo(ndr, NDR_BUFFERS, &r->file_info[cntr_file_info_1]));
1051                         }
1052                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_1, 0);
1053                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_info_0, 0);
1054                         ndr->offset = _relative_save_offset;
1055                 }
1056                 {
1057                         uint32_t _flags_save_string = ndr->flags;
1058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1059                         if (r->monitor_name) {
1060                                 uint32_t _relative_save_offset;
1061                                 _relative_save_offset = ndr->offset;
1062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
1063                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1064                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
1065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
1066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
1067                                 ndr->offset = _relative_save_offset;
1068                         }
1069                         ndr->flags = _flags_save_string;
1070                 }
1071                 {
1072                         uint32_t _flags_save_string = ndr->flags;
1073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1074                         if (r->default_datatype) {
1075                                 uint32_t _relative_save_offset;
1076                                 _relative_save_offset = ndr->offset;
1077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
1078                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1079                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
1080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
1081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
1082                                 ndr->offset = _relative_save_offset;
1083                         }
1084                         ndr->flags = _flags_save_string;
1085                 }
1086                 {
1087                         uint32_t _flags_save_string_array = ndr->flags;
1088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1089                         if (r->previous_names) {
1090                                 uint32_t _relative_save_offset;
1091                                 _relative_save_offset = ndr->offset;
1092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
1093                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
1094                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
1095                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
1096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
1097                                 ndr->offset = _relative_save_offset;
1098                         }
1099                         ndr->flags = _flags_save_string_array;
1100                 }
1101                 {
1102                         uint32_t _flags_save_string = ndr->flags;
1103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1104                         if (r->manufacturer_name) {
1105                                 uint32_t _relative_save_offset;
1106                                 _relative_save_offset = ndr->offset;
1107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
1108                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
1109                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
1110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
1111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
1112                                 ndr->offset = _relative_save_offset;
1113                         }
1114                         ndr->flags = _flags_save_string;
1115                 }
1116                 {
1117                         uint32_t _flags_save_string = ndr->flags;
1118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1119                         if (r->manufacturer_url) {
1120                                 uint32_t _relative_save_offset;
1121                                 _relative_save_offset = ndr->offset;
1122                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
1123                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
1124                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
1125                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
1126                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
1127                                 ndr->offset = _relative_save_offset;
1128                         }
1129                         ndr->flags = _flags_save_string;
1130                 }
1131                 {
1132                         uint32_t _flags_save_string = ndr->flags;
1133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1134                         if (r->hardware_id) {
1135                                 uint32_t _relative_save_offset;
1136                                 _relative_save_offset = ndr->offset;
1137                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
1138                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
1139                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
1140                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
1141                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
1142                                 ndr->offset = _relative_save_offset;
1143                         }
1144                         ndr->flags = _flags_save_string;
1145                 }
1146                 {
1147                         uint32_t _flags_save_string = ndr->flags;
1148                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1149                         if (r->provider) {
1150                                 uint32_t _relative_save_offset;
1151                                 _relative_save_offset = ndr->offset;
1152                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
1153                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
1154                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
1155                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
1156                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
1157                                 ndr->offset = _relative_save_offset;
1158                         }
1159                         ndr->flags = _flags_save_string;
1160                 }
1161                 if (r->file_info) {
1162                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->file_info, r->file_count));
1163                 }
1164         }
1165         return NDR_ERR_SUCCESS;
1166 }