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