source: branches/samba-3.0/source/python/py_spoolss_jobs.c

Last change on this file was 1, checked in by Paul Smedley, 18 years ago

Initial code import
File size: 8.6 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
23/* Enumerate jobs */
24
25PyObject *spoolss_hnd_enumjobs(PyObject *self, PyObject *args, PyObject *kw)
26{
27 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
28 WERROR werror;
29 PyObject *result;
30 int level = 1;
31 uint32 i, num_jobs;
32 static char *kwlist[] = {"level", NULL};
33 JOB_INFO_CTR ctr;
34
35 /* Parse parameters */
36
37 if (!PyArg_ParseTupleAndKeywords(args, kw, "|i", kwlist, &level))
38 return NULL;
39
40 /* Call rpc function */
41
42 werror = rpccli_spoolss_enumjobs(
43 hnd->cli, hnd->mem_ctx, &hnd->pol, level, 0, 1000,
44 &num_jobs, &ctr);
45
46 /* Return value */
47
48 result = Py_None;
49
50 if (!W_ERROR_IS_OK(werror)) {
51 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
52 goto done;
53 }
54
55 result = PyList_New(num_jobs);
56
57 switch (level) {
58 case 1:
59 for (i = 0; i < num_jobs; i++) {
60 PyObject *value;
61
62 py_from_JOB_INFO_1(&value, &ctr.job.job_info_1[i]);
63
64 PyList_SetItem(result, i, value);
65 }
66
67 break;
68 case 2:
69 for(i = 0; i < num_jobs; i++) {
70 PyObject *value;
71
72 py_from_JOB_INFO_2(&value, &ctr.job.job_info_2[i]);
73
74 PyList_SetItem(result, i, value);
75 }
76
77 break;
78 }
79
80 done:
81 Py_INCREF(result);
82 return result;
83}
84
85/* Set job command */
86
87PyObject *spoolss_hnd_setjob(PyObject *self, PyObject *args, PyObject *kw)
88{
89 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
90 WERROR werror;
91 uint32 level = 0, command, jobid;
92 static char *kwlist[] = {"jobid", "command", "level", NULL};
93
94 /* Parse parameters */
95
96 if (!PyArg_ParseTupleAndKeywords(
97 args, kw, "ii|i", kwlist, &jobid, &command, &level))
98 return NULL;
99
100 /* Call rpc function */
101
102 werror = rpccli_spoolss_setjob(
103 hnd->cli, hnd->mem_ctx, &hnd->pol, jobid, level, command);
104
105 if (!W_ERROR_IS_OK(werror)) {
106 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
107 return NULL;
108 }
109
110 Py_INCREF(Py_None);
111 return Py_None;
112}
113
114/* Get job */
115
116PyObject *spoolss_hnd_getjob(PyObject *self, PyObject *args, PyObject *kw)
117{
118 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
119 WERROR werror;
120 PyObject *result;
121 uint32 level = 1, jobid;
122 static char *kwlist[] = {"jobid", "level", NULL};
123 JOB_INFO_CTR ctr;
124
125 /* Parse parameters */
126
127 if (!PyArg_ParseTupleAndKeywords(
128 args, kw, "i|i", kwlist, &jobid, &level))
129 return NULL;
130
131 /* Call rpc function */
132
133 werror = rpccli_spoolss_getjob(
134 hnd->cli, hnd->mem_ctx, &hnd->pol, jobid, level, &ctr);
135
136 if (!W_ERROR_IS_OK(werror)) {
137 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
138 return NULL;
139 }
140
141 switch(level) {
142 case 1:
143 py_from_JOB_INFO_1(&result, &ctr.job.job_info_1[0]);
144 break;
145 case 2:
146 py_from_JOB_INFO_2(&result, &ctr.job.job_info_2[0]);
147 break;
148 }
149
150 return result;
151}
152
153/* Start page printer. This notifies the spooler that a page is about to be
154 printed on the specified printer. */
155
156PyObject *spoolss_hnd_startpageprinter(PyObject *self, PyObject *args, PyObject *kw)
157{
158 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
159 WERROR werror;
160 static char *kwlist[] = { NULL };
161
162 /* Parse parameters */
163
164 if (!PyArg_ParseTupleAndKeywords(args, kw, "", kwlist))
165 return NULL;
166
167 /* Call rpc function */
168
169 werror = rpccli_spoolss_startpageprinter(
170 hnd->cli, hnd->mem_ctx, &hnd->pol);
171
172 if (!W_ERROR_IS_OK(werror)) {
173 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
174 return NULL;
175 }
176
177 Py_INCREF(Py_None);
178 return Py_None;
179}
180
181/* End page printer. This notifies the spooler that a page has finished
182 being printed on the specified printer. */
183
184PyObject *spoolss_hnd_endpageprinter(PyObject *self, PyObject *args, PyObject *kw)
185{
186 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
187 WERROR werror;
188 static char *kwlist[] = { NULL };
189
190 /* Parse parameters */
191
192 if (!PyArg_ParseTupleAndKeywords(args, kw, "", kwlist))
193 return NULL;
194
195 /* Call rpc function */
196
197 werror = rpccli_spoolss_endpageprinter(
198 hnd->cli, hnd->mem_ctx, &hnd->pol);
199
200 if (!W_ERROR_IS_OK(werror)) {
201 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
202 return NULL;
203 }
204
205 Py_INCREF(Py_None);
206 return Py_None;
207}
208
209/* Start doc printer. This notifies the spooler that a document is about to be
210 printed on the specified printer. */
211
212PyObject *spoolss_hnd_startdocprinter(PyObject *self, PyObject *args, PyObject *kw)
213{
214 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
215 WERROR werror;
216 static char *kwlist[] = { "document_info", NULL };
217 PyObject *info, *obj;
218 uint32 level, jobid;
219 char *document_name = NULL, *output_file = NULL, *data_type = NULL;
220
221 /* Parse parameters */
222
223 if (!PyArg_ParseTupleAndKeywords(
224 args, kw, "O!", kwlist, &PyDict_Type, &info))
225 return NULL;
226
227 /* Check document_info parameter */
228
229 if (!get_level_value(info, &level)) {
230 PyErr_SetString(spoolss_error, "invalid info level");
231 return NULL;
232 }
233
234 if (level != 1) {
235 PyErr_SetString(spoolss_error, "unsupported info level");
236 return NULL;
237 }
238
239 if ((obj = PyDict_GetItemString(info, "document_name"))) {
240
241 if (!PyString_Check(obj) && obj != Py_None) {
242 PyErr_SetString(spoolss_error,
243 "document_name not a string");
244 return NULL;
245 }
246
247 if (PyString_Check(obj))
248 document_name = PyString_AsString(obj);
249
250 } else {
251 PyErr_SetString(spoolss_error, "no document_name present");
252 return NULL;
253 }
254
255 if ((obj = PyDict_GetItemString(info, "output_file"))) {
256
257 if (!PyString_Check(obj) && obj != Py_None) {
258 PyErr_SetString(spoolss_error,
259 "output_file not a string");
260 return NULL;
261 }
262
263 if (PyString_Check(obj))
264 output_file = PyString_AsString(obj);
265
266 } else {
267 PyErr_SetString(spoolss_error, "no output_file present");
268 return NULL;
269 }
270
271 if ((obj = PyDict_GetItemString(info, "data_type"))) {
272
273 if (!PyString_Check(obj) && obj != Py_None) {
274 PyErr_SetString(spoolss_error,
275 "data_type not a string");
276 return NULL;
277 }
278
279 if (PyString_Check(obj))
280 data_type = PyString_AsString(obj);
281
282 } else {
283 PyErr_SetString(spoolss_error, "no data_type present");
284 return NULL;
285 }
286
287 /* Call rpc function */
288
289 werror = rpccli_spoolss_startdocprinter(
290 hnd->cli, hnd->mem_ctx, &hnd->pol, document_name,
291 output_file, data_type, &jobid);
292
293 if (!W_ERROR_IS_OK(werror)) {
294 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
295 return NULL;
296 }
297
298 /* The return value is zero for an error (where does the status
299 code come from now??) and the return value is the jobid
300 allocated for the new job. */
301
302 return Py_BuildValue("i", jobid);
303}
304
305/* End doc printer. This notifies the spooler that a document has finished
306 being printed on the specified printer. */
307
308PyObject *spoolss_hnd_enddocprinter(PyObject *self, PyObject *args, PyObject *kw)
309{
310 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
311 WERROR werror;
312 static char *kwlist[] = { NULL };
313
314 /* Parse parameters */
315
316 if (!PyArg_ParseTupleAndKeywords(args, kw, "", kwlist))
317 return NULL;
318
319 /* Call rpc function */
320
321 werror = rpccli_spoolss_enddocprinter(
322 hnd->cli, hnd->mem_ctx, &hnd->pol);
323
324 if (!W_ERROR_IS_OK(werror)) {
325 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
326 return NULL;
327 }
328
329 Py_INCREF(Py_None);
330 return Py_None;
331}
332
333/* Write data to a printer */
334
335PyObject *spoolss_hnd_writeprinter(PyObject *self, PyObject *args, PyObject *kw)
336{
337 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self;
338 WERROR werror;
339 static char *kwlist[] = { "data", NULL };
340 PyObject *data;
341 uint32 num_written;
342
343 /* Parse parameters */
344
345 if (!PyArg_ParseTupleAndKeywords(
346 args, kw, "O!", kwlist, &PyString_Type, &data))
347 return NULL;
348
349 /* Call rpc function */
350
351 werror = rpccli_spoolss_writeprinter(
352 hnd->cli, hnd->mem_ctx, &hnd->pol, PyString_Size(data),
353 PyString_AsString(data), &num_written);
354
355 if (!W_ERROR_IS_OK(werror)) {
356 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror));
357 return NULL;
358 }
359
360 Py_INCREF(Py_None);
361 return Py_None;
362}
363
364PyObject *spoolss_hnd_addjob(PyObject *self, PyObject *args, PyObject *kw)
365{
366 PyErr_SetString(spoolss_error, "Not implemented");
367 return NULL;
368}
Note: See TracBrowser for help on using the repository browser.