source3/python/py_spoolss_printers_conv.c

   1 /*
   2    Python wrappers for DCERPC/SMB client routines.
   3
   4    Copyright (C) Tim Potter, 2002
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "python/py_spoolss.h"
  22 #include "python/py_conv.h"
  23
  24 struct pyconv py_PRINTER_INFO_0[] = {
  25         { "printer_name", PY_UNISTR, offsetof(PRINTER_INFO_0, printername) },
  26         { "server_name", PY_UNISTR, offsetof(PRINTER_INFO_0, servername) },
  27
  28         { "cjobs", PY_UINT32, offsetof(PRINTER_INFO_0, cjobs) },
  29         { "total_jobs", PY_UINT32, offsetof(PRINTER_INFO_0, total_jobs) },
  30         { "total_bytes", PY_UINT32, offsetof(PRINTER_INFO_0, total_bytes) },
  31
  32         { "year", PY_UINT16, offsetof(PRINTER_INFO_0, year) },
  33         { "month", PY_UINT16, offsetof(PRINTER_INFO_0, month) },
  34         { "day_of_week", PY_UINT16, offsetof(PRINTER_INFO_0, dayofweek) },
  35         { "day", PY_UINT16, offsetof(PRINTER_INFO_0, day) },
  36         { "hour", PY_UINT16, offsetof(PRINTER_INFO_0, hour) },
  37         { "minute", PY_UINT16, offsetof(PRINTER_INFO_0, minute) },
  38         { "second", PY_UINT16, offsetof(PRINTER_INFO_0, second) },
  39         { "milliseconds", PY_UINT16, offsetof(PRINTER_INFO_0, milliseconds) },
  40
  41         { "global_counter", PY_UINT32, offsetof(PRINTER_INFO_0, global_counter) },
  42         { "total_pages", PY_UINT32, offsetof(PRINTER_INFO_0, total_pages) },
  43
  44         { "major_version", PY_UINT16, offsetof(PRINTER_INFO_0, major_version) },
  45         { "build_version", PY_UINT16, offsetof(PRINTER_INFO_0, build_version) },
  46
  47         { "unknown7", PY_UINT32, offsetof(PRINTER_INFO_0, unknown7) },
  48         { "unknown8", PY_UINT32, offsetof(PRINTER_INFO_0, unknown8) },
  49         { "unknown9", PY_UINT32, offsetof(PRINTER_INFO_0, unknown9) },
  50         { "session_counter", PY_UINT32, offsetof(PRINTER_INFO_0, session_counter)},
  51         { "unknown11", PY_UINT32, offsetof(PRINTER_INFO_0, unknown11) },
  52         { "printer_errors", PY_UINT32, offsetof(PRINTER_INFO_0, printer_errors) },
  53         { "unknown13", PY_UINT32, offsetof(PRINTER_INFO_0, unknown13) },
  54         { "unknown14", PY_UINT32, offsetof(PRINTER_INFO_0, unknown14) },
  55         { "unknown15", PY_UINT32, offsetof(PRINTER_INFO_0, unknown15) },
  56         { "unknown16", PY_UINT32, offsetof(PRINTER_INFO_0, unknown16) },
  57         { "change_id", PY_UINT32, offsetof(PRINTER_INFO_0, change_id) },
  58         { "unknown18", PY_UINT32, offsetof(PRINTER_INFO_0, unknown18) },
  59         { "status", PY_UINT32, offsetof(PRINTER_INFO_0, status) },
  60         { "unknown20", PY_UINT32, offsetof(PRINTER_INFO_0, unknown20) },
  61         { "c_setprinter", PY_UINT32, offsetof(PRINTER_INFO_0, c_setprinter) },
  62         { "unknown22", PY_UINT32, offsetof(PRINTER_INFO_0, unknown22) },
  63         { "unknown23", PY_UINT32, offsetof(PRINTER_INFO_0, unknown23) },
  64         { "unknown24", PY_UINT32, offsetof(PRINTER_INFO_0, unknown24) },
  65         { "unknown25", PY_UINT32, offsetof(PRINTER_INFO_0, unknown25) },
  66         { "unknown26", PY_UINT32, offsetof(PRINTER_INFO_0, unknown26) },
  67         { "unknown27", PY_UINT32, offsetof(PRINTER_INFO_0, unknown27) },
  68         { "unknown28", PY_UINT32, offsetof(PRINTER_INFO_0, unknown28) },
  69         { "unknown29", PY_UINT32, offsetof(PRINTER_INFO_0, unknown29) },
  70
  71         { NULL }
  72 };
  73
  74 struct pyconv py_PRINTER_INFO_1[] = {
  75         { "printer_name", PY_UNISTR, offsetof(PRINTER_INFO_1, name) },
  76         { "description", PY_UNISTR, offsetof(PRINTER_INFO_1, description) },
  77         { "comment", PY_UNISTR, offsetof(PRINTER_INFO_1, comment) },
  78         { "flags", PY_UINT32, offsetof(PRINTER_INFO_1, flags) },
  79         { NULL }
  80 };
  81
  82 struct pyconv py_PRINTER_INFO_2[] = {
  83         { "server_name", PY_UNISTR, offsetof(PRINTER_INFO_2, servername) },
  84         { "printer_name", PY_UNISTR, offsetof(PRINTER_INFO_2, printername) },
  85         { "share_name", PY_UNISTR, offsetof(PRINTER_INFO_2, sharename) },
  86         { "port_name", PY_UNISTR, offsetof(PRINTER_INFO_2, portname) },
  87         { "driver_name", PY_UNISTR, offsetof(PRINTER_INFO_2, drivername) },
  88         { "comment", PY_UNISTR, offsetof(PRINTER_INFO_2, comment) },
  89         { "location", PY_UNISTR, offsetof(PRINTER_INFO_2, location) },
  90         { "datatype", PY_UNISTR, offsetof(PRINTER_INFO_2, datatype) },
  91         { "sepfile", PY_UNISTR, offsetof(PRINTER_INFO_2, sepfile) },
  92         { "print_processor", PY_UNISTR, offsetof(PRINTER_INFO_2, printprocessor) },
  93         { "parameters", PY_UNISTR, offsetof(PRINTER_INFO_2, parameters) },
  94         { "attributes", PY_UINT32, offsetof(PRINTER_INFO_2, attributes) },
  95         { "default_priority", PY_UINT32, offsetof(PRINTER_INFO_2, defaultpriority) },
  96         { "priority", PY_UINT32, offsetof(PRINTER_INFO_2, priority) },
  97         { "start_time", PY_UINT32, offsetof(PRINTER_INFO_2, starttime) },
  98         { "until_time", PY_UINT32, offsetof(PRINTER_INFO_2, untiltime) },
  99         { "status", PY_UINT32, offsetof(PRINTER_INFO_2, status) },
 100         { "cjobs", PY_UINT32, offsetof(PRINTER_INFO_2, cjobs) },
 101         { "average_ppm", PY_UINT32, offsetof(PRINTER_INFO_2, averageppm) },
 102         { NULL }
 103 };
 104
 105 struct pyconv py_PRINTER_INFO_3[] = {
 106         { "flags", PY_UINT32, offsetof(PRINTER_INFO_3, flags) },
 107         { NULL }
 108 };
 109
 110 struct pyconv py_DEVICEMODE[] = {
 111         { "device_name", PY_UNISTR, offsetof(DEVICEMODE, devicename) },
 112         { "spec_version", PY_UINT16, offsetof(DEVICEMODE, specversion) },
 113         { "driver_version", PY_UINT16, offsetof(DEVICEMODE, driverversion) },
 114         { "size", PY_UINT16, offsetof(DEVICEMODE, size) },
 115         { "fields", PY_UINT16, offsetof(DEVICEMODE, fields) },
 116         { "orientation", PY_UINT16, offsetof(DEVICEMODE, orientation) },
 117         { "paper_size", PY_UINT16, offsetof(DEVICEMODE, papersize) },
 118         { "paper_width", PY_UINT16, offsetof(DEVICEMODE, paperwidth) },
 119         { "paper_length", PY_UINT16, offsetof(DEVICEMODE, paperlength) },
 120         { "scale", PY_UINT16, offsetof(DEVICEMODE, scale) },
 121         { "copies", PY_UINT16, offsetof(DEVICEMODE, copies) },
 122         { "default_source", PY_UINT16, offsetof(DEVICEMODE, defaultsource) },
 123         { "print_quality", PY_UINT16, offsetof(DEVICEMODE, printquality) },
 124         { "color", PY_UINT16, offsetof(DEVICEMODE, color) },
 125         { "duplex", PY_UINT16, offsetof(DEVICEMODE, duplex) },
 126         { "y_resolution", PY_UINT16, offsetof(DEVICEMODE, yresolution) },
 127         { "tt_option", PY_UINT16, offsetof(DEVICEMODE, ttoption) },
 128         { "collate", PY_UINT16, offsetof(DEVICEMODE, collate) },
 129         { "form_name", PY_UNISTR, offsetof(DEVICEMODE, formname) },
 130         { "log_pixels", PY_UINT16, offsetof(DEVICEMODE, logpixels) },
 131         { "bits_per_pel", PY_UINT32, offsetof(DEVICEMODE, bitsperpel) },
 132         { "pels_width", PY_UINT32, offsetof(DEVICEMODE, pelswidth) },
 133         { "pels_height", PY_UINT32, offsetof(DEVICEMODE, pelsheight) },
 134         { "display_flags", PY_UINT32, offsetof(DEVICEMODE, displayflags) },
 135         { "display_frequency", PY_UINT32, offsetof(DEVICEMODE, displayfrequency) },
 136         { "icm_method", PY_UINT32, offsetof(DEVICEMODE, icmmethod) },
 137         { "icm_intent", PY_UINT32, offsetof(DEVICEMODE, icmintent) },
 138         { "media_type", PY_UINT32, offsetof(DEVICEMODE, mediatype) },
 139         { "dither_type", PY_UINT32, offsetof(DEVICEMODE, dithertype) },
 140         { "reserved1", PY_UINT32, offsetof(DEVICEMODE, reserved1) },
 141         { "reserved2", PY_UINT32, offsetof(DEVICEMODE, reserved2) },
 142         { "panning_width", PY_UINT32, offsetof(DEVICEMODE, panningwidth) },
 143         { "panning_height", PY_UINT32, offsetof(DEVICEMODE, panningheight) },
 144         { NULL }
 145 };
 146
 147 /* Convert a security descriptor to a Python dict */
 148
 149 BOOL py_from_SID(PyObject **obj, DOM_SID *sid)
 150 {
 151         fstring sidstr;
 152
 153         if (!sid) {
 154                 Py_INCREF(Py_None);
 155                 *obj = Py_None;
 156                 return True;
 157         }
 158
 159         if (!sid_to_string(sidstr, sid))
 160                 return False;
 161
 162         *obj = PyString_FromString(sidstr);
 163
 164         return True;
 165 }
 166
 167 BOOL py_to_SID(DOM_SID *sid, PyObject *dict)
 168 {
 169         return False;
 170 }
 171
 172 BOOL py_from_ACE(PyObject **dict, SEC_ACE *ace)
 173 {
 174         PyObject *obj;
 175
 176         if (!ace) {
 177                 Py_INCREF(Py_None);
 178                 *dict = Py_None;
 179                 return True;
 180         }
 181
 182         *dict = PyDict_New();
 183
 184         PyDict_SetItemString(*dict, "type", PyInt_FromLong(ace->type));
 185         PyDict_SetItemString(*dict, "flags", PyInt_FromLong(ace->flags));
 186         PyDict_SetItemString(*dict, "mask", PyInt_FromLong(ace->info.mask));
 187
 188         if (py_from_SID(&obj, &ace->trustee))
 189                 PyDict_SetItemString(*dict, "trustee", obj);
 190
 191         return True;
 192 }
 193
 194 BOOL py_to_ACE(SEC_ACE *ace, PyObject *dict)
 195 {
 196         return False;
 197 }
 198
 199 BOOL py_from_ACL(PyObject **dict, SEC_ACL *acl)
 200 {
 201         PyObject *ace_list;
 202         int i;
 203
 204         if (!acl) {
 205                 Py_INCREF(Py_None);
 206                 *dict = Py_None;
 207                 return True;
 208         }
 209
 210         *dict = PyDict_New();
 211
 212         PyDict_SetItemString(*dict, "revision", PyInt_FromLong(acl->revision));
 213
 214         ace_list = PyList_New(acl->num_aces);
 215
 216         for (i = 0; i < acl->num_aces; i++) {
 217                 PyObject *obj;
 218
 219                 if (py_from_ACE(&obj, &acl->ace[i]))
 220                         PyList_SetItem(ace_list, i, obj);
 221         }
 222
 223         PyDict_SetItemString(*dict, "ace_list", ace_list);
 224
 225         return True;
 226 }
 227
 228 BOOL py_to_ACL(SEC_ACL *acl, PyObject *dict)
 229 {
 230         return False;
 231 }
 232
 233 BOOL py_from_SECDESC(PyObject **dict, SEC_DESC *sd)
 234 {
 235         PyObject *obj;
 236
 237         *dict = PyDict_New();
 238
 239         PyDict_SetItemString(*dict, "revision", PyInt_FromLong(sd->revision));
 240         PyDict_SetItemString(*dict, "type", PyInt_FromLong(sd->type));
 241
 242         if (py_from_SID(&obj, sd->owner_sid))
 243                 PyDict_SetItemString(*dict, "owner_sid", obj);
 244
 245         if (py_from_SID(&obj, sd->grp_sid))
 246                 PyDict_SetItemString(*dict, "group_sid", obj);
 247
 248         if (py_from_ACL(&obj, sd->dacl))
 249                 PyDict_SetItemString(*dict, "dacl", obj);
 250
 251         if (py_from_ACL(&obj, sd->sacl))
 252                 PyDict_SetItemString(*dict, "sacl", obj);
 253
 254         return True;
 255 }
 256
 257 BOOL py_to_SECDESC(SEC_DESC *sd, PyObject *dict)
 258 {
 259         return False;
 260 }
 261
 262 /*
 263  * Convert between DEVICEMODE and Python
 264  */
 265
 266 BOOL py_from_DEVICEMODE(PyObject **dict, DEVICEMODE *devmode)
 267 {
 268         *dict = from_struct(devmode, py_DEVICEMODE);
 269
 270         PyDict_SetItemString(*dict, "private",
 271                              PyString_FromStringAndSize(
 272                                      devmode->private, devmode->driverextra));
 273
 274         return True;
 275 }
 276
 277 BOOL py_to_DEVICEMODE(DEVICEMODE *devmode, PyObject *dict)
 278 {
 279         PyObject *obj;
 280
 281         to_struct(devmode, dict, py_DEVICEMODE);
 282
 283         obj = PyDict_GetItemString(dict, "private");
 284
 285         if (!obj)
 286                 return False;
 287
 288         devmode->private = PyString_AsString(obj);
 289         devmode->driverextra = PyString_Size(obj);
 290
 291         return True;
 292 }
 293
 294 /*
 295  * Convert between PRINTER_INFO_0 and Python
 296  */
 297
 298 BOOL py_from_PRINTER_INFO_0(PyObject **dict, PRINTER_INFO_0 *info)
 299 {
 300         *dict = from_struct(info, py_PRINTER_INFO_0);
 301         return True;
 302 }
 303
 304 BOOL py_to_PRINTER_INFO_0(PRINTER_INFO_0 *info, PyObject *dict)
 305 {
 306         return False;
 307 }
 308
 309 /*
 310  * Convert between PRINTER_INFO_1 and Python
 311  */
 312
 313 BOOL py_from_PRINTER_INFO_1(PyObject **dict, PRINTER_INFO_1 *info)
 314 {
 315         *dict = from_struct(info, py_PRINTER_INFO_1);
 316         return True;
 317 }
 318
 319 BOOL py_to_PRINTER_INFO_1(PRINTER_INFO_1 *info, PyObject *dict)
 320 {
 321         return False;
 322 }
 323
 324 /*
 325  * Convert between PRINTER_INFO_2 and Python
 326  */
 327
 328 BOOL py_from_PRINTER_INFO_2(PyObject **dict, PRINTER_INFO_2 *info)
 329 {
 330         PyObject *obj;
 331
 332         *dict = from_struct(info, py_PRINTER_INFO_2);
 333
 334         if (py_from_SECDESC(&obj, info->secdesc))
 335                 PyDict_SetItemString(*dict, "security_descriptor", obj);
 336
 337         if (py_from_DEVICEMODE(&obj, info->devmode))
 338                 PyDict_SetItemString(*dict, "device_mode", obj);
 339
 340         return True;
 341 }
 342
 343 BOOL py_to_PRINTER_INFO_2(PRINTER_INFO_2 *info, PyObject *dict)
 344 {
 345         return False;
 346 }
 347
 348 /*
 349  * Convert between PRINTER_INFO_1 and Python
 350  */
 351
 352 BOOL py_from_PRINTER_INFO_3(PyObject **dict, PRINTER_INFO_3 *info)
 353 {
 354         PyObject *obj;
 355
 356         *dict = from_struct(info, py_PRINTER_INFO_3);
 357
 358         if (py_from_SECDESC(&obj, info->secdesc))
 359                 PyDict_SetItemString(*dict, "security_descriptor", obj);
 360
 361         return True;
 362 }
 363
 364 BOOL py_to_PRINTER_INFO_3(PRINTER_INFO_3 *info, PyObject *dict)
 365 {
 366         return False;
 367 }