s3:libsmb: s/struct event_context/struct tevent_context
[Samba/gebeck_regimport.git] / source3 / libsmb / pylibsmb.c
blob900d05212c54516110717c86dd807f51f72cb311
1 /*
2 * Unix SMB/CIFS implementation.
3 * Samba-internal work in progress Python binding for libsmbclient
5 * Copyright (C) Volker Lendecke 2012
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 3 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program. If not, see <http://www.gnu.org/licenses/>.
21 #include <Python.h>
22 #include "includes.h"
23 #include "libsmb/libsmb.h"
24 #include "libcli/security/security.h"
25 #include "system/select.h"
26 #include "source4/libcli/util/pyerrors.h"
27 #include "auth/credentials/pycredentials.h"
28 #include "trans2.h"
30 static PyTypeObject *get_pytype(const char *module, const char *type)
32 PyObject *mod;
33 PyTypeObject *result;
35 mod = PyImport_ImportModule(module);
36 if (mod == NULL) {
37 PyErr_Format(PyExc_RuntimeError,
38 "Unable to import %s to check type %s",
39 module, type);
40 return NULL;
42 result = (PyTypeObject *)PyObject_GetAttrString(mod, type);
43 Py_DECREF(mod);
44 if (result == NULL) {
45 PyErr_Format(PyExc_RuntimeError,
46 "Unable to find type %s in module %s",
47 module, type);
48 return NULL;
50 return result;
54 * We're using "const char **" for keywords,
55 * PyArg_ParseTupleAndKeywords expects a "char **". Confine the
56 * inevitable warnings to just one place.
58 static int ParseTupleAndKeywords(PyObject *args, PyObject *kw,
59 const char *format, const char **keywords,
60 ...)
62 va_list a;
63 int ret;
64 va_start(a, keywords);
65 ret = PyArg_VaParseTupleAndKeywords(args, kw, format,
66 (char **)keywords, a);
67 va_end(a);
68 return ret;
71 struct py_cli_thread;
73 struct py_cli_oplock_break {
74 uint16_t fnum;
75 uint8_t level;
78 struct py_cli_state {
79 PyObject_HEAD
80 struct cli_state *cli;
81 struct tevent_context *ev;
82 struct py_cli_thread *thread_state;
84 struct tevent_req *oplock_waiter;
85 struct py_cli_oplock_break *oplock_breaks;
86 struct py_tevent_cond *oplock_cond;
89 #if HAVE_PTHREAD
91 #include <pthread.h>
93 struct py_cli_thread {
96 * Pipe to make the poll thread wake up in our destructor, so
97 * that we can exit and join the thread.
99 int shutdown_pipe[2];
100 struct tevent_fd *shutdown_fde;
101 bool do_shutdown;
102 pthread_t id;
105 * Thread state to release the GIL during the poll(2) syscall
107 PyThreadState *py_threadstate;
110 static void *py_cli_state_poll_thread(void *private_data)
112 struct py_cli_state *self = (struct py_cli_state *)private_data;
113 struct py_cli_thread *t = self->thread_state;
114 PyGILState_STATE gstate;
116 gstate = PyGILState_Ensure();
118 while (!t->do_shutdown) {
119 int ret;
120 ret = tevent_loop_once(self->ev);
121 assert(ret == 0);
123 PyGILState_Release(gstate);
124 return NULL;
127 static void py_cli_state_trace_callback(enum tevent_trace_point point,
128 void *private_data)
130 struct py_cli_state *self = (struct py_cli_state *)private_data;
131 struct py_cli_thread *t = self->thread_state;
133 switch(point) {
134 case TEVENT_TRACE_BEFORE_WAIT:
135 assert(t->py_threadstate == NULL);
136 t->py_threadstate = PyEval_SaveThread();
137 break;
138 case TEVENT_TRACE_AFTER_WAIT:
139 assert(t->py_threadstate != NULL);
140 PyEval_RestoreThread(t->py_threadstate);
141 t->py_threadstate = NULL;
142 break;
143 default:
144 break;
148 static void py_cli_state_shutdown_handler(struct tevent_context *ev,
149 struct tevent_fd *fde,
150 uint16_t flags,
151 void *private_data)
153 struct py_cli_state *self = (struct py_cli_state *)private_data;
154 struct py_cli_thread *t = self->thread_state;
156 if ((flags & TEVENT_FD_READ) == 0) {
157 return;
159 TALLOC_FREE(t->shutdown_fde);
160 t->do_shutdown = true;
163 static int py_cli_thread_destructor(struct py_cli_thread *t)
165 char c = 0;
166 ssize_t written;
167 int ret;
169 do {
171 * This will wake the poll thread from the poll(2)
173 written = write(t->shutdown_pipe[1], &c, 1);
174 } while ((written == -1) && (errno == EINTR));
177 * Allow the poll thread to do its own cleanup under the GIL
179 Py_BEGIN_ALLOW_THREADS
180 ret = pthread_join(t->id, NULL);
181 Py_END_ALLOW_THREADS
182 assert(ret == 0);
184 if (t->shutdown_pipe[0] != -1) {
185 close(t->shutdown_pipe[0]);
186 t->shutdown_pipe[0] = -1;
188 if (t->shutdown_pipe[1] != -1) {
189 close(t->shutdown_pipe[1]);
190 t->shutdown_pipe[1] = -1;
192 return 0;
195 static bool py_cli_state_setup_ev(struct py_cli_state *self)
197 struct py_cli_thread *t = NULL;
198 int ret;
200 self->ev = tevent_context_init_byname(NULL, "poll_mt");
201 if (self->ev == NULL) {
202 goto fail;
204 tevent_set_trace_callback(self->ev, py_cli_state_trace_callback, self);
206 self->thread_state = talloc_zero(NULL, struct py_cli_thread);
207 if (self->thread_state == NULL) {
208 goto fail;
210 t = self->thread_state;
212 ret = pipe(t->shutdown_pipe);
213 if (ret == -1) {
214 goto fail;
216 t->shutdown_fde = tevent_add_fd(
217 self->ev, self->ev, t->shutdown_pipe[0], TEVENT_FD_READ,
218 py_cli_state_shutdown_handler, self);
219 if (t->shutdown_fde == NULL) {
220 goto fail;
223 PyEval_InitThreads();
225 ret = pthread_create(&t->id, NULL, py_cli_state_poll_thread, self);
226 if (ret != 0) {
227 goto fail;
229 talloc_set_destructor(self->thread_state, py_cli_thread_destructor);
230 return true;
232 fail:
233 if (t != NULL) {
234 TALLOC_FREE(t->shutdown_fde);
236 if (t->shutdown_pipe[0] != -1) {
237 close(t->shutdown_pipe[0]);
238 t->shutdown_pipe[0] = -1;
240 if (t->shutdown_pipe[1] != -1) {
241 close(t->shutdown_pipe[1]);
242 t->shutdown_pipe[1] = -1;
246 TALLOC_FREE(self->thread_state);
247 TALLOC_FREE(self->ev);
248 return false;
251 struct py_tevent_cond {
252 pthread_mutex_t mutex;
253 pthread_cond_t cond;
254 bool is_done;
257 static void py_tevent_signalme(struct tevent_req *req);
259 static int py_tevent_cond_wait(struct py_tevent_cond *cond)
261 int ret, result;
263 result = pthread_mutex_init(&cond->mutex, NULL);
264 if (result != 0) {
265 goto fail;
267 result = pthread_cond_init(&cond->cond, NULL);
268 if (result != 0) {
269 goto fail_mutex;
272 result = pthread_mutex_lock(&cond->mutex);
273 if (result != 0) {
274 goto fail_cond;
277 cond->is_done = false;
279 while (!cond->is_done) {
281 Py_BEGIN_ALLOW_THREADS
282 result = pthread_cond_wait(&cond->cond, &cond->mutex);
283 Py_END_ALLOW_THREADS
285 if (result != 0) {
286 goto fail_unlock;
290 fail_unlock:
291 ret = pthread_mutex_unlock(&cond->mutex);
292 assert(ret == 0);
293 fail_cond:
294 ret = pthread_cond_destroy(&cond->cond);
295 assert(ret == 0);
296 fail_mutex:
297 ret = pthread_mutex_destroy(&cond->mutex);
298 assert(ret == 0);
299 fail:
300 return result;
303 static int py_tevent_req_wait(struct tevent_context *ev,
304 struct tevent_req *req)
306 struct py_tevent_cond cond;
307 tevent_req_set_callback(req, py_tevent_signalme, &cond);
308 return py_tevent_cond_wait(&cond);
311 static void py_tevent_cond_signal(struct py_tevent_cond *cond)
313 int ret;
315 ret = pthread_mutex_lock(&cond->mutex);
316 assert(ret == 0);
318 cond->is_done = true;
320 ret = pthread_cond_signal(&cond->cond);
321 assert(ret == 0);
322 ret = pthread_mutex_unlock(&cond->mutex);
323 assert(ret == 0);
326 static void py_tevent_signalme(struct tevent_req *req)
328 struct py_tevent_cond *cond = (struct py_tevent_cond *)
329 tevent_req_callback_data_void(req);
331 py_tevent_cond_signal(cond);
334 #else
336 static bool py_cli_state_setup_ev(struct py_cli_state *self)
338 self->ev = tevent_context_init(NULL);
339 return (self->ev != NULL);
342 static int py_tevent_req_wait(struct tevent_context *ev,
343 struct tevent_req *req)
345 while (tevent_req_is_in_progress(req)) {
346 int ret;
348 ret = tevent_loop_once(ev);
349 if (ret != 0) {
350 return ret;
353 return 0;
356 #endif
358 static bool py_tevent_req_wait_exc(struct tevent_context *ev,
359 struct tevent_req *req)
361 int ret;
363 if (req == NULL) {
364 PyErr_NoMemory();
365 return false;
367 ret = py_tevent_req_wait(ev, req);
368 if (ret != 0) {
369 TALLOC_FREE(req);
370 errno = ret;
371 PyErr_SetFromErrno(PyExc_RuntimeError);
372 return false;
374 return true;
377 static PyObject *py_cli_state_new(PyTypeObject *type, PyObject *args,
378 PyObject *kwds)
380 struct py_cli_state *self;
382 self = (struct py_cli_state *)type->tp_alloc(type, 0);
383 if (self == NULL) {
384 return NULL;
386 self->cli = NULL;
387 self->ev = NULL;
388 self->thread_state = NULL;
389 self->oplock_waiter = NULL;
390 self->oplock_cond = NULL;
391 self->oplock_breaks = NULL;
392 return (PyObject *)self;
395 static void py_cli_got_oplock_break(struct tevent_req *req);
397 static int py_cli_state_init(struct py_cli_state *self, PyObject *args,
398 PyObject *kwds)
400 NTSTATUS status;
401 char *host, *share;
402 PyObject *creds;
403 struct cli_credentials *cli_creds;
404 bool ret;
406 static const char *kwlist[] = {
407 "host", "share", "credentials", NULL
410 PyTypeObject *py_type_Credentials = get_pytype(
411 "samba.credentials", "Credentials");
412 if (py_type_Credentials == NULL) {
413 return -1;
416 ret = ParseTupleAndKeywords(
417 args, kwds, "ss|O!", kwlist,
418 &host, &share, py_type_Credentials, &creds);
420 Py_DECREF(py_type_Credentials);
422 if (!ret) {
423 return -1;
426 if (!py_cli_state_setup_ev(self)) {
427 return -1;
430 cli_creds = cli_credentials_from_py_object(creds);
431 if (cli_creds == NULL) {
432 PyErr_SetString(PyExc_TypeError, "Expected credentials");
433 return -1;
436 status = cli_full_connection(
437 &self->cli, "myname", host, NULL, 0, share, "?????",
438 cli_credentials_get_username(cli_creds),
439 cli_credentials_get_domain(cli_creds),
440 cli_credentials_get_password(cli_creds),
441 0, 0);
442 if (!NT_STATUS_IS_OK(status)) {
443 PyErr_SetNTSTATUS(status);
444 return -1;
447 self->oplock_waiter = cli_smb_oplock_break_waiter_send(
448 self->ev, self->ev, self->cli);
449 if (self->oplock_waiter == NULL) {
450 PyErr_NoMemory();
451 return -1;
453 tevent_req_set_callback(self->oplock_waiter, py_cli_got_oplock_break,
454 self);
455 return 0;
458 static void py_cli_got_oplock_break(struct tevent_req *req)
460 struct py_cli_state *self = (struct py_cli_state *)
461 tevent_req_callback_data_void(req);
462 struct py_cli_oplock_break b;
463 struct py_cli_oplock_break *tmp;
464 size_t num_breaks;
465 NTSTATUS status;
467 status = cli_smb_oplock_break_waiter_recv(req, &b.fnum, &b.level);
468 TALLOC_FREE(req);
469 self->oplock_waiter = NULL;
471 if (!NT_STATUS_IS_OK(status)) {
472 return;
475 num_breaks = talloc_array_length(self->oplock_breaks);
476 tmp = talloc_realloc(self->ev, self->oplock_breaks,
477 struct py_cli_oplock_break, num_breaks+1);
478 if (tmp == NULL) {
479 return;
481 self->oplock_breaks = tmp;
482 self->oplock_breaks[num_breaks] = b;
484 if (self->oplock_cond != NULL) {
485 py_tevent_cond_signal(self->oplock_cond);
488 self->oplock_waiter = cli_smb_oplock_break_waiter_send(
489 self->ev, self->ev, self->cli);
490 if (self->oplock_waiter == NULL) {
491 return;
493 tevent_req_set_callback(self->oplock_waiter, py_cli_got_oplock_break,
494 self);
497 static PyObject *py_cli_get_oplock_break(struct py_cli_state *self,
498 PyObject *args)
500 size_t num_oplock_breaks;
502 if (!PyArg_ParseTuple(args, "")) {
503 return NULL;
506 if (self->oplock_cond != NULL) {
507 errno = EBUSY;
508 PyErr_SetFromErrno(PyExc_RuntimeError);
509 return NULL;
512 num_oplock_breaks = talloc_array_length(self->oplock_breaks);
514 if (num_oplock_breaks == 0) {
515 struct py_tevent_cond cond;
516 int ret;
518 self->oplock_cond = &cond;
519 ret = py_tevent_cond_wait(&cond);
520 self->oplock_cond = NULL;
522 if (ret != 0) {
523 errno = ret;
524 PyErr_SetFromErrno(PyExc_RuntimeError);
525 return NULL;
529 num_oplock_breaks = talloc_array_length(self->oplock_breaks);
530 if (num_oplock_breaks > 0) {
531 PyObject *result;
533 result = Py_BuildValue(
534 "{s:i,s:i}",
535 "fnum", self->oplock_breaks[0].fnum,
536 "level", self->oplock_breaks[0].level);
538 memmove(&self->oplock_breaks[0], &self->oplock_breaks[1],
539 sizeof(self->oplock_breaks[0]) *
540 (num_oplock_breaks - 1));
541 self->oplock_breaks = talloc_realloc(
542 NULL, self->oplock_breaks, struct py_cli_oplock_break,
543 num_oplock_breaks - 1);
545 return result;
547 Py_RETURN_NONE;
550 static void py_cli_state_dealloc(struct py_cli_state *self)
552 TALLOC_FREE(self->thread_state);
553 TALLOC_FREE(self->oplock_waiter);
554 TALLOC_FREE(self->ev);
556 if (self->cli != NULL) {
557 cli_shutdown(self->cli);
558 self->cli = NULL;
560 self->ob_type->tp_free((PyObject *)self);
563 static PyObject *py_cli_create(struct py_cli_state *self, PyObject *args,
564 PyObject *kwds)
566 char *fname;
567 unsigned CreateFlags = 0;
568 unsigned DesiredAccess = FILE_GENERIC_READ;
569 unsigned FileAttributes = 0;
570 unsigned ShareAccess = 0;
571 unsigned CreateDisposition = FILE_OPEN;
572 unsigned CreateOptions = 0;
573 unsigned SecurityFlags = 0;
574 uint16_t fnum;
575 struct tevent_req *req;
576 NTSTATUS status;
578 static const char *kwlist[] = {
579 "Name", "CreateFlags", "DesiredAccess", "FileAttributes",
580 "ShareAccess", "CreateDisposition", "CreateOptions",
581 "SecurityFlags", NULL };
583 if (!ParseTupleAndKeywords(
584 args, kwds, "s|IIIIIII", kwlist,
585 &fname, &CreateFlags, &DesiredAccess, &FileAttributes,
586 &ShareAccess, &CreateDisposition, &CreateOptions,
587 &SecurityFlags)) {
588 return NULL;
591 req = cli_ntcreate_send(NULL, self->ev, self->cli, fname, CreateFlags,
592 DesiredAccess, FileAttributes, ShareAccess,
593 CreateDisposition, CreateOptions,
594 SecurityFlags);
595 if (!py_tevent_req_wait_exc(self->ev, req)) {
596 return NULL;
598 status = cli_ntcreate_recv(req, &fnum);
599 TALLOC_FREE(req);
601 if (!NT_STATUS_IS_OK(status)) {
602 PyErr_SetNTSTATUS(status);
603 return NULL;
605 return Py_BuildValue("I", (unsigned)fnum);
608 static PyObject *py_cli_close(struct py_cli_state *self, PyObject *args)
610 struct tevent_req *req;
611 int fnum;
612 NTSTATUS status;
614 if (!PyArg_ParseTuple(args, "i", &fnum)) {
615 return NULL;
618 req = cli_close_send(NULL, self->ev, self->cli, fnum);
619 if (!py_tevent_req_wait_exc(self->ev, req)) {
620 return NULL;
622 status = cli_close_recv(req);
623 TALLOC_FREE(req);
625 if (!NT_STATUS_IS_OK(status)) {
626 PyErr_SetNTSTATUS(status);
627 return NULL;
629 Py_RETURN_NONE;
632 static PyObject *py_cli_write(struct py_cli_state *self, PyObject *args,
633 PyObject *kwds)
635 int fnum;
636 unsigned mode = 0;
637 char *buf;
638 int buflen;
639 unsigned long long offset;
640 struct tevent_req *req;
641 NTSTATUS status;
642 size_t written;
644 static const char *kwlist[] = {
645 "fnum", "buffer", "offset", "mode", NULL };
647 if (!ParseTupleAndKeywords(
648 args, kwds, "Is#K|I", kwlist,
649 &fnum, &buf, &buflen, &offset, &mode)) {
650 return NULL;
653 req = cli_write_andx_send(NULL, self->ev, self->cli, fnum, mode,
654 (uint8_t *)buf, offset, buflen);
655 if (!py_tevent_req_wait_exc(self->ev, req)) {
656 return NULL;
658 status = cli_write_andx_recv(req, &written);
659 TALLOC_FREE(req);
661 if (!NT_STATUS_IS_OK(status)) {
662 PyErr_SetNTSTATUS(status);
663 return NULL;
665 return Py_BuildValue("K", (unsigned long long)written);
668 static PyObject *py_cli_read(struct py_cli_state *self, PyObject *args,
669 PyObject *kwds)
671 int fnum;
672 unsigned long long offset;
673 unsigned size;
674 struct tevent_req *req;
675 NTSTATUS status;
676 uint8_t *buf;
677 ssize_t buflen;
678 PyObject *result;
680 static const char *kwlist[] = {
681 "fnum", "offset", "size", NULL };
683 if (!ParseTupleAndKeywords(
684 args, kwds, "IKI", kwlist, &fnum, &offset,
685 &size)) {
686 return NULL;
689 req = cli_read_andx_send(NULL, self->ev, self->cli, fnum,
690 offset, size);
691 if (!py_tevent_req_wait_exc(self->ev, req)) {
692 return NULL;
694 status = cli_read_andx_recv(req, &buflen, &buf);
696 if (!NT_STATUS_IS_OK(status)) {
697 TALLOC_FREE(req);
698 PyErr_SetNTSTATUS(status);
699 return NULL;
701 result = Py_BuildValue("s#", (char *)buf, (int)buflen);
702 TALLOC_FREE(req);
703 return result;
706 static PyObject *py_cli_ftruncate(struct py_cli_state *self, PyObject *args,
707 PyObject *kwds)
709 int fnum;
710 unsigned long long size;
711 struct tevent_req *req;
712 NTSTATUS status;
714 static const char *kwlist[] = {
715 "fnum", "size", NULL };
717 if (!ParseTupleAndKeywords(
718 args, kwds, "IK", kwlist, &fnum, &size)) {
719 return NULL;
722 req = cli_ftruncate_send(NULL, self->ev, self->cli, fnum, size);
723 if (!py_tevent_req_wait_exc(self->ev, req)) {
724 return NULL;
726 status = cli_ftruncate_recv(req);
727 TALLOC_FREE(req);
729 if (!NT_STATUS_IS_OK(status)) {
730 PyErr_SetNTSTATUS(status);
731 return NULL;
733 Py_RETURN_NONE;
736 static PyObject *py_cli_delete_on_close(struct py_cli_state *self,
737 PyObject *args,
738 PyObject *kwds)
740 unsigned fnum, flag;
741 struct tevent_req *req;
742 NTSTATUS status;
744 static const char *kwlist[] = {
745 "fnum", "flag", NULL };
747 if (!ParseTupleAndKeywords(
748 args, kwds, "II", kwlist, &fnum, &flag)) {
749 return NULL;
752 req = cli_nt_delete_on_close_send(NULL, self->ev, self->cli, fnum,
753 flag);
754 if (!py_tevent_req_wait_exc(self->ev, req)) {
755 return NULL;
757 status = cli_nt_delete_on_close_recv(req);
758 TALLOC_FREE(req);
760 if (!NT_STATUS_IS_OK(status)) {
761 PyErr_SetNTSTATUS(status);
762 return NULL;
764 Py_RETURN_NONE;
767 static PyObject *py_cli_list(struct py_cli_state *self,
768 PyObject *args,
769 PyObject *kwds)
771 char *mask;
772 unsigned attribute =
773 FILE_ATTRIBUTE_DIRECTORY |
774 FILE_ATTRIBUTE_SYSTEM |
775 FILE_ATTRIBUTE_HIDDEN;
776 unsigned info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
777 struct tevent_req *req;
778 NTSTATUS status;
779 struct file_info *finfos;
780 size_t i, num_finfos;
781 PyObject *result;
783 const char *kwlist[] = {
784 "mask", "attribute", "info_level", NULL
787 if (!ParseTupleAndKeywords(
788 args, kwds, "s|II", kwlist,
789 &mask, &attribute, &info_level)) {
790 return NULL;
793 req = cli_list_send(NULL, self->ev, self->cli, mask, attribute,
794 info_level);
795 if (!py_tevent_req_wait_exc(self->ev, req)) {
796 return NULL;
798 status = cli_list_recv(req, NULL, &finfos, &num_finfos);
799 TALLOC_FREE(req);
801 if (!NT_STATUS_IS_OK(status)) {
802 PyErr_SetNTSTATUS(status);
803 return NULL;
806 result = Py_BuildValue("[]");
807 if (result == NULL) {
808 return NULL;
811 for (i=0; i<num_finfos; i++) {
812 struct file_info *finfo = &finfos[i];
813 PyObject *file;
814 int ret;
816 file = Py_BuildValue(
817 "{s:s,s:i}",
818 "name", finfo->name,
819 "mode", (int)finfo->mode);
820 if (file == NULL) {
821 Py_XDECREF(result);
822 return NULL;
825 ret = PyList_Append(result, file);
826 if (ret == -1) {
827 Py_XDECREF(result);
828 return NULL;
832 return result;
835 static PyMethodDef py_cli_state_methods[] = {
836 { "create", (PyCFunction)py_cli_create, METH_VARARGS|METH_KEYWORDS,
837 "Open a file" },
838 { "close", (PyCFunction)py_cli_close, METH_VARARGS,
839 "Close a file handle" },
840 { "write", (PyCFunction)py_cli_write, METH_VARARGS|METH_KEYWORDS,
841 "Write to a file handle" },
842 { "read", (PyCFunction)py_cli_read, METH_VARARGS|METH_KEYWORDS,
843 "Read from a file handle" },
844 { "truncate", (PyCFunction)py_cli_ftruncate,
845 METH_VARARGS|METH_KEYWORDS,
846 "Truncate a file" },
847 { "delete_on_close", (PyCFunction)py_cli_delete_on_close,
848 METH_VARARGS|METH_KEYWORDS,
849 "Set/Reset the delete on close flag" },
850 { "readdir", (PyCFunction)py_cli_list,
851 METH_VARARGS|METH_KEYWORDS,
852 "List a directory" },
853 { "get_oplock_break", (PyCFunction)py_cli_get_oplock_break,
854 METH_VARARGS, "Wait for an oplock break" },
855 { NULL, NULL, 0, NULL }
858 static PyTypeObject py_cli_state_type = {
859 PyObject_HEAD_INIT(NULL)
860 .tp_name = "libsmb_samba_internal.Conn",
861 .tp_basicsize = sizeof(struct py_cli_state),
862 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
863 .tp_doc = "libsmb connection",
864 .tp_new = py_cli_state_new,
865 .tp_init = (initproc)py_cli_state_init,
866 .tp_dealloc = (destructor)py_cli_state_dealloc,
867 .tp_methods = py_cli_state_methods,
870 static PyMethodDef py_libsmb_methods[] = {
871 { NULL },
874 void initlibsmb_samba_internal(void);
875 void initlibsmb_samba_internal(void)
877 PyObject *m;
879 talloc_stackframe();
881 m = Py_InitModule3("libsmb_samba_internal", py_libsmb_methods,
882 "libsmb wrapper");
884 if (PyType_Ready(&py_cli_state_type) < 0) {
885 return;
887 Py_INCREF(&py_cli_state_type);
888 PyModule_AddObject(m, "Conn", (PyObject *)&py_cli_state_type);