source: branches/samba-3.0/source/python/py_spoolss_printers_conv.c@ 436

Last change on this file since 436 was 39, checked in by Paul Smedley, 19 years ago

Upgrade source to 3.0.25a
File size: 11.7 KB
Line 
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
24struct pyconv py_PRINTER_INFO_0[] = {
25 { "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
74struct pyconv py_PRINTER_INFO_1[] = {
75 { "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
82struct pyconv py_PRINTER_INFO_2[] = {
83 { "server_name", PY_UNISTR, offsetof(PRINTER_INFO_2, servername) },
84 { "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
105struct pyconv py_PRINTER_INFO_3[] = {
106 { NULL }
107};
108
109struct pyconv py_DEVICEMODE[] = {
110 { "device_name", PY_UNISTR, offsetof(DEVICEMODE, devicename) },
111 { "spec_version", PY_UINT16, offsetof(DEVICEMODE, specversion) },
112 { "driver_version", PY_UINT16, offsetof(DEVICEMODE, driverversion) },
113 { "size", PY_UINT16, offsetof(DEVICEMODE, size) },
114 { "fields", PY_UINT16, offsetof(DEVICEMODE, fields) },
115 { "orientation", PY_UINT16, offsetof(DEVICEMODE, orientation) },
116 { "paper_size", PY_UINT16, offsetof(DEVICEMODE, papersize) },
117 { "paper_width", PY_UINT16, offsetof(DEVICEMODE, paperwidth) },
118 { "paper_length", PY_UINT16, offsetof(DEVICEMODE, paperlength) },
119 { "scale", PY_UINT16, offsetof(DEVICEMODE, scale) },
120 { "copies", PY_UINT16, offsetof(DEVICEMODE, copies) },
121 { "default_source", PY_UINT16, offsetof(DEVICEMODE, defaultsource) },
122 { "print_quality", PY_UINT16, offsetof(DEVICEMODE, printquality) },
123 { "color", PY_UINT16, offsetof(DEVICEMODE, color) },
124 { "duplex", PY_UINT16, offsetof(DEVICEMODE, duplex) },
125 { "y_resolution", PY_UINT16, offsetof(DEVICEMODE, yresolution) },
126 { "tt_option", PY_UINT16, offsetof(DEVICEMODE, ttoption) },
127 { "collate", PY_UINT16, offsetof(DEVICEMODE, collate) },
128 { "form_name", PY_UNISTR, offsetof(DEVICEMODE, formname) },
129 { "log_pixels", PY_UINT16, offsetof(DEVICEMODE, logpixels) },
130 { "bits_per_pel", PY_UINT32, offsetof(DEVICEMODE, bitsperpel) },
131 { "pels_width", PY_UINT32, offsetof(DEVICEMODE, pelswidth) },
132 { "pels_height", PY_UINT32, offsetof(DEVICEMODE, pelsheight) },
133 { "display_flags", PY_UINT32, offsetof(DEVICEMODE, displayflags) },
134 { "display_frequency", PY_UINT32, offsetof(DEVICEMODE, displayfrequency) },
135 { "icm_method", PY_UINT32, offsetof(DEVICEMODE, icmmethod) },
136 { "icm_intent", PY_UINT32, offsetof(DEVICEMODE, icmintent) },
137 { "media_type", PY_UINT32, offsetof(DEVICEMODE, mediatype) },
138 { "dither_type", PY_UINT32, offsetof(DEVICEMODE, dithertype) },
139 { "reserved1", PY_UINT32, offsetof(DEVICEMODE, reserved1) },
140 { "reserved2", PY_UINT32, offsetof(DEVICEMODE, reserved2) },
141 { "panning_width", PY_UINT32, offsetof(DEVICEMODE, panningwidth) },
142 { "panning_height", PY_UINT32, offsetof(DEVICEMODE, panningheight) },
143 { NULL }
144};
145
146/*
147 * Convert between DEVICEMODE and Python
148 */
149
150BOOL py_from_DEVICEMODE(PyObject **dict, DEVICEMODE *devmode)
151{
152 *dict = from_struct(devmode, py_DEVICEMODE);
153
154 PyDict_SetItemString(*dict, "private",
155 PyString_FromStringAndSize(
156 devmode->dev_private, devmode->driverextra));
157
158 return True;
159}
160
161BOOL py_to_DEVICEMODE(DEVICEMODE *devmode, PyObject *dict)
162{
163 PyObject *obj, *dict_copy = PyDict_Copy(dict);
164 BOOL result = False;
165
166 if (!(obj = PyDict_GetItemString(dict_copy, "private")))
167 goto done;
168
169 if (!PyString_Check(obj))
170 goto done;
171
172 devmode->dev_private = PyString_AsString(obj);
173 devmode->driverextra = PyString_Size(obj);
174
175 PyDict_DelItemString(dict_copy, "private");
176
177 if (!to_struct(devmode, dict_copy, py_DEVICEMODE))
178 goto done;
179
180 result = True;
181
182done:
183 Py_DECREF(dict_copy);
184 return result;
185}
186
187/*
188 * Convert between PRINTER_INFO_0 and Python
189 */
190
191BOOL py_from_PRINTER_INFO_0(PyObject **dict, PRINTER_INFO_0 *info)
192{
193 *dict = from_struct(info, py_PRINTER_INFO_0);
194 PyDict_SetItemString(*dict, "level", PyInt_FromLong(0));
195 return True;
196}
197
198BOOL py_to_PRINTER_INFO_0(PRINTER_INFO_0 *info, PyObject *dict)
199{
200 return False;
201}
202
203/*
204 * Convert between PRINTER_INFO_1 and Python
205 */
206
207BOOL py_from_PRINTER_INFO_1(PyObject **dict, PRINTER_INFO_1 *info)
208{
209 *dict = from_struct(info, py_PRINTER_INFO_1);
210 PyDict_SetItemString(*dict, "level", PyInt_FromLong(1));
211 return True;
212}
213
214BOOL py_to_PRINTER_INFO_1(PRINTER_INFO_1 *info, PyObject *dict)
215{
216 PyObject *obj, *dict_copy = PyDict_Copy(dict);
217 BOOL result = False;
218
219 if (!(obj = PyDict_GetItemString(dict_copy, "level")) ||
220 !PyInt_Check(obj))
221 goto done;
222
223 PyDict_DelItemString(dict_copy, "level");
224
225 if (!to_struct(info, dict_copy, py_PRINTER_INFO_1))
226 goto done;
227
228 result = True;
229
230done:
231 Py_DECREF(dict_copy);
232 return result;
233}
234
235/*
236 * Convert between PRINTER_INFO_2 and Python
237 */
238
239BOOL py_from_PRINTER_INFO_2(PyObject **dict, PRINTER_INFO_2 *info)
240{
241 PyObject *obj;
242
243 *dict = from_struct(info, py_PRINTER_INFO_2);
244
245 /* The security descriptor could be NULL */
246
247 if (info->secdesc) {
248 if (py_from_SECDESC(&obj, info->secdesc))
249 PyDict_SetItemString(*dict, "security_descriptor", obj);
250 }
251
252 /* Bong! The devmode could be NULL */
253
254 if (info->devmode)
255 py_from_DEVICEMODE(&obj, info->devmode);
256 else
257 obj = PyDict_New();
258
259 PyDict_SetItemString(*dict, "device_mode", obj);
260
261 PyDict_SetItemString(*dict, "level", PyInt_FromLong(2));
262
263 return True;
264}
265
266BOOL py_to_PRINTER_INFO_2(PRINTER_INFO_2 *info, PyObject *dict,
267 TALLOC_CTX *mem_ctx)
268{
269 PyObject *obj, *dict_copy = PyDict_Copy(dict);
270 BOOL result = False;
271
272 /* Convert security descriptor - may be NULL */
273
274 info->secdesc = NULL;
275
276 if ((obj = PyDict_GetItemString(dict_copy, "security_descriptor"))) {
277
278 if (!PyDict_Check(obj))
279 goto done;
280
281 if (!py_to_SECDESC(&info->secdesc, obj, mem_ctx))
282 goto done;
283
284 PyDict_DelItemString(dict_copy, "security_descriptor");
285 }
286
287 /* Convert device mode */
288
289 if (!(obj = PyDict_GetItemString(dict_copy, "device_mode"))
290 || !PyDict_Check(obj))
291 goto done;
292
293 info->devmode = _talloc(mem_ctx, sizeof(DEVICEMODE));
294
295 if (!py_to_DEVICEMODE(info->devmode, obj))
296 goto done;
297
298 PyDict_DelItemString(dict_copy, "device_mode");
299
300 /* Check info level */
301
302 if (!(obj = PyDict_GetItemString(dict_copy, "level")) ||
303 !PyInt_Check(obj))
304 goto done;
305
306 PyDict_DelItemString(dict_copy, "level");
307
308 /* Convert remaining elements of dictionary */
309
310 if (!to_struct(info, dict_copy, py_PRINTER_INFO_2))
311 goto done;
312
313 result = True;
314
315done:
316 Py_DECREF(dict_copy);
317 return result;
318}
319
320/*
321 * Convert between PRINTER_INFO_1 and Python
322 */
323
324BOOL py_from_PRINTER_INFO_3(PyObject **dict, PRINTER_INFO_3 *info)
325{
326 PyObject *obj;
327
328 *dict = from_struct(info, py_PRINTER_INFO_3);
329
330 if (py_from_SECDESC(&obj, info->secdesc))
331 PyDict_SetItemString(*dict, "security_descriptor", obj);
332
333 PyDict_SetItemString(*dict, "level", PyInt_FromLong(3));
334
335 return True;
336}
337
338BOOL py_to_PRINTER_INFO_3(PRINTER_INFO_3 *info, PyObject *dict,
339 TALLOC_CTX *mem_ctx)
340{
341 PyObject *obj;
342
343 if (!to_struct(info, dict, py_PRINTER_INFO_3))
344 return False;
345
346 if (!(obj = PyDict_GetItemString(dict, "security_descriptor")))
347 return False;
348
349 if (!py_to_SECDESC(&info->secdesc, obj, mem_ctx))
350 return False;
351
352 return True;
353}
Note: See TracBrowser for help on using the repository browser.