source/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 2 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, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24
  25 #include "includes.h"
  26 #include "librpc/gen_ndr/ndr_spoolss.h"
  27
  28 #define NDR_SPOOLSS_PUSH_ENUM_IN(fn) do { \
  29         _r.in.level     = r->in.level;\
  30         _r.in.buffer    = r->in.buffer;\
  31         _r.in.buf_size  = r->in.buf_size;\
  32         NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
  33 } while(0)
  34
  35 #define NDR_SPOOLSS_PUSH_ENUM_OUT(fn) do { \
  36         struct ndr_push *_ndr_info;\
  37         _r.in.level     = r->in.level;\
  38         _r.in.buffer    = r->in.buffer;\
  39         _r.in.buf_size  = r->in.buf_size;\
  40         _r.out.buffer   = NULL;\
  41         _r.out.buf_size = r->out.buf_size;\
  42         _r.out.count    = r->out.count;\
  43         _r.out.result   = r->out.result;\
  44         if (r->out.info) {\
  45                 struct __##fn __r;\
  46                 DATA_BLOB _data_blob_info;\
  47                 _ndr_info = ndr_push_init_ctx(ndr);\
  48                 if (!_ndr_info) return NT_STATUS_NO_MEMORY;\
  49                 _ndr_info->flags= ndr->flags;\
  50                 __r.in.level    = r->in.level;\
  51                 __r.in.count    = r->out.count;\
  52                 __r.out.info    = r->out.info;\
  53                 NDR_CHECK(ndr_push___##fn(_ndr_info, flags, &__r)); \
  54                 _data_blob_info = ndr_push_blob(_ndr_info);\
  55                 _r.out.buffer   = &_data_blob_info;\
  56         }\
  57         NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
  58 } while(0)
  59
  60 #define NDR_SPOOLSS_PUSH_ENUM(fn,in,out) do { \
  61         struct _##fn _r;\
  62         if (flags & NDR_IN) {\
  63                 in;\
  64                 NDR_SPOOLSS_PUSH_ENUM_IN(fn);\
  65         }\
  66         if (flags & NDR_OUT) {\
  67                 out;\
  68                 NDR_SPOOLSS_PUSH_ENUM_OUT(fn);\
  69         }\
  70 } while(0)
  71
  72 #define NDR_SPOOLSS_PULL_ENUM_IN(fn) do { \
  73         ZERO_STRUCT(r->out);\
  74         NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
  75         r->in.level     = _r.in.level;\
  76         r->in.buffer    = _r.in.buffer;\
  77         r->in.buf_size  = _r.in.buf_size;\
  78 } while(0)
  79
  80 #define NDR_SPOOLSS_PULL_ENUM_OUT(fn) do { \
  81         struct ndr_pull *_ndr_info;\
  82         _r.in.level     = r->in.level;\
  83         _r.in.buffer    = r->in.buffer;\
  84         _r.in.buf_size  = r->in.buf_size;\
  85         _r.out.buf_size = r->out.buf_size;\
  86         NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
  87         r->out.info     = NULL;\
  88         r->out.buf_size = _r.out.buf_size;\
  89         r->out.count    = _r.out.count;\
  90         r->out.result   = _r.out.result;\
  91         if (_r.out.buffer) {\
  92                 struct __##fn __r;\
  93                 _ndr_info = ndr_pull_init_blob(_r.out.buffer, ndr);\
  94                 if (!_ndr_info) return NT_STATUS_NO_MEMORY;\
  95                 _ndr_info->flags= ndr->flags;\
  96                 __r.in.level    = r->in.level;\
  97                 __r.in.count    = r->out.count;\
  98                 __r.out.info    = NULL;\
  99                 NDR_CHECK(ndr_pull___##fn(_ndr_info, flags, &__r));\
 100                 r->out.info     = __r.out.info;\
 101         }\
 102 } while(0)
 103
 104 #define NDR_SPOOLSS_PULL_ENUM(fn,in,out) do { \
 105         struct _##fn _r;\
 106         if (flags & NDR_IN) {\
 107                 out;\
 108                 NDR_SPOOLSS_PULL_ENUM_IN(fn);\
 109                 in;\
 110         }\
 111         if (flags & NDR_OUT) {\
 112                 out;\
 113                 NDR_SPOOLSS_PULL_ENUM_OUT(fn);\
 114         }\
 115 } while(0)
 116
 117 #define _NDR_CHECK_UINT32(call) do { NTSTATUS _status; \
 118                              _status = call; \
 119                              if (!NT_STATUS_IS_OK(_status)) \
 120                                 return 0; \
 121                         } while (0)
 122
 123 /* TODO: set _ndr_info->flags correct */
 124 #define NDR_SPOOLSS_SIZE_ENUM(fn) do { \
 125         struct __##fn __r;\
 126         DATA_BLOB _data_blob_info;\
 127         struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx);\
 128         if (!_ndr_info) return 0;\
 129         _ndr_info->flags|=0;\
 130         __r.in.level    = level;\
 131         __r.in.count    = count;\
 132         __r.out.info    = info;\
 133         _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
 134         _data_blob_info = ndr_push_blob(_ndr_info);\
 135         return _data_blob_info.length;\
 136 } while(0)
 137
 138 /*
 139   spoolss_EnumPrinters
 140 */
 141 NTSTATUS ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, struct spoolss_EnumPrinters *r)
 142 {
 143         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
 144                 _r.in.flags     = r->in.flags;
 145                 _r.in.server    = r->in.server;
 146         },{
 147                 _r.in.flags     = r->in.flags;
 148                 _r.in.server    = r->in.server;
 149         });
 150         return NT_STATUS_OK;
 151 }
 152
 153 NTSTATUS ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
 154 {
 155         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
 156                 r->in.flags     = _r.in.flags;
 157                 r->in.server    = _r.in.server;
 158         },{
 159                 _r.in.flags     = r->in.flags;
 160                 _r.in.server    = r->in.server;
 161         });
 162         return NT_STATUS_OK;
 163 }
 164
 165 uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info)
 166 {
 167         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinters);
 168 }
 169
 170 /*
 171   spoolss_EnumJobs
 172 */
 173 NTSTATUS ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, struct spoolss_EnumJobs *r)
 174 {
 175         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
 176                 _r.in.handle    = r->in.handle;
 177                 _r.in.firstjob  = r->in.firstjob;
 178                 _r.in.numjobs   = r->in.numjobs;
 179         },{
 180                 _r.in.handle    = r->in.handle;
 181                 _r.in.firstjob  = r->in.firstjob;
 182                 _r.in.numjobs   = r->in.numjobs;
 183         });
 184         return NT_STATUS_OK;
 185 }
 186
 187 NTSTATUS ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
 188 {
 189         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
 190                 r->in.handle    = _r.in.handle;
 191                 r->in.firstjob  = _r.in.firstjob;
 192                 r->in.numjobs   = _r.in.numjobs;
 193         },{
 194                 _r.in.handle    = r->in.handle;
 195                 _r.in.firstjob  = r->in.firstjob;
 196                 _r.in.numjobs   = r->in.numjobs;
 197         });
 198         return NT_STATUS_OK;
 199 }
 200
 201 uint32_t ndr_size_spoolss_EnumJobss_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_JobInfo *info)
 202 {
 203         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumJobs);
 204 }
 205
 206 /*
 207   spoolss_EnumPrinterDrivers
 208 */
 209 NTSTATUS ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 210 {
 211         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
 212                 _r.in.server            = r->in.server;
 213                 _r.in.environment       = r->in.environment;
 214         },{
 215                 _r.in.server            = r->in.server;
 216                 _r.in.environment       = r->in.environment;
 217         });
 218         return NT_STATUS_OK;
 219 }
 220
 221 NTSTATUS ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 222 {
 223         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
 224                 r->in.server            = _r.in.server;
 225                 r->in.environment       = _r.in.environment;
 226         },{
 227                 _r.in.server            = r->in.server;
 228                 _r.in.environment       = r->in.environment;
 229         });
 230         return NT_STATUS_OK;
 231 }
 232
 233 uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_DriverInfo *info)
 234 {
 235         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDrivers);
 236 }
 237
 238 /*
 239   spoolss_EnumForms
 240 */
 241 NTSTATUS ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, struct spoolss_EnumForms *r)
 242 {
 243         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
 244                 _r.in.handle    = r->in.handle;
 245         },{
 246                 _r.in.handle    = r->in.handle;
 247         });
 248         return NT_STATUS_OK;
 249 }
 250
 251 NTSTATUS ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
 252 {
 253         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
 254                 r->in.handle    = _r.in.handle;
 255         },{
 256                 _r.in.handle    = r->in.handle;
 257         });
 258         return NT_STATUS_OK;
 259 }
 260
 261 uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_FormInfo *info)
 262 {
 263         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumForms);
 264 }
 265
 266 /*
 267   spoolss_EnumPorts
 268 */
 269 NTSTATUS ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, struct spoolss_EnumPorts *r)
 270 {
 271         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
 272                 _r.in.servername= r->in.servername;
 273         },{
 274                 _r.in.servername= r->in.servername;
 275         });
 276         return NT_STATUS_OK;
 277 }
 278
 279 NTSTATUS ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
 280 {
 281         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
 282                 r->in.servername= _r.in.servername;
 283         },{
 284                 _r.in.servername= r->in.servername;
 285         });
 286         return NT_STATUS_OK;
 287 }
 288
 289 uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PortInfo *info)
 290 {
 291         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPorts);
 292 }
 293
 294 /*
 295   spoolss_EnumMonitors
 296 */
 297 NTSTATUS ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, struct spoolss_EnumMonitors *r)
 298 {
 299         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
 300                 _r.in.servername= r->in.servername;
 301         },{
 302                 _r.in.servername= r->in.servername;
 303         });
 304         return NT_STATUS_OK;
 305 }
 306
 307 NTSTATUS ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
 308 {
 309         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
 310                 r->in.servername= _r.in.servername;
 311         },{
 312                 _r.in.servername= r->in.servername;
 313         });
 314         return NT_STATUS_OK;
 315 }
 316
 317 uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info)
 318 {
 319         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumMonitors);
 320 }
 321
 322 /*
 323   spoolss_EnumPrintProcessors
 324 */
 325 NTSTATUS ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 326 {
 327         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
 328                 _r.in.servername        = r->in.servername;
 329                 _r.in.environment       = r->in.environment;
 330         },{
 331                 _r.in.servername        = r->in.servername;
 332                 _r.in.environment       = r->in.environment;
 333         });
 334         return NT_STATUS_OK;
 335 }
 336
 337 NTSTATUS ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 338 {
 339         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
 340                 r->in.servername        = _r.in.servername;
 341                 r->in.environment       = _r.in.environment;
 342         },{
 343                 _r.in.servername        = r->in.servername;
 344                 _r.in.environment       = r->in.environment;
 345         });
 346         return NT_STATUS_OK;
 347 }
 348
 349 uint32_t ndr_size_spoolss_EnumPrinterProcessors_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
 350 {
 351         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrintProcessors);
 352 }
 353
 354 /*
 355   spoolss_GetPrinterData
 356 */
 357 NTSTATUS ndr_pull_spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterData *r)
 358 {
 359         struct _spoolss_GetPrinterData _r;
 360         if (flags & NDR_IN) {
 361                 ZERO_STRUCT(r->out);
 362
 363                 _r.in.handle    = r->in.handle;
 364                 _r.in.value_name= r->in.value_name;
 365                 _r.in.buf_size  = r->in.buf_size;
 366                 _r.out.type     = r->out.type;
 367                 _r.out.data     = data_blob(NULL,0),
 368                 _r.out.buf_size = r->out.buf_size;
 369                 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
 370                 r->in.handle    = _r.in.handle;
 371                 r->in.value_name= _r.in.value_name;
 372                 r->in.buf_size  = _r.in.buf_size;
 373         }
 374         if (flags & NDR_OUT) {
 375                 _r.in.handle    = r->in.handle;
 376                 _r.in.value_name= r->in.value_name;
 377                 _r.in.buf_size  = r->in.buf_size;
 378                 _r.out.type     = r->out.type;
 379                 _r.out.data     = data_blob(NULL,0),
 380                 _r.out.buf_size = r->out.buf_size;
 381                 _r.out.result   = r->out.result;
 382                 NDR_CHECK(ndr_pull__spoolss_GetPrinterData(ndr, flags, &_r));
 383                 r->out.type     = _r.out.type;
 384                 ZERO_STRUCT(r->out.data);
 385                 r->out.buf_size = _r.out.buf_size;
 386                 r->out.result   = _r.out.result;
 387                 if (_r.out.data.length > 0) {
 388                         struct __spoolss_GetPrinterData __r;
 389                         struct ndr_pull *_ndr_data = ndr_pull_init_blob(&_r.out.data, ndr);\
 390                         if (!_ndr_data) return NT_STATUS_NO_MEMORY;\
 391                         _ndr_data->flags= ndr->flags;\
 392                         __r.in.type     = r->out.type;
 393                         __r.out.data    = r->out.data;
 394                         NDR_CHECK(ndr_pull___spoolss_GetPrinterData(_ndr_data, flags, &__r));
 395                         r->out.data     = __r.out.data;
 396                 } else {
 397                         r->out.type     = SPOOLSS_PRINTER_DATA_TYPE_NULL;
 398                 }
 399         }
 400         return NT_STATUS_OK;
 401 }
 402
 403 /*
 404   spoolss_SetPrinterData
 405 */
 406 NTSTATUS ndr_push_spoolss_SetPrinterData(struct ndr_push *ndr, int flags, struct spoolss_SetPrinterData *r)
 407 {
 408         struct _spoolss_SetPrinterData _r;
 409         if (flags & NDR_IN) {
 410                 struct ndr_push *_ndr_data;
 411                 struct __spoolss_SetPrinterData __r;
 412                 DATA_BLOB _data_blob_data;
 413
 414                 _ndr_data = ndr_push_init_ctx(ndr);\
 415                 if (!_ndr_data) return NT_STATUS_NO_MEMORY;\
 416                 _ndr_data->flags= ndr->flags;\
 417
 418                 __r.in.type     = r->in.type;
 419                 __r.out.data    = r->in.data;
 420                 NDR_CHECK(ndr_push___spoolss_SetPrinterData(_ndr_data, NDR_OUT, &__r));
 421                 _data_blob_data = ndr_push_blob(_ndr_data);
 422
 423                 r->in._buf_size = _data_blob_data.length;
 424
 425                 _r.in.handle    = r->in.handle;
 426                 _r.in.value_name= r->in.value_name;
 427                 _r.in.type      = r->in.type;
 428                 _r.in.data      = _data_blob_data;
 429                 _r.in._buf_size = r->in._buf_size;
 430                 _r.out.result   = r->out.result;
 431                 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
 432         }
 433         if (flags & NDR_OUT) {
 434                 _r.in.handle    = r->in.handle;
 435                 _r.in.value_name= r->in.value_name;
 436                 _r.in.type      = r->in.type;
 437                 _r.in.data      = data_blob(NULL,0),
 438                 _r.in._buf_size = r->in._buf_size;
 439                 _r.out.result   = r->out.result;
 440                 NDR_CHECK(ndr_push__spoolss_SetPrinterData(ndr, flags, &_r));
 441         }
 442         return NT_STATUS_OK;
 443 }