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 24static BOOL py_from_printerdata(PyObject **dict, char *key, char *value, 25 uint16 data_type, uint8 *data, 26 uint32 data_size) 27{ 28 *dict = PyDict_New(); 29 30 PyDict_SetItemString(*dict, "key", Py_BuildValue("s", key ? key : "")); 31 PyDict_SetItemString(*dict, "value", Py_BuildValue("s", value)); 32 PyDict_SetItemString(*dict, "type", Py_BuildValue("i", data_type)); 33 34 PyDict_SetItemString(*dict, "data", 35 Py_BuildValue("s#", data, data_size)); 36 37 return True; 38} 39 40static BOOL py_to_printerdata(char **key, char **value, uint16 *data_type, 41 uint8 **data, uint32 *data_size, 42 PyObject *dict) 43{ 44 PyObject *obj; 45 46 if ((obj = PyDict_GetItemString(dict, "key"))) { 47 48 if (!PyString_Check(obj)) { 49 PyErr_SetString(spoolss_error, 50 "key not a string"); 51 return False; 52 } 53 54 if (key) { 55 *key = PyString_AsString(obj); 56 57 if (!key[0]) 58 *key = NULL; 59 } 60 } else 61 *key = NULL; 62 63 if ((obj = PyDict_GetItemString(dict, "value"))) { 64 65 if (!PyString_Check(obj)) { 66 PyErr_SetString(spoolss_error, 67 "value not a string"); 68 return False; 69 } 70 71 *value = PyString_AsString(obj); 72 } else { 73 PyErr_SetString(spoolss_error, "no value present"); 74 return False; 75 } 76 77 if ((obj = PyDict_GetItemString(dict, "type"))) { 78 79 if (!PyInt_Check(obj)) { 80 PyErr_SetString(spoolss_error, 81 "type not an integer"); 82 return False; 83 } 84 85 *data_type = PyInt_AsLong(obj); 86 } else { 87 PyErr_SetString(spoolss_error, "no type present"); 88 return False; 89 } 90 91 if ((obj = PyDict_GetItemString(dict, "data"))) { 92 93 if (!PyString_Check(obj)) { 94 PyErr_SetString(spoolss_error, 95 "data not a string"); 96 return False; 97 } 98 99 *data = PyString_AsString(obj); 100 *data_size = PyString_Size(obj); 101 } else { 102 PyErr_SetString(spoolss_error, "no data present"); 103 return False; 104 } 105 106 return True; 107} 108 109PyObject *spoolss_hnd_getprinterdata(PyObject *self, PyObject *args, PyObject *kw) 110{ 111 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 112 static char *kwlist[] = { "value", NULL }; 113 char *valuename; 114 WERROR werror; 115 PyObject *result; 116 REGISTRY_VALUE value; 117 118 /* Parse parameters */ 119 120 if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &valuename)) 121 return NULL; 122 123 /* Call rpc function */ 124 125 werror = rpccli_spoolss_getprinterdata( 126 hnd->cli, hnd->mem_ctx, &hnd->pol, valuename, 127 &value); 128 129 if (!W_ERROR_IS_OK(werror)) { 130 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 131 return NULL; 132 } 133 134 py_from_printerdata( 135 &result, NULL, valuename, value.type, value.data_p, 136 value.size); 137 138 return result; 139} 140 141PyObject *spoolss_hnd_setprinterdata(PyObject *self, PyObject *args, PyObject *kw) 142{ 143 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 144 static char *kwlist[] = { "data", NULL }; 145 PyObject *py_data; 146 char *valuename; 147 WERROR werror; 148 REGISTRY_VALUE value; 149 150 if (!PyArg_ParseTupleAndKeywords( 151 args, kw, "O!", kwlist, &PyDict_Type, &py_data)) 152 return NULL; 153 154 if (!py_to_printerdata( 155 NULL, &valuename, &value.type, &value.data_p, 156 &value.size, py_data)) 157 return NULL; 158 159 fstrcpy(value.valuename, valuename); 160 161 /* Call rpc function */ 162 163 werror = rpccli_spoolss_setprinterdata( 164 hnd->cli, hnd->mem_ctx, &hnd->pol, &value); 165 166 if (!W_ERROR_IS_OK(werror)) { 167 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 168 return NULL; 169 } 170 171 Py_INCREF(Py_None); 172 return Py_None; 173} 174 175PyObject *spoolss_hnd_enumprinterdata(PyObject *self, PyObject *args, PyObject *kw) 176{ 177 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 178 static char *kwlist[] = { NULL }; 179 uint32 data_needed, value_needed, ndx = 0; 180 WERROR werror; 181 PyObject *result; 182 REGISTRY_VALUE value; 183 184 if (!PyArg_ParseTupleAndKeywords(args, kw, "", kwlist)) 185 return NULL; 186 187 /* Get max buffer sizes for value and data */ 188 189 werror = rpccli_spoolss_enumprinterdata( 190 hnd->cli, hnd->mem_ctx, &hnd->pol, ndx, 0, 0, 191 &value_needed, &data_needed, NULL); 192 193 if (!W_ERROR_IS_OK(werror)) { 194 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 195 return NULL; 196 } 197 198 /* Iterate over all printerdata */ 199 200 result = PyDict_New(); 201 202 while (W_ERROR_IS_OK(werror)) { 203 PyObject *obj; 204 205 werror = rpccli_spoolss_enumprinterdata( 206 hnd->cli, hnd->mem_ctx, &hnd->pol, ndx, 207 value_needed, data_needed, NULL, NULL, &value); 208 209 if (py_from_printerdata( 210 &obj, NULL, value.valuename, value.type, 211 value.data_p, value.size)) 212 PyDict_SetItemString(result, value.valuename, obj); 213 214 ndx++; 215 } 216 217 return result; 218} 219 220PyObject *spoolss_hnd_deleteprinterdata(PyObject *self, PyObject *args, PyObject *kw) 221{ 222 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 223 static char *kwlist[] = { "value", NULL }; 224 char *value; 225 WERROR werror; 226 227 /* Parse parameters */ 228 229 if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &value)) 230 return NULL; 231 232 /* Call rpc function */ 233 234 werror = rpccli_spoolss_deleteprinterdata( 235 hnd->cli, hnd->mem_ctx, &hnd->pol, value); 236 237 if (!W_ERROR_IS_OK(werror)) { 238 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 239 return NULL; 240 } 241 242 Py_INCREF(Py_None); 243 return Py_None; 244} 245 246PyObject *spoolss_hnd_getprinterdataex(PyObject *self, PyObject *args, PyObject *kw) 247{ 248 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 249 static char *kwlist[] = { "key", "value", NULL }; 250 char *key, *valuename; 251 WERROR werror; 252 PyObject *result; 253 REGISTRY_VALUE value; 254 255 /* Parse parameters */ 256 257 if (!PyArg_ParseTupleAndKeywords(args, kw, "ss", kwlist, &key, &valuename)) 258 return NULL; 259 260 /* Call rpc function */ 261 262 werror = rpccli_spoolss_getprinterdataex( 263 hnd->cli, hnd->mem_ctx, &hnd->pol, key, 264 valuename, &value); 265 266 if (!W_ERROR_IS_OK(werror)) { 267 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 268 return NULL; 269 } 270 271 py_from_printerdata( 272 &result, key, valuename, value.type, value.data_p, value.size); 273 274 return result; 275} 276 277PyObject *spoolss_hnd_setprinterdataex(PyObject *self, PyObject *args, PyObject *kw) 278{ 279 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 280 static char *kwlist[] = { "data", NULL }; 281 PyObject *py_data; 282 char *keyname, *valuename; 283 WERROR werror; 284 REGISTRY_VALUE value; 285 286 if (!PyArg_ParseTupleAndKeywords( 287 args, kw, "O!", kwlist, &PyDict_Type, &py_data)) 288 return NULL; 289 290 if (!py_to_printerdata( 291 &keyname, &valuename, &value.type, &value.data_p, &value.size, py_data)) 292 return NULL; 293 294 fstrcpy(value.valuename, valuename); 295 296 /* Call rpc function */ 297 298 werror = rpccli_spoolss_setprinterdataex( 299 hnd->cli, hnd->mem_ctx, &hnd->pol, keyname, &value); 300 301 if (!W_ERROR_IS_OK(werror)) { 302 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 303 return NULL; 304 } 305 306 Py_INCREF(Py_None); 307 return Py_None; 308} 309 310PyObject *spoolss_hnd_enumprinterdataex(PyObject *self, PyObject *args, PyObject *kw) 311{ 312 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 313 static char *kwlist[] = { "key", NULL }; 314 uint32 i; 315 char *key; 316 WERROR werror; 317 PyObject *result; 318 REGVAL_CTR *ctr; 319 320 if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &key)) 321 return NULL; 322 323 if (!(ctr = TALLOC_ZERO_P(hnd->mem_ctx, REGVAL_CTR))) { 324 PyErr_SetString(spoolss_error, "talloc failed"); 325 return NULL; 326 } 327 328 /* Get max buffer sizes for value and data */ 329 330 werror = rpccli_spoolss_enumprinterdataex( 331 hnd->cli, hnd->mem_ctx, &hnd->pol, key, &ctr); 332 333 if (!W_ERROR_IS_OK(werror)) { 334 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 335 return NULL; 336 } 337 338 /* Iterate over all printerdata */ 339 340 result = PyDict_New(); 341 342 for (i = 0; i < regval_ctr_numvals(&ctr); i++) { 343 REGISTRY_VALUE *value; 344 PyObject *item; 345 346 item = PyDict_New(); 347 value = regval_ctr_specific_value(&ctr, i); 348 349 if (py_from_printerdata( 350 &item, key, value->valuename, value->type, 351 value->data_p, value->size)) 352 PyDict_SetItemString(result, value->valuename, item); 353 } 354 355 return result; 356} 357 358PyObject *spoolss_hnd_deleteprinterdataex(PyObject *self, PyObject *args, PyObject *kw) 359{ 360 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 361 static char *kwlist[] = { "key", "value", NULL }; 362 char *key, *value; 363 WERROR werror; 364 365 /* Parse parameters */ 366 367 if (!PyArg_ParseTupleAndKeywords(args, kw, "ss", kwlist, &key, &value)) 368 return NULL; 369 370 /* Call rpc function */ 371 372 werror = rpccli_spoolss_deleteprinterdataex( 373 hnd->cli, hnd->mem_ctx, &hnd->pol, key, value); 374 375 if (!W_ERROR_IS_OK(werror)) { 376 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 377 return NULL; 378 } 379 380 Py_INCREF(Py_None); 381 return Py_None; 382} 383 384PyObject *spoolss_hnd_enumprinterkey(PyObject *self, PyObject *args, 385 PyObject *kw) 386{ 387 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 388 static char *kwlist[] = { "key", NULL }; 389 char *keyname; 390 WERROR werror; 391 uint32 keylist_len; 392 uint16 *keylist; 393 PyObject *result; 394 395 /* Parse parameters */ 396 397 if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &keyname)) 398 return NULL; 399 400 /* Call rpc function */ 401 402 werror = rpccli_spoolss_enumprinterkey( 403 hnd->cli, hnd->mem_ctx, &hnd->pol, keyname, &keylist, 404 &keylist_len); 405 406 if (!W_ERROR_IS_OK(werror)) { 407 PyErr_SetObject(spoolss_werror, py_werror_tuple(werror)); 408 return NULL; 409 } 410 411 result = from_unistr_list(keylist); 412 413 return result; 414} 415 416#if 0 417 418PyObject *spoolss_hnd_deleteprinterkey(PyObject *self, PyObject *args, 419 PyObject *kw) 420{ 421 spoolss_policy_hnd_object *hnd = (spoolss_policy_hnd_object *)self; 422 static char *kwlist[] = { "key", NULL }; 423 char *keyname; 424 WERROR werror; 425 426 if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &keyname)) 427 return NULL; 428 429 Py_INCREF(Py_None); 430 return Py_None; 431} 432 433#endif 434