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/>.
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"
30 static PyTypeObject *get_pytype(const char *module, const char *type)
35 mod = PyImport_ImportModule(module);
37 PyErr_Format(PyExc_RuntimeError,
38 "Unable to import %s to check type %s",
42 result = (PyTypeObject *)PyObject_GetAttrString(mod, type);
45 PyErr_Format(PyExc_RuntimeError,
46 "Unable to find type %s in module %s",
54 * We're using "const char * const *" 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 * const *keywords,
62 char **_keywords = discard_const_p(char *, keywords);
65 va_start(a, keywords);
66 ret = PyArg_VaParseTupleAndKeywords(args, kw, format,
74 struct py_cli_oplock_break {
81 struct cli_state *cli;
82 struct tevent_context *ev;
83 struct py_cli_thread *thread_state;
85 struct tevent_req *oplock_waiter;
86 struct py_cli_oplock_break *oplock_breaks;
87 struct py_tevent_cond *oplock_cond;
94 struct py_cli_thread {
97 * Pipe to make the poll thread wake up in our destructor, so
98 * that we can exit and join the thread.
100 int shutdown_pipe[2];
101 struct tevent_fd *shutdown_fde;
106 * Thread state to release the GIL during the poll(2) syscall
108 PyThreadState *py_threadstate;
111 static void *py_cli_state_poll_thread(void *private_data)
113 struct py_cli_state *self = (struct py_cli_state *)private_data;
114 struct py_cli_thread *t = self->thread_state;
115 PyGILState_STATE gstate;
117 gstate = PyGILState_Ensure();
119 while (!t->do_shutdown) {
121 ret = tevent_loop_once(self->ev);
124 PyGILState_Release(gstate);
128 static void py_cli_state_trace_callback(enum tevent_trace_point point,
131 struct py_cli_state *self = (struct py_cli_state *)private_data;
132 struct py_cli_thread *t = self->thread_state;
135 case TEVENT_TRACE_BEFORE_WAIT:
136 assert(t->py_threadstate == NULL);
137 t->py_threadstate = PyEval_SaveThread();
139 case TEVENT_TRACE_AFTER_WAIT:
140 assert(t->py_threadstate != NULL);
141 PyEval_RestoreThread(t->py_threadstate);
142 t->py_threadstate = NULL;
149 static void py_cli_state_shutdown_handler(struct tevent_context *ev,
150 struct tevent_fd *fde,
154 struct py_cli_state *self = (struct py_cli_state *)private_data;
155 struct py_cli_thread *t = self->thread_state;
157 if ((flags & TEVENT_FD_READ) == 0) {
160 TALLOC_FREE(t->shutdown_fde);
161 t->do_shutdown = true;
164 static int py_cli_thread_destructor(struct py_cli_thread *t)
172 * This will wake the poll thread from the poll(2)
174 written = write(t->shutdown_pipe[1], &c, 1);
175 } while ((written == -1) && (errno == EINTR));
178 * Allow the poll thread to do its own cleanup under the GIL
180 Py_BEGIN_ALLOW_THREADS
181 ret = pthread_join(t->id, NULL);
185 if (t->shutdown_pipe[0] != -1) {
186 close(t->shutdown_pipe[0]);
187 t->shutdown_pipe[0] = -1;
189 if (t->shutdown_pipe[1] != -1) {
190 close(t->shutdown_pipe[1]);
191 t->shutdown_pipe[1] = -1;
196 static bool py_cli_state_setup_ev(struct py_cli_state *self)
198 struct py_cli_thread *t = NULL;
201 self->ev = tevent_context_init_byname(NULL, "poll_mt");
202 if (self->ev == NULL) {
205 samba_tevent_set_debug(self->ev, "pylibsmb_tevent_mt");
206 tevent_set_trace_callback(self->ev, py_cli_state_trace_callback, self);
208 self->thread_state = talloc_zero(NULL, struct py_cli_thread);
209 if (self->thread_state == NULL) {
212 t = self->thread_state;
214 ret = pipe(t->shutdown_pipe);
218 t->shutdown_fde = tevent_add_fd(
219 self->ev, self->ev, t->shutdown_pipe[0], TEVENT_FD_READ,
220 py_cli_state_shutdown_handler, self);
221 if (t->shutdown_fde == NULL) {
225 PyEval_InitThreads();
227 ret = pthread_create(&t->id, NULL, py_cli_state_poll_thread, self);
231 talloc_set_destructor(self->thread_state, py_cli_thread_destructor);
236 TALLOC_FREE(t->shutdown_fde);
238 if (t->shutdown_pipe[0] != -1) {
239 close(t->shutdown_pipe[0]);
240 t->shutdown_pipe[0] = -1;
242 if (t->shutdown_pipe[1] != -1) {
243 close(t->shutdown_pipe[1]);
244 t->shutdown_pipe[1] = -1;
248 TALLOC_FREE(self->thread_state);
249 TALLOC_FREE(self->ev);
253 struct py_tevent_cond {
254 pthread_mutex_t mutex;
259 static void py_tevent_signalme(struct tevent_req *req);
261 static int py_tevent_cond_wait(struct py_tevent_cond *cond)
265 result = pthread_mutex_init(&cond->mutex, NULL);
269 result = pthread_cond_init(&cond->cond, NULL);
274 result = pthread_mutex_lock(&cond->mutex);
279 cond->is_done = false;
281 while (!cond->is_done) {
283 Py_BEGIN_ALLOW_THREADS
284 result = pthread_cond_wait(&cond->cond, &cond->mutex);
293 ret = pthread_mutex_unlock(&cond->mutex);
296 ret = pthread_cond_destroy(&cond->cond);
299 ret = pthread_mutex_destroy(&cond->mutex);
305 static int py_tevent_req_wait(struct tevent_context *ev,
306 struct tevent_req *req)
308 struct py_tevent_cond cond;
309 tevent_req_set_callback(req, py_tevent_signalme, &cond);
310 return py_tevent_cond_wait(&cond);
313 static void py_tevent_cond_signal(struct py_tevent_cond *cond)
317 ret = pthread_mutex_lock(&cond->mutex);
320 cond->is_done = true;
322 ret = pthread_cond_signal(&cond->cond);
324 ret = pthread_mutex_unlock(&cond->mutex);
328 static void py_tevent_signalme(struct tevent_req *req)
330 struct py_tevent_cond *cond = (struct py_tevent_cond *)
331 tevent_req_callback_data_void(req);
333 py_tevent_cond_signal(cond);
338 static bool py_cli_state_setup_ev(struct py_cli_state *self)
340 self->ev = tevent_context_init(NULL);
341 if (self->ev == NULL) {
345 samba_tevent_set_debug(self->ev, "pylibsmb_tevent");
350 static int py_tevent_req_wait(struct tevent_context *ev,
351 struct tevent_req *req)
353 while (tevent_req_is_in_progress(req)) {
356 ret = tevent_loop_once(ev);
366 static bool py_tevent_req_wait_exc(struct tevent_context *ev,
367 struct tevent_req *req)
375 ret = py_tevent_req_wait(ev, req);
379 PyErr_SetFromErrno(PyExc_RuntimeError);
385 static PyObject *py_cli_state_new(PyTypeObject *type, PyObject *args,
388 struct py_cli_state *self;
390 self = (struct py_cli_state *)type->tp_alloc(type, 0);
396 self->thread_state = NULL;
397 self->oplock_waiter = NULL;
398 self->oplock_cond = NULL;
399 self->oplock_breaks = NULL;
400 return (PyObject *)self;
403 static void py_cli_got_oplock_break(struct tevent_req *req);
405 static int py_cli_state_init(struct py_cli_state *self, PyObject *args,
410 PyObject *creds = NULL;
411 struct cli_credentials *cli_creds;
412 struct tevent_req *req;
415 * For now we only support SMB1,
416 * as most of the cli_*_send() function
417 * don't support SMB2, it's only plugged
418 * into the sync wrapper functions currently.
420 int flags = CLI_FULL_CONNECTION_FORCE_SMB1;
422 static const char *kwlist[] = {
423 "host", "share", "credentials", NULL
426 PyTypeObject *py_type_Credentials = get_pytype(
427 "samba.credentials", "Credentials");
428 if (py_type_Credentials == NULL) {
432 ret = ParseTupleAndKeywords(
433 args, kwds, "ss|O!", kwlist,
434 &host, &share, py_type_Credentials, &creds);
436 Py_DECREF(py_type_Credentials);
442 if (!py_cli_state_setup_ev(self)) {
447 cli_creds = cli_credentials_init_anon(NULL);
449 cli_creds = PyCredentials_AsCliCredentials(creds);
452 req = cli_full_connection_creds_send(
453 NULL, self->ev, "myname", host, NULL, 0, share, "?????",
454 cli_creds, flags, SMB_SIGNING_DEFAULT);
455 if (!py_tevent_req_wait_exc(self->ev, req)) {
458 status = cli_full_connection_creds_recv(req, &self->cli);
461 if (!NT_STATUS_IS_OK(status)) {
462 PyErr_SetNTSTATUS(status);
466 self->oplock_waiter = cli_smb_oplock_break_waiter_send(
467 self->ev, self->ev, self->cli);
468 if (self->oplock_waiter == NULL) {
472 tevent_req_set_callback(self->oplock_waiter, py_cli_got_oplock_break,
477 static void py_cli_got_oplock_break(struct tevent_req *req)
479 struct py_cli_state *self = (struct py_cli_state *)
480 tevent_req_callback_data_void(req);
481 struct py_cli_oplock_break b;
482 struct py_cli_oplock_break *tmp;
486 status = cli_smb_oplock_break_waiter_recv(req, &b.fnum, &b.level);
488 self->oplock_waiter = NULL;
490 if (!NT_STATUS_IS_OK(status)) {
494 num_breaks = talloc_array_length(self->oplock_breaks);
495 tmp = talloc_realloc(self->ev, self->oplock_breaks,
496 struct py_cli_oplock_break, num_breaks+1);
500 self->oplock_breaks = tmp;
501 self->oplock_breaks[num_breaks] = b;
503 if (self->oplock_cond != NULL) {
504 py_tevent_cond_signal(self->oplock_cond);
507 self->oplock_waiter = cli_smb_oplock_break_waiter_send(
508 self->ev, self->ev, self->cli);
509 if (self->oplock_waiter == NULL) {
512 tevent_req_set_callback(self->oplock_waiter, py_cli_got_oplock_break,
516 static PyObject *py_cli_get_oplock_break(struct py_cli_state *self,
519 size_t num_oplock_breaks;
521 if (!PyArg_ParseTuple(args, "")) {
525 if (self->oplock_cond != NULL) {
527 PyErr_SetFromErrno(PyExc_RuntimeError);
531 num_oplock_breaks = talloc_array_length(self->oplock_breaks);
533 if (num_oplock_breaks == 0) {
534 struct py_tevent_cond cond;
537 self->oplock_cond = &cond;
538 ret = py_tevent_cond_wait(&cond);
539 self->oplock_cond = NULL;
543 PyErr_SetFromErrno(PyExc_RuntimeError);
548 num_oplock_breaks = talloc_array_length(self->oplock_breaks);
549 if (num_oplock_breaks > 0) {
552 result = Py_BuildValue(
554 "fnum", self->oplock_breaks[0].fnum,
555 "level", self->oplock_breaks[0].level);
557 memmove(&self->oplock_breaks[0], &self->oplock_breaks[1],
558 sizeof(self->oplock_breaks[0]) *
559 (num_oplock_breaks - 1));
560 self->oplock_breaks = talloc_realloc(
561 NULL, self->oplock_breaks, struct py_cli_oplock_break,
562 num_oplock_breaks - 1);
569 static void py_cli_state_dealloc(struct py_cli_state *self)
571 TALLOC_FREE(self->thread_state);
572 TALLOC_FREE(self->oplock_waiter);
573 TALLOC_FREE(self->ev);
575 if (self->cli != NULL) {
576 cli_shutdown(self->cli);
579 self->ob_type->tp_free((PyObject *)self);
582 static PyObject *py_cli_create(struct py_cli_state *self, PyObject *args,
586 unsigned CreateFlags = 0;
587 unsigned DesiredAccess = FILE_GENERIC_READ;
588 unsigned FileAttributes = 0;
589 unsigned ShareAccess = 0;
590 unsigned CreateDisposition = FILE_OPEN;
591 unsigned CreateOptions = 0;
592 unsigned SecurityFlags = 0;
594 struct tevent_req *req;
597 static const char *kwlist[] = {
598 "Name", "CreateFlags", "DesiredAccess", "FileAttributes",
599 "ShareAccess", "CreateDisposition", "CreateOptions",
600 "SecurityFlags", NULL };
602 if (!ParseTupleAndKeywords(
603 args, kwds, "s|IIIIIII", kwlist,
604 &fname, &CreateFlags, &DesiredAccess, &FileAttributes,
605 &ShareAccess, &CreateDisposition, &CreateOptions,
610 req = cli_ntcreate_send(NULL, self->ev, self->cli, fname, CreateFlags,
611 DesiredAccess, FileAttributes, ShareAccess,
612 CreateDisposition, CreateOptions,
614 if (!py_tevent_req_wait_exc(self->ev, req)) {
617 status = cli_ntcreate_recv(req, &fnum, NULL);
620 if (!NT_STATUS_IS_OK(status)) {
621 PyErr_SetNTSTATUS(status);
624 return Py_BuildValue("I", (unsigned)fnum);
627 static PyObject *py_cli_close(struct py_cli_state *self, PyObject *args)
629 struct tevent_req *req;
633 if (!PyArg_ParseTuple(args, "i", &fnum)) {
637 req = cli_close_send(NULL, self->ev, self->cli, fnum);
638 if (!py_tevent_req_wait_exc(self->ev, req)) {
641 status = cli_close_recv(req);
644 if (!NT_STATUS_IS_OK(status)) {
645 PyErr_SetNTSTATUS(status);
651 static PyObject *py_cli_write(struct py_cli_state *self, PyObject *args,
658 unsigned long long offset;
659 struct tevent_req *req;
663 static const char *kwlist[] = {
664 "fnum", "buffer", "offset", "mode", NULL };
666 if (!ParseTupleAndKeywords(
667 args, kwds, "Is#K|I", kwlist,
668 &fnum, &buf, &buflen, &offset, &mode)) {
672 req = cli_write_andx_send(NULL, self->ev, self->cli, fnum, mode,
673 (uint8_t *)buf, offset, buflen);
674 if (!py_tevent_req_wait_exc(self->ev, req)) {
677 status = cli_write_andx_recv(req, &written);
680 if (!NT_STATUS_IS_OK(status)) {
681 PyErr_SetNTSTATUS(status);
684 return Py_BuildValue("K", (unsigned long long)written);
687 static PyObject *py_cli_read(struct py_cli_state *self, PyObject *args,
691 unsigned long long offset;
693 struct tevent_req *req;
699 static const char *kwlist[] = {
700 "fnum", "offset", "size", NULL };
702 if (!ParseTupleAndKeywords(
703 args, kwds, "IKI", kwlist, &fnum, &offset,
708 req = cli_read_andx_send(NULL, self->ev, self->cli, fnum,
710 if (!py_tevent_req_wait_exc(self->ev, req)) {
713 status = cli_read_andx_recv(req, &buflen, &buf);
715 if (!NT_STATUS_IS_OK(status)) {
717 PyErr_SetNTSTATUS(status);
720 result = Py_BuildValue("s#", (char *)buf, (int)buflen);
725 static PyObject *py_cli_ftruncate(struct py_cli_state *self, PyObject *args,
729 unsigned long long size;
730 struct tevent_req *req;
733 static const char *kwlist[] = {
734 "fnum", "size", NULL };
736 if (!ParseTupleAndKeywords(
737 args, kwds, "IK", kwlist, &fnum, &size)) {
741 req = cli_ftruncate_send(NULL, self->ev, self->cli, fnum, size);
742 if (!py_tevent_req_wait_exc(self->ev, req)) {
745 status = cli_ftruncate_recv(req);
748 if (!NT_STATUS_IS_OK(status)) {
749 PyErr_SetNTSTATUS(status);
755 static PyObject *py_cli_delete_on_close(struct py_cli_state *self,
760 struct tevent_req *req;
763 static const char *kwlist[] = {
764 "fnum", "flag", NULL };
766 if (!ParseTupleAndKeywords(
767 args, kwds, "II", kwlist, &fnum, &flag)) {
771 req = cli_nt_delete_on_close_send(NULL, self->ev, self->cli, fnum,
773 if (!py_tevent_req_wait_exc(self->ev, req)) {
776 status = cli_nt_delete_on_close_recv(req);
779 if (!NT_STATUS_IS_OK(status)) {
780 PyErr_SetNTSTATUS(status);
786 static PyObject *py_cli_list(struct py_cli_state *self,
792 FILE_ATTRIBUTE_DIRECTORY |
793 FILE_ATTRIBUTE_SYSTEM |
794 FILE_ATTRIBUTE_HIDDEN;
795 unsigned info_level = SMB_FIND_FILE_BOTH_DIRECTORY_INFO;
796 struct tevent_req *req;
798 struct file_info *finfos;
799 size_t i, num_finfos;
802 const char *kwlist[] = {
803 "mask", "attribute", "info_level", NULL
806 if (!ParseTupleAndKeywords(
807 args, kwds, "s|II", kwlist,
808 &mask, &attribute, &info_level)) {
812 req = cli_list_send(NULL, self->ev, self->cli, mask, attribute,
814 if (!py_tevent_req_wait_exc(self->ev, req)) {
817 status = cli_list_recv(req, NULL, &finfos, &num_finfos);
820 if (!NT_STATUS_IS_OK(status)) {
821 PyErr_SetNTSTATUS(status);
825 result = Py_BuildValue("[]");
826 if (result == NULL) {
830 for (i=0; i<num_finfos; i++) {
831 struct file_info *finfo = &finfos[i];
835 file = Py_BuildValue(
838 "mode", (int)finfo->mode);
844 ret = PyList_Append(result, file);
854 static PyMethodDef py_cli_state_methods[] = {
855 { "create", (PyCFunction)py_cli_create, METH_VARARGS|METH_KEYWORDS,
857 { "close", (PyCFunction)py_cli_close, METH_VARARGS,
858 "Close a file handle" },
859 { "write", (PyCFunction)py_cli_write, METH_VARARGS|METH_KEYWORDS,
860 "Write to a file handle" },
861 { "read", (PyCFunction)py_cli_read, METH_VARARGS|METH_KEYWORDS,
862 "Read from a file handle" },
863 { "truncate", (PyCFunction)py_cli_ftruncate,
864 METH_VARARGS|METH_KEYWORDS,
866 { "delete_on_close", (PyCFunction)py_cli_delete_on_close,
867 METH_VARARGS|METH_KEYWORDS,
868 "Set/Reset the delete on close flag" },
869 { "readdir", (PyCFunction)py_cli_list,
870 METH_VARARGS|METH_KEYWORDS,
871 "List a directory" },
872 { "get_oplock_break", (PyCFunction)py_cli_get_oplock_break,
873 METH_VARARGS, "Wait for an oplock break" },
874 { NULL, NULL, 0, NULL }
877 static PyTypeObject py_cli_state_type = {
878 PyObject_HEAD_INIT(NULL)
879 .tp_name = "libsmb_samba_internal.Conn",
880 .tp_basicsize = sizeof(struct py_cli_state),
881 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
882 .tp_doc = "libsmb connection",
883 .tp_new = py_cli_state_new,
884 .tp_init = (initproc)py_cli_state_init,
885 .tp_dealloc = (destructor)py_cli_state_dealloc,
886 .tp_methods = py_cli_state_methods,
889 static PyMethodDef py_libsmb_methods[] = {
893 void initlibsmb_samba_internal(void);
894 void initlibsmb_samba_internal(void)
900 m = Py_InitModule3("libsmb_samba_internal", py_libsmb_methods,
903 if (PyType_Ready(&py_cli_state_type) < 0) {
906 Py_INCREF(&py_cli_state_type);
907 PyModule_AddObject(m, "Conn", (PyObject *)&py_cli_state_type);