source3/libsmb/pylibsmb.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * Samba-internal work in progress Python binding for libsmbclient
   4  *
   5  * Copyright (C) Volker Lendecke 2012
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 3 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #include <Python.h>
  22 #include "includes.h"
  23 #include "libsmb/libsmb.h"
  24 #include "libcli/security/security.h"
  25 #include "system/select.h"
  26 #include "source4/libcli/util/pyerrors.h"
  27 #include "auth/credentials/pycredentials.h"
  28
  29 static PyTypeObject *get_pytype(const char *module, const char *type)
  30 {
  31         PyObject *mod;
  32         PyTypeObject *result;
  33
  34         mod = PyImport_ImportModule(module);
  35         if (mod == NULL) {
  36                 PyErr_Format(PyExc_RuntimeError,
  37                              "Unable to import %s to check type %s",
  38                              module, type);
  39                 return NULL;
  40         }
  41         result = (PyTypeObject *)PyObject_GetAttrString(mod, type);
  42         Py_DECREF(mod);
  43         if (result == NULL) {
  44                 PyErr_Format(PyExc_RuntimeError,
  45                              "Unable to find type %s in module %s",
  46                              module, type);
  47                 return NULL;
  48         }
  49         return result;
  50 }
  51
  52 struct py_cli_thread;
  53
  54 struct py_cli_state {
  55         PyObject_HEAD
  56         struct cli_state *cli;
  57         struct tevent_context *ev;
  58         struct py_cli_thread *thread_state;
  59 };
  60
  61 #if HAVE_PTHREAD
  62
  63 #include <pthread.h>
  64
  65 struct py_cli_thread {
  66
  67         /*
  68          * Pipe to make the poll thread wake up in our destructor, so
  69          * that we can exit and join the thread.
  70          */
  71         int shutdown_pipe[2];
  72         struct tevent_fd *shutdown_fde;
  73         bool do_shutdown;
  74         pthread_t id;
  75
  76         /*
  77          * Thread state to release the GIL during the poll(2) syscall
  78          */
  79         PyThreadState *py_threadstate;
  80 };
  81
  82 static void *py_cli_state_poll_thread(void *private_data)
  83 {
  84         struct py_cli_state *self = (struct py_cli_state *)private_data;
  85         struct py_cli_thread *t = self->thread_state;
  86         PyGILState_STATE gstate;
  87
  88         gstate = PyGILState_Ensure();
  89
  90         while (!t->do_shutdown) {
  91                 int ret;
  92                 ret = tevent_loop_once(self->ev);
  93                 assert(ret == 0);
  94         }
  95         PyGILState_Release(gstate);
  96         return NULL;
  97 }
  98
  99 static void py_cli_state_trace_callback(enum tevent_trace_point point,
 100                                         void *private_data)
 101 {
 102         struct py_cli_state *self = (struct py_cli_state *)private_data;
 103         struct py_cli_thread *t = self->thread_state;
 104
 105         switch(point) {
 106         case TEVENT_TRACE_BEFORE_WAIT:
 107                 assert(t->py_threadstate == NULL);
 108                 t->py_threadstate = PyEval_SaveThread();
 109                 break;
 110         case TEVENT_TRACE_AFTER_WAIT:
 111                 assert(t->py_threadstate != NULL);
 112                 PyEval_RestoreThread(t->py_threadstate);
 113                 t->py_threadstate = NULL;
 114                 break;
 115         default:
 116                 break;
 117         }
 118 }
 119
 120 static void py_cli_state_shutdown_handler(struct tevent_context *ev,
 121                                           struct tevent_fd *fde,
 122                                           uint16_t flags,
 123                                           void *private_data)
 124 {
 125         struct py_cli_state *self = (struct py_cli_state *)private_data;
 126         struct py_cli_thread *t = self->thread_state;
 127
 128         if ((flags & TEVENT_FD_READ) == 0) {
 129                 return;
 130         }
 131         TALLOC_FREE(t->shutdown_fde);
 132         t->do_shutdown = true;
 133 }
 134
 135 static int py_cli_thread_destructor(struct py_cli_thread *t)
 136 {
 137         char c = 0;
 138         ssize_t written;
 139         int ret;
 140
 141         do {
 142                 /*
 143                  * This will wake the poll thread from the poll(2)
 144                  */
 145                 written = write(t->shutdown_pipe[1], &c, 1);
 146         } while ((written == -1) && (errno == EINTR));
 147
 148         /*
 149          * Allow the poll thread to do its own cleanup under the GIL
 150          */
 151         Py_BEGIN_ALLOW_THREADS
 152         ret = pthread_join(t->id, NULL);
 153         Py_END_ALLOW_THREADS
 154         assert(ret == 0);
 155
 156         if (t->shutdown_pipe[0] != -1) {
 157                 close(t->shutdown_pipe[0]);
 158                 t->shutdown_pipe[0] = -1;
 159         }
 160         if (t->shutdown_pipe[1] != -1) {
 161                 close(t->shutdown_pipe[1]);
 162                 t->shutdown_pipe[1] = -1;
 163         }
 164         return 0;
 165 }
 166
 167 static bool py_cli_state_setup_ev(struct py_cli_state *self)
 168 {
 169         struct py_cli_thread *t = NULL;
 170         int ret;
 171
 172         self->ev = tevent_context_init_byname(NULL, "poll_mt");
 173         if (self->ev == NULL) {
 174                 goto fail;
 175         }
 176         tevent_set_trace_callback(self->ev, py_cli_state_trace_callback, self);
 177
 178         self->thread_state = talloc_zero(NULL, struct py_cli_thread);
 179         if (self->thread_state == NULL) {
 180                 goto fail;
 181         }
 182         t = self->thread_state;
 183
 184         ret = pipe(t->shutdown_pipe);
 185         if (ret == -1) {
 186                 goto fail;
 187         }
 188         t->shutdown_fde = tevent_add_fd(
 189                 self->ev, self->ev, t->shutdown_pipe[0], TEVENT_FD_READ,
 190                 py_cli_state_shutdown_handler, self);
 191         if (t->shutdown_fde == NULL) {
 192                 goto fail;
 193         }
 194
 195         PyEval_InitThreads();
 196
 197         ret = pthread_create(&t->id, NULL, py_cli_state_poll_thread, self);
 198         if (ret != 0) {
 199                 goto fail;
 200         }
 201         talloc_set_destructor(self->thread_state, py_cli_thread_destructor);
 202         return true;
 203
 204 fail:
 205         if (t != NULL) {
 206                 TALLOC_FREE(t->shutdown_fde);
 207
 208                 if (t->shutdown_pipe[0] != -1) {
 209                         close(t->shutdown_pipe[0]);
 210                         t->shutdown_pipe[0] = -1;
 211                 }
 212                 if (t->shutdown_pipe[1] != -1) {
 213                         close(t->shutdown_pipe[1]);
 214                         t->shutdown_pipe[1] = -1;
 215                 }
 216         }
 217
 218         TALLOC_FREE(self->thread_state);
 219         TALLOC_FREE(self->ev);
 220         return false;
 221 }
 222
 223 struct py_tevent_cond {
 224         pthread_mutex_t mutex;
 225         pthread_cond_t cond;
 226         bool is_done;
 227 };
 228
 229 static void py_tevent_signalme(struct tevent_req *req);
 230
 231 static int py_tevent_req_wait(struct tevent_context *ev,
 232                               struct tevent_req *req)
 233 {
 234         struct py_tevent_cond cond;
 235         int ret, result;
 236
 237         result = pthread_mutex_init(&cond.mutex, NULL);
 238         if (result != 0) {
 239                 goto fail;
 240         }
 241         result = pthread_cond_init(&cond.cond, NULL);
 242         if (result != 0) {
 243                 goto fail_mutex;
 244         }
 245
 246         cond.is_done = false;
 247         tevent_req_set_callback(req, py_tevent_signalme, &cond);
 248
 249         result = pthread_mutex_lock(&cond.mutex);
 250         if (result != 0) {
 251                 goto fail_cond;
 252         }
 253
 254         while (!cond.is_done) {
 255
 256                 Py_BEGIN_ALLOW_THREADS
 257                 result = pthread_cond_wait(&cond.cond, &cond.mutex);
 258                 Py_END_ALLOW_THREADS
 259
 260                 if (result != 0) {
 261                         goto fail_unlock;
 262                 }
 263         }
 264
 265 fail_unlock:
 266         ret = pthread_mutex_unlock(&cond.mutex);
 267         assert(ret == 0);
 268 fail_cond:
 269         ret = pthread_cond_destroy(&cond.cond);
 270         assert(ret == 0);
 271 fail_mutex:
 272         ret = pthread_mutex_destroy(&cond.mutex);
 273         assert(ret == 0);
 274 fail:
 275         return result;
 276 }
 277
 278 static void py_tevent_signalme(struct tevent_req *req)
 279 {
 280         struct py_tevent_cond *cond = (struct py_tevent_cond *)
 281                 tevent_req_callback_data_void(req);
 282         int ret;
 283
 284         ret = pthread_mutex_lock(&cond->mutex);
 285         assert(ret == 0);
 286
 287         cond->is_done = true;
 288
 289         ret = pthread_cond_signal(&cond->cond);
 290         assert(ret == 0);
 291         ret = pthread_mutex_unlock(&cond->mutex);
 292         assert(ret == 0);
 293 }
 294
 295 #else
 296
 297 static bool py_cli_state_setup_ev(struct py_cli_state *self)
 298 {
 299         self->ev = tevent_context_init(NULL);
 300         return (self->ev != NULL);
 301 }
 302
 303 static int py_tevent_req_wait(struct tevent_context *ev,
 304                               struct tevent_req *req)
 305 {
 306         while (tevent_req_is_in_progress(req)) {
 307                 int ret;
 308
 309                 ret = tevent_loop_once(ev);
 310                 if (ret != 0) {
 311                         return ret;
 312                 }
 313         }
 314         return 0;
 315 }
 316
 317 #endif
 318
 319 static PyObject *py_cli_state_new(PyTypeObject *type, PyObject *args,
 320                                   PyObject *kwds)
 321 {
 322         struct py_cli_state *self;
 323
 324         self = (struct py_cli_state *)type->tp_alloc(type, 0);
 325         if (self == NULL) {
 326                 return NULL;
 327         }
 328         self->cli = NULL;
 329         self->ev = NULL;
 330         self->thread_state = NULL;
 331         return (PyObject *)self;
 332 }
 333
 334 static int py_cli_state_init(struct py_cli_state *self, PyObject *args,
 335                              PyObject *kwds)
 336 {
 337         NTSTATUS status;
 338         char *host, *share;
 339         PyObject *creds;
 340         struct cli_credentials *cli_creds;
 341         bool ret;
 342
 343         static const char *kwlist[] = {
 344                 "host", "share", "credentials", NULL
 345         };
 346
 347         PyTypeObject *py_type_Credentials = get_pytype(
 348                 "samba.credentials", "Credentials");
 349         if (py_type_Credentials == NULL) {
 350                 return -1;
 351         }
 352
 353         ret = PyArg_ParseTupleAndKeywords(
 354                 args, kwds, "ss|O!", (char **)kwlist,
 355                 &host, &share, py_type_Credentials, &creds);
 356
 357         Py_DECREF(py_type_Credentials);
 358
 359         if (!ret) {
 360                 return -1;
 361         }
 362
 363         if (!py_cli_state_setup_ev(self)) {
 364                 return -1;
 365         }
 366
 367         cli_creds = cli_credentials_from_py_object(creds);
 368         if (cli_creds == NULL) {
 369                 PyErr_SetString(PyExc_TypeError, "Expected credentials");
 370                 return -1;
 371         }
 372
 373         status = cli_full_connection(
 374                 &self->cli, "myname", host, NULL, 0, share, "?????",
 375                 cli_credentials_get_username(cli_creds),
 376                 cli_credentials_get_domain(cli_creds),
 377                 cli_credentials_get_password(cli_creds),
 378                 0, 0);
 379         if (!NT_STATUS_IS_OK(status)) {
 380                 PyErr_SetNTSTATUS(status);
 381                 return -1;
 382         }
 383         return 0;
 384 }
 385
 386 static void py_cli_state_dealloc(struct py_cli_state *self)
 387 {
 388         TALLOC_FREE(self->thread_state);
 389         TALLOC_FREE(self->ev);
 390
 391         if (self->cli != NULL) {
 392                 cli_shutdown(self->cli);
 393                 self->cli = NULL;
 394         }
 395         self->ob_type->tp_free((PyObject *)self);
 396 }
 397
 398 static bool py_tevent_req_wait_exc(struct tevent_context *ev,
 399                                    struct tevent_req *req)
 400 {
 401         int ret;
 402
 403         if (req == NULL) {
 404                 PyErr_NoMemory();
 405                 return false;
 406         }
 407         ret = py_tevent_req_wait(ev, req);
 408         if (ret != 0) {
 409                 TALLOC_FREE(req);
 410                 errno = ret;
 411                 PyErr_SetFromErrno(PyExc_RuntimeError);
 412                 return false;
 413         }
 414         return true;
 415 }
 416
 417 static PyObject *py_cli_create(struct py_cli_state *self, PyObject *args,
 418                                PyObject *kwds)
 419 {
 420         char *fname;
 421         unsigned CreateFlags = 0;
 422         unsigned DesiredAccess = FILE_GENERIC_READ;
 423         unsigned FileAttributes = 0;
 424         unsigned ShareAccess = 0;
 425         unsigned CreateDisposition = FILE_OPEN;
 426         unsigned CreateOptions = 0;
 427         unsigned SecurityFlags = 0;
 428         uint16_t fnum;
 429         struct tevent_req *req;
 430         NTSTATUS status;
 431
 432         static const char *kwlist[] = {
 433                 "Name", "CreateFlags", "DesiredAccess", "FileAttributes",
 434                 "ShareAccess", "CreateDisposition", "CreateOptions",
 435                 "SecurityFlags", NULL };
 436
 437         if (!PyArg_ParseTupleAndKeywords(
 438                     args, kwds, "s|IIIIIII", (char **)kwlist,
 439                     &fname, &CreateFlags, &DesiredAccess, &FileAttributes,
 440                     &ShareAccess, &CreateDisposition, &CreateOptions,
 441                     &SecurityFlags)) {
 442                 return NULL;
 443         }
 444
 445         req = cli_ntcreate_send(NULL, self->ev, self->cli, fname, CreateFlags,
 446                                 DesiredAccess, FileAttributes, ShareAccess,
 447                                 CreateDisposition, CreateOptions,
 448                                 SecurityFlags);
 449         if (!py_tevent_req_wait_exc(self->ev, req)) {
 450                 return NULL;
 451         }
 452         status = cli_ntcreate_recv(req, &fnum);
 453         TALLOC_FREE(req);
 454
 455         if (!NT_STATUS_IS_OK(status)) {
 456                 PyErr_SetNTSTATUS(status);
 457                 return NULL;
 458         }
 459         return Py_BuildValue("I", (unsigned)fnum);
 460 }
 461
 462 static PyObject *py_cli_close(struct py_cli_state *self, PyObject *args)
 463 {
 464         struct tevent_req *req;
 465         int fnum;
 466         NTSTATUS status;
 467
 468         if (!PyArg_ParseTuple(args, "i", &fnum)) {
 469                 return NULL;
 470         }
 471
 472         req = cli_close_send(NULL, self->ev, self->cli, fnum);
 473         if (!py_tevent_req_wait_exc(self->ev, req)) {
 474                 return NULL;
 475         }
 476         status = cli_close_recv(req);
 477         TALLOC_FREE(req);
 478
 479         if (!NT_STATUS_IS_OK(status)) {
 480                 PyErr_SetNTSTATUS(status);
 481                 return NULL;
 482         }
 483         Py_INCREF(Py_None);
 484         return Py_None;
 485 }
 486
 487 static PyObject *py_cli_write(struct py_cli_state *self, PyObject *args,
 488                               PyObject *kwds)
 489 {
 490         int fnum;
 491         unsigned mode = 0;
 492         char *buf;
 493         int buflen;
 494         unsigned long long offset;
 495         struct tevent_req *req;
 496         NTSTATUS status;
 497         size_t written;
 498
 499         static const char *kwlist[] = {
 500                 "fnum", "buffer", "offset", "mode", NULL };
 501
 502         if (!PyArg_ParseTupleAndKeywords(
 503                     args, kwds, "Is#K|I", (char **)kwlist,
 504                     &fnum, &buf, &buflen, &offset, &mode)) {
 505                 return NULL;
 506         }
 507
 508         req = cli_write_andx_send(NULL, self->ev, self->cli, fnum, mode,
 509                                   (uint8_t *)buf, offset, buflen);
 510         if (!py_tevent_req_wait_exc(self->ev, req)) {
 511                 return NULL;
 512         }
 513         status = cli_write_andx_recv(req, &written);
 514         TALLOC_FREE(req);
 515
 516         if (!NT_STATUS_IS_OK(status)) {
 517                 PyErr_SetNTSTATUS(status);
 518                 return NULL;
 519         }
 520         return Py_BuildValue("K", (unsigned long long)written);
 521 }
 522
 523 static PyObject *py_cli_read(struct py_cli_state *self, PyObject *args,
 524                              PyObject *kwds)
 525 {
 526         int fnum;
 527         unsigned long long offset;
 528         unsigned size;
 529         struct tevent_req *req;
 530         NTSTATUS status;
 531         uint8_t *buf;
 532         ssize_t buflen;
 533         PyObject *result;
 534
 535         static const char *kwlist[] = {
 536                 "fnum", "offset", "size", NULL };
 537
 538         if (!PyArg_ParseTupleAndKeywords(
 539                     args, kwds, "IKI", (char **)kwlist, &fnum, &offset,
 540                     &size)) {
 541                 return NULL;
 542         }
 543
 544         req = cli_read_andx_send(NULL, self->ev, self->cli, fnum,
 545                                  offset, size);
 546         if (!py_tevent_req_wait_exc(self->ev, req)) {
 547                 return NULL;
 548         }
 549         status = cli_read_andx_recv(req, &buflen, &buf);
 550
 551         if (!NT_STATUS_IS_OK(status)) {
 552                 TALLOC_FREE(req);
 553                 PyErr_SetNTSTATUS(status);
 554                 return NULL;
 555         }
 556         result = Py_BuildValue("s#", (char *)buf, (int)buflen);
 557         TALLOC_FREE(req);
 558         return result;
 559 }
 560
 561 static PyObject *py_cli_ftruncate(struct py_cli_state *self, PyObject *args,
 562                                   PyObject *kwds)
 563 {
 564         int fnum;
 565         unsigned long long size;
 566         struct tevent_req *req;
 567         NTSTATUS status;
 568
 569         static const char *kwlist[] = {
 570                 "fnum", "size", NULL };
 571
 572         if (!PyArg_ParseTupleAndKeywords(
 573                     args, kwds, "IK", (char **)kwlist, &fnum, &size)) {
 574                 return NULL;
 575         }
 576
 577         req = cli_ftruncate_send(NULL, self->ev, self->cli, fnum, size);
 578         if (!py_tevent_req_wait_exc(self->ev, req)) {
 579                 return NULL;
 580         }
 581         status = cli_ftruncate_recv(req);
 582         TALLOC_FREE(req);
 583
 584         if (!NT_STATUS_IS_OK(status)) {
 585                 PyErr_SetNTSTATUS(status);
 586                 return NULL;
 587         }
 588         Py_INCREF(Py_None);
 589         return Py_None;
 590 }
 591
 592 static PyObject *py_cli_delete_on_close(struct py_cli_state *self,
 593                                         PyObject *args,
 594                                         PyObject *kwds)
 595 {
 596         unsigned fnum, flag;
 597         struct tevent_req *req;
 598         NTSTATUS status;
 599
 600         static const char *kwlist[] = {
 601                 "fnum", "flag", NULL };
 602
 603         if (!PyArg_ParseTupleAndKeywords(
 604                     args, kwds, "II", (char **)kwlist, &fnum, &flag)) {
 605                 return NULL;
 606         }
 607
 608         req = cli_nt_delete_on_close_send(NULL, self->ev, self->cli, fnum,
 609                                           flag);
 610         if (!py_tevent_req_wait_exc(self->ev, req)) {
 611                 return NULL;
 612         }
 613         status = cli_nt_delete_on_close_recv(req);
 614         TALLOC_FREE(req);
 615
 616         if (!NT_STATUS_IS_OK(status)) {
 617                 PyErr_SetNTSTATUS(status);
 618                 return NULL;
 619         }
 620         Py_INCREF(Py_None);
 621         return Py_None;
 622 }
 623
 624 static PyMethodDef py_cli_state_methods[] = {
 625         { "create", (PyCFunction)py_cli_create, METH_VARARGS|METH_KEYWORDS,
 626           "Open a file" },
 627         { "close", (PyCFunction)py_cli_close, METH_VARARGS,
 628           "Close a file handle" },
 629         { "write", (PyCFunction)py_cli_write, METH_VARARGS|METH_KEYWORDS,
 630           "Write to a file handle" },
 631         { "read", (PyCFunction)py_cli_read, METH_VARARGS|METH_KEYWORDS,
 632           "Read from a file handle" },
 633         { "truncate", (PyCFunction)py_cli_ftruncate,
 634           METH_VARARGS|METH_KEYWORDS,
 635           "Truncate a file" },
 636         { "delete_on_close", (PyCFunction)py_cli_delete_on_close,
 637           METH_VARARGS|METH_KEYWORDS,
 638           "Set/Reset the delete on close flag" },
 639         { NULL, NULL, 0, NULL }
 640 };
 641
 642 static PyTypeObject py_cli_state_type = {
 643         PyObject_HEAD_INIT(NULL)
 644         .tp_name = "libsmb_samba_internal.Conn",
 645         .tp_basicsize = sizeof(struct py_cli_state),
 646         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 647         .tp_doc = "libsmb connection",
 648         .tp_new = py_cli_state_new,
 649         .tp_init = (initproc)py_cli_state_init,
 650         .tp_dealloc = (destructor)py_cli_state_dealloc,
 651         .tp_methods = py_cli_state_methods,
 652 };
 653
 654 static PyMethodDef py_libsmb_methods[] = {
 655         { NULL },
 656 };
 657
 658 void initlibsmb_samba_internal(void);
 659 void initlibsmb_samba_internal(void)
 660 {
 661         PyObject *m;
 662
 663         talloc_stackframe();
 664
 665         m = Py_InitModule3("libsmb_samba_internal", py_libsmb_methods,
 666                            "libsmb wrapper");
 667
 668         if (PyType_Ready(&py_cli_state_type) < 0) {
 669                 return;
 670         }
 671         Py_INCREF(&py_cli_state_type);
 672         PyModule_AddObject(m, "Conn", (PyObject *)&py_cli_state_type);
 673 }