source/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", NULL };
 153         char *filename;
 154         uint32 desired_access, file_attributes = 0,
 155                 share_access = FILE_SHARE_READ | FILE_SHARE_WRITE,
 156                 create_disposition = FILE_EXISTS_OPEN, create_options = 0;
 157         int result;
 158
 159         /* Parse parameters */
 160
 161         if (!PyArg_ParseTupleAndKeywords(
 162                     args, kw, "si|iii", kwlist, &filename, &desired_access,
 163                     &file_attributes, &share_access, &create_disposition,
 164                     &create_options))
 165                 return NULL;
 166
 167         result = cli_nt_create_full(
 168                 cli->cli, filename, 0, desired_access, file_attributes,
 169                 share_access, create_disposition, create_options, 0);
 170
 171         if (cli_is_error(cli->cli)) {
 172                 PyErr_SetString(PyExc_RuntimeError, "nt_create_andx failed");
 173                 return NULL;
 174         }
 175
 176         /* Return FID */
 177
 178         return PyInt_FromLong(result);
 179 }
 180
 181 static PyObject *py_smb_close(PyObject *self, PyObject *args,
 182                               PyObject *kw)
 183 {
 184         cli_state_object *cli = (cli_state_object *)self;
 185         static char *kwlist[] = { "fnum", NULL };
 186         BOOL result;
 187         int fnum;
 188
 189         /* Parse parameters */
 190
 191         if (!PyArg_ParseTupleAndKeywords(
 192                     args, kw, "i", kwlist, &fnum))
 193                 return NULL;
 194
 195         result = cli_close(cli->cli, fnum);
 196
 197         return PyInt_FromLong(result);
 198 }
 199
 200 static PyObject *py_smb_unlink(PyObject *self, PyObject *args,
 201                                PyObject *kw)
 202 {
 203         cli_state_object *cli = (cli_state_object *)self;
 204         static char *kwlist[] = { "filename", NULL };
 205         char *filename;
 206         BOOL result;
 207
 208         /* Parse parameters */
 209
 210         if (!PyArg_ParseTupleAndKeywords(
 211                     args, kw, "s", kwlist, &filename))
 212                 return NULL;
 213
 214         result = cli_unlink(cli->cli, filename);
 215
 216         return PyInt_FromLong(result);
 217 }
 218
 219 static PyObject *py_smb_query_secdesc(PyObject *self, PyObject *args,
 220                                       PyObject *kw)
 221 {
 222         cli_state_object *cli = (cli_state_object *)self;
 223         static char *kwlist[] = { "fnum", NULL };
 224         PyObject *result;
 225         SEC_DESC *secdesc = NULL;
 226         int fnum;
 227         TALLOC_CTX *mem_ctx;
 228
 229         /* Parse parameters */
 230
 231         if (!PyArg_ParseTupleAndKeywords(
 232                     args, kw, "i", kwlist, &fnum))
 233                 return NULL;
 234
 235         mem_ctx = talloc_init("py_smb_query_secdesc");
 236
 237         secdesc = cli_query_secdesc(cli->cli, fnum, mem_ctx);
 238
 239         if (cli_is_error(cli->cli)) {
 240                 PyErr_SetString(PyExc_RuntimeError, "query_secdesc failed");
 241                 return NULL;
 242         }
 243
 244         if (!secdesc) {
 245                 Py_INCREF(Py_None);
 246                 result = Py_None;
 247                 goto done;
 248         }
 249
 250         if (!py_from_SECDESC(&result, secdesc)) {
 251                 PyErr_SetString(
 252                         PyExc_TypeError,
 253                         "Invalid security descriptor returned");
 254                 result = NULL;
 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 *py_secdesc;
 271         SEC_DESC *secdesc;
 272         TALLOC_CTX *mem_ctx = talloc_init("py_smb_set_secdesc");
 273         int fnum;
 274         BOOL result;
 275
 276         /* Parse parameters */
 277
 278         if (!PyArg_ParseTupleAndKeywords(
 279                     args, kw, "iO", kwlist, &fnum, &py_secdesc))
 280                 return NULL;
 281
 282         if (!py_to_SECDESC(&secdesc, py_secdesc, mem_ctx)) {
 283                 PyErr_SetString(PyExc_TypeError,
 284                                 "Invalid security descriptor");
 285                 return NULL;
 286         }
 287
 288         result = cli_set_secdesc(cli->cli, fnum, secdesc);
 289
 290         if (cli_is_error(cli->cli)) {
 291                 PyErr_SetString(PyExc_RuntimeError, "set_secdesc failed");
 292                 return NULL;
 293         }
 294
 295         return PyInt_FromLong(result);
 296 }
 297
 298 static PyMethodDef smb_hnd_methods[] = {
 299
 300         /* Session and connection handling */
 301
 302         { "session_request", (PyCFunction)py_smb_session_request,
 303           METH_VARARGS | METH_KEYWORDS, "Request a session" },
 304
 305         { "negprot", (PyCFunction)py_smb_negprot,
 306           METH_VARARGS | METH_KEYWORDS, "Protocol negotiation" },
 307
 308         { "session_setup", (PyCFunction)py_smb_session_setup,
 309           METH_VARARGS | METH_KEYWORDS, "Session setup" },
 310
 311         { "tconx", (PyCFunction)py_smb_tconx,
 312           METH_VARARGS | METH_KEYWORDS, "Tree connect" },
 313
 314         /* File operations */
 315
 316         { "nt_create_andx", (PyCFunction)py_smb_nt_create_andx,
 317           METH_VARARGS | METH_KEYWORDS, "NT Create&X" },
 318
 319         { "close", (PyCFunction)py_smb_close,
 320           METH_VARARGS | METH_KEYWORDS, "Close" },
 321
 322         { "unlink", (PyCFunction)py_smb_unlink,
 323           METH_VARARGS | METH_KEYWORDS, "Unlink" },
 324
 325         /* Security descriptors */
 326
 327         { "query_secdesc", (PyCFunction)py_smb_query_secdesc,
 328           METH_VARARGS | METH_KEYWORDS, "Query security descriptor" },
 329
 330         { "set_secdesc", (PyCFunction)py_smb_set_secdesc,
 331           METH_VARARGS | METH_KEYWORDS, "Set security descriptor" },
 332
 333         { NULL }
 334 };
 335
 336 /*
 337  * Method dispatch tables
 338  */
 339
 340 static PyMethodDef smb_methods[] = {
 341
 342         { "connect", (PyCFunction)py_smb_connect, METH_VARARGS | METH_KEYWORDS,
 343           "Connect to a host" },
 344
 345         { NULL }
 346 };
 347
 348 static void py_cli_state_dealloc(PyObject* self)
 349 {
 350         PyObject_Del(self);
 351 }
 352
 353 static PyObject *py_cli_state_getattr(PyObject *self, char *attrname)
 354 {
 355         return Py_FindMethod(smb_hnd_methods, self, attrname);
 356 }
 357
 358 PyTypeObject cli_state_type = {
 359         PyObject_HEAD_INIT(NULL)
 360         0,
 361         "SMB client connection",
 362         sizeof(cli_state_object),
 363         0,
 364         py_cli_state_dealloc, /*tp_dealloc*/
 365         0,          /*tp_print*/
 366         py_cli_state_getattr,          /*tp_getattr*/
 367         0,          /*tp_setattr*/
 368         0,          /*tp_compare*/
 369         0,          /*tp_repr*/
 370         0,          /*tp_as_number*/
 371         0,          /*tp_as_sequence*/
 372         0,          /*tp_as_mapping*/
 373         0,          /*tp_hash */
 374 };
 375
 376 /*
 377  * Module initialisation
 378  */
 379
 380 void initsmb(void)
 381 {
 382         PyObject *module, *dict;
 383
 384         /* Initialise module */
 385
 386         module = Py_InitModule("smb", smb_methods);
 387         dict = PyModule_GetDict(module);
 388
 389         /* Initialise policy handle object */
 390
 391         cli_state_type.ob_type = &PyType_Type;
 392
 393         /* Do samba initialisation */
 394
 395         py_samba_init();
 396
 397         setup_logging("smb", True);
 398         DEBUGLEVEL = 10;
 399 }