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                 in;\
 106                 NDR_SPOOLSS_PULL_ENUM_IN(fn);\
 107         }\
 108         if (flags & NDR_OUT) {\
 109                 out;\
 110                 NDR_SPOOLSS_PULL_ENUM_OUT(fn);\
 111         }\
 112 } while(0)
 113
 114 /*
 115   spoolss_EnumPrinters
 116 */
 117 NTSTATUS ndr_push_spoolss_EnumPrinters(struct ndr_push *ndr, int flags, struct spoolss_EnumPrinters *r)
 118 {
 119         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinters,{
 120                 _r.in.flags     = r->in.flags;
 121                 _r.in.server    = r->in.server;
 122         },{
 123                 _r.in.flags     = r->in.flags;
 124                 _r.in.server    = r->in.server;
 125         });
 126         return NT_STATUS_OK;
 127 }
 128
 129 NTSTATUS ndr_pull_spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinters *r)
 130 {
 131         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinters,{
 132                 r->in.flags     = _r.in.flags;
 133                 r->in.server    = _r.in.server;
 134         },{
 135                 _r.in.flags     = r->in.flags;
 136                 _r.in.server    = r->in.server;
 137         });
 138         return NT_STATUS_OK;
 139 }
 140
 141 /*
 142   spoolss_EnumJobs
 143 */
 144 NTSTATUS ndr_push_spoolss_EnumJobs(struct ndr_push *ndr, int flags, struct spoolss_EnumJobs *r)
 145 {
 146         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumJobs,{
 147                 _r.in.handle    = r->in.handle;
 148                 _r.in.firstjob  = r->in.firstjob;
 149                 _r.in.numjobs   = r->in.numjobs;
 150         },{
 151                 _r.in.handle    = r->in.handle;
 152                 _r.in.firstjob  = r->in.firstjob;
 153                 _r.in.numjobs   = r->in.numjobs;
 154         });
 155         return NT_STATUS_OK;
 156 }
 157
 158 NTSTATUS ndr_pull_spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct spoolss_EnumJobs *r)
 159 {
 160         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumJobs,{
 161                 r->in.handle    = _r.in.handle;
 162                 r->in.firstjob  = _r.in.firstjob;
 163                 r->in.numjobs   = _r.in.numjobs;
 164         },{
 165                 _r.in.handle    = r->in.handle;
 166                 _r.in.firstjob  = r->in.firstjob;
 167                 _r.in.numjobs   = r->in.numjobs;
 168         });
 169         return NT_STATUS_OK;
 170 }
 171
 172 /*
 173   spoolss_EnumPrinterDrivers
 174 */
 175 NTSTATUS ndr_push_spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 176 {
 177         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrinterDrivers,{
 178                 _r.in.server            = r->in.server;
 179                 _r.in.environment       = r->in.environment;
 180         },{
 181                 _r.in.server            = r->in.server;
 182                 _r.in.environment       = r->in.environment;
 183         });
 184         return NT_STATUS_OK;
 185 }
 186
 187 NTSTATUS ndr_pull_spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDrivers *r)
 188 {
 189         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrinterDrivers,{
 190                 r->in.server            = _r.in.server;
 191                 r->in.environment       = _r.in.environment;
 192         },{
 193                 _r.in.server            = r->in.server;
 194                 _r.in.environment       = r->in.environment;
 195         });
 196         return NT_STATUS_OK;
 197 }
 198
 199 /*
 200   spoolss_EnumForms
 201 */
 202 NTSTATUS ndr_push_spoolss_EnumForms(struct ndr_push *ndr, int flags, struct spoolss_EnumForms *r)
 203 {
 204         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumForms,{
 205                 _r.in.handle    = r->in.handle;
 206         },{
 207                 _r.in.handle    = r->in.handle;
 208         });
 209         return NT_STATUS_OK;
 210 }
 211
 212 NTSTATUS ndr_pull_spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct spoolss_EnumForms *r)
 213 {
 214         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumForms,{
 215                 r->in.handle    = _r.in.handle;
 216         },{
 217                 _r.in.handle    = r->in.handle;
 218         });
 219         return NT_STATUS_OK;
 220 }
 221
 222 /*
 223   spoolss_EnumPorts
 224 */
 225 NTSTATUS ndr_push_spoolss_EnumPorts(struct ndr_push *ndr, int flags, struct spoolss_EnumPorts *r)
 226 {
 227         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPorts,{
 228                 _r.in.servername= r->in.servername;
 229         },{
 230                 _r.in.servername= r->in.servername;
 231         });
 232         return NT_STATUS_OK;
 233 }
 234
 235 NTSTATUS ndr_pull_spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct spoolss_EnumPorts *r)
 236 {
 237         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPorts,{
 238                 r->in.servername= _r.in.servername;
 239         },{
 240                 _r.in.servername= r->in.servername;
 241         });
 242         return NT_STATUS_OK;
 243 }
 244
 245 /*
 246   spoolss_EnumMonitors
 247 */
 248 NTSTATUS ndr_push_spoolss_EnumMonitors(struct ndr_push *ndr, int flags, struct spoolss_EnumMonitors *r)
 249 {
 250         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumMonitors,{
 251                 _r.in.servername= r->in.servername;
 252         },{
 253                 _r.in.servername= r->in.servername;
 254         });
 255         return NT_STATUS_OK;
 256 }
 257
 258 NTSTATUS ndr_pull_spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct spoolss_EnumMonitors *r)
 259 {
 260         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumMonitors,{
 261                 r->in.servername= _r.in.servername;
 262         },{
 263                 _r.in.servername= r->in.servername;
 264         });
 265         return NT_STATUS_OK;
 266 }
 267
 268 /*
 269   spoolss_EnumPrintProcessors
 270 */
 271 NTSTATUS ndr_push_spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 272 {
 273         NDR_SPOOLSS_PUSH_ENUM(spoolss_EnumPrintProcessors,{
 274                 _r.in.servername        = r->in.servername;
 275                 _r.in.environment       = r->in.environment;
 276         },{
 277                 _r.in.servername        = r->in.servername;
 278                 _r.in.environment       = r->in.environment;
 279         });
 280         return NT_STATUS_OK;
 281 }
 282
 283 NTSTATUS ndr_pull_spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrintProcessors *r)
 284 {
 285         NDR_SPOOLSS_PULL_ENUM(spoolss_EnumPrintProcessors,{
 286                 r->in.servername        = r->in.servername;
 287                 r->in.environment       = r->in.environment;
 288         },{
 289                 _r.in.servername        = r->in.servername;
 290                 _r.in.environment       = r->in.environment;
 291         });
 292         return NT_STATUS_OK;
 293 }