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"
29 static PyTypeObject *get_pytype(const char *module, const char *type)
34 mod = PyImport_ImportModule(module);
36 PyErr_Format(PyExc_RuntimeError,
37 "Unable to import %s to check type %s",
41 result = (PyTypeObject *)PyObject_GetAttrString(mod, type);
44 PyErr_Format(PyExc_RuntimeError,
45 "Unable to find type %s in module %s",
56 struct cli_state *cli;
57 struct tevent_context *ev;
58 struct py_cli_thread *thread_state;
65 struct py_cli_thread {
68 * Pipe to make the poll thread wake up in our destructor, so
69 * that we can exit and join the thread.
72 struct tevent_fd *shutdown_fde;
77 * Thread state to release the GIL during the poll(2) syscall
79 PyThreadState *py_threadstate;
82 static void *py_cli_state_poll_thread(void *private_data)
84 struct py_cli_state *self = (struct py_cli_state *)private_data;
85 struct py_cli_thread *t = self->thread_state;
86 PyGILState_STATE gstate;
88 gstate = PyGILState_Ensure();
90 while (!t->do_shutdown) {
92 ret = tevent_loop_once(self->ev);
95 PyGILState_Release(gstate);
99 static void py_cli_state_trace_callback(enum tevent_trace_point point,
102 struct py_cli_state *self = (struct py_cli_state *)private_data;
103 struct py_cli_thread *t = self->thread_state;
106 case TEVENT_TRACE_BEFORE_WAIT:
107 assert(t->py_threadstate == NULL);
108 t->py_threadstate = PyEval_SaveThread();
110 case TEVENT_TRACE_AFTER_WAIT:
111 assert(t->py_threadstate != NULL);
112 PyEval_RestoreThread(t->py_threadstate);
113 t->py_threadstate = NULL;
120 static void py_cli_state_shutdown_handler(struct tevent_context *ev,
121 struct tevent_fd *fde,
125 struct py_cli_state *self = (struct py_cli_state *)private_data;
126 struct py_cli_thread *t = self->thread_state;
128 if ((flags & TEVENT_FD_READ) == 0) {
131 TALLOC_FREE(t->shutdown_fde);
132 t->do_shutdown = true;
135 static int py_cli_thread_destructor(struct py_cli_thread *t)
143 * This will wake the poll thread from the poll(2)
145 written = write(t->shutdown_pipe[1], &c, 1);
146 } while ((written == -1) && (errno == EINTR));
149 * Allow the poll thread to do its own cleanup under the GIL
151 Py_BEGIN_ALLOW_THREADS
152 ret = pthread_join(t->id, NULL);
156 if (t->shutdown_pipe[0] != -1) {
157 close(t->shutdown_pipe[0]);
158 t->shutdown_pipe[0] = -1;
160 if (t->shutdown_pipe[1] != -1) {
161 close(t->shutdown_pipe[1]);
162 t->shutdown_pipe[1] = -1;
167 static bool py_cli_state_setup_ev(struct py_cli_state *self)
169 struct py_cli_thread *t = NULL;
172 self->ev = tevent_context_init_byname(NULL, "poll_mt");
173 if (self->ev == NULL) {
176 tevent_set_trace_callback(self->ev, py_cli_state_trace_callback, self);
178 self->thread_state = talloc_zero(NULL, struct py_cli_thread);
179 if (self->thread_state == NULL) {
182 t = self->thread_state;
184 ret = pipe(t->shutdown_pipe);
188 t->shutdown_fde = tevent_add_fd(
189 self->ev, self->ev, t->shutdown_pipe[0], TEVENT_FD_READ,
190 py_cli_state_shutdown_handler, self);
191 if (t->shutdown_fde == NULL) {
195 PyEval_InitThreads();
197 ret = pthread_create(&t->id, NULL, py_cli_state_poll_thread, self);
201 talloc_set_destructor(self->thread_state, py_cli_thread_destructor);
206 TALLOC_FREE(t->shutdown_fde);
208 if (t->shutdown_pipe[0] != -1) {
209 close(t->shutdown_pipe[0]);
210 t->shutdown_pipe[0] = -1;
212 if (t->shutdown_pipe[1] != -1) {
213 close(t->shutdown_pipe[1]);
214 t->shutdown_pipe[1] = -1;
218 TALLOC_FREE(self->thread_state);
219 TALLOC_FREE(self->ev);
223 struct py_tevent_cond {
224 pthread_mutex_t mutex;
229 static void py_tevent_signalme(struct tevent_req *req);
231 static int py_tevent_cond_wait(struct py_tevent_cond *cond)
235 result = pthread_mutex_init(&cond->mutex, NULL);
239 result = pthread_cond_init(&cond->cond, NULL);
244 result = pthread_mutex_lock(&cond->mutex);
249 cond->is_done = false;
251 while (!cond->is_done) {
253 Py_BEGIN_ALLOW_THREADS
254 result = pthread_cond_wait(&cond->cond, &cond->mutex);
263 ret = pthread_mutex_unlock(&cond->mutex);
266 ret = pthread_cond_destroy(&cond->cond);
269 ret = pthread_mutex_destroy(&cond->mutex);
275 static int py_tevent_req_wait(struct tevent_context *ev,
276 struct tevent_req *req)
278 struct py_tevent_cond cond;
279 tevent_req_set_callback(req, py_tevent_signalme, &cond);
280 return py_tevent_cond_wait(&cond);
283 static void py_tevent_signalme(struct tevent_req *req)
285 struct py_tevent_cond *cond = (struct py_tevent_cond *)
286 tevent_req_callback_data_void(req);
289 ret = pthread_mutex_lock(&cond->mutex);
292 cond->is_done = true;
294 ret = pthread_cond_signal(&cond->cond);
296 ret = pthread_mutex_unlock(&cond->mutex);
302 static bool py_cli_state_setup_ev(struct py_cli_state *self)
304 self->ev = tevent_context_init(NULL);
305 return (self->ev != NULL);
308 static int py_tevent_req_wait(struct tevent_context *ev,
309 struct tevent_req *req)
311 while (tevent_req_is_in_progress(req)) {
314 ret = tevent_loop_once(ev);
324 static PyObject *py_cli_state_new(PyTypeObject *type, PyObject *args,
327 struct py_cli_state *self;
329 self = (struct py_cli_state *)type->tp_alloc(type, 0);
335 self->thread_state = NULL;
336 return (PyObject *)self;
339 static int py_cli_state_init(struct py_cli_state *self, PyObject *args,
345 struct cli_credentials *cli_creds;
348 static const char *kwlist[] = {
349 "host", "share", "credentials", NULL
352 PyTypeObject *py_type_Credentials = get_pytype(
353 "samba.credentials", "Credentials");
354 if (py_type_Credentials == NULL) {
358 ret = PyArg_ParseTupleAndKeywords(
359 args, kwds, "ss|O!", (char **)kwlist,
360 &host, &share, py_type_Credentials, &creds);
362 Py_DECREF(py_type_Credentials);
368 if (!py_cli_state_setup_ev(self)) {
372 cli_creds = cli_credentials_from_py_object(creds);
373 if (cli_creds == NULL) {
374 PyErr_SetString(PyExc_TypeError, "Expected credentials");
378 status = cli_full_connection(
379 &self->cli, "myname", host, NULL, 0, share, "?????",
380 cli_credentials_get_username(cli_creds),
381 cli_credentials_get_domain(cli_creds),
382 cli_credentials_get_password(cli_creds),
384 if (!NT_STATUS_IS_OK(status)) {
385 PyErr_SetNTSTATUS(status);
391 static void py_cli_state_dealloc(struct py_cli_state *self)
393 TALLOC_FREE(self->thread_state);
394 TALLOC_FREE(self->ev);
396 if (self->cli != NULL) {
397 cli_shutdown(self->cli);
400 self->ob_type->tp_free((PyObject *)self);
403 static bool py_tevent_req_wait_exc(struct tevent_context *ev,
404 struct tevent_req *req)
412 ret = py_tevent_req_wait(ev, req);
416 PyErr_SetFromErrno(PyExc_RuntimeError);
422 static PyObject *py_cli_create(struct py_cli_state *self, PyObject *args,
426 unsigned CreateFlags = 0;
427 unsigned DesiredAccess = FILE_GENERIC_READ;
428 unsigned FileAttributes = 0;
429 unsigned ShareAccess = 0;
430 unsigned CreateDisposition = FILE_OPEN;
431 unsigned CreateOptions = 0;
432 unsigned SecurityFlags = 0;
434 struct tevent_req *req;
437 static const char *kwlist[] = {
438 "Name", "CreateFlags", "DesiredAccess", "FileAttributes",
439 "ShareAccess", "CreateDisposition", "CreateOptions",
440 "SecurityFlags", NULL };
442 if (!PyArg_ParseTupleAndKeywords(
443 args, kwds, "s|IIIIIII", (char **)kwlist,
444 &fname, &CreateFlags, &DesiredAccess, &FileAttributes,
445 &ShareAccess, &CreateDisposition, &CreateOptions,
450 req = cli_ntcreate_send(NULL, self->ev, self->cli, fname, CreateFlags,
451 DesiredAccess, FileAttributes, ShareAccess,
452 CreateDisposition, CreateOptions,
454 if (!py_tevent_req_wait_exc(self->ev, req)) {
457 status = cli_ntcreate_recv(req, &fnum);
460 if (!NT_STATUS_IS_OK(status)) {
461 PyErr_SetNTSTATUS(status);
464 return Py_BuildValue("I", (unsigned)fnum);
467 static PyObject *py_cli_close(struct py_cli_state *self, PyObject *args)
469 struct tevent_req *req;
473 if (!PyArg_ParseTuple(args, "i", &fnum)) {
477 req = cli_close_send(NULL, self->ev, self->cli, fnum);
478 if (!py_tevent_req_wait_exc(self->ev, req)) {
481 status = cli_close_recv(req);
484 if (!NT_STATUS_IS_OK(status)) {
485 PyErr_SetNTSTATUS(status);
492 static PyObject *py_cli_write(struct py_cli_state *self, PyObject *args,
499 unsigned long long offset;
500 struct tevent_req *req;
504 static const char *kwlist[] = {
505 "fnum", "buffer", "offset", "mode", NULL };
507 if (!PyArg_ParseTupleAndKeywords(
508 args, kwds, "Is#K|I", (char **)kwlist,
509 &fnum, &buf, &buflen, &offset, &mode)) {
513 req = cli_write_andx_send(NULL, self->ev, self->cli, fnum, mode,
514 (uint8_t *)buf, offset, buflen);
515 if (!py_tevent_req_wait_exc(self->ev, req)) {
518 status = cli_write_andx_recv(req, &written);
521 if (!NT_STATUS_IS_OK(status)) {
522 PyErr_SetNTSTATUS(status);
525 return Py_BuildValue("K", (unsigned long long)written);
528 static PyObject *py_cli_read(struct py_cli_state *self, PyObject *args,
532 unsigned long long offset;
534 struct tevent_req *req;
540 static const char *kwlist[] = {
541 "fnum", "offset", "size", NULL };
543 if (!PyArg_ParseTupleAndKeywords(
544 args, kwds, "IKI", (char **)kwlist, &fnum, &offset,
549 req = cli_read_andx_send(NULL, self->ev, self->cli, fnum,
551 if (!py_tevent_req_wait_exc(self->ev, req)) {
554 status = cli_read_andx_recv(req, &buflen, &buf);
556 if (!NT_STATUS_IS_OK(status)) {
558 PyErr_SetNTSTATUS(status);
561 result = Py_BuildValue("s#", (char *)buf, (int)buflen);
566 static PyObject *py_cli_ftruncate(struct py_cli_state *self, PyObject *args,
570 unsigned long long size;
571 struct tevent_req *req;
574 static const char *kwlist[] = {
575 "fnum", "size", NULL };
577 if (!PyArg_ParseTupleAndKeywords(
578 args, kwds, "IK", (char **)kwlist, &fnum, &size)) {
582 req = cli_ftruncate_send(NULL, self->ev, self->cli, fnum, size);
583 if (!py_tevent_req_wait_exc(self->ev, req)) {
586 status = cli_ftruncate_recv(req);
589 if (!NT_STATUS_IS_OK(status)) {
590 PyErr_SetNTSTATUS(status);
597 static PyObject *py_cli_delete_on_close(struct py_cli_state *self,
602 struct tevent_req *req;
605 static const char *kwlist[] = {
606 "fnum", "flag", NULL };
608 if (!PyArg_ParseTupleAndKeywords(
609 args, kwds, "II", (char **)kwlist, &fnum, &flag)) {
613 req = cli_nt_delete_on_close_send(NULL, self->ev, self->cli, fnum,
615 if (!py_tevent_req_wait_exc(self->ev, req)) {
618 status = cli_nt_delete_on_close_recv(req);
621 if (!NT_STATUS_IS_OK(status)) {
622 PyErr_SetNTSTATUS(status);
629 static PyMethodDef py_cli_state_methods[] = {
630 { "create", (PyCFunction)py_cli_create, METH_VARARGS|METH_KEYWORDS,
632 { "close", (PyCFunction)py_cli_close, METH_VARARGS,
633 "Close a file handle" },
634 { "write", (PyCFunction)py_cli_write, METH_VARARGS|METH_KEYWORDS,
635 "Write to a file handle" },
636 { "read", (PyCFunction)py_cli_read, METH_VARARGS|METH_KEYWORDS,
637 "Read from a file handle" },
638 { "truncate", (PyCFunction)py_cli_ftruncate,
639 METH_VARARGS|METH_KEYWORDS,
641 { "delete_on_close", (PyCFunction)py_cli_delete_on_close,
642 METH_VARARGS|METH_KEYWORDS,
643 "Set/Reset the delete on close flag" },
644 { NULL, NULL, 0, NULL }
647 static PyTypeObject py_cli_state_type = {
648 PyObject_HEAD_INIT(NULL)
649 .tp_name = "libsmb_samba_internal.Conn",
650 .tp_basicsize = sizeof(struct py_cli_state),
651 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
652 .tp_doc = "libsmb connection",
653 .tp_new = py_cli_state_new,
654 .tp_init = (initproc)py_cli_state_init,
655 .tp_dealloc = (destructor)py_cli_state_dealloc,
656 .tp_methods = py_cli_state_methods,
659 static PyMethodDef py_libsmb_methods[] = {
663 void initlibsmb_samba_internal(void);
664 void initlibsmb_samba_internal(void)
670 m = Py_InitModule3("libsmb_samba_internal", py_libsmb_methods,
673 if (PyType_Ready(&py_cli_state_type) < 0) {
676 Py_INCREF(&py_cli_state_type);
677 PyModule_AddObject(m, "Conn", (PyObject *)&py_cli_state_type);