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