source3/python/py_smb.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_smb.h"
  22
  23 /* Create a new cli_state python object */
  24
  25 PyObject *new_cli_state_object(struct cli_state *cli)
  26 {
  27         cli_state_object *o;
  28
  29         o = PyObject_New(cli_state_object, &cli_state_type);
  30
  31         o->cli = cli;
  32
  33         return (PyObject*)o;
  34 }
  35
  36 static PyObject *py_smb_connect(PyObject *self, PyObject *args, PyObject *kw)
  37 {
  38         static char *kwlist[] = { "server", NULL };
  39         struct cli_state *cli;
  40         char *server;
  41         struct in_addr ip;
  42
  43         if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &server))
  44                 return NULL;
  45
  46         if (!(cli = cli_initialise(NULL)))
  47                 return NULL;
  48
  49         ZERO_STRUCT(ip);
  50
  51         if (!cli_connect(cli, server, &ip))
  52                 return NULL;
  53
  54         return new_cli_state_object(cli);
  55 }
  56
  57 static PyObject *py_smb_session_request(PyObject *self, PyObject *args,
  58                                         PyObject *kw)
  59 {
  60         cli_state_object *cli = (cli_state_object *)self;
  61         static char *kwlist[] = { "called", "calling", NULL };
  62         char *calling_name = NULL, *called_name;
  63         struct nmb_name calling, called;
  64         BOOL result;
  65
  66         if (!PyArg_ParseTupleAndKeywords(args, kw, "s|s", kwlist, &called_name,
  67                                          &calling_name))
  68                 return NULL;
  69
  70         if (!calling_name)
  71                 calling_name = global_myname();
  72
  73         make_nmb_name(&calling, calling_name, 0x00);
  74         make_nmb_name(&called, called_name, 0x20);
  75
  76         result = cli_session_request(cli->cli, &calling, &called);
  77
  78         return Py_BuildValue("i", result);
  79 }
  80
  81 static PyObject *py_smb_negprot(PyObject *self, PyObject *args, PyObject *kw)
  82 {
  83         cli_state_object *cli = (cli_state_object *)self;
  84         static char *kwlist[] = { NULL };
  85         BOOL result;
  86
  87         if (!PyArg_ParseTupleAndKeywords(args, kw, "", kwlist))
  88                 return NULL;
  89
  90         result = cli_negprot(cli->cli);
  91
  92         return Py_BuildValue("i", result);
  93 }
  94
  95 static PyObject *py_smb_session_setup(PyObject *self, PyObject *args,
  96                                       PyObject *kw)
  97 {
  98         cli_state_object *cli = (cli_state_object *)self;
  99         static char *kwlist[] = { "creds", NULL };
 100         PyObject *creds;
 101         char *username, *domain, *password, *errstr;
 102         BOOL result;
 103
 104         if (!PyArg_ParseTupleAndKeywords(args, kw, "|O", kwlist, &creds))
 105                 return NULL;
 106
 107         if (!py_parse_creds(creds, &username, &domain, &password, &errstr)) {
 108                 free(errstr);
 109                 return NULL;
 110         }
 111
 112         result = cli_session_setup(
 113                 cli->cli, username, password, strlen(password) + 1,
 114                 password, strlen(password) + 1, domain);
 115
 116         if (cli_is_error(cli->cli)) {
 117                 PyErr_SetString(PyExc_RuntimeError, "session setup failed");
 118                 return NULL;
 119         }
 120
 121         return Py_BuildValue("i", result);
 122 }
 123
 124 static PyObject *py_smb_tconx(PyObject *self, PyObject *args, PyObject *kw)
 125 {
 126         cli_state_object *cli = (cli_state_object *)self;
 127         static char *kwlist[] = { "service", NULL };
 128         char *service;
 129         BOOL result;
 130
 131         if (!PyArg_ParseTupleAndKeywords(args, kw, "s", kwlist, &service))
 132                 return NULL;
 133
 134         result = cli_send_tconX(
 135                 cli->cli, service, strequal(service, "IPC$") ? "IPC" :
 136                 "?????", "", 1);
 137
 138         if (cli_is_error(cli->cli)) {
 139                 PyErr_SetString(PyExc_RuntimeError, "tconx failed");
 140                 return NULL;
 141         }
 142
 143         return Py_BuildValue("i", result);
 144 }
 145
 146 static PyObject *py_smb_nt_create_andx(PyObject *self, PyObject *args,
 147                                        PyObject *kw)
 148 {
 149         cli_state_object *cli = (cli_state_object *)self;
 150         static char *kwlist[] = { "filename", "desired_access",
 151                                   "file_attributes", "share_access",
 152                                   "create_disposition", "create_options",
 153                                   NULL };
 154         char *filename;
 155         uint32 desired_access, file_attributes = 0,
 156                 share_access = FILE_SHARE_READ | FILE_SHARE_WRITE,
 157                 create_disposition = FILE_EXISTS_OPEN, create_options = 0;
 158         int result;
 159
 160         /* Parse parameters */
 161
 162         if (!PyArg_ParseTupleAndKeywords(
 163                     args, kw, "si|iiii", kwlist, &filename, &desired_access,
 164                     &file_attributes, &share_access, &create_disposition,
 165                     &create_options))
 166                 return NULL;
 167
 168         result = cli_nt_create_full(
 169                 cli->cli, filename, 0, desired_access, file_attributes,
 170                 share_access, create_disposition, create_options, 0);
 171
 172         if (cli_is_error(cli->cli)) {
 173                 PyErr_SetString(PyExc_RuntimeError, "nt_create_andx failed");
 174                 return NULL;
 175         }
 176
 177         /* Return FID */
 178
 179         return PyInt_FromLong(result);
 180 }
 181
 182 static PyObject *py_smb_close(PyObject *self, PyObject *args,
 183                               PyObject *kw)
 184 {
 185         cli_state_object *cli = (cli_state_object *)self;
 186         static char *kwlist[] = { "fnum", NULL };
 187         BOOL result;
 188         int fnum;
 189
 190         /* Parse parameters */
 191
 192         if (!PyArg_ParseTupleAndKeywords(
 193                     args, kw, "i", kwlist, &fnum))
 194                 return NULL;
 195
 196         result = cli_close(cli->cli, fnum);
 197
 198         return PyInt_FromLong(result);
 199 }
 200
 201 static PyObject *py_smb_unlink(PyObject *self, PyObject *args,
 202                                PyObject *kw)
 203 {
 204         cli_state_object *cli = (cli_state_object *)self;
 205         static char *kwlist[] = { "filename", NULL };
 206         char *filename;
 207         BOOL result;
 208
 209         /* Parse parameters */
 210
 211         if (!PyArg_ParseTupleAndKeywords(
 212                     args, kw, "s", kwlist, &filename))
 213                 return NULL;
 214
 215         result = cli_unlink(cli->cli, filename);
 216
 217         return PyInt_FromLong(result);
 218 }
 219
 220 static PyObject *py_smb_query_secdesc(PyObject *self, PyObject *args,
 221                                       PyObject *kw)
 222 {
 223         cli_state_object *cli = (cli_state_object *)self;
 224         static char *kwlist[] = { "fnum", NULL };
 225         PyObject *result = NULL;
 226         SEC_DESC *secdesc = NULL;
 227         int fnum;
 228         TALLOC_CTX *mem_ctx = NULL;
 229
 230         /* Parse parameters */
 231
 232         if (!PyArg_ParseTupleAndKeywords(
 233                     args, kw, "i", kwlist, &fnum))
 234                 return NULL;
 235
 236         mem_ctx = talloc_init("py_smb_query_secdesc");
 237
 238         secdesc = cli_query_secdesc(cli->cli, fnum, mem_ctx);
 239
 240         if (cli_is_error(cli->cli)) {
 241                 PyErr_SetString(PyExc_RuntimeError, "query_secdesc failed");
 242                 goto done;
 243         }
 244
 245         if (!secdesc) {
 246                 Py_INCREF(Py_None);
 247                 result = Py_None;
 248                 goto done;
 249         }
 250
 251         if (!py_from_SECDESC(&result, secdesc)) {
 252                 PyErr_SetString(
 253                         PyExc_TypeError,
 254                         "Invalid security descriptor returned");
 255                 goto done;
 256         }
 257
 258  done:
 259         talloc_destroy(mem_ctx);
 260
 261         return result;
 262
 263 }
 264
 265 static PyObject *py_smb_set_secdesc(PyObject *self, PyObject *args,
 266                                     PyObject *kw)
 267 {
 268         cli_state_object *cli = (cli_state_object *)self;
 269         static char *kwlist[] = { "fnum", "security_descriptor", NULL };
 270         PyObject *result = NULL;
 271         PyObject *py_secdesc;
 272         SEC_DESC *secdesc;
 273         TALLOC_CTX *mem_ctx = NULL;
 274         int fnum;
 275         BOOL err;
 276
 277         /* Parse parameters */
 278
 279         if (!PyArg_ParseTupleAndKeywords(
 280                     args, kw, "iO", kwlist, &fnum, &py_secdesc))
 281                 return NULL;
 282
 283         mem_ctx = talloc_init("py_smb_set_secdesc");
 284
 285         if (!py_to_SECDESC(&secdesc, py_secdesc, mem_ctx)) {
 286                 PyErr_SetString(PyExc_TypeError,
 287                                 "Invalid security descriptor");
 288                 goto done;
 289         }
 290
 291         err = cli_set_secdesc(cli->cli, fnum, secdesc);
 292
 293         if (cli_is_error(cli->cli)) {
 294                 PyErr_SetString(PyExc_RuntimeError, "set_secdesc failed");
 295                 goto done;
 296         }
 297
 298         result =  PyInt_FromLong(err);
 299  done:
 300         talloc_destroy(mem_ctx);
 301
 302         return result;
 303 }
 304
 305 static PyMethodDef smb_hnd_methods[] = {
 306
 307         /* Session and connection handling */
 308
 309         { "session_request", (PyCFunction)py_smb_session_request,
 310           METH_VARARGS | METH_KEYWORDS, "Request a session" },
 311
 312         { "negprot", (PyCFunction)py_smb_negprot,
 313           METH_VARARGS | METH_KEYWORDS, "Protocol negotiation" },
 314
 315         { "session_setup", (PyCFunction)py_smb_session_setup,
 316           METH_VARARGS | METH_KEYWORDS, "Session setup" },
 317
 318         { "tconx", (PyCFunction)py_smb_tconx,
 319           METH_VARARGS | METH_KEYWORDS, "Tree connect" },
 320
 321         /* File operations */
 322
 323         { "nt_create_andx", (PyCFunction)py_smb_nt_create_andx,
 324           METH_VARARGS | METH_KEYWORDS, "NT Create&X" },
 325
 326         { "close", (PyCFunction)py_smb_close,
 327           METH_VARARGS | METH_KEYWORDS, "Close" },
 328
 329         { "unlink", (PyCFunction)py_smb_unlink,
 330           METH_VARARGS | METH_KEYWORDS, "Unlink" },
 331
 332         /* Security descriptors */
 333
 334         { "query_secdesc", (PyCFunction)py_smb_query_secdesc,
 335           METH_VARARGS | METH_KEYWORDS, "Query security descriptor" },
 336
 337         { "set_secdesc", (PyCFunction)py_smb_set_secdesc,
 338           METH_VARARGS | METH_KEYWORDS, "Set security descriptor" },
 339
 340         { NULL }
 341 };
 342
 343 /*
 344  * Method dispatch tables
 345  */
 346
 347 static PyMethodDef smb_methods[] = {
 348
 349         { "connect", (PyCFunction)py_smb_connect, METH_VARARGS | METH_KEYWORDS,
 350           "Connect to a host" },
 351
 352         /* Other stuff - this should really go into a samba config module
 353            but for the moment let's leave it here. */
 354
 355         { "setup_logging", (PyCFunction)py_setup_logging,
 356           METH_VARARGS | METH_KEYWORDS,
 357           "Set up debug logging.\n"
 358 "\n"
 359 "Initialises Samba's debug logging system.  One argument is expected which\n"
 360 "is a boolean specifying whether debugging is interactive and sent to stdout\n"
 361 "or logged to a file.\n"
 362 "\n"
 363 "Example:\n"
 364 "\n"
 365 ">>> smb.setup_logging(interactive = 1)" },
 366
 367         { "get_debuglevel", (PyCFunction)get_debuglevel,
 368           METH_VARARGS,
 369           "Set the current debug level.\n"
 370 "\n"
 371 "Example:\n"
 372 "\n"
 373 ">>> smb.get_debuglevel()\n"
 374 "0" },
 375
 376         { "set_debuglevel", (PyCFunction)set_debuglevel,
 377           METH_VARARGS,
 378           "Get the current debug level.\n"
 379 "\n"
 380 "Example:\n"
 381 "\n"
 382 ">>> smb.set_debuglevel(10)" },
 383
 384         { NULL }
 385 };
 386
 387 static void py_cli_state_dealloc(PyObject* self)
 388 {
 389         cli_state_object *cli = (cli_state_object *)self;
 390
 391         if (cli->cli)
 392                 cli_shutdown(cli->cli);
 393
 394         PyObject_Del(self);
 395 }
 396
 397 static PyObject *py_cli_state_getattr(PyObject *self, char *attrname)
 398 {
 399         return Py_FindMethod(smb_hnd_methods, self, attrname);
 400 }
 401
 402 PyTypeObject cli_state_type = {
 403         PyObject_HEAD_INIT(NULL)
 404         0,
 405         "SMB client connection",
 406         sizeof(cli_state_object),
 407         0,
 408         py_cli_state_dealloc, /*tp_dealloc*/
 409         0,          /*tp_print*/
 410         py_cli_state_getattr,          /*tp_getattr*/
 411         0,          /*tp_setattr*/
 412         0,          /*tp_compare*/
 413         0,          /*tp_repr*/
 414         0,          /*tp_as_number*/
 415         0,          /*tp_as_sequence*/
 416         0,          /*tp_as_mapping*/
 417         0,          /*tp_hash */
 418 };
 419
 420 /*
 421  * Module initialisation
 422  */
 423
 424 void initsmb(void)
 425 {
 426         PyObject *module, *dict;
 427
 428         /* Initialise module */
 429
 430         module = Py_InitModule("smb", smb_methods);
 431         dict = PyModule_GetDict(module);
 432
 433         /* Initialise policy handle object */
 434
 435         cli_state_type.ob_type = &PyType_Type;
 436
 437         /* Do samba initialisation */
 438
 439         py_samba_init();
 440
 441         setup_logging("smb", True);
 442         DEBUGLEVEL = 3;
 443 }