source4/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                 __r.in.level    = r->in.level;\
  50                 __r.in.count    = r->out.count;\
  51                 __r.out.info    = r->out.info;\
  52                 NDR_CHECK(ndr_push___##fn(_ndr_info, flags, &__r)); \
  53                 _data_blob_info = ndr_push_blob(_ndr_info);\
  54                 _r.out.buffer   = &_data_blob_info;\
  55         }\
  56         NDR_CHECK(ndr_push__##fn(ndr, flags, &_r));\
  57 } while(0)
  58
  59 #define NDR_SPOOLSS_PUSH_ENUM(fn,in,out) do { \
  60         struct _##fn _r;\
  61         if (flags & NDR_IN) {\
  62                 in;\
  63                 NDR_SPOOLSS_PUSH_ENUM_IN(fn);\
  64         }\
  65         if (flags & NDR_OUT) {\
  66                 out;\
  67                 NDR_SPOOLSS_PUSH_ENUM_OUT(fn);\
  68         }\
  69 } while(0)
  70
  71 #define NDR_SPOOLSS_PULL_ENUM_IN(fn) do { \
  72         ZERO_STRUCT(r->out);\
  73         NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
  74         r->in.level     = _r.in.level;\
  75         r->in.buffer    = _r.in.buffer;\
  76         r->in.buf_size  = _r.in.buf_size;\
  77 } while(0)
  78
  79 #define NDR_SPOOLSS_PULL_ENUM_OUT(fn) do { \
  80         struct ndr_pull *_ndr_info;\
  81         _r.in.level     = r->in.level;\
  82         _r.in.buffer    = r->in.buffer;\
  83         _r.in.buf_size  = r->in.buf_size;\
  84         _r.out.buf_size = r->out.buf_size;\
  85         NDR_CHECK(ndr_pull__##fn(ndr, flags, &_r));\
  86         r->out.info     = NULL;\
  87         r->out.buf_size = _r.out.buf_size;\
  88         r->out.count    = _r.out.count;\
  89         r->out.result   = _r.out.result;\
  90         if (_r.out.buffer) {\
  91                 struct __##fn __r;\
  92                 _ndr_info = ndr_pull_init_blob(_r.out.buffer, ndr);\
  93                 if (!_ndr_info) return NT_STATUS_NO_MEMORY;\
  94                 __r.in.level    = r->in.level;\
  95                 __r.in.count    = r->out.count;\
  96                 __r.out.info    = NULL;\
  97                 NDR_CHECK(ndr_pull___##fn(_ndr_info, flags, &__r));\
  98                 r->out.info     = __r.out.info;\
  99         }\
 100 } while(0)
 101
 102 #define NDR_SPOOLSS_PULL_ENUM(fn,in,out) do { \
 103         struct _##fn _r;\
 104         if (flags & NDR_IN) {\
 105                 out;\
 106                 NDR_SPOOLSS_PULL_ENUM_IN(fn);\
 107                 in;\
 108         }\
 109         if (flags & NDR_OUT) {\
 110                 out;\
 111                 NDR_SPOOLSS_PULL_ENUM_OUT(fn);\
 112         }\
 113 } while(0)
 114
 115 #define _NDR_CHECK_UINT32(call) do { NTSTATUS _status; \
 116                              _status = call; \
 117                              if (!NT_STATUS_IS_OK(_status)) \
 118                                 return 0; \
 119                         } while (0)
 120
 121 #define NDR_SPOOLSS_SIZE_ENUM(fn) do { \
 122         struct __##fn __r;\
 123         DATA_BLOB _data_blob_info;\
 124         struct ndr_push *_ndr_info = ndr_push_init_ctx(mem_ctx);\
 125         if (!_ndr_info) return 0;\
 126         __r.in.level    = level;\
 127         __r.in.count    = count;\
 128         __r.out.info    = info;\
 129         _NDR_CHECK_UINT32(ndr_push___##fn(_ndr_info, NDR_OUT, &__r)); \
 130         _data_blob_info = ndr_push_blob(_ndr_info);\
 131         return _data_blob_info.length;\
 132 } while(0)
 133
 134 /*
 135   spoolss_EnumPrinters
 136 */
 137 NTSTATUS ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, struct spoolss_EnumPrinters *r)
 138 {
 139         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
 140                 _r.in.flags     = r->in.flags;
 141                 _r.in.server    = r->in.server;
 142         },{
 143                 _r.in.flags     = r->in.flags;
 144                 _r.in.server    = r->in.server;
 145         });
 146         return NT_STATUS_OK;
 147 }
 148
 149 NTSTATUS ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
 150 {
 151         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
 152                 r->in.flags     = _r.in.flags;
 153                 r->in.server    = _r.in.server;
 154         },{
 155                 _r.in.flags     = r->in.flags;
 156                 _r.in.server    = r->in.server;
 157         });
 158         return NT_STATUS_OK;
 159 }
 160
 161 uint32_t ndr_size_spoolss_EnumPrinters_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PrinterInfo *info)
 162 {
 163         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinters);
 164 }
 165
 166 /*
 167   spoolss_EnumJobs
 168 */
 169 NTSTATUS ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, struct spoolss_EnumJobs *r)
 170 {
 171         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
 172                 _r.in.handle    = r->in.handle;
 173                 _r.in.firstjob  = r->in.firstjob;
 174                 _r.in.numjobs   = r->in.numjobs;
 175         },{
 176                 _r.in.handle    = r->in.handle;
 177                 _r.in.firstjob  = r->in.firstjob;
 178                 _r.in.numjobs   = r->in.numjobs;
 179         });
 180         return NT_STATUS_OK;
 181 }
 182
 183 NTSTATUS ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
 184 {
 185         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
 186                 r->in.handle    = _r.in.handle;
 187                 r->in.firstjob  = _r.in.firstjob;
 188                 r->in.numjobs   = _r.in.numjobs;
 189         },{
 190                 _r.in.handle    = r->in.handle;
 191                 _r.in.firstjob  = r->in.firstjob;
 192                 _r.in.numjobs   = r->in.numjobs;
 193         });
 194         return NT_STATUS_OK;
 195 }
 196
 197 uint32_t ndr_size_spoolss_EnumJobss_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_JobInfo *info)
 198 {
 199         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumJobs);
 200 }
 201
 202 /*
 203   spoolss_EnumPrinterDrivers
 204 */
 205 NTSTATUS ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 206 {
 207         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
 208                 _r.in.server            = r->in.server;
 209                 _r.in.environment       = r->in.environment;
 210         },{
 211                 _r.in.server            = r->in.server;
 212                 _r.in.environment       = r->in.environment;
 213         });
 214         return NT_STATUS_OK;
 215 }
 216
 217 NTSTATUS ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 218 {
 219         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
 220                 r->in.server            = _r.in.server;
 221                 r->in.environment       = _r.in.environment;
 222         },{
 223                 _r.in.server            = r->in.server;
 224                 _r.in.environment       = r->in.environment;
 225         });
 226         return NT_STATUS_OK;
 227 }
 228
 229 uint32_t ndr_size_spoolss_EnumPrinterDrivers_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_DriverInfo *info)
 230 {
 231         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrinterDrivers);
 232 }
 233
 234 /*
 235   spoolss_EnumForms
 236 */
 237 NTSTATUS ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, struct spoolss_EnumForms *r)
 238 {
 239         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
 240                 _r.in.handle    = r->in.handle;
 241         },{
 242                 _r.in.handle    = r->in.handle;
 243         });
 244         return NT_STATUS_OK;
 245 }
 246
 247 NTSTATUS ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
 248 {
 249         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
 250                 r->in.handle    = _r.in.handle;
 251         },{
 252                 _r.in.handle    = r->in.handle;
 253         });
 254         return NT_STATUS_OK;
 255 }
 256
 257 uint32_t ndr_size_spoolss_EnumForms_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_FormInfo *info)
 258 {
 259         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumForms);
 260 }
 261
 262 /*
 263   spoolss_EnumPorts
 264 */
 265 NTSTATUS ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, struct spoolss_EnumPorts *r)
 266 {
 267         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
 268                 _r.in.servername= r->in.servername;
 269         },{
 270                 _r.in.servername= r->in.servername;
 271         });
 272         return NT_STATUS_OK;
 273 }
 274
 275 NTSTATUS ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
 276 {
 277         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
 278                 r->in.servername= _r.in.servername;
 279         },{
 280                 _r.in.servername= r->in.servername;
 281         });
 282         return NT_STATUS_OK;
 283 }
 284
 285 uint32_t ndr_size_spoolss_EnumPorts_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PortInfo *info)
 286 {
 287         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPorts);
 288 }
 289
 290 /*
 291   spoolss_EnumMonitors
 292 */
 293 NTSTATUS ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, struct spoolss_EnumMonitors *r)
 294 {
 295         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
 296                 _r.in.servername= r->in.servername;
 297         },{
 298                 _r.in.servername= r->in.servername;
 299         });
 300         return NT_STATUS_OK;
 301 }
 302
 303 NTSTATUS ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
 304 {
 305         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
 306                 r->in.servername= _r.in.servername;
 307         },{
 308                 _r.in.servername= r->in.servername;
 309         });
 310         return NT_STATUS_OK;
 311 }
 312
 313 uint32_t ndr_size_spoolss_EnumMonitors_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_MonitorInfo *info)
 314 {
 315         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumMonitors);
 316 }
 317
 318 /*
 319   spoolss_EnumPrintProcessors
 320 */
 321 NTSTATUS ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 322 {
 323         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
 324                 _r.in.servername        = r->in.servername;
 325                 _r.in.environment       = r->in.environment;
 326         },{
 327                 _r.in.servername        = r->in.servername;
 328                 _r.in.environment       = r->in.environment;
 329         });
 330         return NT_STATUS_OK;
 331 }
 332
 333 NTSTATUS ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 334 {
 335         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
 336                 r->in.servername        = _r.in.servername;
 337                 r->in.environment       = _r.in.environment;
 338         },{
 339                 _r.in.servername        = r->in.servername;
 340                 _r.in.environment       = r->in.environment;
 341         });
 342         return NT_STATUS_OK;
 343 }
 344
 345 uint32_t ndr_size_spoolss_EnumPrinterProcessors_info(TALLOC_CTX *mem_ctx, uint32_t level, uint32_t count, union spoolss_PrintProcessorInfo *info)
 346 {
 347         NDR_SPOOLSS_SIZE_ENUM(spoolss_EnumPrintProcessors);
 348 }