source/python/py_spoolss_jobs.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
  23 /* Enumerate jobs */
  24
  25 PyObject *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
  87 PyObject *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
 116 PyObject *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
 156 PyObject *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
 184 PyObject *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
 212 PyObject *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
 308 PyObject *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
 335 PyObject *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
 364 PyObject *spoolss_hnd_addjob(PyObject *self, PyObject *args, PyObject *kw)
 365 {
 366         PyErr_SetString(spoolss_error, "Not implemented");
 367         return NULL;
 368 }