source3/libsmb/pylibsmb.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  *
   4  * SMB client Python bindings used internally by Samba (for things like
   5  * samba-tool). These Python bindings may change without warning, and so
   6  * should not be used outside of the Samba codebase.
   7  *
   8  * Copyright (C) Volker Lendecke 2012
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 3 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 /*
  25 Template code to use this library:
  26
  27 -------------------------
  28 from samba.samba3 import libsmb_samba_internal as libsmb
  29 from samba.samba3 import param as s3param
  30 from samba import (credentials,NTSTATUSError)
  31
  32 lp = s3param.get_context()
  33 lp.load("/etc/samba/smb.conf");
  34
  35 creds = credentials.Credentials()
  36 creds.guess(lp)
  37 creds.set_username("administrator")
  38 creds.set_password("1234")
  39
  40 c = libsmb.Conn("127.0.0.1",
  41                 "tmp",
  42                 lp,
  43                 creds,
  44                 multi_threaded=True)
  45 -------------------------
  46 */
  47
  48 #include "lib/replace/system/python.h"
  49 #include "includes.h"
  50 #include "python/py3compat.h"
  51 #include "python/modules.h"
  52 #include "libcli/smb/smbXcli_base.h"
  53 #include "libcli/smb/smb2_negotiate_context.h"
  54 #include "libcli/smb/reparse.h"
  55 #include "libsmb/libsmb.h"
  56 #include "libcli/security/security.h"
  57 #include "system/select.h"
  58 #include "source4/libcli/util/pyerrors.h"
  59 #include "auth/credentials/pycredentials.h"
  60 #include "trans2.h"
  61 #include "libsmb/clirap.h"
  62 #include "librpc/rpc/pyrpc_util.h"
  63
  64 #define LIST_ATTRIBUTE_MASK \
  65         (FILE_ATTRIBUTE_DIRECTORY|FILE_ATTRIBUTE_SYSTEM|FILE_ATTRIBUTE_HIDDEN)
  66
  67 static PyTypeObject *dom_sid_Type = NULL;
  68
  69 static PyTypeObject *get_pytype(const char *module, const char *type)
  70 {
  71         PyObject *mod;
  72         PyTypeObject *result;
  73
  74         mod = PyImport_ImportModule(module);
  75         if (mod == NULL) {
  76                 PyErr_Format(PyExc_RuntimeError,
  77                              "Unable to import %s to check type %s",
  78                              module, type);
  79                 return NULL;
  80         }
  81         result = (PyTypeObject *)PyObject_GetAttrString(mod, type);
  82         Py_DECREF(mod);
  83         if (result == NULL) {
  84                 PyErr_Format(PyExc_RuntimeError,
  85                              "Unable to find type %s in module %s",
  86                              module, type);
  87                 return NULL;
  88         }
  89         return result;
  90 }
  91
  92 /*
  93  * We're using "const char * const *" for keywords,
  94  * PyArg_ParseTupleAndKeywords expects a "char **". Confine the
  95  * inevitable warnings to just one place.
  96  */
  97 static int ParseTupleAndKeywords(PyObject *args, PyObject *kw,
  98                                  const char *format, const char * const *keywords,
  99                                  ...)
 100 {
 101         char **_keywords = discard_const_p(char *, keywords);
 102         va_list a;
 103         int ret;
 104         va_start(a, keywords);
 105         ret = PyArg_VaParseTupleAndKeywords(args, kw, format,
 106                                             _keywords, a);
 107         va_end(a);
 108         return ret;
 109 }
 110
 111 struct py_cli_thread;
 112
 113 struct py_cli_oplock_break {
 114         uint16_t fnum;
 115         uint8_t level;
 116 };
 117
 118 struct py_cli_state {
 119         PyObject_HEAD
 120         struct cli_state *cli;
 121         struct tevent_context *ev;
 122         int (*req_wait_fn)(struct tevent_context *ev,
 123                            struct tevent_req *req);
 124         struct py_cli_thread *thread_state;
 125
 126         struct tevent_req *oplock_waiter;
 127         struct py_cli_oplock_break *oplock_breaks;
 128         struct py_tevent_cond *oplock_cond;
 129 };
 130
 131 #ifdef HAVE_PTHREAD
 132
 133 #include <pthread.h>
 134
 135 struct py_cli_thread {
 136
 137         /*
 138          * Pipe to make the poll thread wake up in our destructor, so
 139          * that we can exit and join the thread.
 140          */
 141         int shutdown_pipe[2];
 142         struct tevent_fd *shutdown_fde;
 143         bool do_shutdown;
 144         pthread_t id;
 145
 146         /*
 147          * Thread state to release the GIL during the poll(2) syscall
 148          */
 149         PyThreadState *py_threadstate;
 150 };
 151
 152 static void *py_cli_state_poll_thread(void *private_data)
 153 {
 154         struct py_cli_state *self = (struct py_cli_state *)private_data;
 155         struct py_cli_thread *t = self->thread_state;
 156         PyGILState_STATE gstate;
 157
 158         gstate = PyGILState_Ensure();
 159
 160         while (!t->do_shutdown) {
 161                 int ret;
 162                 ret = tevent_loop_once(self->ev);
 163                 assert(ret == 0);
 164         }
 165         PyGILState_Release(gstate);
 166         return NULL;
 167 }
 168
 169 static void py_cli_state_trace_callback(enum tevent_trace_point point,
 170                                         void *private_data)
 171 {
 172         struct py_cli_state *self = (struct py_cli_state *)private_data;
 173         struct py_cli_thread *t = self->thread_state;
 174
 175         switch(point) {
 176         case TEVENT_TRACE_BEFORE_WAIT:
 177                 assert(t->py_threadstate == NULL);
 178                 t->py_threadstate = PyEval_SaveThread();
 179                 break;
 180         case TEVENT_TRACE_AFTER_WAIT:
 181                 assert(t->py_threadstate != NULL);
 182                 PyEval_RestoreThread(t->py_threadstate);
 183                 t->py_threadstate = NULL;
 184                 break;
 185         default:
 186                 break;
 187         }
 188 }
 189
 190 static void py_cli_state_shutdown_handler(struct tevent_context *ev,
 191                                           struct tevent_fd *fde,
 192                                           uint16_t flags,
 193                                           void *private_data)
 194 {
 195         struct py_cli_state *self = (struct py_cli_state *)private_data;
 196         struct py_cli_thread *t = self->thread_state;
 197
 198         if ((flags & TEVENT_FD_READ) == 0) {
 199                 return;
 200         }
 201         TALLOC_FREE(t->shutdown_fde);
 202         t->do_shutdown = true;
 203 }
 204
 205 static int py_cli_thread_destructor(struct py_cli_thread *t)
 206 {
 207         char c = 0;
 208         ssize_t written;
 209         int ret;
 210
 211         do {
 212                 /*
 213                  * This will wake the poll thread from the poll(2)
 214                  */
 215                 written = write(t->shutdown_pipe[1], &c, 1);
 216         } while ((written == -1) && (errno == EINTR));
 217
 218         /*
 219          * Allow the poll thread to do its own cleanup under the GIL
 220          */
 221         Py_BEGIN_ALLOW_THREADS
 222         ret = pthread_join(t->id, NULL);
 223         Py_END_ALLOW_THREADS
 224         assert(ret == 0);
 225
 226         if (t->shutdown_pipe[0] != -1) {
 227                 close(t->shutdown_pipe[0]);
 228                 t->shutdown_pipe[0] = -1;
 229         }
 230         if (t->shutdown_pipe[1] != -1) {
 231                 close(t->shutdown_pipe[1]);
 232                 t->shutdown_pipe[1] = -1;
 233         }
 234         return 0;
 235 }
 236
 237 static int py_tevent_cond_req_wait(struct tevent_context *ev,
 238                                    struct tevent_req *req);
 239
 240 static bool py_cli_state_setup_mt_ev(struct py_cli_state *self)
 241 {
 242         struct py_cli_thread *t = NULL;
 243         int ret;
 244
 245         self->ev = tevent_context_init_byname(NULL, "poll_mt");
 246         if (self->ev == NULL) {
 247                 goto fail;
 248         }
 249         samba_tevent_set_debug(self->ev, "pylibsmb_tevent_mt");
 250         tevent_set_trace_callback(self->ev, py_cli_state_trace_callback, self);
 251
 252         self->req_wait_fn = py_tevent_cond_req_wait;
 253
 254         self->thread_state = talloc_zero(NULL, struct py_cli_thread);
 255         if (self->thread_state == NULL) {
 256                 goto fail;
 257         }
 258         t = self->thread_state;
 259
 260         ret = pipe(t->shutdown_pipe);
 261         if (ret == -1) {
 262                 goto fail;
 263         }
 264         t->shutdown_fde = tevent_add_fd(
 265                 self->ev, self->ev, t->shutdown_pipe[0], TEVENT_FD_READ,
 266                 py_cli_state_shutdown_handler, self);
 267         if (t->shutdown_fde == NULL) {
 268                 goto fail;
 269         }
 270
 271         PyEval_InitThreads();
 272
 273         ret = pthread_create(&t->id, NULL, py_cli_state_poll_thread, self);
 274         if (ret != 0) {
 275                 goto fail;
 276         }
 277         talloc_set_destructor(self->thread_state, py_cli_thread_destructor);
 278         return true;
 279
 280 fail:
 281         if (t != NULL) {
 282                 TALLOC_FREE(t->shutdown_fde);
 283
 284                 if (t->shutdown_pipe[0] != -1) {
 285                         close(t->shutdown_pipe[0]);
 286                         t->shutdown_pipe[0] = -1;
 287                 }
 288                 if (t->shutdown_pipe[1] != -1) {
 289                         close(t->shutdown_pipe[1]);
 290                         t->shutdown_pipe[1] = -1;
 291                 }
 292         }
 293
 294         TALLOC_FREE(self->thread_state);
 295         TALLOC_FREE(self->ev);
 296         return false;
 297 }
 298
 299 struct py_tevent_cond {
 300         pthread_mutex_t mutex;
 301         pthread_cond_t cond;
 302         bool is_done;
 303 };
 304
 305 static void py_tevent_signalme(struct tevent_req *req);
 306
 307 static int py_tevent_cond_wait(struct py_tevent_cond *cond)
 308 {
 309         int ret, result;
 310
 311         result = pthread_mutex_init(&cond->mutex, NULL);
 312         if (result != 0) {
 313                 goto fail;
 314         }
 315         result = pthread_cond_init(&cond->cond, NULL);
 316         if (result != 0) {
 317                 goto fail_mutex;
 318         }
 319
 320         result = pthread_mutex_lock(&cond->mutex);
 321         if (result != 0) {
 322                 goto fail_cond;
 323         }
 324
 325         cond->is_done = false;
 326
 327         while (!cond->is_done) {
 328
 329                 Py_BEGIN_ALLOW_THREADS
 330                 result = pthread_cond_wait(&cond->cond, &cond->mutex);
 331                 Py_END_ALLOW_THREADS
 332
 333                 if (result != 0) {
 334                         goto fail_unlock;
 335                 }
 336         }
 337
 338 fail_unlock:
 339         ret = pthread_mutex_unlock(&cond->mutex);
 340         assert(ret == 0);
 341 fail_cond:
 342         ret = pthread_cond_destroy(&cond->cond);
 343         assert(ret == 0);
 344 fail_mutex:
 345         ret = pthread_mutex_destroy(&cond->mutex);
 346         assert(ret == 0);
 347 fail:
 348         return result;
 349 }
 350
 351 static int py_tevent_cond_req_wait(struct tevent_context *ev,
 352                                    struct tevent_req *req)
 353 {
 354         struct py_tevent_cond cond;
 355         tevent_req_set_callback(req, py_tevent_signalme, &cond);
 356         return py_tevent_cond_wait(&cond);
 357 }
 358
 359 static void py_tevent_cond_signal(struct py_tevent_cond *cond)
 360 {
 361         int ret;
 362
 363         ret = pthread_mutex_lock(&cond->mutex);
 364         assert(ret == 0);
 365
 366         cond->is_done = true;
 367
 368         ret = pthread_cond_signal(&cond->cond);
 369         assert(ret == 0);
 370         ret = pthread_mutex_unlock(&cond->mutex);
 371         assert(ret == 0);
 372 }
 373
 374 static void py_tevent_signalme(struct tevent_req *req)
 375 {
 376         struct py_tevent_cond *cond = (struct py_tevent_cond *)
 377                 tevent_req_callback_data_void(req);
 378
 379         py_tevent_cond_signal(cond);
 380 }
 381
 382 #endif
 383
 384 static int py_tevent_req_wait(struct tevent_context *ev,
 385                               struct tevent_req *req);
 386
 387 static bool py_cli_state_setup_ev(struct py_cli_state *self)
 388 {
 389         self->ev = tevent_context_init(NULL);
 390         if (self->ev == NULL) {
 391                 return false;
 392         }
 393
 394         samba_tevent_set_debug(self->ev, "pylibsmb_tevent");
 395
 396         self->req_wait_fn = py_tevent_req_wait;
 397
 398         return true;
 399 }
 400
 401 static int py_tevent_req_wait(struct tevent_context *ev,
 402                               struct tevent_req *req)
 403 {
 404         while (tevent_req_is_in_progress(req)) {
 405                 int ret;
 406
 407                 ret = tevent_loop_once(ev);
 408                 if (ret != 0) {
 409                         return ret;
 410                 }
 411         }
 412         return 0;
 413 }
 414
 415 static bool py_tevent_req_wait_exc(struct py_cli_state *self,
 416                                    struct tevent_req *req)
 417 {
 418         int ret;
 419
 420         if (req == NULL) {
 421                 PyErr_NoMemory();
 422                 return false;
 423         }
 424         ret = self->req_wait_fn(self->ev, req);
 425         if (ret != 0) {
 426                 TALLOC_FREE(req);
 427                 errno = ret;
 428                 PyErr_SetFromErrno(PyExc_RuntimeError);
 429                 return false;
 430         }
 431         return true;
 432 }
 433
 434 static PyObject *py_cli_state_new(PyTypeObject *type, PyObject *args,
 435                                   PyObject *kwds)
 436 {
 437         struct py_cli_state *self;
 438
 439         self = (struct py_cli_state *)type->tp_alloc(type, 0);
 440         if (self == NULL) {
 441                 return NULL;
 442         }
 443         self->cli = NULL;
 444         self->ev = NULL;
 445         self->thread_state = NULL;
 446         self->oplock_waiter = NULL;
 447         self->oplock_cond = NULL;
 448         self->oplock_breaks = NULL;
 449         return (PyObject *)self;
 450 }
 451
 452 static struct smb2_negotiate_contexts *py_cli_get_negotiate_contexts(
 453         TALLOC_CTX *mem_ctx, PyObject *list)
 454 {
 455         struct smb2_negotiate_contexts *ctxs = NULL;
 456         Py_ssize_t i, len;
 457         int ret;
 458
 459         ret = PyList_Check(list);
 460         if (!ret) {
 461                 goto fail;
 462         }
 463
 464         len = PyList_Size(list);
 465         if (len == 0) {
 466                 goto fail;
 467         }
 468
 469         ctxs = talloc_zero(mem_ctx, struct smb2_negotiate_contexts);
 470         if (ctxs == NULL) {
 471                 goto fail;
 472         }
 473
 474         for (i=0; i<len; i++) {
 475                 NTSTATUS status;
 476
 477                 PyObject *t = PyList_GetItem(list, i);
 478                 Py_ssize_t tlen;
 479
 480                 PyObject *ptype = NULL;
 481                 long type;
 482
 483                 PyObject *pdata = NULL;
 484                 DATA_BLOB data = { .data = NULL, };
 485
 486                 if (t == NULL) {
 487                         goto fail;
 488                 }
 489
 490                 ret = PyTuple_Check(t);
 491                 if (!ret) {
 492                         goto fail;
 493                 }
 494
 495                 tlen = PyTuple_Size(t);
 496                 if (tlen != 2) {
 497                         goto fail;
 498                 }
 499
 500                 ptype = PyTuple_GetItem(t, 0);
 501                 if (ptype == NULL) {
 502                         goto fail;
 503                 }
 504                 type = PyLong_AsLong(ptype);
 505                 if ((type < 0) || (type > UINT16_MAX)) {
 506                         goto fail;
 507                 }
 508
 509                 pdata = PyTuple_GetItem(t, 1);
 510
 511                 ret = PyBytes_Check(pdata);
 512                 if (!ret) {
 513                         goto fail;
 514                 }
 515
 516                 data.data = (uint8_t *)PyBytes_AsString(pdata);
 517                 data.length = PyBytes_Size(pdata);
 518
 519                 status = smb2_negotiate_context_add(
 520                         ctxs, ctxs, type, data.data, data.length);
 521                 if (!NT_STATUS_IS_OK(status)) {
 522                         goto fail;
 523                 }
 524         }
 525         return ctxs;
 526
 527 fail:
 528         TALLOC_FREE(ctxs);
 529         return NULL;
 530 }
 531
 532 static void py_cli_got_oplock_break(struct tevent_req *req);
 533
 534 static int py_cli_state_init(struct py_cli_state *self, PyObject *args,
 535                              PyObject *kwds)
 536 {
 537         NTSTATUS status;
 538         char *host, *share;
 539         PyObject *creds = NULL;
 540         struct cli_credentials *cli_creds;
 541         PyObject *py_lp = Py_None;
 542         PyObject *py_multi_threaded = Py_False;
 543         bool multi_threaded = false;
 544         PyObject *py_force_smb1 = Py_False;
 545         bool force_smb1 = false;
 546         PyObject *py_ipc = Py_False;
 547         PyObject *py_posix = Py_False;
 548         PyObject *py_negotiate_contexts = NULL;
 549         struct smb2_negotiate_contexts *negotiate_contexts = NULL;
 550         bool use_ipc = false;
 551         bool request_posix = false;
 552         struct tevent_req *req;
 553         bool ret;
 554         int flags = 0;
 555
 556         static const char *kwlist[] = {
 557                 "host", "share", "lp", "creds",
 558                 "multi_threaded", "force_smb1",
 559                 "ipc",
 560                 "posix",
 561                 "negotiate_contexts",
 562                 NULL
 563         };
 564
 565         PyTypeObject *py_type_Credentials = get_pytype(
 566                 "samba.credentials", "Credentials");
 567         if (py_type_Credentials == NULL) {
 568                 return -1;
 569         }
 570
 571         ret = ParseTupleAndKeywords(
 572                 args, kwds, "ssO|O!OOOOO", kwlist,
 573                 &host, &share, &py_lp,
 574                 py_type_Credentials, &creds,
 575                 &py_multi_threaded,
 576                 &py_force_smb1,
 577                 &py_ipc,
 578                 &py_posix,
 579                 &py_negotiate_contexts);
 580
 581         Py_DECREF(py_type_Credentials);
 582
 583         if (!ret) {
 584                 return -1;
 585         }
 586
 587         multi_threaded = PyObject_IsTrue(py_multi_threaded);
 588         force_smb1 = PyObject_IsTrue(py_force_smb1);
 589
 590         if (force_smb1) {
 591                 /*
 592                  * As most of the cli_*_send() function
 593                  * don't support SMB2 (it's only plugged
 594                  * into the sync wrapper functions currently)
 595                  * we have a way to force SMB1.
 596                  */
 597                 flags = CLI_FULL_CONNECTION_FORCE_SMB1;
 598         }
 599
 600         use_ipc = PyObject_IsTrue(py_ipc);
 601         if (use_ipc) {
 602                 flags |= CLI_FULL_CONNECTION_IPC;
 603         }
 604
 605         request_posix = PyObject_IsTrue(py_posix);
 606         if (request_posix) {
 607                 flags |= CLI_FULL_CONNECTION_REQUEST_POSIX;
 608         }
 609
 610         if (py_negotiate_contexts != NULL) {
 611                 negotiate_contexts = py_cli_get_negotiate_contexts(
 612                         talloc_tos(), py_negotiate_contexts);
 613                 if (negotiate_contexts == NULL) {
 614                         return -1;
 615                 }
 616         }
 617
 618         if (multi_threaded) {
 619 #ifdef HAVE_PTHREAD
 620                 ret = py_cli_state_setup_mt_ev(self);
 621                 if (!ret) {
 622                         return -1;
 623                 }
 624 #else
 625                 PyErr_SetString(PyExc_RuntimeError,
 626                                 "No PTHREAD support available");
 627                 return -1;
 628 #endif
 629         } else {
 630                 ret = py_cli_state_setup_ev(self);
 631                 if (!ret) {
 632                         return -1;
 633                 }
 634         }
 635
 636         if (creds == NULL) {
 637                 cli_creds = cli_credentials_init_anon(NULL);
 638         } else {
 639                 cli_creds = PyCredentials_AsCliCredentials(creds);
 640         }
 641
 642         req = cli_full_connection_creds_send(
 643                 NULL, self->ev, "myname", host, NULL, 0, share, "?????",
 644                 cli_creds, flags,
 645                 negotiate_contexts);
 646         if (!py_tevent_req_wait_exc(self, req)) {
 647                 return -1;
 648         }
 649         status = cli_full_connection_creds_recv(req, NULL, &self->cli);
 650         TALLOC_FREE(req);
 651
 652         if (!NT_STATUS_IS_OK(status)) {
 653                 PyErr_SetNTSTATUS(status);
 654                 return -1;
 655         }
 656
 657         /*
 658          * Oplocks require a multi threaded connection
 659          */
 660         if (self->thread_state == NULL) {
 661                 return 0;
 662         }
 663
 664         self->oplock_waiter = cli_smb_oplock_break_waiter_send(
 665                 self->ev, self->ev, self->cli);
 666         if (self->oplock_waiter == NULL) {
 667                 PyErr_NoMemory();
 668                 return -1;
 669         }
 670         tevent_req_set_callback(self->oplock_waiter, py_cli_got_oplock_break,
 671                                 self);
 672         return 0;
 673 }
 674
 675 static void py_cli_got_oplock_break(struct tevent_req *req)
 676 {
 677         struct py_cli_state *self = (struct py_cli_state *)
 678                 tevent_req_callback_data_void(req);
 679         struct py_cli_oplock_break b;
 680         struct py_cli_oplock_break *tmp;
 681         size_t num_breaks;
 682         NTSTATUS status;
 683
 684         status = cli_smb_oplock_break_waiter_recv(req, &b.fnum, &b.level);
 685         TALLOC_FREE(req);
 686         self->oplock_waiter = NULL;
 687
 688         if (!NT_STATUS_IS_OK(status)) {
 689                 return;
 690         }
 691
 692         num_breaks = talloc_array_length(self->oplock_breaks);
 693         tmp = talloc_realloc(self->ev, self->oplock_breaks,
 694                              struct py_cli_oplock_break, num_breaks+1);
 695         if (tmp == NULL) {
 696                 return;
 697         }
 698         self->oplock_breaks = tmp;
 699         self->oplock_breaks[num_breaks] = b;
 700
 701         if (self->oplock_cond != NULL) {
 702                 py_tevent_cond_signal(self->oplock_cond);
 703         }
 704
 705         self->oplock_waiter = cli_smb_oplock_break_waiter_send(
 706                 self->ev, self->ev, self->cli);
 707         if (self->oplock_waiter == NULL) {
 708                 return;
 709         }
 710         tevent_req_set_callback(self->oplock_waiter, py_cli_got_oplock_break,
 711                                 self);
 712 }
 713
 714 static PyObject *py_cli_get_oplock_break(struct py_cli_state *self,
 715                                          PyObject *args)
 716 {
 717         size_t num_oplock_breaks;
 718
 719         if (!PyArg_ParseTuple(args, "")) {
 720                 return NULL;
 721         }
 722
 723         if (self->thread_state == NULL) {
 724                 PyErr_SetString(PyExc_RuntimeError,
 725                                 "get_oplock_break() only possible on "
 726                                 "a multi_threaded connection");
 727                 return NULL;
 728         }
 729
 730         if (self->oplock_cond != NULL) {
 731                 errno = EBUSY;
 732                 PyErr_SetFromErrno(PyExc_RuntimeError);
 733                 return NULL;
 734         }
 735
 736         num_oplock_breaks = talloc_array_length(self->oplock_breaks);
 737
 738         if (num_oplock_breaks == 0) {
 739                 struct py_tevent_cond cond;
 740                 int ret;
 741
 742                 self->oplock_cond = &cond;
 743                 ret = py_tevent_cond_wait(&cond);
 744                 self->oplock_cond = NULL;
 745
 746                 if (ret != 0) {
 747                         errno = ret;
 748                         PyErr_SetFromErrno(PyExc_RuntimeError);
 749                         return NULL;
 750                 }
 751         }
 752
 753         num_oplock_breaks = talloc_array_length(self->oplock_breaks);
 754         if (num_oplock_breaks > 0) {
 755                 PyObject *result;
 756
 757                 result = Py_BuildValue(
 758                         "{s:i,s:i}",
 759                         "fnum", self->oplock_breaks[0].fnum,
 760                         "level", self->oplock_breaks[0].level);
 761
 762                 memmove(&self->oplock_breaks[0], &self->oplock_breaks[1],
 763                         sizeof(self->oplock_breaks[0]) *
 764                         (num_oplock_breaks - 1));
 765                 self->oplock_breaks = talloc_realloc(
 766                         NULL, self->oplock_breaks, struct py_cli_oplock_break,
 767                         num_oplock_breaks - 1);
 768
 769                 return result;
 770         }
 771         Py_RETURN_NONE;
 772 }
 773
 774 static void py_cli_state_dealloc(struct py_cli_state *self)
 775 {
 776         TALLOC_FREE(self->thread_state);
 777         TALLOC_FREE(self->oplock_waiter);
 778         TALLOC_FREE(self->ev);
 779
 780         if (self->cli != NULL) {
 781                 cli_shutdown(self->cli);
 782                 self->cli = NULL;
 783         }
 784         Py_TYPE(self)->tp_free((PyObject *)self);
 785 }
 786
 787 static PyObject *py_cli_settimeout(struct py_cli_state *self, PyObject *args)
 788 {
 789         unsigned int nmsecs = 0;
 790         unsigned int omsecs = 0;
 791
 792         if (!PyArg_ParseTuple(args, "I", &nmsecs)) {
 793                 return NULL;
 794         }
 795
 796         omsecs = cli_set_timeout(self->cli, nmsecs);
 797
 798         return PyLong_FromLong(omsecs);
 799 }
 800
 801 static PyObject *py_cli_echo(struct py_cli_state *self,
 802                              PyObject *Py_UNUSED(ignored))
 803 {
 804         DATA_BLOB data = data_blob_string_const("keepalive");
 805         struct tevent_req *req = NULL;
 806         NTSTATUS status;
 807
 808         req = cli_echo_send(NULL, self->ev, self->cli, 1, data);
 809         if (!py_tevent_req_wait_exc(self, req)) {
 810                 return NULL;
 811         }
 812         status = cli_echo_recv(req);
 813         TALLOC_FREE(req);
 814         PyErr_NTSTATUS_NOT_OK_RAISE(status);
 815
 816         Py_RETURN_NONE;
 817 }
 818
 819 static PyObject *py_cli_create(struct py_cli_state *self, PyObject *args,
 820                                PyObject *kwds)
 821 {
 822         char *fname;
 823         unsigned CreateFlags = 0;
 824         unsigned DesiredAccess = FILE_GENERIC_READ;
 825         unsigned FileAttributes = 0;
 826         unsigned ShareAccess = 0;
 827         unsigned CreateDisposition = FILE_OPEN;
 828         unsigned CreateOptions = 0;
 829         unsigned ImpersonationLevel = SMB2_IMPERSONATION_IMPERSONATION;
 830         unsigned SecurityFlags = 0;
 831         uint16_t fnum;
 832         struct tevent_req *req;
 833         NTSTATUS status;
 834
 835         static const char *kwlist[] = {
 836                 "Name", "CreateFlags", "DesiredAccess", "FileAttributes",
 837                 "ShareAccess", "CreateDisposition", "CreateOptions",
 838                 "ImpersonationLevel", "SecurityFlags", NULL };
 839
 840         if (!ParseTupleAndKeywords(
 841                     args, kwds, "s|IIIIIIII", kwlist,
 842                     &fname, &CreateFlags, &DesiredAccess, &FileAttributes,
 843                     &ShareAccess, &CreateDisposition, &CreateOptions,
 844                     &ImpersonationLevel, &SecurityFlags)) {
 845                 return NULL;
 846         }
 847
 848         req = cli_ntcreate_send(NULL, self->ev, self->cli, fname, CreateFlags,
 849                                 DesiredAccess, FileAttributes, ShareAccess,
 850                                 CreateDisposition, CreateOptions,
 851                                 ImpersonationLevel, SecurityFlags);
 852         if (!py_tevent_req_wait_exc(self, req)) {
 853                 return NULL;
 854         }
 855         status = cli_ntcreate_recv(req, &fnum, NULL);
 856         TALLOC_FREE(req);
 857
 858         if (!NT_STATUS_IS_OK(status)) {
 859                 PyErr_SetNTSTATUS(status);
 860                 return NULL;
 861         }
 862         return Py_BuildValue("I", (unsigned)fnum);
 863 }
 864
 865 static struct smb2_create_blobs *py_cli_get_create_contexts(
 866         TALLOC_CTX *mem_ctx, PyObject *list)
 867 {
 868         struct smb2_create_blobs *ctxs = NULL;
 869         Py_ssize_t i, len;
 870         int ret;
 871
 872         ret = PyList_Check(list);
 873         if (!ret) {
 874                 goto fail;
 875         }
 876
 877         len = PyList_Size(list);
 878         if (len == 0) {
 879                 goto fail;
 880         }
 881
 882         ctxs = talloc_zero(mem_ctx, struct smb2_create_blobs);
 883         if (ctxs == NULL) {
 884                 goto fail;
 885         }
 886
 887         for (i=0; i<len; i++) {
 888                 NTSTATUS status;
 889
 890                 PyObject *t = NULL;
 891                 Py_ssize_t tlen;
 892
 893                 PyObject *pname = NULL;
 894                 char *name = NULL;
 895
 896                 PyObject *pdata = NULL;
 897                 DATA_BLOB data = { .data = NULL, };
 898
 899                 t = PyList_GetItem(list, i);
 900                 if (t == NULL) {
 901                         goto fail;
 902                 }
 903
 904                 ret = PyTuple_Check(t);
 905                 if (!ret) {
 906                         goto fail;
 907                 }
 908
 909                 tlen = PyTuple_Size(t);
 910                 if (tlen != 2) {
 911                         goto fail;
 912                 }
 913
 914                 pname = PyTuple_GetItem(t, 0);
 915                 if (pname == NULL) {
 916                         goto fail;
 917                 }
 918                 ret = PyBytes_Check(pname);
 919                 if (!ret) {
 920                         goto fail;
 921                 }
 922                 name = PyBytes_AsString(pname);
 923
 924                 pdata = PyTuple_GetItem(t, 1);
 925                 if (pdata == NULL) {
 926                         goto fail;
 927                 }
 928                 ret = PyBytes_Check(pdata);
 929                 if (!ret) {
 930                         goto fail;
 931                 }
 932                 data = (DATA_BLOB) {
 933                         .data = (uint8_t *)PyBytes_AsString(pdata),
 934                         .length = PyBytes_Size(pdata),
 935                 };
 936                 status = smb2_create_blob_add(ctxs, ctxs, name, data);
 937                 if (!NT_STATUS_IS_OK(status)) {
 938                         goto fail;
 939                 }
 940         }
 941         return ctxs;
 942
 943 fail:
 944         TALLOC_FREE(ctxs);
 945         return NULL;
 946 }
 947
 948 static PyObject *py_cli_create_contexts(const struct smb2_create_blobs *blobs)
 949 {
 950         PyObject *py_blobs = NULL;
 951         uint32_t i;
 952
 953         if (blobs == NULL) {
 954                 Py_RETURN_NONE;
 955         }
 956
 957         py_blobs = PyList_New(blobs->num_blobs);
 958         if (py_blobs == NULL) {
 959                 return NULL;
 960         }
 961
 962         for (i=0; i<blobs->num_blobs; i++) {
 963                 struct smb2_create_blob *blob = &blobs->blobs[i];
 964                 PyObject *py_blob = NULL;
 965                 int ret;
 966
 967                 py_blob = Py_BuildValue(
 968                         "(yy#)",
 969                         blob->tag,
 970                         blob->data.data,
 971                         (int)blob->data.length);
 972                 if (py_blob == NULL) {
 973                         goto fail;
 974                 }
 975
 976                 ret = PyList_SetItem(py_blobs, i, py_blob);
 977                 if (ret == -1) {
 978                         Py_XDECREF(py_blob);
 979                         goto fail;
 980                 }
 981         }
 982         return py_blobs;
 983
 984 fail:
 985         Py_XDECREF(py_blobs);
 986         return NULL;
 987 }
 988
 989 static PyObject *py_cli_create_returns(const struct smb_create_returns *r)
 990 {
 991         PyObject *v = NULL;
 992
 993         v = Py_BuildValue(
 994                 "{sLsLsLsLsLsLsLsLsLsL}",
 995                 "oplock_level",
 996                 (unsigned long long)r->oplock_level,
 997                 "flags",
 998                 (unsigned long long)r->flags,
 999                 "create_action",
1000                 (unsigned long long)r->create_action,
1001                 "creation_time",
1002                 (unsigned long long)r->creation_time,
1003                 "last_access_time",
1004                 (unsigned long long)r->last_access_time,
1005                 "last_write_time",
1006                 (unsigned long long)r->last_write_time,
1007                 "change_time",
1008                 (unsigned long long)r->change_time,
1009                 "allocation_size",
1010                 (unsigned long long)r->allocation_size,
1011                 "end_of_file",
1012                 (unsigned long long)r->end_of_file,
1013                 "file_attributes",
1014                 (unsigned long long)r->file_attributes);
1015         return v;
1016 }
1017
1018 static PyObject *py_cli_symlink_error(const struct symlink_reparse_struct *s)
1019 {
1020         char *subst_utf8 = NULL, *print_utf8 = NULL;
1021         size_t subst_utf8_len, print_utf8_len;
1022         PyObject *v = NULL;
1023         bool ok = true;
1024
1025         /*
1026          * Python wants utf-8, regardless of our unix charset (which
1027          * most likely is utf-8 these days, but you never know).
1028          */
1029
1030         ok = convert_string_talloc(
1031                 talloc_tos(),
1032                 CH_UNIX,
1033                 CH_UTF8,
1034                 s->substitute_name,
1035                 strlen(s->substitute_name),
1036                 &subst_utf8,
1037                 &subst_utf8_len);
1038         if (!ok) {
1039                 goto fail;
1040         }
1041
1042         ok = convert_string_talloc(
1043                 talloc_tos(),
1044                 CH_UNIX,
1045                 CH_UTF8,
1046                 s->print_name,
1047                 strlen(s->print_name),
1048                 &print_utf8,
1049                 &print_utf8_len);
1050         if (!ok) {
1051                 goto fail;
1052         }
1053
1054         v = Py_BuildValue(
1055                 "{sLsssssL}",
1056                 "unparsed_path_length",
1057                 (unsigned long long)s->unparsed_path_length,
1058                 "substitute_name",
1059                 subst_utf8,
1060                 "print_name",
1061                 print_utf8,
1062                 "flags",
1063                 (unsigned long long)s->flags);
1064
1065 fail:
1066         TALLOC_FREE(subst_utf8);
1067         TALLOC_FREE(print_utf8);
1068         return v;
1069 }
1070
1071 static PyObject *py_cli_create_ex(
1072         struct py_cli_state *self, PyObject *args, PyObject *kwds)
1073 {
1074         char *fname = NULL;
1075         unsigned CreateFlags = 0;
1076         unsigned DesiredAccess = FILE_GENERIC_READ;
1077         unsigned FileAttributes = 0;
1078         unsigned ShareAccess = 0;
1079         unsigned CreateDisposition = FILE_OPEN;
1080         unsigned CreateOptions = 0;
1081         unsigned ImpersonationLevel = SMB2_IMPERSONATION_IMPERSONATION;
1082         unsigned SecurityFlags = 0;
1083         PyObject *py_create_contexts_in = NULL;
1084         PyObject *py_create_contexts_out = NULL;
1085         struct smb2_create_blobs *create_contexts_in = NULL;
1086         struct smb2_create_blobs create_contexts_out = { .num_blobs = 0 };
1087         struct smb_create_returns cr = { .create_action = 0, };
1088         struct symlink_reparse_struct *symlink = NULL;
1089         PyObject *py_cr = NULL;
1090         uint16_t fnum;
1091         struct tevent_req *req;
1092         NTSTATUS status;
1093         int ret;
1094         bool ok;
1095         PyObject *v = NULL;
1096
1097         static const char *kwlist[] = {
1098                 "Name",
1099                 "CreateFlags",
1100                 "DesiredAccess",
1101                 "FileAttributes",
1102                 "ShareAccess",
1103                 "CreateDisposition",
1104                 "CreateOptions",
1105                 "ImpersonationLevel",
1106                 "SecurityFlags",
1107                 "CreateContexts",
1108                 NULL };
1109
1110         ret = ParseTupleAndKeywords(
1111                 args,
1112                 kwds,
1113                 "s|IIIIIIIIO",
1114                 kwlist,
1115                 &fname,
1116                 &CreateFlags,
1117                 &DesiredAccess,
1118                 &FileAttributes,
1119                 &ShareAccess,
1120                 &CreateDisposition,
1121                 &CreateOptions,
1122                 &ImpersonationLevel,
1123                 &SecurityFlags,
1124                 &py_create_contexts_in);
1125         if (!ret) {
1126                 return NULL;
1127         }
1128
1129         if (py_create_contexts_in != NULL) {
1130                 create_contexts_in = py_cli_get_create_contexts(
1131                         NULL, py_create_contexts_in);
1132                 if (create_contexts_in == NULL) {
1133                         errno = EINVAL;
1134                         PyErr_SetFromErrno(PyExc_RuntimeError);
1135                         return NULL;
1136                 }
1137         }
1138
1139         if (smbXcli_conn_protocol(self->cli->conn) >= PROTOCOL_SMB2_02) {
1140                 struct cli_smb2_create_flags cflags = {
1141                         .batch_oplock = (CreateFlags & REQUEST_BATCH_OPLOCK),
1142                         .exclusive_oplock = (CreateFlags & REQUEST_OPLOCK),
1143                 };
1144
1145                 req = cli_smb2_create_fnum_send(
1146                         NULL,
1147                         self->ev,
1148                         self->cli,
1149                         fname,
1150                         cflags,
1151                         ImpersonationLevel,
1152                         DesiredAccess,
1153                         FileAttributes,
1154                         ShareAccess,
1155                         CreateDisposition,
1156                         CreateOptions,
1157                         create_contexts_in);
1158         } else {
1159                 req = cli_ntcreate_send(
1160                         NULL,
1161                         self->ev,
1162                         self->cli,
1163                         fname,
1164                         CreateFlags,
1165                         DesiredAccess,
1166                         FileAttributes,
1167                         ShareAccess,
1168                         CreateDisposition,
1169                         CreateOptions,
1170                         ImpersonationLevel,
1171                         SecurityFlags);
1172         }
1173
1174         TALLOC_FREE(create_contexts_in);
1175
1176         ok = py_tevent_req_wait_exc(self, req);
1177         if (!ok) {
1178                 return NULL;
1179         }
1180
1181         if (smbXcli_conn_protocol(self->cli->conn) >= PROTOCOL_SMB2_02) {
1182                 status = cli_smb2_create_fnum_recv(
1183                         req,
1184                         &fnum,
1185                         &cr,
1186                         NULL,
1187                         &create_contexts_out,
1188                         &symlink);
1189         } else {
1190                 status = cli_ntcreate_recv(req, &fnum, &cr);
1191         }
1192
1193         TALLOC_FREE(req);
1194
1195         if (!NT_STATUS_IS_OK(status)) {
1196                 goto fail;
1197         }
1198
1199         SMB_ASSERT(symlink == NULL);
1200
1201         py_create_contexts_out = py_cli_create_contexts(&create_contexts_out);
1202         TALLOC_FREE(create_contexts_out.blobs);
1203         if (py_create_contexts_out == NULL) {
1204                 goto nomem;
1205         }
1206
1207         py_cr = py_cli_create_returns(&cr);
1208         if (py_cr == NULL) {
1209                 goto nomem;
1210         }
1211
1212         v = Py_BuildValue("(IOO)",
1213                           (unsigned)fnum,
1214                           py_cr,
1215                           py_create_contexts_out);
1216         return v;
1217 nomem:
1218         status = NT_STATUS_NO_MEMORY;
1219 fail:
1220         Py_XDECREF(py_create_contexts_out);
1221         Py_XDECREF(py_cr);
1222         Py_XDECREF(v);
1223
1224         if (NT_STATUS_EQUAL(status, NT_STATUS_STOPPED_ON_SYMLINK) &&
1225             (symlink != NULL)) {
1226                 PyErr_SetObject(
1227                         PyObject_GetAttrString(
1228                                 PyImport_ImportModule("samba"),
1229                                 "NTSTATUSError"),
1230                         Py_BuildValue(
1231                                 "I,s,O",
1232                                 NT_STATUS_V(status),
1233                                 get_friendly_nt_error_msg(status),
1234                                 py_cli_symlink_error(symlink)));
1235         } else {
1236                 PyErr_SetNTSTATUS(status);
1237         }
1238         return NULL;
1239 }
1240
1241 static PyObject *py_cli_close(struct py_cli_state *self, PyObject *args)
1242 {
1243         struct tevent_req *req;
1244         int fnum;
1245         int flags = 0;
1246         NTSTATUS status;
1247
1248         if (!PyArg_ParseTuple(args, "i|i", &fnum, &flags)) {
1249                 return NULL;
1250         }
1251
1252         req = cli_close_send(NULL, self->ev, self->cli, fnum, flags);
1253         if (!py_tevent_req_wait_exc(self, req)) {
1254                 return NULL;
1255         }
1256         status = cli_close_recv(req);
1257         TALLOC_FREE(req);
1258
1259         if (!NT_STATUS_IS_OK(status)) {
1260                 PyErr_SetNTSTATUS(status);
1261                 return NULL;
1262         }
1263         Py_RETURN_NONE;
1264 }
1265
1266 static PyObject *py_cli_rename(
1267         struct py_cli_state *self, PyObject *args, PyObject *kwds)
1268 {
1269         char *fname_src = NULL, *fname_dst = NULL;
1270         int replace = false;
1271         struct tevent_req *req = NULL;
1272         NTSTATUS status;
1273         bool ok;
1274
1275         static const char *kwlist[] = { "src", "dst", "replace", NULL };
1276
1277         ok = ParseTupleAndKeywords(
1278                 args, kwds, "ss|p", kwlist, &fname_src, &fname_dst, &replace);
1279         if (!ok) {
1280                 return NULL;
1281         }
1282
1283         req = cli_rename_send(
1284                 NULL, self->ev, self->cli, fname_src, fname_dst, replace);
1285         if (!py_tevent_req_wait_exc(self, req)) {
1286                 return NULL;
1287         }
1288         status = cli_rename_recv(req);
1289         TALLOC_FREE(req);
1290
1291         if (!NT_STATUS_IS_OK(status)) {
1292                 PyErr_SetNTSTATUS(status);
1293                 return NULL;
1294         }
1295         Py_RETURN_NONE;
1296 }
1297
1298
1299 struct push_state {
1300         char *data;
1301         off_t nread;
1302         off_t total_data;
1303 };
1304
1305 /*
1306  * cli_push() helper to write a chunk of data to a remote file
1307  */
1308 static size_t push_data(uint8_t *buf, size_t n, void *priv)
1309 {
1310         struct push_state *state = (struct push_state *)priv;
1311         char *curr_ptr = NULL;
1312         off_t remaining;
1313         size_t copied_bytes;
1314
1315         if (state->nread >= state->total_data) {
1316                 return 0;
1317         }
1318
1319         curr_ptr = state->data + state->nread;
1320         remaining = state->total_data - state->nread;
1321         copied_bytes = MIN(remaining, n);
1322
1323         memcpy(buf, curr_ptr, copied_bytes);
1324         state->nread += copied_bytes;
1325         return copied_bytes;
1326 }
1327
1328 /*
1329  * Writes a file with the contents specified
1330  */
1331 static PyObject *py_smb_savefile(struct py_cli_state *self, PyObject *args)
1332 {
1333         uint16_t fnum;
1334         const char *filename = NULL;
1335         char *data = NULL;
1336         Py_ssize_t size = 0;
1337         NTSTATUS status;
1338         struct tevent_req *req = NULL;
1339         struct push_state state;
1340
1341         if (!PyArg_ParseTuple(args, "s"PYARG_BYTES_LEN":savefile", &filename,
1342                               &data, &size)) {
1343                 return NULL;
1344         }
1345
1346         /* create a new file handle for writing to */
1347         req = cli_ntcreate_send(NULL, self->ev, self->cli, filename, 0,
1348                                 FILE_WRITE_DATA, FILE_ATTRIBUTE_NORMAL,
1349                                 FILE_SHARE_READ|FILE_SHARE_WRITE,
1350                                 FILE_OVERWRITE_IF, FILE_NON_DIRECTORY_FILE,
1351                                 SMB2_IMPERSONATION_IMPERSONATION, 0);
1352         if (!py_tevent_req_wait_exc(self, req)) {
1353                 return NULL;
1354         }
1355         status = cli_ntcreate_recv(req, &fnum, NULL);
1356         TALLOC_FREE(req);
1357         PyErr_NTSTATUS_NOT_OK_RAISE(status);
1358
1359         /* write the new file contents */
1360         state.data = data;
1361         state.nread = 0;
1362         state.total_data = size;
1363
1364         req = cli_push_send(NULL, self->ev, self->cli, fnum, 0, 0, 0,
1365                             push_data, &state);
1366         if (!py_tevent_req_wait_exc(self, req)) {
1367                 return NULL;
1368         }
1369         status = cli_push_recv(req);
1370         TALLOC_FREE(req);
1371         PyErr_NTSTATUS_NOT_OK_RAISE(status);
1372
1373         /* close the file handle */
1374         req = cli_close_send(NULL, self->ev, self->cli, fnum, 0);
1375         if (!py_tevent_req_wait_exc(self, req)) {
1376                 return NULL;
1377         }
1378         status = cli_close_recv(req);
1379         PyErr_NTSTATUS_NOT_OK_RAISE(status);
1380
1381         Py_RETURN_NONE;
1382 }
1383
1384 static PyObject *py_cli_write(struct py_cli_state *self, PyObject *args,
1385                               PyObject *kwds)
1386 {
1387         int fnum;
1388         unsigned mode = 0;
1389         char *buf;
1390         Py_ssize_t buflen;
1391         unsigned long long offset;
1392         struct tevent_req *req;
1393         NTSTATUS status;
1394         size_t written;
1395
1396         static const char *kwlist[] = {
1397                 "fnum", "buffer", "offset", "mode", NULL };
1398
1399         if (!ParseTupleAndKeywords(
1400                     args, kwds, "i" PYARG_BYTES_LEN "K|I", kwlist,
1401                     &fnum, &buf, &buflen, &offset, &mode)) {
1402                 return NULL;
1403         }
1404
1405         req = cli_write_send(NULL, self->ev, self->cli, fnum, mode,
1406                              (uint8_t *)buf, offset, buflen);
1407         if (!py_tevent_req_wait_exc(self, req)) {
1408                 return NULL;
1409         }
1410         status = cli_write_recv(req, &written);
1411         TALLOC_FREE(req);
1412
1413         if (!NT_STATUS_IS_OK(status)) {
1414                 PyErr_SetNTSTATUS(status);
1415                 return NULL;
1416         }
1417         return Py_BuildValue("K", (unsigned long long)written);
1418 }
1419
1420 /*
1421  * Returns the size of the given file
1422  */
1423 static NTSTATUS py_smb_filesize(struct py_cli_state *self, uint16_t fnum,
1424                                 off_t *size)
1425 {
1426         NTSTATUS status;
1427         struct tevent_req *req = NULL;
1428
1429         req = cli_qfileinfo_basic_send(NULL, self->ev, self->cli, fnum);
1430         if (!py_tevent_req_wait_exc(self, req)) {
1431                 return NT_STATUS_INTERNAL_ERROR;
1432         }
1433         status = cli_qfileinfo_basic_recv(
1434                 req, NULL, size, NULL, NULL, NULL, NULL, NULL);
1435         TALLOC_FREE(req);
1436         return status;
1437 }
1438
1439 /*
1440  * Loads the specified file's contents and returns it
1441  */
1442 static PyObject *py_smb_loadfile(struct py_cli_state *self, PyObject *args)
1443 {
1444         NTSTATUS status;
1445         const char *filename = NULL;
1446         struct tevent_req *req = NULL;
1447         uint16_t fnum;
1448         off_t size;
1449         char *buf = NULL;
1450         off_t nread = 0;
1451         PyObject *result = NULL;
1452
1453         if (!PyArg_ParseTuple(args, "s:loadfile", &filename)) {
1454                 return NULL;
1455         }
1456
1457         /* get a read file handle */
1458         req = cli_ntcreate_send(NULL, self->ev, self->cli, filename, 0,
1459                                 FILE_READ_DATA | FILE_READ_ATTRIBUTES,
1460                                 FILE_ATTRIBUTE_NORMAL,
1461                                 FILE_SHARE_READ, FILE_OPEN, 0,
1462                                 SMB2_IMPERSONATION_IMPERSONATION, 0);
1463         if (!py_tevent_req_wait_exc(self, req)) {
1464                 return NULL;
1465         }
1466         status = cli_ntcreate_recv(req, &fnum, NULL);
1467         TALLOC_FREE(req);
1468         PyErr_NTSTATUS_NOT_OK_RAISE(status);
1469
1470         /* get a buffer to hold the file contents */
1471         status = py_smb_filesize(self, fnum, &size);
1472         PyErr_NTSTATUS_NOT_OK_RAISE(status);
1473
1474         result = PyBytes_FromStringAndSize(NULL, size);
1475         if (result == NULL) {
1476                 return NULL;
1477         }
1478
1479         /* read the file contents */
1480         buf = PyBytes_AS_STRING(result);
1481         req = cli_pull_send(NULL, self->ev, self->cli, fnum, 0, size,
1482                             size, cli_read_sink, &buf);
1483         if (!py_tevent_req_wait_exc(self, req)) {
1484                 Py_XDECREF(result);
1485                 return NULL;
1486         }
1487         status = cli_pull_recv(req, &nread);
1488         TALLOC_FREE(req);
1489         if (!NT_STATUS_IS_OK(status)) {
1490                 Py_XDECREF(result);
1491                 PyErr_SetNTSTATUS(status);
1492                 return NULL;
1493         }
1494
1495         /* close the file handle */
1496         req = cli_close_send(NULL, self->ev, self->cli, fnum, 0);
1497         if (!py_tevent_req_wait_exc(self, req)) {
1498                 Py_XDECREF(result);
1499                 return NULL;
1500         }
1501         status = cli_close_recv(req);
1502         TALLOC_FREE(req);
1503         if (!NT_STATUS_IS_OK(status)) {
1504                 Py_XDECREF(result);
1505                 PyErr_SetNTSTATUS(status);
1506                 return NULL;
1507         }
1508
1509         /* sanity-check we read the expected number of bytes */
1510         if (nread > size) {
1511                 Py_XDECREF(result);
1512                 PyErr_Format(PyExc_IOError,
1513                              "read invalid - got %zu requested %zu",
1514                              nread, size);
1515                 return NULL;
1516         }
1517
1518         if (nread < size) {
1519                 if (_PyBytes_Resize(&result, nread) < 0) {
1520                         return NULL;
1521                 }
1522         }
1523
1524         return result;
1525 }
1526
1527 static PyObject *py_cli_read(struct py_cli_state *self, PyObject *args,
1528                              PyObject *kwds)
1529 {
1530         int fnum;
1531         unsigned long long offset;
1532         unsigned size;
1533         struct tevent_req *req;
1534         NTSTATUS status;
1535         char *buf;
1536         size_t received;
1537         PyObject *result;
1538
1539         static const char *kwlist[] = {
1540                 "fnum", "offset", "size", NULL };
1541
1542         if (!ParseTupleAndKeywords(
1543                     args, kwds, "iKI", kwlist, &fnum, &offset,
1544                     &size)) {
1545                 return NULL;
1546         }
1547
1548         result = PyBytes_FromStringAndSize(NULL, size);
1549         if (result == NULL) {
1550                 return NULL;
1551         }
1552         buf = PyBytes_AS_STRING(result);
1553
1554         req = cli_read_send(NULL, self->ev, self->cli, fnum,
1555                             buf, offset, size);
1556         if (!py_tevent_req_wait_exc(self, req)) {
1557                 Py_XDECREF(result);
1558                 return NULL;
1559         }
1560         status = cli_read_recv(req, &received);
1561         TALLOC_FREE(req);
1562
1563         if (!NT_STATUS_IS_OK(status)) {
1564                 Py_XDECREF(result);
1565                 PyErr_SetNTSTATUS(status);
1566                 return NULL;
1567         }
1568
1569         if (received > size) {
1570                 Py_XDECREF(result);
1571                 PyErr_Format(PyExc_IOError,
1572                              "read invalid - got %zu requested %u",
1573                              received, size);
1574                 return NULL;
1575         }
1576
1577         if (received < size) {
1578                 if (_PyBytes_Resize(&result, received) < 0) {
1579                         return NULL;
1580                 }
1581         }
1582
1583         return result;
1584 }
1585
1586 static PyObject *py_cli_ftruncate(struct py_cli_state *self, PyObject *args,
1587                                   PyObject *kwds)
1588 {
1589         int fnum;
1590         unsigned long long size;
1591         struct tevent_req *req;
1592         NTSTATUS status;
1593
1594         static const char *kwlist[] = {
1595                 "fnum", "size", NULL };
1596
1597         if (!ParseTupleAndKeywords(
1598                     args, kwds, "IK", kwlist, &fnum, &size)) {
1599                 return NULL;
1600         }
1601
1602         req = cli_ftruncate_send(NULL, self->ev, self->cli, fnum, size);
1603         if (!py_tevent_req_wait_exc(self, req)) {
1604                 return NULL;
1605         }
1606         status = cli_ftruncate_recv(req);
1607         TALLOC_FREE(req);
1608
1609         if (!NT_STATUS_IS_OK(status)) {
1610                 PyErr_SetNTSTATUS(status);
1611                 return NULL;
1612         }
1613         Py_RETURN_NONE;
1614 }
1615
1616 static PyObject *py_cli_delete_on_close(struct py_cli_state *self,
1617                                         PyObject *args,
1618                                         PyObject *kwds)
1619 {
1620         unsigned fnum, flag;
1621         struct tevent_req *req;
1622         NTSTATUS status;
1623
1624         static const char *kwlist[] = {
1625                 "fnum", "flag", NULL };
1626
1627         if (!ParseTupleAndKeywords(
1628                     args, kwds, "II", kwlist, &fnum, &flag)) {
1629                 return NULL;
1630         }
1631
1632         req = cli_nt_delete_on_close_send(NULL, self->ev, self->cli, fnum,
1633                                           flag);
1634         if (!py_tevent_req_wait_exc(self, req)) {
1635                 return NULL;
1636         }
1637         status = cli_nt_delete_on_close_recv(req);
1638         TALLOC_FREE(req);
1639
1640         if (!NT_STATUS_IS_OK(status)) {
1641                 PyErr_SetNTSTATUS(status);
1642                 return NULL;
1643         }
1644         Py_RETURN_NONE;
1645 }
1646
1647 struct py_cli_notify_state {
1648         PyObject_HEAD
1649         struct py_cli_state *py_cli_state;
1650         struct tevent_req *req;
1651 };
1652
1653 static void py_cli_notify_state_dealloc(struct py_cli_notify_state *self)
1654 {
1655         TALLOC_FREE(self->req);
1656         Py_CLEAR(self->py_cli_state);
1657         Py_TYPE(self)->tp_free(self);
1658 }
1659
1660 static PyTypeObject py_cli_notify_state_type;
1661
1662 static PyObject *py_cli_notify(struct py_cli_state *self,
1663                                PyObject *args,
1664                                PyObject *kwds)
1665 {
1666         static const char *kwlist[] = {
1667                 "fnum",
1668                 "buffer_size",
1669                 "completion_filter",
1670                 "recursive",
1671                 NULL
1672         };
1673         unsigned fnum = 0;
1674         unsigned buffer_size = 0;
1675         unsigned completion_filter = 0;
1676         PyObject *py_recursive = Py_False;
1677         bool recursive = false;
1678         struct tevent_req *req = NULL;
1679         struct tevent_queue *send_queue = NULL;
1680         struct tevent_req *flush_req = NULL;
1681         bool ok;
1682         struct py_cli_notify_state *py_notify_state = NULL;
1683         struct timeval endtime;
1684
1685         ok = ParseTupleAndKeywords(args,
1686                                    kwds,
1687                                    "IIIO",
1688                                    kwlist,
1689                                    &fnum,
1690                                    &buffer_size,
1691                                    &completion_filter,
1692                                    &py_recursive);
1693         if (!ok) {
1694                 return NULL;
1695         }
1696
1697         recursive = PyObject_IsTrue(py_recursive);
1698
1699         req = cli_notify_send(NULL,
1700                               self->ev,
1701                               self->cli,
1702                               fnum,
1703                               buffer_size,
1704                               completion_filter,
1705                               recursive);
1706         if (req == NULL) {
1707                 PyErr_NoMemory();
1708                 return NULL;
1709         }
1710
1711         /*
1712          * Just wait for the request being submitted to
1713          * the kernel/socket/wire.
1714          */
1715         send_queue = smbXcli_conn_send_queue(self->cli->conn);
1716         flush_req = tevent_queue_wait_send(req,
1717                                            self->ev,
1718                                            send_queue);
1719         endtime = timeval_current_ofs_msec(self->cli->timeout);
1720         ok = tevent_req_set_endtime(flush_req,
1721                                     self->ev,
1722                                     endtime);
1723         if (!ok) {
1724                 TALLOC_FREE(req);
1725                 PyErr_NoMemory();
1726                 return NULL;
1727         }
1728         ok = py_tevent_req_wait_exc(self, flush_req);
1729         if (!ok) {
1730                 TALLOC_FREE(req);
1731                 return NULL;
1732         }
1733         TALLOC_FREE(flush_req);
1734
1735         py_notify_state = (struct py_cli_notify_state *)
1736                 py_cli_notify_state_type.tp_alloc(&py_cli_notify_state_type, 0);
1737         if (py_notify_state == NULL) {
1738                 TALLOC_FREE(req);
1739                 PyErr_NoMemory();
1740                 return NULL;
1741         }
1742         Py_INCREF(self);
1743         py_notify_state->py_cli_state = self;
1744         py_notify_state->req = req;
1745
1746         return (PyObject *)py_notify_state;
1747 }
1748
1749 static PyObject *py_cli_notify_get_changes(struct py_cli_notify_state *self,
1750                                            PyObject *args,
1751                                            PyObject *kwds)
1752 {
1753         struct py_cli_state *py_cli_state = self->py_cli_state;
1754         struct tevent_req *req = self->req;
1755         uint32_t i;
1756         uint32_t num_changes = 0;
1757         struct notify_change *changes = NULL;
1758         PyObject *result = NULL;
1759         NTSTATUS status;
1760         bool ok;
1761         static const char *kwlist[] = {
1762                 "wait",
1763                 NULL
1764         };
1765         PyObject *py_wait = Py_False;
1766         bool wait = false;
1767         bool pending;
1768
1769         ok = ParseTupleAndKeywords(args,
1770                                    kwds,
1771                                    "O",
1772                                    kwlist,
1773                                    &py_wait);
1774         if (!ok) {
1775                 return NULL;
1776         }
1777
1778         wait = PyObject_IsTrue(py_wait);
1779
1780         if (req == NULL) {
1781                 PyErr_SetString(PyExc_RuntimeError,
1782                                 "TODO req == NULL "
1783                                 "- missing change notify request?");
1784                 return NULL;
1785         }
1786
1787         pending = tevent_req_is_in_progress(req);
1788         if (pending && !wait) {
1789                 Py_RETURN_NONE;
1790         }
1791
1792         if (pending) {
1793                 struct timeval endtime;
1794
1795                 endtime = timeval_current_ofs_msec(py_cli_state->cli->timeout);
1796                 ok = tevent_req_set_endtime(req,
1797                                             py_cli_state->ev,
1798                                             endtime);
1799                 if (!ok) {
1800                         TALLOC_FREE(req);
1801                         PyErr_NoMemory();
1802                         return NULL;
1803                 }
1804         }
1805
1806         ok = py_tevent_req_wait_exc(py_cli_state, req);
1807         self->req = NULL;
1808         Py_CLEAR(self->py_cli_state);
1809         if (!ok) {
1810                 return NULL;
1811         }
1812
1813         status = cli_notify_recv(req, req, &num_changes, &changes);
1814         if (!NT_STATUS_IS_OK(status)) {
1815                 TALLOC_FREE(req);
1816                 PyErr_SetNTSTATUS(status);
1817                 return NULL;
1818         }
1819
1820         result = Py_BuildValue("[]");
1821         if (result == NULL) {
1822                 TALLOC_FREE(req);
1823                 return NULL;
1824         }
1825
1826         for (i = 0; i < num_changes; i++) {
1827                 PyObject *change = NULL;
1828                 int ret;
1829
1830                 change = Py_BuildValue("{s:s,s:I}",
1831                                        "name", changes[i].name,
1832                                        "action", changes[i].action);
1833                 if (change == NULL) {
1834                         Py_XDECREF(result);
1835                         TALLOC_FREE(req);
1836                         return NULL;
1837                 }
1838
1839                 ret = PyList_Append(result, change);
1840                 Py_DECREF(change);
1841                 if (ret == -1) {
1842                         Py_XDECREF(result);
1843                         TALLOC_FREE(req);
1844                         return NULL;
1845                 }
1846         }
1847
1848         TALLOC_FREE(req);
1849         return result;
1850 }
1851
1852 static PyMethodDef py_cli_notify_state_methods[] = {
1853         {
1854                 .ml_name = "get_changes",
1855                 .ml_meth = (PyCFunction)py_cli_notify_get_changes,
1856                 .ml_flags = METH_VARARGS|METH_KEYWORDS,
1857                 .ml_doc  = "Wait for change notifications: \n"
1858                            "N.get_changes(wait=BOOLEAN) -> "
1859                            "change notifications as a dictionary\n"
1860                            "\t\tList contents of a directory. The keys are, \n"
1861                            "\t\t\tname: name of changed object\n"
1862                            "\t\t\taction: type of the change\n"
1863                            "None is returned if there's no response yet and "
1864                            "wait=False is passed"
1865         },
1866         {
1867                 .ml_name = NULL
1868         }
1869 };
1870
1871 static PyTypeObject py_cli_notify_state_type = {
1872         PyVarObject_HEAD_INIT(NULL, 0)
1873         .tp_name = "libsmb_samba_cwrapper.Notify",
1874         .tp_basicsize = sizeof(struct py_cli_notify_state),
1875         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1876         .tp_doc = "notify request",
1877         .tp_dealloc = (destructor)py_cli_notify_state_dealloc,
1878         .tp_methods = py_cli_notify_state_methods,
1879 };
1880
1881 /*
1882  * Helper to add posix directory listing entries to an overall Python list
1883  */
1884 static NTSTATUS list_posix_helper(struct file_info *finfo,
1885                                   const char *mask, void *state)
1886 {
1887         PyObject *result = (PyObject *)state;
1888         PyObject *file = NULL;
1889         int ret;
1890
1891         /*
1892          * Build a dictionary representing the file info.
1893          */
1894         file = Py_BuildValue("{s:s,s:I,"
1895                              "s:K,s:K,"
1896                              "s:l,s:l,s:l,s:l,"
1897                              "s:i,s:K,s:i,s:i,s:I,"
1898                              "s:s,s:s}",
1899                              "name", finfo->name,
1900                              "attrib", finfo->attr,
1901
1902                              "size", finfo->size,
1903                              "allocaction_size", finfo->allocated_size,
1904
1905                              "btime",
1906                              convert_timespec_to_time_t(finfo->btime_ts),
1907                              "atime",
1908                              convert_timespec_to_time_t(finfo->atime_ts),
1909                              "mtime",
1910                              convert_timespec_to_time_t(finfo->mtime_ts),
1911                              "ctime",
1912                              convert_timespec_to_time_t(finfo->ctime_ts),
1913
1914                              "perms", finfo->st_ex_mode,
1915                              "ino", finfo->ino,
1916                              "dev", finfo->st_ex_dev,
1917                              "nlink", finfo->st_ex_nlink,
1918                              "reparse_tag", finfo->reparse_tag,
1919
1920                              "owner_sid",
1921                              dom_sid_string(finfo, &finfo->owner_sid),
1922                              "group_sid",
1923                              dom_sid_string(finfo, &finfo->group_sid));
1924         if (file == NULL) {
1925                 return NT_STATUS_NO_MEMORY;
1926         }
1927
1928         ret = PyList_Append(result, file);
1929         Py_CLEAR(file);
1930         if (ret == -1) {
1931                 return NT_STATUS_INTERNAL_ERROR;
1932         }
1933
1934         return NT_STATUS_OK;
1935 }
1936
1937 /*
1938  * Helper to add directory listing entries to an overall Python list
1939  */
1940 static NTSTATUS list_helper(struct file_info *finfo,
1941                             const char *mask, void *state)
1942 {
1943         PyObject *result = (PyObject *)state;
1944         PyObject *file = NULL;
1945         PyObject *size = NULL;
1946         int ret;
1947
1948         /* suppress '.' and '..' in the results we return */
1949         if (ISDOT(finfo->name) || ISDOTDOT(finfo->name)) {
1950                 return NT_STATUS_OK;
1951         }
1952         size = PyLong_FromUnsignedLongLong(finfo->size);
1953         /*
1954          * Build a dictionary representing the file info.
1955          * Note: Windows does not always return short_name (so it may be None)
1956          */
1957         file = Py_BuildValue("{s:s,s:i,s:s,s:O,s:l}",
1958                              "name", finfo->name,
1959                              "attrib", (int)finfo->attr,
1960                              "short_name", finfo->short_name,
1961                              "size", size,
1962                              "mtime",
1963                              convert_timespec_to_time_t(finfo->mtime_ts));
1964
1965         Py_CLEAR(size);
1966
1967         if (file == NULL) {
1968                 return NT_STATUS_NO_MEMORY;
1969         }
1970
1971         if (finfo->attr & FILE_ATTRIBUTE_REPARSE_POINT) {
1972                 unsigned long tag = finfo->reparse_tag;
1973
1974                 ret = PyDict_SetItemString(
1975                         file,
1976                         "reparse_tag",
1977                         PyLong_FromUnsignedLong(tag));
1978                 if (ret == -1) {
1979                         return NT_STATUS_INTERNAL_ERROR;
1980                 }
1981         }
1982
1983         ret = PyList_Append(result, file);
1984         Py_CLEAR(file);
1985         if (ret == -1) {
1986                 return NT_STATUS_INTERNAL_ERROR;
1987         }
1988
1989         return NT_STATUS_OK;
1990 }
1991
1992 struct do_listing_state {
1993         const char *mask;
1994         NTSTATUS (*callback_fn)(
1995                 struct file_info *finfo,
1996                 const char *mask,
1997                 void *private_data);
1998         void *private_data;
1999         NTSTATUS status;
2000 };
2001
2002 static void do_listing_cb(struct tevent_req *subreq)
2003 {
2004         struct do_listing_state *state = tevent_req_callback_data_void(subreq);
2005         struct file_info *finfo = NULL;
2006
2007         state->status = cli_list_recv(subreq, NULL, &finfo);
2008         if (!NT_STATUS_IS_OK(state->status)) {
2009                 return;
2010         }
2011         state->callback_fn(finfo, state->mask, state->private_data);
2012         TALLOC_FREE(finfo);
2013 }
2014
2015 static NTSTATUS do_listing(struct py_cli_state *self,
2016                            const char *base_dir, const char *user_mask,
2017                            uint16_t attribute,
2018                            unsigned int info_level,
2019                            NTSTATUS (*callback_fn)(struct file_info *,
2020                                                    const char *, void *),
2021                            void *priv)
2022 {
2023         char *mask = NULL;
2024         struct do_listing_state state = {
2025                 .mask = mask,
2026                 .callback_fn = callback_fn,
2027                 .private_data = priv,
2028         };
2029         struct tevent_req *req = NULL;
2030         NTSTATUS status;
2031
2032         if (user_mask == NULL) {
2033                 mask = talloc_asprintf(NULL, "%s\\*", base_dir);
2034         } else {
2035                 mask = talloc_asprintf(NULL, "%s\\%s", base_dir, user_mask);
2036         }
2037
2038         if (mask == NULL) {
2039                 return NT_STATUS_NO_MEMORY;
2040         }
2041         dos_format(mask);
2042
2043         req = cli_list_send(NULL, self->ev, self->cli, mask, attribute,
2044                             info_level);
2045         if (req == NULL) {
2046                 status = NT_STATUS_NO_MEMORY;
2047                 goto done;
2048         }
2049         tevent_req_set_callback(req, do_listing_cb, &state);
2050
2051         if (!py_tevent_req_wait_exc(self, req)) {
2052                 return NT_STATUS_INTERNAL_ERROR;
2053         }
2054         TALLOC_FREE(req);
2055
2056         status = state.status;
2057         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MORE_FILES)) {
2058                 status = NT_STATUS_OK;
2059         }
2060
2061 done:
2062         TALLOC_FREE(mask);
2063         return status;
2064 }
2065
2066 static PyObject *py_cli_list(struct py_cli_state *self,
2067                              PyObject *args,
2068                              PyObject *kwds)
2069 {
2070         char *base_dir;
2071         char *user_mask = NULL;
2072         unsigned int attribute = LIST_ATTRIBUTE_MASK;
2073         unsigned int info_level = 0;
2074         NTSTATUS status;
2075         enum protocol_types proto = smbXcli_conn_protocol(self->cli->conn);
2076         PyObject *result = NULL;
2077         const char *kwlist[] = { "directory", "mask", "attribs",
2078                                  "info_level", NULL };
2079         NTSTATUS (*callback_fn)(struct file_info *, const char *, void *) =
2080                 &list_helper;
2081
2082         if (!ParseTupleAndKeywords(args, kwds, "z|sII:list", kwlist,
2083                                    &base_dir, &user_mask, &attribute,
2084                                    &info_level)) {
2085                 return NULL;
2086         }
2087
2088         result = Py_BuildValue("[]");
2089         if (result == NULL) {
2090                 return NULL;
2091         }
2092
2093         if (!info_level) {
2094                 if (proto >= PROTOCOL_SMB2_02) {
2095                         info_level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO;
2096                 } else {
2097                         info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
2098                 }
2099         }
2100
2101         if (info_level == SMB2_FIND_POSIX_INFORMATION) {
2102                 callback_fn = &list_posix_helper;
2103         }
2104         status = do_listing(self, base_dir, user_mask, attribute,
2105                             info_level, callback_fn, result);
2106
2107         if (!NT_STATUS_IS_OK(status)) {
2108                 Py_XDECREF(result);
2109                 PyErr_SetNTSTATUS(status);
2110                 return NULL;
2111         }
2112
2113         return result;
2114 }
2115
2116 static PyObject *py_smb_unlink(struct py_cli_state *self, PyObject *args)
2117 {
2118         NTSTATUS status;
2119         const char *filename = NULL;
2120         struct tevent_req *req = NULL;
2121         const uint32_t attrs = (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN);
2122
2123         if (!PyArg_ParseTuple(args, "s:unlink", &filename)) {
2124                 return NULL;
2125         }
2126
2127         req = cli_unlink_send(NULL, self->ev, self->cli, filename, attrs);
2128         if (!py_tevent_req_wait_exc(self, req)) {
2129                 return NULL;
2130         }
2131         status = cli_unlink_recv(req);
2132         TALLOC_FREE(req);
2133         PyErr_NTSTATUS_NOT_OK_RAISE(status);
2134
2135         Py_RETURN_NONE;
2136 }
2137
2138 static PyObject *py_smb_rmdir(struct py_cli_state *self, PyObject *args)
2139 {
2140         NTSTATUS status;
2141         struct tevent_req *req = NULL;
2142         const char *dirname = NULL;
2143
2144         if (!PyArg_ParseTuple(args, "s:rmdir", &dirname)) {
2145                 return NULL;
2146         }
2147
2148         req = cli_rmdir_send(NULL, self->ev, self->cli, dirname);
2149         if (!py_tevent_req_wait_exc(self, req)) {
2150                 return NULL;
2151         }
2152         status = cli_rmdir_recv(req);
2153         TALLOC_FREE(req);
2154         PyErr_NTSTATUS_NOT_OK_RAISE(status);
2155
2156         Py_RETURN_NONE;
2157 }
2158
2159 /*
2160  * Create a directory
2161  */
2162 static PyObject *py_smb_mkdir(struct py_cli_state *self, PyObject *args)
2163 {
2164         NTSTATUS status;
2165         const char *dirname = NULL;
2166         struct tevent_req *req = NULL;
2167
2168         if (!PyArg_ParseTuple(args, "s:mkdir", &dirname)) {
2169                 return NULL;
2170         }
2171
2172         req = cli_mkdir_send(NULL, self->ev, self->cli, dirname);
2173         if (!py_tevent_req_wait_exc(self, req)) {
2174                 return NULL;
2175         }
2176         status = cli_mkdir_recv(req);
2177         TALLOC_FREE(req);
2178         PyErr_NTSTATUS_NOT_OK_RAISE(status);
2179
2180         Py_RETURN_NONE;
2181 }
2182
2183 /*
2184  * Does a whoami call
2185  */
2186 static PyObject *py_smb_posix_whoami(struct py_cli_state *self,
2187                                      PyObject *Py_UNUSED(ignored))
2188 {
2189         TALLOC_CTX *frame = talloc_stackframe();
2190         NTSTATUS status;
2191         struct tevent_req *req = NULL;
2192         uint64_t uid;
2193         uint64_t gid;
2194         uint32_t num_gids;
2195         uint64_t *gids = NULL;
2196         uint32_t num_sids;
2197         struct dom_sid *sids = NULL;
2198         bool guest;
2199         PyObject *py_gids = NULL;
2200         PyObject *py_sids = NULL;
2201         PyObject *py_guest = NULL;
2202         PyObject *py_ret = NULL;
2203         Py_ssize_t i;
2204
2205         req = cli_posix_whoami_send(frame, self->ev, self->cli);
2206         if (!py_tevent_req_wait_exc(self, req)) {
2207                 goto fail;
2208         }
2209         status = cli_posix_whoami_recv(req,
2210                                 frame,
2211                                 &uid,
2212                                 &gid,
2213                                 &num_gids,
2214                                 &gids,
2215                                 &num_sids,
2216                                 &sids,
2217                                 &guest);
2218         if (!NT_STATUS_IS_OK(status)) {
2219                 PyErr_SetNTSTATUS(status);
2220                 goto fail;
2221         }
2222         if (num_gids > PY_SSIZE_T_MAX) {
2223                 PyErr_SetString(PyExc_OverflowError, "posix_whoami: Too many GIDs");
2224                 goto fail;
2225         }
2226         if (num_sids > PY_SSIZE_T_MAX) {
2227                 PyErr_SetString(PyExc_OverflowError, "posix_whoami: Too many SIDs");
2228                 goto fail;
2229         }
2230
2231         py_gids = PyList_New(num_gids);
2232         if (!py_gids) {
2233                 goto fail;
2234         }
2235         for (i = 0; i < num_gids; ++i) {
2236                 int ret;
2237                 PyObject *py_item = PyLong_FromUnsignedLongLong(gids[i]);
2238                 if (!py_item) {
2239                         goto fail2;
2240                 }
2241
2242                 ret = PyList_SetItem(py_gids, i, py_item);
2243                 if (ret) {
2244                         goto fail2;
2245                 }
2246         }
2247         py_sids = PyList_New(num_sids);
2248         if (!py_sids) {
2249                 goto fail2;
2250         }
2251         for (i = 0; i < num_sids; ++i) {
2252                 int ret;
2253                 struct dom_sid *sid;
2254                 PyObject *py_item;
2255
2256                 sid = dom_sid_dup(frame, &sids[i]);
2257                 if (!sid) {
2258                         PyErr_NoMemory();
2259                         goto fail3;
2260                 }
2261
2262                 py_item = pytalloc_steal(dom_sid_Type, sid);
2263                 if (!py_item) {
2264                         PyErr_NoMemory();
2265                         goto fail3;
2266                 }
2267
2268                 ret = PyList_SetItem(py_sids, i, py_item);
2269                 if (ret) {
2270                         goto fail3;
2271                 }
2272         }
2273
2274         py_guest = guest ? Py_True : Py_False;
2275
2276         py_ret = Py_BuildValue("KKNNO",
2277                         uid,
2278                         gid,
2279                         py_gids,
2280                         py_sids,
2281                         py_guest);
2282         if (!py_ret) {
2283                 goto fail3;
2284         }
2285
2286         TALLOC_FREE(frame);
2287         return py_ret;
2288
2289 fail3:
2290         Py_CLEAR(py_sids);
2291
2292 fail2:
2293         Py_CLEAR(py_gids);
2294
2295 fail:
2296         TALLOC_FREE(frame);
2297         return NULL;
2298 }
2299
2300 /*
2301  * Checks existence of a directory
2302  */
2303 static bool check_dir_path(struct py_cli_state *self, const char *path)
2304 {
2305         NTSTATUS status;
2306         struct tevent_req *req = NULL;
2307
2308         req = cli_chkpath_send(NULL, self->ev, self->cli, path);
2309         if (!py_tevent_req_wait_exc(self, req)) {
2310                 return false;
2311         }
2312         status = cli_chkpath_recv(req);
2313         TALLOC_FREE(req);
2314
2315         return NT_STATUS_IS_OK(status);
2316 }
2317
2318 static PyObject *py_smb_chkpath(struct py_cli_state *self, PyObject *args)
2319 {
2320         const char *path = NULL;
2321         bool dir_exists;
2322
2323         if (!PyArg_ParseTuple(args, "s:chkpath", &path)) {
2324                 return NULL;
2325         }
2326
2327         dir_exists = check_dir_path(self, path);
2328         return PyBool_FromLong(dir_exists);
2329 }
2330
2331 static PyObject *py_smb_have_posix(struct py_cli_state *self,
2332                                    PyObject *Py_UNUSED(ignored))
2333 {
2334         bool posix = smbXcli_conn_have_posix(self->cli->conn);
2335
2336         if (posix) {
2337                 Py_RETURN_TRUE;
2338         }
2339         Py_RETURN_FALSE;
2340 }
2341
2342 static PyObject *py_smb_protocol(struct py_cli_state *self,
2343                                  PyObject *Py_UNUSED(ignored))
2344 {
2345         enum protocol_types proto = smbXcli_conn_protocol(self->cli->conn);
2346         PyObject *result = PyLong_FromLong(proto);
2347         return result;
2348 }
2349
2350 static PyObject *py_smb_get_sd(struct py_cli_state *self, PyObject *args)
2351 {
2352         int fnum;
2353         unsigned sinfo;
2354         struct tevent_req *req = NULL;
2355         struct security_descriptor *sd = NULL;
2356         NTSTATUS status;
2357
2358         if (!PyArg_ParseTuple(args, "iI:get_acl", &fnum, &sinfo)) {
2359                 return NULL;
2360         }
2361
2362         req = cli_query_security_descriptor_send(
2363                 NULL, self->ev, self->cli, fnum, sinfo);
2364         if (!py_tevent_req_wait_exc(self, req)) {
2365                 return NULL;
2366         }
2367         status = cli_query_security_descriptor_recv(req, NULL, &sd);
2368         PyErr_NTSTATUS_NOT_OK_RAISE(status);
2369
2370         return py_return_ndr_struct(
2371                 "samba.dcerpc.security", "descriptor", sd, sd);
2372 }
2373
2374 static PyObject *py_smb_set_sd(struct py_cli_state *self, PyObject *args)
2375 {
2376         PyObject *py_sd = NULL;
2377         struct tevent_req *req = NULL;
2378         struct security_descriptor *sd = NULL;
2379         uint16_t fnum;
2380         unsigned int sinfo;
2381         NTSTATUS status;
2382
2383         if (!PyArg_ParseTuple(args, "iOI:set_sd", &fnum, &py_sd, &sinfo)) {
2384                 return NULL;
2385         }
2386
2387         sd = pytalloc_get_type(py_sd, struct security_descriptor);
2388         if (!sd) {
2389                 PyErr_Format(PyExc_TypeError,
2390                         "Expected dcerpc.security.descriptor as argument, got %s",
2391                         pytalloc_get_name(py_sd));
2392                 return NULL;
2393         }
2394
2395         req = cli_set_security_descriptor_send(
2396                 NULL, self->ev, self->cli, fnum, sinfo, sd);
2397         if (!py_tevent_req_wait_exc(self, req)) {
2398                 return NULL;
2399         }
2400
2401         status = cli_set_security_descriptor_recv(req);
2402         PyErr_NTSTATUS_NOT_OK_RAISE(status);
2403
2404         Py_RETURN_NONE;
2405 }
2406
2407 static PyObject *py_smb_smb1_posix(
2408         struct py_cli_state *self, PyObject *Py_UNUSED(ignored))
2409 {
2410         NTSTATUS status;
2411         struct tevent_req *req = NULL;
2412         uint16_t major, minor;
2413         uint32_t caplow, caphigh;
2414         PyObject *result = NULL;
2415
2416         req = cli_unix_extensions_version_send(NULL, self->ev, self->cli);
2417         if (!py_tevent_req_wait_exc(self, req)) {
2418                 return NULL;
2419         }
2420         status = cli_unix_extensions_version_recv(
2421                 req, &major, &minor, &caplow, &caphigh);
2422         TALLOC_FREE(req);
2423         if (!NT_STATUS_IS_OK(status)) {
2424                 PyErr_SetNTSTATUS(status);
2425                 return NULL;
2426         }
2427
2428         req = cli_set_unix_extensions_capabilities_send(
2429                 NULL, self->ev, self->cli, major, minor, caplow, caphigh);
2430         if (!py_tevent_req_wait_exc(self, req)) {
2431                 return NULL;
2432         }
2433         status = cli_set_unix_extensions_capabilities_recv(req);
2434         TALLOC_FREE(req);
2435         if (!NT_STATUS_IS_OK(status)) {
2436                 PyErr_SetNTSTATUS(status);
2437                 return NULL;
2438         }
2439
2440         result = Py_BuildValue(
2441                 "[IIII]",
2442                 (unsigned)minor,
2443                 (unsigned)major,
2444                 (unsigned)caplow,
2445                 (unsigned)caphigh);
2446         return result;
2447 }
2448
2449 static PyObject *py_smb_smb1_readlink(
2450         struct py_cli_state *self, PyObject *args)
2451 {
2452         NTSTATUS status;
2453         const char *filename = NULL;
2454         struct tevent_req *req = NULL;
2455         char *target = NULL;
2456         PyObject *result = NULL;
2457
2458         if (!PyArg_ParseTuple(args, "s:smb1_readlink", &filename)) {
2459                 return NULL;
2460         }
2461
2462         req = cli_posix_readlink_send(NULL, self->ev, self->cli, filename);
2463         if (!py_tevent_req_wait_exc(self, req)) {
2464                 return NULL;
2465         }
2466         status = cli_posix_readlink_recv(req, NULL, &target);
2467         TALLOC_FREE(req);
2468         if (!NT_STATUS_IS_OK(status)) {
2469                 PyErr_SetNTSTATUS(status);
2470                 return NULL;
2471         }
2472
2473         result = PyBytes_FromString(target);
2474         TALLOC_FREE(target);
2475         return result;
2476 }
2477
2478 static PyObject *py_smb_smb1_symlink(
2479         struct py_cli_state *self, PyObject *args)
2480 {
2481         NTSTATUS status;
2482         const char *target = NULL, *newname = NULL;
2483         struct tevent_req *req = NULL;
2484
2485         if (!PyArg_ParseTuple(args, "ss:smb1_symlink", &target, &newname)) {
2486                 return NULL;
2487         }
2488
2489         req = cli_posix_symlink_send(
2490                 NULL, self->ev, self->cli, target, newname);
2491         if (!py_tevent_req_wait_exc(self, req)) {
2492                 return NULL;
2493         }
2494         status = cli_posix_symlink_recv(req);
2495         TALLOC_FREE(req);
2496         if (!NT_STATUS_IS_OK(status)) {
2497                 PyErr_SetNTSTATUS(status);
2498                 return NULL;
2499         }
2500
2501         Py_RETURN_NONE;
2502 }
2503
2504 static PyObject *py_smb_smb1_stat(
2505         struct py_cli_state *self, PyObject *args)
2506 {
2507         NTSTATUS status;
2508         const char *fname = NULL;
2509         struct tevent_req *req = NULL;
2510         struct stat_ex sbuf = { .st_ex_nlink = 0, };
2511
2512         if (!PyArg_ParseTuple(args, "s:smb1_stat", &fname)) {
2513                 return NULL;
2514         }
2515
2516         req = cli_posix_stat_send(NULL, self->ev, self->cli, fname);
2517         if (!py_tevent_req_wait_exc(self, req)) {
2518                 return NULL;
2519         }
2520         status = cli_posix_stat_recv(req, &sbuf);
2521         TALLOC_FREE(req);
2522         if (!NT_STATUS_IS_OK(status)) {
2523                 PyErr_SetNTSTATUS(status);
2524                 return NULL;
2525         }
2526
2527         return Py_BuildValue(
2528                 "{sLsLsLsLsLsLsLsLsLsLsLsLsLsLsLsLsLsLsLsL}",
2529                 "dev",
2530                 (unsigned long long)sbuf.st_ex_dev,
2531                 "ino",
2532                 (unsigned long long)sbuf.st_ex_ino,
2533                 "mode",
2534                 (unsigned long long)sbuf.st_ex_mode,
2535                 "nlink",
2536                 (unsigned long long)sbuf.st_ex_nlink,
2537                 "uid",
2538                 (unsigned long long)sbuf.st_ex_uid,
2539                 "gid",
2540                 (unsigned long long)sbuf.st_ex_gid,
2541                 "rdev",
2542                 (unsigned long long)sbuf.st_ex_size,
2543                 "atime_sec",
2544                 (unsigned long long)sbuf.st_ex_atime.tv_sec,
2545                 "atime_nsec",
2546                 (unsigned long long)sbuf.st_ex_atime.tv_nsec,
2547                 "mtime_sec",
2548                 (unsigned long long)sbuf.st_ex_mtime.tv_sec,
2549                 "mtime_nsec",
2550                 (unsigned long long)sbuf.st_ex_mtime.tv_nsec,
2551                 "ctime_sec",
2552                 (unsigned long long)sbuf.st_ex_ctime.tv_sec,
2553                 "ctime_nsec",
2554                 (unsigned long long)sbuf.st_ex_ctime.tv_nsec,
2555                 "btime_sec",
2556                 (unsigned long long)sbuf.st_ex_btime.tv_sec,
2557                 "btime_nsec",
2558                 (unsigned long long)sbuf.st_ex_btime.tv_nsec,
2559                 "cached_dos_attributes",
2560                 (unsigned long long)sbuf.cached_dos_attributes,
2561                 "blksize",
2562                 (unsigned long long)sbuf.st_ex_blksize,
2563                 "blocks",
2564                 (unsigned long long)sbuf.st_ex_blocks,
2565                 "flags",
2566                 (unsigned long long)sbuf.st_ex_flags,
2567                 "iflags",
2568                 (unsigned long long)sbuf.st_ex_iflags);
2569 }
2570
2571 static PyObject *py_cli_mknod(
2572         struct py_cli_state *self, PyObject *args, PyObject *kwds)
2573 {
2574         char *fname = NULL;
2575         int mode = 0, major = 0, minor = 0, dev = 0;
2576         struct tevent_req *req = NULL;
2577         static const char *kwlist[] = {
2578                 "fname", "mode", "major", "minor", NULL,
2579         };
2580         NTSTATUS status;
2581         bool ok;
2582
2583         ok = ParseTupleAndKeywords(
2584                 args,
2585                 kwds,
2586                 "sI|II:mknod",
2587                 kwlist,
2588                 &fname,
2589                 &mode,
2590                 &major,
2591                 &minor);
2592         if (!ok) {
2593                 return NULL;
2594         }
2595
2596 #if defined(HAVE_MAKEDEV)
2597         dev = makedev(major, minor);
2598 #endif
2599
2600         req = cli_mknod_send(
2601                 NULL, self->ev, self->cli, fname, mode, dev);
2602         if (!py_tevent_req_wait_exc(self, req)) {
2603                 return NULL;
2604         }
2605         status = cli_mknod_recv(req);
2606         TALLOC_FREE(req);
2607         if (!NT_STATUS_IS_OK(status)) {
2608                 PyErr_SetNTSTATUS(status);
2609                 return NULL;
2610         }
2611         Py_RETURN_NONE;
2612 }
2613
2614 static PyObject *py_cli_fsctl(
2615         struct py_cli_state *self, PyObject *args, PyObject *kwds)
2616 {
2617         int fnum, ctl_code;
2618         int max_out = 0;
2619         char *buf = NULL;
2620         Py_ssize_t buflen;
2621         DATA_BLOB in = { .data = NULL, };
2622         DATA_BLOB out = { .data = NULL, };
2623         struct tevent_req *req = NULL;
2624         PyObject *result = NULL;
2625         static const char *kwlist[] = {
2626                 "fnum", "ctl_code", "in", "max_out", NULL,
2627         };
2628         NTSTATUS status;
2629         bool ok;
2630
2631         ok = ParseTupleAndKeywords(
2632                     args,
2633                     kwds,
2634                     "ii" PYARG_BYTES_LEN "i",
2635                     kwlist,
2636                     &fnum,
2637                     &ctl_code,
2638                     &buf,
2639                     &buflen,
2640                     &max_out);
2641         if (!ok) {
2642                 return NULL;
2643         }
2644
2645         in = (DATA_BLOB) { .data = (uint8_t *)buf, .length = buflen, };
2646
2647         req = cli_fsctl_send(
2648                 NULL, self->ev, self->cli, fnum, ctl_code, &in, max_out);
2649
2650         if (!py_tevent_req_wait_exc(self, req)) {
2651                 return NULL;
2652         }
2653
2654         status = cli_fsctl_recv(req, NULL, &out);
2655         if (!NT_STATUS_IS_OK(status)) {
2656                 PyErr_SetNTSTATUS(status);
2657                 return NULL;
2658         }
2659
2660         result = PyBytes_FromStringAndSize((char *)out.data, out.length);
2661         data_blob_free(&out);
2662         return result;
2663 }
2664
2665 static PyMethodDef py_cli_state_methods[] = {
2666         { "settimeout", (PyCFunction)py_cli_settimeout, METH_VARARGS,
2667           "settimeout(new_timeout_msecs) => return old_timeout_msecs" },
2668         { "echo", (PyCFunction)py_cli_echo, METH_NOARGS,
2669           "Ping the server connection" },
2670         { "create", PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_create),
2671                 METH_VARARGS|METH_KEYWORDS,
2672           "Open a file" },
2673         { "create_ex",
2674           PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_create_ex),
2675           METH_VARARGS|METH_KEYWORDS,
2676           "Open a file, SMB2 version returning create contexts" },
2677         { "close", (PyCFunction)py_cli_close, METH_VARARGS,
2678           "Close a file handle" },
2679         { "write", PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_write),
2680                 METH_VARARGS|METH_KEYWORDS,
2681           "Write to a file handle" },
2682         { "read", PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_read),
2683                 METH_VARARGS|METH_KEYWORDS,
2684           "Read from a file handle" },
2685         { "truncate", PY_DISCARD_FUNC_SIG(PyCFunction,
2686                         py_cli_ftruncate),
2687           METH_VARARGS|METH_KEYWORDS,
2688           "Truncate a file" },
2689         { "delete_on_close", PY_DISCARD_FUNC_SIG(PyCFunction,
2690                                          py_cli_delete_on_close),
2691           METH_VARARGS|METH_KEYWORDS,
2692           "Set/Reset the delete on close flag" },
2693         { "notify", PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_notify),
2694           METH_VARARGS|METH_KEYWORDS,
2695           "Wait for change notifications: \n"
2696           "notify(fnum, buffer_size, completion_filter...) -> "
2697           "libsmb_samba_internal.Notify request handle\n" },
2698         { "list", PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_list),
2699                 METH_VARARGS|METH_KEYWORDS,
2700           "list(directory, mask='*', attribs=DEFAULT_ATTRS) -> "
2701           "directory contents as a dictionary\n"
2702           "\t\tDEFAULT_ATTRS: FILE_ATTRIBUTE_SYSTEM | "
2703           "FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_ARCHIVE\n\n"
2704           "\t\tList contents of a directory. The keys are, \n"
2705           "\t\t\tname: Long name of the directory item\n"
2706           "\t\t\tshort_name: Short name of the directory item\n"
2707           "\t\t\tsize: File size in bytes\n"
2708           "\t\t\tattrib: Attributes\n"
2709           "\t\t\tmtime: Modification time\n" },
2710         { "get_oplock_break", (PyCFunction)py_cli_get_oplock_break,
2711           METH_VARARGS, "Wait for an oplock break" },
2712         { "unlink", (PyCFunction)py_smb_unlink,
2713           METH_VARARGS,
2714           "unlink(path) -> None\n\n \t\tDelete a file." },
2715         { "mkdir", (PyCFunction)py_smb_mkdir, METH_VARARGS,
2716           "mkdir(path) -> None\n\n \t\tCreate a directory." },
2717         { "posix_whoami", (PyCFunction)py_smb_posix_whoami, METH_NOARGS,
2718         "posix_whoami() -> (uid, gid, gids, sids, guest)" },
2719         { "rmdir", (PyCFunction)py_smb_rmdir, METH_VARARGS,
2720           "rmdir(path) -> None\n\n \t\tDelete a directory." },
2721         { "rename",
2722           PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_rename),
2723           METH_VARARGS|METH_KEYWORDS,
2724           "rename(src,dst) -> None\n\n \t\tRename a file." },
2725         { "chkpath", (PyCFunction)py_smb_chkpath, METH_VARARGS,
2726           "chkpath(dir_path) -> True or False\n\n"
2727           "\t\tReturn true if directory exists, false otherwise." },
2728         { "savefile", (PyCFunction)py_smb_savefile, METH_VARARGS,
2729           "savefile(path, bytes) -> None\n\n"
2730           "\t\tWrite bytes to file." },
2731         { "loadfile", (PyCFunction)py_smb_loadfile, METH_VARARGS,
2732           "loadfile(path) -> file contents as a bytes object"
2733           "\n\n\t\tRead contents of a file." },
2734         { "get_sd", (PyCFunction)py_smb_get_sd, METH_VARARGS,
2735           "get_sd(fnum[, security_info=0]) -> security_descriptor object\n\n"
2736           "\t\tGet security descriptor for opened file." },
2737         { "set_sd", (PyCFunction)py_smb_set_sd, METH_VARARGS,
2738           "set_sd(fnum, security_descriptor[, security_info=0]) -> None\n\n"
2739           "\t\tSet security descriptor for opened file." },
2740         { "protocol",
2741           (PyCFunction)py_smb_protocol,
2742           METH_NOARGS,
2743           "protocol() -> Number"
2744         },
2745         { "have_posix",
2746           (PyCFunction)py_smb_have_posix,
2747           METH_NOARGS,
2748           "have_posix() -> True/False\n\n"
2749           "\t\tReturn if the server has posix extensions"
2750         },
2751         { "smb1_posix",
2752           (PyCFunction)py_smb_smb1_posix,
2753           METH_NOARGS,
2754           "Negotiate SMB1 posix extensions",
2755         },
2756         { "smb1_readlink",
2757           (PyCFunction)py_smb_smb1_readlink,
2758           METH_VARARGS,
2759           "smb1_readlink(path) -> link target",
2760         },
2761         { "smb1_symlink",
2762           (PyCFunction)py_smb_smb1_symlink,
2763           METH_VARARGS,
2764           "smb1_symlink(target, newname) -> None",
2765         },
2766         { "smb1_stat",
2767           (PyCFunction)py_smb_smb1_stat,
2768           METH_VARARGS,
2769           "smb1_stat(path) -> stat info",
2770         },
2771         { "fsctl",
2772           (PyCFunction)py_cli_fsctl,
2773           METH_VARARGS|METH_KEYWORDS,
2774           "fsctl(fnum, ctl_code, in_bytes, max_out) -> out_bytes",
2775         },
2776         { "mknod",
2777           PY_DISCARD_FUNC_SIG(PyCFunction, py_cli_mknod),
2778           METH_VARARGS|METH_KEYWORDS,
2779           "mknod(path, mode | major, minor)",
2780         },
2781         { NULL, NULL, 0, NULL }
2782 };
2783
2784 static PyTypeObject py_cli_state_type = {
2785         PyVarObject_HEAD_INIT(NULL, 0)
2786         .tp_name = "libsmb_samba_cwrapper.LibsmbCConn",
2787         .tp_basicsize = sizeof(struct py_cli_state),
2788         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2789         .tp_doc = "libsmb cwrapper connection",
2790         .tp_new = py_cli_state_new,
2791         .tp_init = (initproc)py_cli_state_init,
2792         .tp_dealloc = (destructor)py_cli_state_dealloc,
2793         .tp_methods = py_cli_state_methods,
2794 };
2795
2796 static PyMethodDef py_libsmb_methods[] = {
2797         {0},
2798 };
2799
2800 void initlibsmb_samba_cwrapper(void);
2801
2802 static struct PyModuleDef moduledef = {
2803     PyModuleDef_HEAD_INIT,
2804     .m_name = "libsmb_samba_cwrapper",
2805     .m_doc = "libsmb wrapper",
2806     .m_size = -1,
2807     .m_methods = py_libsmb_methods,
2808 };
2809
2810 MODULE_INIT_FUNC(libsmb_samba_cwrapper)
2811 {
2812         PyObject *m = NULL;
2813         PyObject *mod = NULL;
2814
2815         talloc_stackframe();
2816
2817         if (PyType_Ready(&py_cli_state_type) < 0) {
2818                 return NULL;
2819         }
2820         if (PyType_Ready(&py_cli_notify_state_type) < 0) {
2821                 return NULL;
2822         }
2823
2824         m = PyModule_Create(&moduledef);
2825         if (m == NULL) {
2826                 return m;
2827         }
2828
2829         /* Import dom_sid type from dcerpc.security */
2830         mod = PyImport_ImportModule("samba.dcerpc.security");
2831         if (mod == NULL) {
2832                 return NULL;
2833         }
2834
2835         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "dom_sid");
2836         if (dom_sid_Type == NULL) {
2837                 Py_DECREF(mod);
2838                 return NULL;
2839         }
2840
2841         Py_INCREF(&py_cli_state_type);
2842         PyModule_AddObject(m, "LibsmbCConn", (PyObject *)&py_cli_state_type);
2843
2844 #define ADD_FLAGS(val)  PyModule_AddObject(m, #val, PyLong_FromLong(val))
2845
2846         ADD_FLAGS(PROTOCOL_NONE);
2847         ADD_FLAGS(PROTOCOL_CORE);
2848         ADD_FLAGS(PROTOCOL_COREPLUS);
2849         ADD_FLAGS(PROTOCOL_LANMAN1);
2850         ADD_FLAGS(PROTOCOL_LANMAN2);
2851         ADD_FLAGS(PROTOCOL_NT1);
2852         ADD_FLAGS(PROTOCOL_SMB2_02);
2853         ADD_FLAGS(PROTOCOL_SMB2_10);
2854         ADD_FLAGS(PROTOCOL_SMB3_00);
2855         ADD_FLAGS(PROTOCOL_SMB3_02);
2856         ADD_FLAGS(PROTOCOL_SMB3_11);
2857
2858         ADD_FLAGS(FILE_ATTRIBUTE_READONLY);
2859         ADD_FLAGS(FILE_ATTRIBUTE_HIDDEN);
2860         ADD_FLAGS(FILE_ATTRIBUTE_SYSTEM);
2861         ADD_FLAGS(FILE_ATTRIBUTE_VOLUME);
2862         ADD_FLAGS(FILE_ATTRIBUTE_DIRECTORY);
2863         ADD_FLAGS(FILE_ATTRIBUTE_ARCHIVE);
2864         ADD_FLAGS(FILE_ATTRIBUTE_DEVICE);
2865         ADD_FLAGS(FILE_ATTRIBUTE_NORMAL);
2866         ADD_FLAGS(FILE_ATTRIBUTE_TEMPORARY);
2867         ADD_FLAGS(FILE_ATTRIBUTE_SPARSE);
2868         ADD_FLAGS(FILE_ATTRIBUTE_REPARSE_POINT);
2869         ADD_FLAGS(FILE_ATTRIBUTE_COMPRESSED);
2870         ADD_FLAGS(FILE_ATTRIBUTE_OFFLINE);
2871         ADD_FLAGS(FILE_ATTRIBUTE_NONINDEXED);
2872         ADD_FLAGS(FILE_ATTRIBUTE_ENCRYPTED);
2873         ADD_FLAGS(FILE_ATTRIBUTE_ALL_MASK);
2874
2875         ADD_FLAGS(FILE_DIRECTORY_FILE);
2876         ADD_FLAGS(FILE_WRITE_THROUGH);
2877         ADD_FLAGS(FILE_SEQUENTIAL_ONLY);
2878         ADD_FLAGS(FILE_NO_INTERMEDIATE_BUFFERING);
2879         ADD_FLAGS(FILE_SYNCHRONOUS_IO_ALERT);
2880         ADD_FLAGS(FILE_SYNCHRONOUS_IO_NONALERT);
2881         ADD_FLAGS(FILE_NON_DIRECTORY_FILE);
2882         ADD_FLAGS(FILE_CREATE_TREE_CONNECTION);
2883         ADD_FLAGS(FILE_COMPLETE_IF_OPLOCKED);
2884         ADD_FLAGS(FILE_NO_EA_KNOWLEDGE);
2885         ADD_FLAGS(FILE_EIGHT_DOT_THREE_ONLY);
2886         ADD_FLAGS(FILE_RANDOM_ACCESS);
2887         ADD_FLAGS(FILE_DELETE_ON_CLOSE);
2888         ADD_FLAGS(FILE_OPEN_BY_FILE_ID);
2889         ADD_FLAGS(FILE_OPEN_FOR_BACKUP_INTENT);
2890         ADD_FLAGS(FILE_NO_COMPRESSION);
2891         ADD_FLAGS(FILE_RESERVER_OPFILTER);
2892         ADD_FLAGS(FILE_OPEN_REPARSE_POINT);
2893         ADD_FLAGS(FILE_OPEN_NO_RECALL);
2894         ADD_FLAGS(FILE_OPEN_FOR_FREE_SPACE_QUERY);
2895
2896         ADD_FLAGS(FILE_SHARE_READ);
2897         ADD_FLAGS(FILE_SHARE_WRITE);
2898         ADD_FLAGS(FILE_SHARE_DELETE);
2899
2900         /* change notify completion filter flags */
2901         ADD_FLAGS(FILE_NOTIFY_CHANGE_FILE_NAME);
2902         ADD_FLAGS(FILE_NOTIFY_CHANGE_DIR_NAME);
2903         ADD_FLAGS(FILE_NOTIFY_CHANGE_ATTRIBUTES);
2904         ADD_FLAGS(FILE_NOTIFY_CHANGE_SIZE);
2905         ADD_FLAGS(FILE_NOTIFY_CHANGE_LAST_WRITE);
2906         ADD_FLAGS(FILE_NOTIFY_CHANGE_LAST_ACCESS);
2907         ADD_FLAGS(FILE_NOTIFY_CHANGE_CREATION);
2908         ADD_FLAGS(FILE_NOTIFY_CHANGE_EA);
2909         ADD_FLAGS(FILE_NOTIFY_CHANGE_SECURITY);
2910         ADD_FLAGS(FILE_NOTIFY_CHANGE_STREAM_NAME);
2911         ADD_FLAGS(FILE_NOTIFY_CHANGE_STREAM_SIZE);
2912         ADD_FLAGS(FILE_NOTIFY_CHANGE_STREAM_WRITE);
2913         ADD_FLAGS(FILE_NOTIFY_CHANGE_NAME);
2914         ADD_FLAGS(FILE_NOTIFY_CHANGE_ALL);
2915
2916         /* change notify action results */
2917         ADD_FLAGS(NOTIFY_ACTION_ADDED);
2918         ADD_FLAGS(NOTIFY_ACTION_REMOVED);
2919         ADD_FLAGS(NOTIFY_ACTION_MODIFIED);
2920         ADD_FLAGS(NOTIFY_ACTION_OLD_NAME);
2921         ADD_FLAGS(NOTIFY_ACTION_NEW_NAME);
2922         ADD_FLAGS(NOTIFY_ACTION_ADDED_STREAM);
2923         ADD_FLAGS(NOTIFY_ACTION_REMOVED_STREAM);
2924         ADD_FLAGS(NOTIFY_ACTION_MODIFIED_STREAM);
2925
2926         /* CreateDisposition values */
2927         ADD_FLAGS(FILE_SUPERSEDE);
2928         ADD_FLAGS(FILE_OPEN);
2929         ADD_FLAGS(FILE_CREATE);
2930         ADD_FLAGS(FILE_OPEN_IF);
2931         ADD_FLAGS(FILE_OVERWRITE);
2932         ADD_FLAGS(FILE_OVERWRITE_IF);
2933
2934         ADD_FLAGS(FSCTL_DFS_GET_REFERRALS);
2935         ADD_FLAGS(FSCTL_DFS_GET_REFERRALS_EX);
2936         ADD_FLAGS(FSCTL_REQUEST_OPLOCK_LEVEL_1);
2937         ADD_FLAGS(FSCTL_REQUEST_OPLOCK_LEVEL_2);
2938         ADD_FLAGS(FSCTL_REQUEST_BATCH_OPLOCK);
2939         ADD_FLAGS(FSCTL_OPLOCK_BREAK_ACKNOWLEDGE);
2940         ADD_FLAGS(FSCTL_OPBATCH_ACK_CLOSE_PENDING);
2941         ADD_FLAGS(FSCTL_OPLOCK_BREAK_NOTIFY);
2942         ADD_FLAGS(FSCTL_GET_COMPRESSION);
2943         ADD_FLAGS(FSCTL_FILESYS_GET_STATISTICS);
2944         ADD_FLAGS(FSCTL_GET_NTFS_VOLUME_DATA);
2945         ADD_FLAGS(FSCTL_IS_VOLUME_DIRTY);
2946         ADD_FLAGS(FSCTL_FIND_FILES_BY_SID);
2947         ADD_FLAGS(FSCTL_SET_OBJECT_ID);
2948         ADD_FLAGS(FSCTL_GET_OBJECT_ID);
2949         ADD_FLAGS(FSCTL_DELETE_OBJECT_ID);
2950         ADD_FLAGS(FSCTL_SET_REPARSE_POINT);
2951         ADD_FLAGS(FSCTL_GET_REPARSE_POINT);
2952         ADD_FLAGS(FSCTL_DELETE_REPARSE_POINT);
2953         ADD_FLAGS(FSCTL_SET_OBJECT_ID_EXTENDED);
2954         ADD_FLAGS(FSCTL_CREATE_OR_GET_OBJECT_ID);
2955         ADD_FLAGS(FSCTL_SET_SPARSE);
2956         ADD_FLAGS(FSCTL_SET_ZERO_DATA);
2957         ADD_FLAGS(FSCTL_SET_ZERO_ON_DEALLOCATION);
2958         ADD_FLAGS(FSCTL_READ_FILE_USN_DATA);
2959         ADD_FLAGS(FSCTL_WRITE_USN_CLOSE_RECORD);
2960         ADD_FLAGS(FSCTL_QUERY_ALLOCATED_RANGES);
2961         ADD_FLAGS(FSCTL_QUERY_ON_DISK_VOLUME_INFO);
2962         ADD_FLAGS(FSCTL_QUERY_SPARING_INFO);
2963         ADD_FLAGS(FSCTL_FILE_LEVEL_TRIM);
2964         ADD_FLAGS(FSCTL_OFFLOAD_READ);
2965         ADD_FLAGS(FSCTL_OFFLOAD_WRITE);
2966         ADD_FLAGS(FSCTL_SET_INTEGRITY_INFORMATION);
2967         ADD_FLAGS(FSCTL_DUP_EXTENTS_TO_FILE);
2968         ADD_FLAGS(FSCTL_DUPLICATE_EXTENTS_TO_FILE_EX);
2969         ADD_FLAGS(FSCTL_STORAGE_QOS_CONTROL);
2970         ADD_FLAGS(FSCTL_SVHDX_SYNC_TUNNEL_REQUEST);
2971         ADD_FLAGS(FSCTL_QUERY_SHARED_VIRTUAL_DISK_SUPPORT);
2972         ADD_FLAGS(FSCTL_PIPE_PEEK);
2973         ADD_FLAGS(FSCTL_NAMED_PIPE_READ_WRITE);
2974         ADD_FLAGS(FSCTL_PIPE_TRANSCEIVE);
2975         ADD_FLAGS(FSCTL_PIPE_WAIT);
2976         ADD_FLAGS(FSCTL_GET_SHADOW_COPY_DATA);
2977         ADD_FLAGS(FSCTL_SRV_ENUM_SNAPS);
2978         ADD_FLAGS(FSCTL_SRV_REQUEST_RESUME_KEY);
2979         ADD_FLAGS(FSCTL_SRV_COPYCHUNK);
2980         ADD_FLAGS(FSCTL_SRV_COPYCHUNK_WRITE);
2981         ADD_FLAGS(FSCTL_SRV_READ_HASH);
2982         ADD_FLAGS(FSCTL_LMR_REQ_RESILIENCY);
2983         ADD_FLAGS(FSCTL_LMR_SET_LINK_TRACKING_INFORMATION);
2984         ADD_FLAGS(FSCTL_QUERY_NETWORK_INTERFACE_INFO);
2985
2986         ADD_FLAGS(SYMLINK_ERROR_TAG);
2987         ADD_FLAGS(SYMLINK_FLAG_RELATIVE);
2988         ADD_FLAGS(SYMLINK_ADMIN);
2989         ADD_FLAGS(SYMLINK_UNTRUSTED);
2990         ADD_FLAGS(SYMLINK_TRUST_UNKNOWN);
2991         ADD_FLAGS(SYMLINK_TRUST_MASK);
2992
2993         ADD_FLAGS(IO_REPARSE_TAG_RESERVED_ZERO);
2994         ADD_FLAGS(IO_REPARSE_TAG_SYMLINK);
2995         ADD_FLAGS(IO_REPARSE_TAG_MOUNT_POINT);
2996         ADD_FLAGS(IO_REPARSE_TAG_HSM);
2997         ADD_FLAGS(IO_REPARSE_TAG_SIS);
2998         ADD_FLAGS(IO_REPARSE_TAG_DFS);
2999         ADD_FLAGS(IO_REPARSE_TAG_NFS);
3000
3001 #define ADD_STRING(val) PyModule_AddObject(m, #val, PyBytes_FromString(val))
3002
3003         ADD_STRING(SMB2_CREATE_TAG_EXTA);
3004         ADD_STRING(SMB2_CREATE_TAG_MXAC);
3005         ADD_STRING(SMB2_CREATE_TAG_SECD);
3006         ADD_STRING(SMB2_CREATE_TAG_DHNQ);
3007         ADD_STRING(SMB2_CREATE_TAG_DHNC);
3008         ADD_STRING(SMB2_CREATE_TAG_ALSI);
3009         ADD_STRING(SMB2_CREATE_TAG_TWRP);
3010         ADD_STRING(SMB2_CREATE_TAG_QFID);
3011         ADD_STRING(SMB2_CREATE_TAG_RQLS);
3012         ADD_STRING(SMB2_CREATE_TAG_DH2Q);
3013         ADD_STRING(SMB2_CREATE_TAG_DH2C);
3014         ADD_STRING(SMB2_CREATE_TAG_AAPL);
3015         ADD_STRING(SMB2_CREATE_TAG_APP_INSTANCE_ID);
3016         ADD_STRING(SVHDX_OPEN_DEVICE_CONTEXT);
3017         ADD_STRING(SMB2_CREATE_TAG_POSIX);
3018         ADD_FLAGS(SMB2_FIND_POSIX_INFORMATION);
3019         ADD_FLAGS(FILE_SUPERSEDE);
3020         ADD_FLAGS(FILE_OPEN);
3021         ADD_FLAGS(FILE_CREATE);
3022         ADD_FLAGS(FILE_OPEN_IF);
3023         ADD_FLAGS(FILE_OVERWRITE);
3024         ADD_FLAGS(FILE_OVERWRITE_IF);
3025         ADD_FLAGS(FILE_DIRECTORY_FILE);
3026
3027         ADD_FLAGS(SMB2_CLOSE_FLAGS_FULL_INFORMATION);
3028
3029         return m;
3030 }