2 Python interface to passdb
4 Copyright (C) Amitay Isaacs 2011
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "lib/util/talloc_stack.h"
24 #include "libcli/security/security.h"
28 /* There's no Py_ssize_t in 2.4, apparently */
29 #if PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5
30 typedef int Py_ssize_t;
31 typedef inquiry lenfunc;
32 typedef intargfunc ssizeargfunc;
35 #ifndef Py_RETURN_NONE
36 #define Py_RETURN_NONE return Py_INCREF(Py_None), Py_None
39 #ifndef Py_TYPE /* Py_TYPE is only available on Python > 2.6 */
40 #define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
44 #define PY_CHECK_TYPE(type, var, fail) \
45 if (!PyObject_TypeCheck(var, type)) {\
46 PyErr_Format(PyExc_TypeError, __location__ ": Expected type '%s' for '%s' of type '%s'", (type)->tp_name, #var, Py_TYPE(var)->tp_name); \
52 static PyTypeObject *dom_sid_Type = NULL;
53 static PyTypeObject *security_Type = NULL;
54 static PyTypeObject *guid_Type = NULL;
56 staticforward PyTypeObject PySamu;
57 staticforward PyTypeObject PyGroupmap;
58 staticforward PyTypeObject PyPDB;
60 static PyObject *py_pdb_error;
62 void initpassdb(void);
65 /************************** PIDL Autogeneratd ******************************/
67 static PyObject *py_samu_get_logon_time(PyObject *obj, void *closure)
69 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
70 PyObject *py_logon_time;
72 py_logon_time = PyInt_FromLong(pdb_get_logon_time(sam_acct));
76 static int py_samu_set_logon_time(PyObject *obj, PyObject *value, void *closure)
78 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
80 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
81 if (!pdb_set_logon_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
87 static PyObject *py_samu_get_logoff_time(PyObject *obj, void *closure)
89 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
90 PyObject *py_logoff_time;
92 py_logoff_time = PyInt_FromLong(pdb_get_logoff_time(sam_acct));
93 return py_logoff_time;
96 static int py_samu_set_logoff_time(PyObject *obj, PyObject *value, void *closure)
98 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
100 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
101 if (!pdb_set_logoff_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
107 static PyObject *py_samu_get_kickoff_time(PyObject *obj, void *closure)
109 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
110 PyObject *py_kickoff_time;
112 py_kickoff_time = PyInt_FromLong(pdb_get_kickoff_time(sam_acct));
113 return py_kickoff_time;
116 static int py_samu_set_kickoff_time(PyObject *obj, PyObject *value, void *closure)
118 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
120 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
121 if (!pdb_set_kickoff_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
127 static PyObject *py_samu_get_bad_password_time(PyObject *obj, void *closure)
129 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
130 PyObject *py_bad_password_time;
132 py_bad_password_time = PyInt_FromLong(pdb_get_bad_password_time(sam_acct));
133 return py_bad_password_time;
136 static int py_samu_set_bad_password_time(PyObject *obj, PyObject *value, void *closure)
138 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
140 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
141 if (!pdb_set_bad_password_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
147 static PyObject *py_samu_get_pass_last_set_time(PyObject *obj, void *closure)
149 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
150 PyObject *py_pass_last_set_time;
152 py_pass_last_set_time = PyInt_FromLong(pdb_get_pass_last_set_time(sam_acct));
153 return py_pass_last_set_time;
156 static int py_samu_set_pass_last_set_time(PyObject *obj, PyObject *value, void *closure)
158 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
160 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
161 if (!pdb_set_pass_last_set_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
167 static PyObject *py_samu_get_pass_can_change_time(PyObject *obj, void *closure)
169 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
170 PyObject *py_pass_can_change_time;
172 py_pass_can_change_time = PyInt_FromLong(pdb_get_pass_can_change_time(sam_acct));
173 return py_pass_can_change_time;
176 static int py_samu_set_pass_can_change_time(PyObject *obj, PyObject *value, void *closure)
178 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
180 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
181 if (!pdb_set_pass_can_change_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
187 static PyObject *py_samu_get_pass_must_change_time(PyObject *obj, void *closure)
189 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
190 PyObject *py_pass_must_change_time;
192 py_pass_must_change_time = PyInt_FromLong(pdb_get_pass_must_change_time(sam_acct));
193 return py_pass_must_change_time;
196 static int py_samu_set_pass_must_change_time(PyObject *obj, PyObject *value, void *closure)
198 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
200 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
201 if (!pdb_set_pass_must_change_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
207 static PyObject *py_samu_get_username(PyObject *obj, void *closure)
209 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
210 PyObject *py_username;
211 const char *username;
213 username = pdb_get_username(sam_acct);
214 if (username == NULL) {
218 py_username = PyString_FromString(username);
222 static int py_samu_set_username(PyObject *obj, PyObject *value, void *closure)
224 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
226 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
227 if (!pdb_set_username(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
233 static PyObject *py_samu_get_domain(PyObject *obj, void *closure)
235 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
239 domain = pdb_get_domain(sam_acct);
240 if (domain == NULL) {
244 py_domain = PyString_FromString(domain);
248 static int py_samu_set_domain(PyObject *obj, PyObject *value, void *closure)
250 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
252 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
253 if (!pdb_set_domain(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
259 static PyObject *py_samu_get_nt_username(PyObject *obj, void *closure)
261 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
262 PyObject *py_nt_username;
263 const char *nt_username;
265 nt_username = pdb_get_nt_username(sam_acct);
266 if (nt_username == NULL) {
270 py_nt_username = PyString_FromString(nt_username);
271 return py_nt_username;
274 static int py_samu_set_nt_username(PyObject *obj, PyObject *value, void *closure)
276 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
278 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
279 if (!pdb_set_nt_username(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
285 static PyObject *py_samu_get_full_name(PyObject *obj, void *closure)
287 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
288 PyObject *py_full_name;
289 const char *full_name;
291 full_name = pdb_get_fullname(sam_acct);
292 if (full_name == NULL) {
296 py_full_name = PyString_FromString(full_name);
300 static int py_samu_set_full_name(PyObject *obj, PyObject *value, void *closure)
302 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
304 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
305 if (!pdb_set_fullname(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
311 static PyObject *py_samu_get_home_dir(PyObject *obj, void *closure)
313 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
314 PyObject *py_home_dir;
315 const char *home_dir;
317 home_dir = pdb_get_homedir(sam_acct);
318 if (home_dir == NULL) {
322 py_home_dir = PyString_FromString(home_dir);
326 static int py_samu_set_home_dir(PyObject *obj, PyObject *value, void *closure)
328 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
330 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
331 if (!pdb_set_homedir(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
337 static PyObject *py_samu_get_dir_drive(PyObject *obj, void *closure)
339 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
340 PyObject *py_dir_drive;
341 const char *dir_drive;
343 dir_drive = pdb_get_dir_drive(sam_acct);
344 if (dir_drive == NULL) {
348 py_dir_drive = PyString_FromString(dir_drive);
352 static int py_samu_set_dir_drive(PyObject *obj, PyObject *value, void *closure)
354 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
356 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
357 if (!pdb_set_dir_drive(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
363 static PyObject *py_samu_get_logon_script(PyObject *obj, void *closure)
365 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
366 PyObject *py_logon_script;
367 const char *logon_script;
369 logon_script = pdb_get_logon_script(sam_acct);
370 if (logon_script == NULL) {
374 py_logon_script = PyString_FromString(logon_script);
375 return py_logon_script;
378 static int py_samu_set_logon_script(PyObject *obj, PyObject *value, void *closure)
380 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
382 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
383 if (!pdb_set_logon_script(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
389 static PyObject *py_samu_get_profile_path(PyObject *obj, void *closure)
391 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
392 PyObject *py_profile_path;
393 const char *profile_path;
395 profile_path = pdb_get_profile_path(sam_acct);
396 if (profile_path == NULL) {
400 py_profile_path = PyString_FromString(profile_path);
401 return py_profile_path;
404 static int py_samu_set_profile_path(PyObject *obj, PyObject *value, void *closure)
406 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
408 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
409 if (!pdb_set_profile_path(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
415 static PyObject *py_samu_get_acct_desc(PyObject *obj, void *closure)
417 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
418 PyObject *py_acct_desc;
419 const char *acct_desc;
421 acct_desc = pdb_get_acct_desc(sam_acct);
422 if (acct_desc == NULL) {
426 py_acct_desc = PyString_FromString(acct_desc);
430 static int py_samu_set_acct_desc(PyObject *obj, PyObject *value, void *closure)
432 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
434 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
435 if (!pdb_set_acct_desc(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
441 static PyObject *py_samu_get_workstations(PyObject *obj, void *closure)
443 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
444 PyObject *py_workstations;
445 const char *workstations;
447 workstations = pdb_get_workstations(sam_acct);
448 if (workstations == NULL) {
452 py_workstations = PyString_FromString(workstations);
453 return py_workstations;
456 static int py_samu_set_workstations(PyObject *obj, PyObject *value, void *closure)
458 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
460 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
461 if (!pdb_set_workstations(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
467 static PyObject *py_samu_get_comment(PyObject *obj, void *closure)
469 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
470 PyObject *py_comment;
473 comment = pdb_get_comment(sam_acct);
474 if (comment == NULL) {
478 py_comment = PyString_FromString(comment);
482 static int py_samu_set_comment(PyObject *obj, PyObject *value, void *closure)
484 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
486 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
487 if (!pdb_set_comment(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
493 static PyObject *py_samu_get_munged_dial(PyObject *obj, void *closure)
495 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
496 PyObject *py_munged_dial;
497 const char *munged_dial;
499 munged_dial = pdb_get_munged_dial(sam_acct);
500 if (munged_dial == NULL) {
504 py_munged_dial = PyString_FromString(munged_dial);
505 return py_munged_dial;
508 static int py_samu_set_munged_dial(PyObject *obj, PyObject *value, void *closure)
510 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
512 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
513 if (!pdb_set_munged_dial(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
519 static PyObject *py_samu_get_user_sid(PyObject *obj, void *closure)
521 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
522 PyObject *py_user_sid;
523 const struct dom_sid *user_sid;
524 struct dom_sid *copy_user_sid;
527 user_sid = pdb_get_user_sid(sam_acct);
528 if(user_sid == NULL) {
532 mem_ctx = talloc_new(NULL);
533 if (mem_ctx == NULL) {
537 copy_user_sid = dom_sid_dup(mem_ctx, user_sid);
538 if (copy_user_sid == NULL) {
540 talloc_free(mem_ctx);
544 py_user_sid = pytalloc_steal(dom_sid_Type, copy_user_sid);
546 talloc_free(mem_ctx);
551 static int py_samu_set_user_sid(PyObject *obj, PyObject *value, void *closure)
553 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
555 PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
556 if (!pdb_set_user_sid(sam_acct, (struct dom_sid *)pytalloc_get_ptr(value), PDB_CHANGED)) {
562 static PyObject *py_samu_get_group_sid(PyObject *obj, void *closure)
564 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
565 PyObject *py_group_sid;
566 const struct dom_sid *group_sid;
567 struct dom_sid *copy_group_sid;
570 mem_ctx = talloc_stackframe();
571 if (mem_ctx == NULL) {
576 group_sid = pdb_get_group_sid(sam_acct);
577 if (group_sid == NULL) {
581 copy_group_sid = dom_sid_dup(mem_ctx, group_sid);
582 if (copy_group_sid == NULL) {
584 talloc_free(mem_ctx);
588 py_group_sid = pytalloc_steal(dom_sid_Type, copy_group_sid);
590 talloc_free(mem_ctx);
595 static int py_samu_set_group_sid(PyObject *obj, PyObject *value, void *closure)
597 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
599 PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
600 if (!pdb_set_group_sid(sam_acct, (struct dom_sid *)pytalloc_get_ptr(value), PDB_CHANGED)) {
606 static PyObject *py_samu_get_lanman_passwd(PyObject *obj, void *closure)
608 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
612 lm_pw = (const char *)pdb_get_lanman_passwd(sam_acct);
617 py_lm_pw = PyString_FromStringAndSize(lm_pw, LM_HASH_LEN);
621 static int py_samu_set_lanman_passwd(PyObject *obj, PyObject *value, void *closure)
623 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
625 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
626 if (!pdb_set_lanman_passwd(sam_acct, (uint8_t *)PyString_AsString(value), PDB_CHANGED)) {
632 static PyObject *py_samu_get_nt_passwd(PyObject *obj, void *closure)
634 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
638 nt_pw = (const char *)pdb_get_nt_passwd(sam_acct);
643 py_nt_pw = PyString_FromStringAndSize(nt_pw, NT_HASH_LEN);
647 static int py_samu_set_nt_passwd(PyObject *obj, PyObject *value, void *closure)
649 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
651 if (!pdb_set_nt_passwd(sam_acct, (uint8_t *)PyString_AsString(value), PDB_CHANGED)) {
657 static PyObject *py_samu_get_pw_history(PyObject *obj, void *closure)
659 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
660 PyObject *py_nt_pw_his;
661 const char *nt_pw_his;
664 nt_pw_his = (const char *)pdb_get_pw_history(sam_acct, &hist_len);
665 if (nt_pw_his == NULL) {
669 py_nt_pw_his = PyString_FromStringAndSize(nt_pw_his, hist_len*PW_HISTORY_ENTRY_LEN);
673 static int py_samu_set_pw_history(PyObject *obj, PyObject *value, void *closure)
675 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
680 PyString_AsStringAndSize(value, &nt_pw_his, &len);
681 hist_len = len / PW_HISTORY_ENTRY_LEN;
682 if (!pdb_set_pw_history(sam_acct, (uint8_t *)nt_pw_his, hist_len, PDB_CHANGED)) {
688 static PyObject *py_samu_get_plaintext_passwd(PyObject *obj, void *closure)
690 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
691 PyObject *py_plaintext_pw;
692 const char *plaintext_pw;
694 plaintext_pw = pdb_get_plaintext_passwd(sam_acct);
695 if (plaintext_pw == NULL) {
699 py_plaintext_pw = PyString_FromString(plaintext_pw);
700 return py_plaintext_pw;
703 static int py_samu_set_plaintext_passwd(PyObject *obj, PyObject *value, void *closure)
705 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
707 if (!pdb_set_plaintext_passwd(sam_acct, PyString_AsString(value))) {
713 static PyObject *py_samu_get_acct_ctrl(PyObject *obj, void *closure)
715 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
716 PyObject *py_acct_ctrl;
718 py_acct_ctrl = PyInt_FromLong(pdb_get_acct_ctrl(sam_acct));
722 static int py_samu_set_acct_ctrl(PyObject *obj, PyObject *value, void *closure)
724 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
726 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
727 if (!pdb_set_acct_ctrl(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
733 static PyObject *py_samu_get_logon_divs(PyObject *obj, void *closure)
735 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
736 PyObject *py_logon_divs;
738 py_logon_divs = PyInt_FromLong(pdb_get_logon_divs(sam_acct));
739 return py_logon_divs;
742 static int py_samu_set_logon_divs(PyObject *obj, PyObject *value, void *closure)
744 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
746 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
747 if (!pdb_set_logon_divs(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
753 static PyObject *py_samu_get_hours_len(PyObject *obj, void *closure)
755 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
756 PyObject *py_hours_len;
758 py_hours_len = PyInt_FromLong(pdb_get_hours_len(sam_acct));
762 static int py_samu_set_hours_len(PyObject *obj, PyObject *value, void *closure)
764 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
766 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
767 if (!pdb_set_hours_len(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
773 static PyObject *py_samu_get_hours(PyObject *obj, void *closure)
775 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
780 hours = (const char *)pdb_get_hours(sam_acct);
785 hours_len = pdb_get_hours_len(sam_acct);
786 if ((py_hours = PyList_New(hours_len)) == NULL) {
791 for (i=0; i<hours_len; i++) {
792 PyList_SetItem(py_hours, i, PyInt_FromLong(hours[i]));
797 static int py_samu_set_hours(PyObject *obj, PyObject *value, void *closure)
799 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
805 PY_CHECK_TYPE(&PyList_Type, value, return -1;);
807 hours_len = PyList_GET_SIZE(value);
809 hours = talloc_array(pytalloc_get_mem_ctx(obj), uint8_t, hours_len);
815 for (i=0; i < hours_len; i++) {
816 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value,i), return -1;);
817 hours[i] = PyInt_AsLong(PyList_GET_ITEM(value, i));
820 status = pdb_set_hours(sam_acct, hours, hours_len, PDB_CHANGED);
829 static PyObject *py_samu_get_bad_password_count(PyObject *obj, void *closure)
831 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
832 PyObject *py_bad_password_count;
834 py_bad_password_count = PyInt_FromLong(pdb_get_bad_password_count(sam_acct));
835 return py_bad_password_count;
838 static int py_samu_set_bad_password_count(PyObject *obj, PyObject *value, void *closure)
840 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
842 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
843 if (!pdb_set_bad_password_count(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
849 static PyObject *py_samu_get_logon_count(PyObject *obj, void *closure)
851 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
852 PyObject *py_logon_count;
854 py_logon_count = PyInt_FromLong(pdb_get_logon_count(sam_acct));
855 return py_logon_count;
858 static int py_samu_set_logon_count(PyObject *obj, PyObject *value, void *closure)
860 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
862 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
863 if (!pdb_set_logon_count(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
869 static PyObject *py_samu_get_country_code(PyObject *obj, void *closure)
871 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
872 PyObject *py_country_code;
874 py_country_code = PyInt_FromLong(pdb_get_country_code(sam_acct));
875 return py_country_code;
878 static int py_samu_set_country_code(PyObject *obj, PyObject *value, void *closure)
880 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
882 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
883 if (!pdb_set_country_code(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
889 static PyObject *py_samu_get_code_page(PyObject *obj, void *closure)
891 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
892 PyObject *py_code_page;
894 py_code_page = PyInt_FromLong(pdb_get_code_page(sam_acct));
898 static int py_samu_set_code_page(PyObject *obj, PyObject *value, void *closure)
900 struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
902 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
903 if (!pdb_set_code_page(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
909 static PyGetSetDef py_samu_getsetters[] = {
910 { discard_const_p(char, "logon_time"), py_samu_get_logon_time, py_samu_set_logon_time },
911 { discard_const_p(char, "logoff_time"), py_samu_get_logoff_time, py_samu_set_logoff_time },
912 { discard_const_p(char, "kickoff_time"), py_samu_get_kickoff_time, py_samu_set_kickoff_time },
913 { discard_const_p(char, "bad_password_time"), py_samu_get_bad_password_time, py_samu_set_bad_password_time },
914 { discard_const_p(char, "pass_last_set_time"), py_samu_get_pass_last_set_time, py_samu_set_pass_last_set_time },
915 { discard_const_p(char, "pass_can_change_time"), py_samu_get_pass_can_change_time, py_samu_set_pass_can_change_time },
916 { discard_const_p(char, "pass_must_change_time"), py_samu_get_pass_must_change_time, py_samu_set_pass_must_change_time },
917 { discard_const_p(char, "username"), py_samu_get_username, py_samu_set_username },
918 { discard_const_p(char, "domain"), py_samu_get_domain, py_samu_set_domain },
919 { discard_const_p(char, "nt_username"), py_samu_get_nt_username, py_samu_set_nt_username },
920 { discard_const_p(char, "full_name"), py_samu_get_full_name, py_samu_set_full_name },
921 { discard_const_p(char, "home_dir"), py_samu_get_home_dir, py_samu_set_home_dir },
922 { discard_const_p(char, "dir_drive"), py_samu_get_dir_drive, py_samu_set_dir_drive },
923 { discard_const_p(char, "logon_script"), py_samu_get_logon_script, py_samu_set_logon_script },
924 { discard_const_p(char, "profile_path"), py_samu_get_profile_path, py_samu_set_profile_path },
925 { discard_const_p(char, "acct_desc"), py_samu_get_acct_desc, py_samu_set_acct_desc },
926 { discard_const_p(char, "workstations"), py_samu_get_workstations, py_samu_set_workstations },
927 { discard_const_p(char, "comment"), py_samu_get_comment, py_samu_set_comment },
928 { discard_const_p(char, "munged_dial"), py_samu_get_munged_dial, py_samu_set_munged_dial },
929 { discard_const_p(char, "user_sid"), py_samu_get_user_sid, py_samu_set_user_sid },
930 { discard_const_p(char, "group_sid"), py_samu_get_group_sid, py_samu_set_group_sid },
931 { discard_const_p(char, "lanman_passwd"), py_samu_get_lanman_passwd, py_samu_set_lanman_passwd },
932 { discard_const_p(char, "nt_passwd"), py_samu_get_nt_passwd, py_samu_set_nt_passwd },
933 { discard_const_p(char, "pw_history"), py_samu_get_pw_history, py_samu_set_pw_history },
934 { discard_const_p(char, "plaintext_passwd"), py_samu_get_plaintext_passwd, py_samu_set_plaintext_passwd },
935 { discard_const_p(char, "acct_ctrl"), py_samu_get_acct_ctrl, py_samu_set_acct_ctrl },
936 { discard_const_p(char, "logon_divs"), py_samu_get_logon_divs, py_samu_set_logon_divs },
937 { discard_const_p(char, "hours_len"), py_samu_get_hours_len, py_samu_set_hours_len },
938 { discard_const_p(char, "hours"), py_samu_get_hours, py_samu_set_hours },
939 { discard_const_p(char, "bad_password_count"), py_samu_get_bad_password_count, py_samu_set_bad_password_count },
940 { discard_const_p(char, "logon_count"), py_samu_get_logon_count, py_samu_set_logon_count },
941 { discard_const_p(char, "country_code"), py_samu_get_country_code, py_samu_set_country_code },
942 { discard_const_p(char, "code_page"), py_samu_get_code_page, py_samu_set_code_page },
947 /************************** PIDL Autogeneratd ******************************/
949 static PyObject *py_samu_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
951 struct samu *sam_acct;
953 sam_acct = samu_new(NULL);
959 return pytalloc_steal(type, sam_acct);
962 static PyTypeObject PySamu = {
963 .tp_name = "passdb.Samu",
964 .tp_basicsize = sizeof(pytalloc_Object),
965 .tp_getset = py_samu_getsetters,
967 .tp_new = py_samu_new,
968 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
969 .tp_doc = "Samu() -> samu object\n",
973 static PyObject *py_groupmap_get_gid(PyObject *obj, void *closure)
975 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
978 py_gid = PyInt_FromLong(group_map->gid);
982 static int py_groupmap_set_gid(PyObject *obj, PyObject *value, void *closure)
984 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
986 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
987 group_map->gid = PyInt_AsLong(value);
991 static PyObject *py_groupmap_get_sid(PyObject *obj, void *closure)
993 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
995 struct dom_sid *group_sid;
998 mem_ctx = talloc_new(NULL);
999 if (mem_ctx == NULL) {
1004 group_sid = dom_sid_dup(mem_ctx, &group_map->sid);
1005 if (group_sid == NULL) {
1007 talloc_free(mem_ctx);
1011 py_sid = pytalloc_steal(dom_sid_Type, group_sid);
1013 talloc_free(mem_ctx);
1018 static int py_groupmap_set_sid(PyObject *obj, PyObject *value, void *closure)
1020 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1022 PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
1023 group_map->sid = *pytalloc_get_type(value, struct dom_sid);
1027 static PyObject *py_groupmap_get_sid_name_use(PyObject *obj, void *closure)
1029 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1030 PyObject *py_sid_name_use;
1032 py_sid_name_use = PyInt_FromLong(group_map->sid_name_use);
1033 return py_sid_name_use;
1036 static int py_groupmap_set_sid_name_use(PyObject *obj, PyObject *value, void *closure)
1038 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1040 PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1041 group_map->sid_name_use = PyInt_AsLong(value);
1045 static PyObject *py_groupmap_get_nt_name(PyObject *obj, void *closure)
1047 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1048 PyObject *py_nt_name;
1049 if (group_map->nt_name == NULL) {
1050 py_nt_name = Py_None;
1051 Py_INCREF(py_nt_name);
1053 py_nt_name = PyString_FromString(group_map->nt_name);
1058 static int py_groupmap_set_nt_name(PyObject *obj, PyObject *value, void *closure)
1060 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1062 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
1063 if (value == Py_None) {
1064 fstrcpy(group_map->nt_name, NULL);
1066 fstrcpy(group_map->nt_name, PyString_AsString(value));
1071 static PyObject *py_groupmap_get_comment(PyObject *obj, void *closure)
1073 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1074 PyObject *py_comment;
1075 if (group_map->comment == NULL) {
1076 py_comment = Py_None;
1077 Py_INCREF(py_comment);
1079 py_comment = PyString_FromString(group_map->comment);
1084 static int py_groupmap_set_comment(PyObject *obj, PyObject *value, void *closure)
1086 GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1088 PY_CHECK_TYPE(&PyString_Type, value, return -1;);
1089 if (value == Py_None) {
1090 fstrcpy(group_map->comment, NULL);
1092 fstrcpy(group_map->comment, PyString_AsString(value));
1097 static PyGetSetDef py_groupmap_getsetters[] = {
1098 { discard_const_p(char, "gid"), py_groupmap_get_gid, py_groupmap_set_gid },
1099 { discard_const_p(char, "sid"), py_groupmap_get_sid, py_groupmap_set_sid },
1100 { discard_const_p(char, "sid_name_use"), py_groupmap_get_sid_name_use, py_groupmap_set_sid_name_use },
1101 { discard_const_p(char, "nt_name"), py_groupmap_get_nt_name, py_groupmap_set_nt_name },
1102 { discard_const_p(char, "comment"), py_groupmap_get_comment, py_groupmap_set_comment },
1106 static PyObject *py_groupmap_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1108 GROUP_MAP *group_map;
1109 TALLOC_CTX *mem_ctx;
1110 PyObject *py_group_map;
1112 mem_ctx = talloc_new(NULL);
1113 if (mem_ctx == NULL) {
1118 group_map = talloc_zero(mem_ctx, GROUP_MAP);
1119 if (group_map == NULL) {
1121 talloc_free(mem_ctx);
1125 py_group_map = pytalloc_steal(type, group_map);
1126 if (py_group_map == NULL) {
1128 talloc_free(mem_ctx);
1132 talloc_free(mem_ctx);
1134 return py_group_map;
1138 static PyTypeObject PyGroupmap = {
1139 .tp_name = "passdb.Groupmap",
1140 .tp_basicsize = sizeof(pytalloc_Object),
1141 .tp_getset = py_groupmap_getsetters,
1143 .tp_new = py_groupmap_new,
1144 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1145 .tp_doc = "Groupmap() -> group map object\n",
1149 static PyObject *py_pdb_domain_info(pytalloc_Object *self, PyObject *args)
1151 struct pdb_methods *methods;
1152 struct pdb_domain_info *domain_info;
1153 PyObject *py_domain_info;
1155 struct dom_sid *sid;
1158 methods = pytalloc_get_ptr(self);
1160 if ((tframe = talloc_stackframe()) == NULL) {
1165 domain_info = methods->get_domain_info(methods, tframe);
1166 if (! domain_info) {
1170 sid = dom_sid_dup(tframe, &domain_info->sid);
1173 talloc_free(tframe);
1177 guid = talloc(tframe, struct GUID);
1180 talloc_free(tframe);
1183 *guid = domain_info->guid;
1185 if ((py_domain_info = PyDict_New()) == NULL) {
1190 PyDict_SetItemString(py_domain_info, "name", PyString_FromString(domain_info->name));
1191 PyDict_SetItemString(py_domain_info, "dns_domain", PyString_FromString(domain_info->name));
1192 PyDict_SetItemString(py_domain_info, "dns_forest", PyString_FromString(domain_info->name));
1193 PyDict_SetItemString(py_domain_info, "dom_sid", pytalloc_steal(dom_sid_Type, sid));
1194 PyDict_SetItemString(py_domain_info, "guid", pytalloc_steal(guid_Type, guid));
1196 talloc_free(tframe);
1198 return py_domain_info;
1202 static PyObject *py_pdb_getsampwnam(pytalloc_Object *self, PyObject *args)
1205 const char *username;
1206 struct pdb_methods *methods;
1207 struct samu *sam_acct;
1208 PyObject *py_sam_acct;
1211 if (!PyArg_ParseTuple(args, "s:getsampwnam", &username)) {
1215 methods = pytalloc_get_ptr(self);
1217 if ((tframe = talloc_stackframe()) == NULL) {
1222 py_sam_acct = py_samu_new(&PySamu, NULL, NULL);
1223 if (py_sam_acct == NULL) {
1225 talloc_free(tframe);
1228 sam_acct = (struct samu *)pytalloc_get_ptr(py_sam_acct);
1230 status = methods->getsampwnam(methods, sam_acct, username);
1231 if (!NT_STATUS_IS_OK(status)) {
1232 PyErr_Format(py_pdb_error, "Unable to get user information for '%s', (%d,%s)",
1234 NT_STATUS_V(status),
1235 get_friendly_nt_error_msg(status));
1236 Py_DECREF(py_sam_acct);
1237 talloc_free(tframe);
1241 talloc_free(tframe);
1245 static PyObject *py_pdb_getsampwsid(pytalloc_Object *self, PyObject *args)
1248 struct pdb_methods *methods;
1249 struct samu *sam_acct;
1250 PyObject *py_sam_acct;
1252 PyObject *py_user_sid;
1254 if (!PyArg_ParseTuple(args, "O:getsampwsid", &py_user_sid)) {
1258 methods = pytalloc_get_ptr(self);
1260 if ((tframe = talloc_stackframe()) == NULL) {
1265 py_sam_acct = py_samu_new(&PySamu, NULL, NULL);
1266 if (py_sam_acct == NULL) {
1268 talloc_free(tframe);
1271 sam_acct = (struct samu *)pytalloc_get_ptr(py_sam_acct);
1273 status = methods->getsampwsid(methods, sam_acct, pytalloc_get_ptr(py_user_sid));
1274 if (!NT_STATUS_IS_OK(status)) {
1275 PyErr_Format(py_pdb_error, "Unable to get user information from SID, (%d,%s)",
1276 NT_STATUS_V(status),
1277 get_friendly_nt_error_msg(status));
1278 Py_DECREF(py_sam_acct);
1279 talloc_free(tframe);
1283 talloc_free(tframe);
1287 static PyObject *py_pdb_create_user(pytalloc_Object *self, PyObject *args)
1290 struct pdb_methods *methods;
1291 const char *username;
1292 unsigned int acct_flags;
1296 if (!PyArg_ParseTuple(args, "sI:create_user", &username, &acct_flags)) {
1300 methods = pytalloc_get_ptr(self);
1302 if ((tframe = talloc_stackframe()) == NULL) {
1307 status = methods->create_user(methods, tframe, username, acct_flags, &rid);
1308 if (!NT_STATUS_IS_OK(status)) {
1309 PyErr_Format(py_pdb_error, "Unable to create user (%s), (%d,%s)",
1311 NT_STATUS_V(status),
1312 get_friendly_nt_error_msg(status));
1313 talloc_free(tframe);
1317 talloc_free(tframe);
1318 return PyInt_FromLong(rid);
1321 static PyObject *py_pdb_delete_user(pytalloc_Object *self, PyObject *args)
1324 struct pdb_methods *methods;
1326 struct samu *sam_acct;
1327 PyObject *py_sam_acct;
1329 if (!PyArg_ParseTuple(args, "O!:delete_user", &PySamu, &py_sam_acct)) {
1333 methods = pytalloc_get_ptr(self);
1335 if ((tframe = talloc_stackframe()) == NULL) {
1340 sam_acct = pytalloc_get_ptr(py_sam_acct);
1342 status = methods->delete_user(methods, tframe, sam_acct);
1343 if (!NT_STATUS_IS_OK(status)) {
1344 PyErr_Format(py_pdb_error, "Unable to delete user, (%d,%s)",
1345 NT_STATUS_V(status),
1346 get_friendly_nt_error_msg(status));
1347 talloc_free(tframe);
1351 talloc_free(tframe);
1355 static PyObject *py_pdb_add_sam_account(pytalloc_Object *self, PyObject *args)
1358 struct pdb_methods *methods;
1360 struct samu *sam_acct;
1361 PyObject *py_sam_acct;
1363 if (!PyArg_ParseTuple(args, "O!:add_sam_account", &PySamu, &py_sam_acct)) {
1367 methods = pytalloc_get_ptr(self);
1369 if ((tframe = talloc_stackframe()) == NULL) {
1374 sam_acct = pytalloc_get_ptr(py_sam_acct);
1376 status = methods->add_sam_account(methods, sam_acct);
1377 if (!NT_STATUS_IS_OK(status)) {
1378 PyErr_Format(py_pdb_error, "Unable to add sam account '%s', (%d,%s)",
1380 NT_STATUS_V(status),
1381 get_friendly_nt_error_msg(status));
1382 talloc_free(tframe);
1386 talloc_free(tframe);
1390 static PyObject *py_pdb_update_sam_account(pytalloc_Object *self, PyObject *args)
1393 struct pdb_methods *methods;
1395 struct samu *sam_acct;
1396 PyObject *py_sam_acct;
1398 if (!PyArg_ParseTuple(args, "O!:update_sam_account", &PySamu, &py_sam_acct)) {
1402 methods = pytalloc_get_ptr(self);
1404 if ((tframe = talloc_stackframe()) == NULL) {
1409 sam_acct = pytalloc_get_ptr(py_sam_acct);
1411 status = methods->update_sam_account(methods, sam_acct);
1412 if (!NT_STATUS_IS_OK(status)) {
1413 PyErr_Format(py_pdb_error, "Unable to update sam account, (%d,%s)",
1414 NT_STATUS_V(status),
1415 get_friendly_nt_error_msg(status));
1416 talloc_free(tframe);
1420 talloc_free(tframe);
1424 static PyObject *py_pdb_delete_sam_account(pytalloc_Object *self, PyObject *args)
1427 struct pdb_methods *methods;
1429 struct samu *sam_acct;
1430 PyObject *py_sam_acct;
1432 if (!PyArg_ParseTuple(args, "O!:delete_sam_account", &PySamu, &py_sam_acct)) {
1436 methods = pytalloc_get_ptr(self);
1438 if ((tframe = talloc_stackframe()) == NULL) {
1443 sam_acct = pytalloc_get_ptr(py_sam_acct);
1445 status = methods->delete_sam_account(methods, sam_acct);
1446 if (!NT_STATUS_IS_OK(status)) {
1447 PyErr_Format(py_pdb_error, "Unable to delete sam account, (%d,%s)",
1448 NT_STATUS_V(status),
1449 get_friendly_nt_error_msg(status));
1450 talloc_free(tframe);
1454 talloc_free(tframe);
1458 static PyObject *py_pdb_rename_sam_account(pytalloc_Object *self, PyObject *args)
1461 struct pdb_methods *methods;
1463 struct samu *sam_acct;
1464 const char *new_username;
1465 PyObject *py_sam_acct;
1467 if (!PyArg_ParseTuple(args, "O!s:rename_sam_account", &PySamu, &py_sam_acct,
1472 methods = pytalloc_get_ptr(self);
1474 if ((tframe = talloc_stackframe()) == NULL) {
1479 sam_acct = pytalloc_get_ptr(py_sam_acct);
1481 status = methods->rename_sam_account(methods, sam_acct, new_username);
1482 if (!NT_STATUS_IS_OK(status)) {
1483 PyErr_Format(py_pdb_error, "Unable to rename sam account, (%d,%s)",
1484 NT_STATUS_V(status),
1485 get_friendly_nt_error_msg(status));
1486 talloc_free(tframe);
1490 talloc_free(tframe);
1495 static PyObject *py_pdb_getgrsid(pytalloc_Object *self, PyObject *args)
1498 struct pdb_methods *methods;
1500 GROUP_MAP *group_map;
1501 struct dom_sid *domain_sid;
1502 PyObject *py_domain_sid, *py_group_map;
1504 if (!PyArg_ParseTuple(args, "O!:getgrsid", dom_sid_Type, &py_domain_sid)) {
1508 methods = pytalloc_get_ptr(self);
1510 if ((tframe = talloc_stackframe()) == NULL) {
1515 domain_sid = pytalloc_get_ptr(py_domain_sid);
1517 py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1518 if (py_group_map == NULL) {
1520 talloc_free(tframe);
1524 group_map = pytalloc_get_ptr(py_group_map);
1526 status = methods->getgrsid(methods, group_map, *domain_sid);
1527 if (!NT_STATUS_IS_OK(status)) {
1528 PyErr_Format(py_pdb_error, "Unable to get group information by sid, (%d,%s)",
1529 NT_STATUS_V(status),
1530 get_friendly_nt_error_msg(status));
1531 talloc_free(tframe);
1535 talloc_free(tframe);
1536 return py_group_map;
1540 static PyObject *py_pdb_getgrgid(pytalloc_Object *self, PyObject *args)
1543 struct pdb_methods *methods;
1545 GROUP_MAP *group_map;
1546 PyObject *py_group_map;
1547 unsigned int gid_value;
1549 if (!PyArg_ParseTuple(args, "I:getgrgid", &gid_value)) {
1553 methods = pytalloc_get_ptr(self);
1555 if ((tframe = talloc_stackframe()) == NULL) {
1560 py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1561 if (py_group_map == NULL) {
1563 talloc_free(tframe);
1567 group_map = pytalloc_get_ptr(py_group_map);
1569 status = methods->getgrgid(methods, group_map, gid_value);
1570 if (!NT_STATUS_IS_OK(status)) {
1571 PyErr_Format(py_pdb_error, "Unable to get group information by gid, (%d,%s)",
1572 NT_STATUS_V(status),
1573 get_friendly_nt_error_msg(status));
1574 talloc_free(tframe);
1578 talloc_free(tframe);
1579 return py_group_map;
1583 static PyObject *py_pdb_getgrnam(pytalloc_Object *self, PyObject *args)
1586 struct pdb_methods *methods;
1588 GROUP_MAP *group_map;
1589 PyObject *py_group_map;
1590 const char *groupname;
1592 if (!PyArg_ParseTuple(args, "s:getgrnam", &groupname)) {
1596 methods = pytalloc_get_ptr(self);
1598 if ((tframe = talloc_stackframe()) == NULL) {
1603 py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1604 if (py_group_map == NULL) {
1606 talloc_free(tframe);
1610 group_map = pytalloc_get_ptr(py_group_map);
1612 status = methods->getgrnam(methods, group_map, groupname);
1613 if (!NT_STATUS_IS_OK(status)) {
1614 PyErr_Format(py_pdb_error, "Unable to get group information by name, (%d,%s)",
1615 NT_STATUS_V(status),
1616 get_friendly_nt_error_msg(status));
1617 talloc_free(tframe);
1621 talloc_free(tframe);
1622 return py_group_map;
1626 static PyObject *py_pdb_create_dom_group(pytalloc_Object *self, PyObject *args)
1629 struct pdb_methods *methods;
1631 const char *groupname;
1634 if (!PyArg_ParseTuple(args, "s:create_dom_group", &groupname)) {
1638 methods = pytalloc_get_ptr(self);
1640 if ((tframe = talloc_stackframe()) == NULL) {
1645 status = methods->create_dom_group(methods, tframe, groupname, &group_rid);
1646 if (!NT_STATUS_IS_OK(status)) {
1647 PyErr_Format(py_pdb_error, "Unable to create domain group (%s), (%d,%s)",
1649 NT_STATUS_V(status),
1650 get_friendly_nt_error_msg(status));
1651 talloc_free(tframe);
1655 talloc_free(tframe);
1656 return PyInt_FromLong(group_rid);
1660 static PyObject *py_pdb_delete_dom_group(pytalloc_Object *self, PyObject *args)
1663 struct pdb_methods *methods;
1665 unsigned int group_rid;
1667 if (!PyArg_ParseTuple(args, "I:delete_dom_group", &group_rid)) {
1671 methods = pytalloc_get_ptr(self);
1673 if ((tframe = talloc_stackframe()) == NULL) {
1678 status = methods->delete_dom_group(methods, tframe, group_rid);
1679 if (!NT_STATUS_IS_OK(status)) {
1680 PyErr_Format(py_pdb_error, "Unable to delete domain group (rid=%d), (%d,%s)",
1682 NT_STATUS_V(status),
1683 get_friendly_nt_error_msg(status));
1684 talloc_free(tframe);
1688 talloc_free(tframe);
1693 static PyObject *py_pdb_add_group_mapping_entry(pytalloc_Object *self, PyObject *args)
1696 struct pdb_methods *methods;
1698 PyObject *py_group_map;
1699 GROUP_MAP *group_map;
1701 if (!PyArg_ParseTuple(args, "O!:add_group_mapping_entry", &PyGroupmap, &py_group_map)) {
1705 methods = pytalloc_get_ptr(self);
1707 if ((tframe = talloc_stackframe()) == NULL) {
1712 group_map = pytalloc_get_ptr(py_group_map);
1714 status = methods->add_group_mapping_entry(methods, group_map);
1715 if (!NT_STATUS_IS_OK(status)) {
1716 PyErr_Format(py_pdb_error, "Unable to add group mapping entry, (%d,%s)",
1717 NT_STATUS_V(status),
1718 get_friendly_nt_error_msg(status));
1719 talloc_free(tframe);
1723 talloc_free(tframe);
1728 static PyObject *py_pdb_update_group_mapping_entry(pytalloc_Object *self, PyObject *args)
1731 struct pdb_methods *methods;
1733 PyObject *py_group_map;
1734 GROUP_MAP *group_map;
1736 if (!PyArg_ParseTuple(args, "O!:update_group_mapping_entry", &PyGroupmap, &py_group_map)) {
1740 methods = pytalloc_get_ptr(self);
1742 if ((tframe = talloc_stackframe()) == NULL) {
1747 group_map = pytalloc_get_ptr(py_group_map);
1749 status = methods->update_group_mapping_entry(methods, group_map);
1750 if (!NT_STATUS_IS_OK(status)) {
1751 PyErr_Format(py_pdb_error, "Unable to update group mapping entry, (%d,%s)",
1752 NT_STATUS_V(status),
1753 get_friendly_nt_error_msg(status));
1754 talloc_free(tframe);
1758 talloc_free(tframe);
1763 static PyObject *py_pdb_delete_group_mapping_entry(pytalloc_Object *self, PyObject *args)
1766 struct pdb_methods *methods;
1768 PyObject *py_group_sid;
1769 struct dom_sid *group_sid;
1771 if (!PyArg_ParseTuple(args, "O!:delete_group_mapping_entry", dom_sid_Type, &py_group_sid)) {
1775 methods = pytalloc_get_ptr(self);
1777 if ((tframe = talloc_stackframe()) == NULL) {
1782 group_sid = pytalloc_get_ptr(py_group_sid);
1784 status = methods->delete_group_mapping_entry(methods, *group_sid);
1785 if (!NT_STATUS_IS_OK(status)) {
1786 PyErr_Format(py_pdb_error, "Unable to delete group mapping entry, (%d,%s)",
1787 NT_STATUS_V(status),
1788 get_friendly_nt_error_msg(status));
1789 talloc_free(tframe);
1793 talloc_free(tframe);
1798 static PyObject *py_pdb_enum_group_mapping(pytalloc_Object *self, PyObject *args)
1801 struct pdb_methods *methods;
1803 enum lsa_SidType sid_name_use;
1804 int lsa_sidtype_value = SID_NAME_UNKNOWN;
1806 PyObject *py_domain_sid;
1807 struct dom_sid *domain_sid = NULL;
1808 GROUP_MAP **gmap, *group_map;
1810 PyObject *py_gmap_list, *py_group_map;
1813 py_domain_sid = Py_None;
1816 if (!PyArg_ParseTuple(args, "|O!ii:enum_group_mapping", dom_sid_Type, &py_domain_sid,
1817 &lsa_sidtype_value, &unix_only)) {
1821 methods = pytalloc_get_ptr(self);
1823 if ((tframe = talloc_stackframe()) == NULL) {
1828 sid_name_use = lsa_sidtype_value;
1830 if (py_domain_sid != Py_None) {
1831 domain_sid = pytalloc_get_ptr(py_domain_sid);
1834 status = methods->enum_group_mapping(methods, domain_sid, sid_name_use,
1835 &gmap, &num_entries, unix_only);
1836 if (!NT_STATUS_IS_OK(status)) {
1837 PyErr_Format(py_pdb_error, "Unable to enumerate group mappings, (%d,%s)",
1838 NT_STATUS_V(status),
1839 get_friendly_nt_error_msg(status));
1840 talloc_free(tframe);
1844 py_gmap_list = PyList_New(0);
1845 if (py_gmap_list == NULL) {
1847 talloc_free(tframe);
1851 for(i=0; i<num_entries; i++) {
1852 py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1854 group_map = pytalloc_get_ptr(py_group_map);
1855 *group_map = *gmap[i];
1856 talloc_steal(group_map, gmap[i]->nt_name);
1857 talloc_steal(group_map, gmap[i]->comment);
1859 PyList_Append(py_gmap_list, py_group_map);
1864 talloc_free(tframe);
1866 return py_gmap_list;
1870 static PyObject *py_pdb_enum_group_members(pytalloc_Object *self, PyObject *args)
1873 struct pdb_methods *methods;
1875 PyObject *py_group_sid;
1876 struct dom_sid *group_sid;
1877 uint32_t *member_rids;
1879 PyObject *py_sid_list;
1880 struct dom_sid *domain_sid, *member_sid;
1883 if (!PyArg_ParseTuple(args, "O!:enum_group_members", dom_sid_Type, &py_group_sid)) {
1887 methods = pytalloc_get_ptr(self);
1889 if ((tframe = talloc_stackframe()) == NULL) {
1894 group_sid = pytalloc_get_ptr(py_group_sid);
1896 status = methods->enum_group_members(methods, tframe, group_sid,
1897 &member_rids, &num_members);
1898 if (!NT_STATUS_IS_OK(status)) {
1899 PyErr_Format(py_pdb_error, "Unable to enumerate group members, (%d,%s)",
1900 NT_STATUS_V(status),
1901 get_friendly_nt_error_msg(status));
1902 talloc_free(tframe);
1906 py_sid_list = PyList_New(0);
1907 if (py_sid_list == NULL) {
1909 talloc_free(tframe);
1913 domain_sid = get_global_sam_sid();
1915 for(i=0; i<num_members; i++) {
1916 member_sid = dom_sid_add_rid(tframe, domain_sid, member_rids[i]);
1917 PyList_Append(py_sid_list, pytalloc_steal(dom_sid_Type, member_sid));
1920 talloc_free(tframe);
1926 static PyObject *py_pdb_add_groupmem(pytalloc_Object *self, PyObject *args)
1929 struct pdb_methods *methods;
1931 uint32_t group_rid, member_rid;
1933 if (!PyArg_ParseTuple(args, "II:add_groupmem", &group_rid, &member_rid)) {
1937 methods = pytalloc_get_ptr(self);
1939 if ((tframe = talloc_stackframe()) == NULL) {
1944 status = methods->add_groupmem(methods, tframe, group_rid, member_rid);
1945 if (!NT_STATUS_IS_OK(status)) {
1946 PyErr_Format(py_pdb_error, "Unable to add group member, (%d,%s)",
1947 NT_STATUS_V(status),
1948 get_friendly_nt_error_msg(status));
1949 talloc_free(tframe);
1953 talloc_free(tframe);
1958 static PyObject *py_pdb_del_groupmem(pytalloc_Object *self, PyObject *args)
1961 struct pdb_methods *methods;
1963 uint32_t group_rid, member_rid;
1965 if (!PyArg_ParseTuple(args, "II:del_groupmem", &group_rid, &member_rid)) {
1969 methods = pytalloc_get_ptr(self);
1971 if ((tframe = talloc_stackframe()) == NULL) {
1976 status = methods->del_groupmem(methods, tframe, group_rid, member_rid);
1977 if (!NT_STATUS_IS_OK(status)) {
1978 PyErr_Format(py_pdb_error, "Unable to rename sam account, (%d,%s)",
1979 NT_STATUS_V(status),
1980 get_friendly_nt_error_msg(status));
1981 talloc_free(tframe);
1985 talloc_free(tframe);
1990 static PyObject *py_pdb_create_alias(pytalloc_Object *self, PyObject *args)
1993 struct pdb_methods *methods;
1995 const char *alias_name;
1998 if (!PyArg_ParseTuple(args, "s:create_alias", &alias_name)) {
2002 methods = pytalloc_get_ptr(self);
2004 if ((tframe = talloc_stackframe()) == NULL) {
2009 status = methods->create_alias(methods, alias_name, &rid);
2010 if (!NT_STATUS_IS_OK(status)) {
2011 PyErr_Format(py_pdb_error, "Unable to create alias (%s), (%d,%s)",
2013 NT_STATUS_V(status),
2014 get_friendly_nt_error_msg(status));
2015 talloc_free(tframe);
2019 talloc_free(tframe);
2021 return PyInt_FromLong(rid);
2025 static PyObject *py_pdb_delete_alias(pytalloc_Object *self, PyObject *args)
2028 struct pdb_methods *methods;
2030 PyObject *py_alias_sid;
2031 struct dom_sid *alias_sid;
2033 if (!PyArg_ParseTuple(args, "O!:delete_alias", dom_sid_Type, &py_alias_sid)) {
2037 methods = pytalloc_get_ptr(self);
2039 if ((tframe = talloc_stackframe()) == NULL) {
2044 alias_sid = pytalloc_get_ptr(py_alias_sid);
2046 status = methods->delete_alias(methods, alias_sid);
2047 if (!NT_STATUS_IS_OK(status)) {
2048 PyErr_Format(py_pdb_error, "Unable to delete alias, (%d,%s)",
2049 NT_STATUS_V(status),
2050 get_friendly_nt_error_msg(status));
2051 talloc_free(tframe);
2055 talloc_free(tframe);
2060 static PyObject *py_pdb_get_aliasinfo(pytalloc_Object *self, PyObject *args)
2063 struct pdb_methods *methods;
2065 PyObject *py_alias_sid;
2066 struct dom_sid *alias_sid;
2067 struct acct_info *alias_info;
2068 PyObject *py_alias_info;
2070 if (!PyArg_ParseTuple(args, "O!:get_aliasinfo", dom_sid_Type, &py_alias_sid)) {
2074 methods = pytalloc_get_ptr(self);
2076 if ((tframe = talloc_stackframe()) == NULL) {
2081 alias_sid = pytalloc_get_ptr(py_alias_sid);
2083 alias_info = talloc_zero(tframe, struct acct_info);
2089 status = methods->get_aliasinfo(methods, alias_sid, alias_info);
2090 if (!NT_STATUS_IS_OK(status)) {
2091 PyErr_Format(py_pdb_error, "Unable to get alias information, (%d,%s)",
2092 NT_STATUS_V(status),
2093 get_friendly_nt_error_msg(status));
2094 talloc_free(tframe);
2098 py_alias_info = PyDict_New();
2099 if (py_alias_info == NULL) {
2101 talloc_free(tframe);
2105 PyDict_SetItemString(py_alias_info, "acct_name",
2106 PyString_FromString(alias_info->acct_name));
2107 PyDict_SetItemString(py_alias_info, "acct_desc",
2108 PyString_FromString(alias_info->acct_desc));
2109 PyDict_SetItemString(py_alias_info, "rid",
2110 PyInt_FromLong(alias_info->rid));
2112 talloc_free(tframe);
2114 return py_alias_info;
2118 static PyObject *py_pdb_set_aliasinfo(pytalloc_Object *self, PyObject *args)
2121 struct pdb_methods *methods;
2123 PyObject *py_alias_sid, *py_alias_info;
2124 struct dom_sid *alias_sid;
2125 struct acct_info alias_info;
2127 if (!PyArg_ParseTuple(args, "O!O:set_alias_info", dom_sid_Type, &py_alias_sid,
2132 methods = pytalloc_get_ptr(self);
2134 if ((tframe = talloc_stackframe()) == NULL) {
2139 alias_sid = pytalloc_get_ptr(py_alias_sid);
2141 fstrcpy(alias_info.acct_name, PyString_AsString(PyDict_GetItemString(py_alias_info, "acct_name")));
2142 fstrcpy(alias_info.acct_desc, PyString_AsString(PyDict_GetItemString(py_alias_info, "acct_desc")));
2144 status = methods->set_aliasinfo(methods, alias_sid, &alias_info);
2145 if (!NT_STATUS_IS_OK(status)) {
2146 PyErr_Format(py_pdb_error, "Unable to set alias information, (%d,%s)",
2147 NT_STATUS_V(status),
2148 get_friendly_nt_error_msg(status));
2149 talloc_free(tframe);
2153 talloc_free(tframe);
2158 static PyObject *py_pdb_add_aliasmem(pytalloc_Object *self, PyObject *args)
2161 struct pdb_methods *methods;
2163 PyObject *py_alias_sid, *py_member_sid;
2164 struct dom_sid *alias_sid, *member_sid;
2166 if (!PyArg_ParseTuple(args, "O!O!:add_aliasmem", dom_sid_Type, &py_alias_sid,
2167 dom_sid_Type, &py_member_sid)) {
2171 methods = pytalloc_get_ptr(self);
2173 if ((tframe = talloc_stackframe()) == NULL) {
2178 alias_sid = pytalloc_get_ptr(py_alias_sid);
2179 member_sid = pytalloc_get_ptr(py_member_sid);
2181 status = methods->add_aliasmem(methods, alias_sid, member_sid);
2182 if (!NT_STATUS_IS_OK(status)) {
2183 PyErr_Format(py_pdb_error, "Unable to add member to alias, (%d,%s)",
2184 NT_STATUS_V(status),
2185 get_friendly_nt_error_msg(status));
2186 talloc_free(tframe);
2190 talloc_free(tframe);
2195 static PyObject *py_pdb_del_aliasmem(pytalloc_Object *self, PyObject *args)
2198 struct pdb_methods *methods;
2200 PyObject *py_alias_sid, *py_member_sid;
2201 const struct dom_sid *alias_sid, *member_sid;
2203 if (!PyArg_ParseTuple(args, "O!O!:del_aliasmem", dom_sid_Type, &py_alias_sid,
2204 dom_sid_Type, &py_member_sid)) {
2208 methods = pytalloc_get_ptr(self);
2210 if ((tframe = talloc_stackframe()) == NULL) {
2215 alias_sid = pytalloc_get_ptr(py_alias_sid);
2216 member_sid = pytalloc_get_ptr(py_member_sid);
2218 status = methods->del_aliasmem(methods, alias_sid, member_sid);
2219 if (!NT_STATUS_IS_OK(status)) {
2220 PyErr_Format(py_pdb_error, "Unable to delete member from alias, (%d,%s)",
2221 NT_STATUS_V(status),
2222 get_friendly_nt_error_msg(status));
2223 talloc_free(tframe);
2227 talloc_free(tframe);
2232 static PyObject *py_pdb_enum_aliasmem(pytalloc_Object *self, PyObject *args)
2235 struct pdb_methods *methods;
2237 PyObject *py_alias_sid;
2238 struct dom_sid *alias_sid, *member_sid;
2239 PyObject *py_member_list, *py_member_sid;
2243 if (!PyArg_ParseTuple(args, "O!:enum_aliasmem", dom_sid_Type, &py_alias_sid)) {
2247 methods = pytalloc_get_ptr(self);
2249 if ((tframe = talloc_stackframe()) == NULL) {
2254 alias_sid = pytalloc_get_ptr(py_alias_sid);
2256 status = methods->enum_aliasmem(methods, alias_sid, tframe, &member_sid, &num_members);
2257 if (!NT_STATUS_IS_OK(status)) {
2258 PyErr_Format(py_pdb_error, "Unable to enumerate members for alias, (%d,%s)",
2259 NT_STATUS_V(status),
2260 get_friendly_nt_error_msg(status));
2261 talloc_free(tframe);
2265 py_member_list = PyList_New(0);
2266 if (py_member_list == NULL) {
2268 talloc_free(tframe);
2272 for(i=0; i<num_members; i++) {
2273 py_member_sid = pytalloc_steal(dom_sid_Type, &member_sid[i]);
2274 if (py_member_sid) {
2275 PyList_Append(py_member_list, py_member_sid);
2279 talloc_free(tframe);
2281 return py_member_list;
2285 static PyObject *py_pdb_get_account_policy(pytalloc_Object *self)
2288 struct pdb_methods *methods;
2290 PyObject *py_acct_policy;
2294 enum pdb_policy_type type;
2296 methods = pytalloc_get_ptr(self);
2298 if ((tframe = talloc_stackframe()) == NULL) {
2303 py_acct_policy = PyDict_New();
2304 if (py_acct_policy == NULL) {
2309 account_policy_names_list(tframe, &names, &count);
2310 for (i=0; i<count; i++) {
2311 type = account_policy_name_to_typenum(names[i]);
2312 status = methods->get_account_policy(methods, type, &value);
2313 if (NT_STATUS_IS_OK(status)) {
2314 PyDict_SetItemString(py_acct_policy, names[i], PyInt_FromLong(value));
2318 talloc_free(tframe);
2320 return py_acct_policy;
2324 static PyObject *py_pdb_set_account_policy(pytalloc_Object *self, PyObject *args)
2327 struct pdb_methods *methods;
2329 PyObject *py_acct_policy, *py_value;
2332 enum pdb_policy_type type;
2334 if (!PyArg_ParseTuple(args, "O!:set_account_policy", PyDict_Type, &py_acct_policy)) {
2338 methods = pytalloc_get_ptr(self);
2340 if ((tframe = talloc_stackframe()) == NULL) {
2345 account_policy_names_list(tframe, &names, &count);
2346 for (i=0; i<count; i++) {
2347 if ((py_value = PyDict_GetItemString(py_acct_policy, names[i])) != NULL) {
2348 type = account_policy_name_to_typenum(names[i]);
2349 status = methods->set_account_policy(methods, type, PyInt_AsLong(py_value));
2350 if (!NT_STATUS_IS_OK(status)) {
2351 PyErr_Format(py_pdb_error, "Error setting account policy (%s), (%d,%s)",
2353 NT_STATUS_V(status),
2354 get_friendly_nt_error_msg(status));
2360 talloc_free(tframe);
2365 static PyObject *py_pdb_search_users(pytalloc_Object *self, PyObject *args)
2368 struct pdb_methods *methods;
2370 unsigned int acct_flags;
2371 struct pdb_search *search;
2372 struct samr_displayentry *entry;
2373 PyObject *py_userlist, *py_dict;
2375 if (!PyArg_ParseTuple(args, "I:search_users", &acct_flags)) {
2379 methods = pytalloc_get_ptr(self);
2381 if ((tframe = talloc_stackframe()) == NULL) {
2386 search = talloc_zero(tframe, struct pdb_search);
2387 if (search == NULL) {
2389 talloc_free(tframe);
2393 if (!methods->search_users(methods, search, acct_flags)) {
2394 PyErr_Format(py_pdb_error, "Unable to search users, (%d,%s)",
2395 NT_STATUS_V(status),
2396 get_friendly_nt_error_msg(status));
2397 talloc_free(tframe);
2401 entry = talloc_zero(tframe, struct samr_displayentry);
2402 if (entry == NULL) {
2404 talloc_free(tframe);
2408 py_userlist = PyList_New(0);
2409 if (py_userlist == NULL) {
2411 talloc_free(tframe);
2415 while (search->next_entry(search, entry)) {
2416 py_dict = PyDict_New();
2417 if (py_dict == NULL) {
2420 PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2421 PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2422 PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2423 PyDict_SetItemString(py_dict, "account_name", PyString_FromString(entry->account_name));
2424 PyDict_SetItemString(py_dict, "fullname", PyString_FromString(entry->fullname));
2425 PyDict_SetItemString(py_dict, "description", PyString_FromString(entry->description));
2426 PyList_Append(py_userlist, py_dict);
2429 search->search_end(search);
2431 talloc_free(tframe);
2437 static PyObject *py_pdb_search_groups(pytalloc_Object *self)
2440 struct pdb_methods *methods;
2442 struct pdb_search *search;
2443 struct samr_displayentry *entry;
2444 PyObject *py_grouplist, *py_dict;
2446 methods = pytalloc_get_ptr(self);
2448 if ((tframe = talloc_stackframe()) == NULL) {
2453 search = talloc_zero(tframe, struct pdb_search);
2454 if (search == NULL) {
2456 talloc_free(tframe);
2460 if (!methods->search_groups(methods, search)) {
2461 PyErr_Format(py_pdb_error, "Unable to search groups, (%d,%s)",
2462 NT_STATUS_V(status),
2463 get_friendly_nt_error_msg(status));
2464 talloc_free(tframe);
2468 entry = talloc_zero(tframe, struct samr_displayentry);
2469 if (entry == NULL) {
2471 talloc_free(tframe);
2475 py_grouplist = PyList_New(0);
2476 if (py_grouplist == NULL) {
2478 talloc_free(tframe);
2482 while (search->next_entry(search, entry)) {
2483 py_dict = PyDict_New();
2484 if (py_dict == NULL) {
2487 PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2488 PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2489 PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2490 PyDict_SetItemString(py_dict, "account_name", PyString_FromString(entry->account_name));
2491 PyDict_SetItemString(py_dict, "fullname", PyString_FromString(entry->fullname));
2492 PyDict_SetItemString(py_dict, "description", PyString_FromString(entry->description));
2493 PyList_Append(py_grouplist, py_dict);
2496 search->search_end(search);
2498 talloc_free(tframe);
2500 return py_grouplist;
2504 static PyObject *py_pdb_search_aliases(pytalloc_Object *self, PyObject *args)
2506 struct pdb_methods *methods;
2508 struct pdb_search *search;
2509 struct samr_displayentry *entry;
2510 PyObject *py_aliaslist, *py_dict;
2511 PyObject *py_domain_sid;
2512 struct dom_sid *domain_sid = NULL;
2514 py_domain_sid = Py_None;
2517 if (!PyArg_ParseTuple(args, "|O!:search_aliases", dom_sid_Type, &py_domain_sid)) {
2521 methods = pytalloc_get_ptr(self);
2523 if ((tframe = talloc_stackframe()) == NULL) {
2528 if (py_domain_sid != Py_None) {
2529 domain_sid = pytalloc_get_ptr(py_domain_sid);
2532 search = talloc_zero(tframe, struct pdb_search);
2533 if (search == NULL) {
2535 talloc_free(tframe);
2539 if (!methods->search_aliases(methods, search, domain_sid)) {
2540 PyErr_Format(py_pdb_error, "Unable to search aliases");
2541 talloc_free(tframe);
2545 entry = talloc_zero(tframe, struct samr_displayentry);
2546 if (entry == NULL) {
2548 talloc_free(tframe);
2552 py_aliaslist = PyList_New(0);
2553 if (py_aliaslist == NULL) {
2555 talloc_free(tframe);
2559 while (search->next_entry(search, entry)) {
2560 py_dict = PyDict_New();
2561 if (py_dict == NULL) {
2564 PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2565 PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2566 PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2567 PyDict_SetItemString(py_dict, "account_name", PyString_FromString(entry->account_name));
2568 PyDict_SetItemString(py_dict, "fullname", PyString_FromString(entry->fullname));
2569 PyDict_SetItemString(py_dict, "description", PyString_FromString(entry->description));
2570 PyList_Append(py_aliaslist, py_dict);
2573 search->search_end(search);
2575 talloc_free(tframe);
2577 return py_aliaslist;
2581 static PyObject *py_pdb_uid_to_sid(pytalloc_Object *self, PyObject *args)
2583 struct pdb_methods *methods;
2586 struct dom_sid user_sid, *copy_user_sid;
2587 PyObject *py_user_sid;
2589 if (!PyArg_ParseTuple(args, "I:uid_to_sid", &uid)) {
2593 methods = pytalloc_get_ptr(self);
2595 if ((tframe = talloc_stackframe()) == NULL) {
2600 if (!methods->uid_to_sid(methods, uid, &user_sid)) {
2601 PyErr_Format(py_pdb_error, "Unable to get sid for uid=%d", uid);
2602 talloc_free(tframe);
2606 copy_user_sid = dom_sid_dup(tframe, &user_sid);
2607 if (copy_user_sid == NULL) {
2609 talloc_free(tframe);
2613 py_user_sid = pytalloc_steal(dom_sid_Type, copy_user_sid);
2615 talloc_free(tframe);
2621 static PyObject *py_pdb_gid_to_sid(pytalloc_Object *self, PyObject *args)
2623 struct pdb_methods *methods;
2626 struct dom_sid group_sid, *copy_group_sid;
2627 PyObject *py_group_sid;
2629 if (!PyArg_ParseTuple(args, "I:gid_to_sid", &gid)) {
2633 methods = pytalloc_get_ptr(self);
2635 if ((tframe = talloc_stackframe()) == NULL) {
2640 if (!methods->gid_to_sid(methods, gid, &group_sid)) {
2641 PyErr_Format(py_pdb_error, "Unable to get sid for gid=%d", gid);
2642 talloc_free(tframe);
2646 copy_group_sid = dom_sid_dup(tframe, &group_sid);
2647 if (copy_group_sid == NULL) {
2649 talloc_free(tframe);
2653 py_group_sid = pytalloc_steal(dom_sid_Type, copy_group_sid);
2655 talloc_free(tframe);
2657 return py_group_sid;
2661 static PyObject *py_pdb_sid_to_id(pytalloc_Object *self, PyObject *args)
2663 struct pdb_methods *methods;
2666 struct dom_sid *sid;
2668 enum lsa_SidType type;
2670 if (!PyArg_ParseTuple(args, "O!:sid_to_id", dom_sid_Type, &py_sid)) {
2674 methods = pytalloc_get_ptr(self);
2676 if ((tframe = talloc_stackframe()) == NULL) {
2681 sid = pytalloc_get_ptr(py_sid);
2683 if (!methods->sid_to_id(methods, sid, &id, &type)) {
2684 PyErr_Format(py_pdb_error, "Unable to get id for sid");
2685 talloc_free(tframe);
2689 talloc_free(tframe);
2691 return Py_BuildValue("(II)", id.uid, type);
2695 static PyObject *py_pdb_new_rid(pytalloc_Object *self)
2697 struct pdb_methods *methods;
2701 methods = pytalloc_get_ptr(self);
2703 if ((tframe = talloc_stackframe()) == NULL) {
2708 if (!methods->new_rid(methods, &rid)) {
2709 PyErr_Format(py_pdb_error, "Unable to get new rid");
2710 talloc_free(tframe);
2714 talloc_free(tframe);
2716 return PyInt_FromLong(rid);
2720 static PyObject *py_pdb_get_trusteddom_pw(pytalloc_Object *self, PyObject *args)
2722 struct pdb_methods *methods;
2726 struct dom_sid sid, *copy_sid;
2728 time_t last_set_time;
2731 if (!PyArg_ParseTuple(args, "s:get_trusteddom_pw", &domain)) {
2735 methods = pytalloc_get_ptr(self);
2737 if ((tframe = talloc_stackframe()) == NULL) {
2742 if (!methods->get_trusteddom_pw(methods, domain, &pwd, &sid, &last_set_time)) {
2743 PyErr_Format(py_pdb_error, "Unable to get trusted domain password");
2744 talloc_free(tframe);
2748 copy_sid = dom_sid_dup(tframe, &sid);
2749 if (copy_sid == NULL) {
2751 talloc_free(tframe);
2755 py_sid = pytalloc_steal(dom_sid_Type, copy_sid);
2756 if (py_sid == NULL) {
2758 talloc_free(tframe);
2762 talloc_free(tframe);
2764 py_value = PyDict_New();
2765 if (py_value == NULL) {
2770 PyDict_SetItemString(py_value, "pwd", PyString_FromString(pwd));
2771 PyDict_SetItemString(py_value, "sid", py_sid);
2772 PyDict_SetItemString(py_value, "last_set_tim", PyInt_FromLong(last_set_time));
2778 static PyObject *py_pdb_set_trusteddom_pw(pytalloc_Object *self, PyObject *args)
2780 struct pdb_methods *methods;
2784 const struct dom_sid *domain_sid;
2785 PyObject *py_domain_sid;
2787 if (!PyArg_ParseTuple(args, "ssO!:set_trusteddom_pw", &domain, &pwd,
2788 dom_sid_Type, &py_domain_sid)) {
2792 methods = pytalloc_get_ptr(self);
2794 if ((tframe = talloc_stackframe()) == NULL) {
2799 domain_sid = pytalloc_get_ptr(py_domain_sid);
2801 if (!methods->set_trusteddom_pw(methods, domain, pwd, domain_sid)) {
2802 PyErr_Format(py_pdb_error, "Unable to set trusted domain password");
2803 talloc_free(tframe);
2811 static PyObject *py_pdb_del_trusteddom_pw(pytalloc_Object *self, PyObject *args)
2813 struct pdb_methods *methods;
2817 if (!PyArg_ParseTuple(args, "s:del_trusteddom_pw", &domain)) {
2821 methods = pytalloc_get_ptr(self);
2823 if ((tframe = talloc_stackframe()) == NULL) {
2828 if (!methods->del_trusteddom_pw(methods, domain)) {
2829 PyErr_Format(py_pdb_error, "Unable to delete trusted domain password");
2830 talloc_free(tframe);
2838 static PyObject *py_pdb_enum_trusteddoms(pytalloc_Object *self)
2841 struct pdb_methods *methods;
2843 uint32_t num_domains;
2844 struct trustdom_info **domains;
2845 PyObject *py_domain_list, *py_dict;
2848 methods = pytalloc_get_ptr(self);
2850 if ((tframe = talloc_stackframe()) == NULL) {
2855 status = methods->enum_trusteddoms(methods, tframe, &num_domains, &domains);
2856 if (!NT_STATUS_IS_OK(status)) {
2857 PyErr_Format(py_pdb_error, "Unable to enumerate trusted domains, (%d,%s)",
2858 NT_STATUS_V(status),
2859 get_friendly_nt_error_msg(status));
2860 talloc_free(tframe);
2864 py_domain_list = PyList_New(0);
2865 if (py_domain_list == NULL) {
2867 talloc_free(tframe);
2871 for(i=0; i<num_domains; i++) {
2872 py_dict = PyDict_New();
2874 PyDict_SetItemString(py_dict, "name",
2875 PyString_FromString(domains[i]->name));
2876 PyDict_SetItemString(py_dict, "sid",
2877 pytalloc_steal(dom_sid_Type, &domains[i]->sid));
2880 PyList_Append(py_domain_list, py_dict);
2883 talloc_free(tframe);
2885 return py_domain_list;
2889 static PyObject *py_pdb_get_trusted_domain(pytalloc_Object *self, PyObject *args)
2892 struct pdb_methods *methods;
2895 struct pdb_trusted_domain *td;
2896 PyObject *py_domain_info;
2898 if (!PyArg_ParseTuple(args, "s:get_trusted_domain", &domain)) {
2902 methods = pytalloc_get_ptr(self);
2904 if ((tframe = talloc_stackframe()) == NULL) {
2909 status = methods->get_trusted_domain(methods, tframe, domain, &td);
2910 if (!NT_STATUS_IS_OK(status)) {
2911 PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
2912 NT_STATUS_V(status),
2913 get_friendly_nt_error_msg(status));
2914 talloc_free(tframe);
2918 py_domain_info = PyDict_New();
2919 if (py_domain_info == NULL) {
2921 talloc_free(tframe);
2925 PyDict_SetItemString(py_domain_info, "domain_name",
2926 PyString_FromString(td->domain_name));
2927 PyDict_SetItemString(py_domain_info, "netbios_name",
2928 PyString_FromString(td->netbios_name));
2929 PyDict_SetItemString(py_domain_info, "security_identifier",
2930 pytalloc_steal(dom_sid_Type, &td->security_identifier));
2931 PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
2932 PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
2933 td->trust_auth_incoming.length));
2934 PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
2935 PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
2936 td->trust_auth_outgoing.length));
2937 PyDict_SetItemString(py_domain_info, "trust_direction",
2938 PyInt_FromLong(td->trust_direction));
2939 PyDict_SetItemString(py_domain_info, "trust_type",
2940 PyInt_FromLong(td->trust_type));
2941 PyDict_SetItemString(py_domain_info, "trust_attributes",
2942 PyInt_FromLong(td->trust_attributes));
2943 PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
2944 PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
2945 td->trust_forest_trust_info.length));
2947 talloc_free(tframe);
2949 return py_domain_info;
2953 static PyObject *py_pdb_get_trusted_domain_by_sid(pytalloc_Object *self, PyObject *args)
2956 struct pdb_methods *methods;
2958 PyObject *py_domain_sid;
2959 struct dom_sid *domain_sid;
2960 struct pdb_trusted_domain *td;
2961 PyObject *py_domain_info;
2963 if (!PyArg_ParseTuple(args, "O!:get_trusted_domain_by_sid", dom_sid_Type, &py_domain_sid)) {
2967 methods = pytalloc_get_ptr(self);
2969 if ((tframe = talloc_stackframe()) == NULL) {
2974 domain_sid = pytalloc_get_ptr(py_domain_sid);
2976 status = methods->get_trusted_domain_by_sid(methods, tframe, domain_sid, &td);
2977 if (!NT_STATUS_IS_OK(status)) {
2978 PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
2979 NT_STATUS_V(status),
2980 get_friendly_nt_error_msg(status));
2981 talloc_free(tframe);
2985 py_domain_info = PyDict_New();
2986 if (py_domain_info == NULL) {
2988 talloc_free(tframe);
2992 PyDict_SetItemString(py_domain_info, "domain_name",
2993 PyString_FromString(td->domain_name));
2994 PyDict_SetItemString(py_domain_info, "netbios_name",
2995 PyString_FromString(td->netbios_name));
2996 PyDict_SetItemString(py_domain_info, "security_identifier",
2997 pytalloc_steal(dom_sid_Type, &td->security_identifier));
2998 PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
2999 PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
3000 td->trust_auth_incoming.length));
3001 PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
3002 PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
3003 td->trust_auth_outgoing.length));
3004 PyDict_SetItemString(py_domain_info, "trust_direction",
3005 PyInt_FromLong(td->trust_direction));
3006 PyDict_SetItemString(py_domain_info, "trust_type",
3007 PyInt_FromLong(td->trust_type));
3008 PyDict_SetItemString(py_domain_info, "trust_attributes",
3009 PyInt_FromLong(td->trust_attributes));
3010 PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
3011 PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
3012 td->trust_forest_trust_info.length));
3014 talloc_free(tframe);
3016 return py_domain_info;
3020 static PyObject *py_pdb_set_trusted_domain(pytalloc_Object *self, PyObject *args)
3023 struct pdb_methods *methods;
3026 PyObject *py_td_info;
3027 struct pdb_trusted_domain td_info;
3031 if (!PyArg_ParseTuple(args, "sO!:set_trusted_domain", &domain, &PyDict_Type, &py_td_info)) {
3035 py_tmp = PyDict_GetItemString(py_td_info, "domain_name");
3036 td_info.domain_name = PyString_AsString(py_tmp);
3038 py_tmp = PyDict_GetItemString(py_td_info, "netbios_name");
3039 td_info.netbios_name = PyString_AsString(py_tmp);
3041 py_tmp = PyDict_GetItemString(py_td_info, "security_identifier");
3042 td_info.security_identifier = *pytalloc_get_type(py_tmp, struct dom_sid);
3044 py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_incoming");
3045 PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_incoming.data, &len);
3046 td_info.trust_auth_incoming.length = len;
3048 py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_outgoing");
3049 PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_outgoing.data, &len);
3050 td_info.trust_auth_outgoing.length = len;
3052 py_tmp = PyDict_GetItemString(py_td_info, "trust_direction");
3053 td_info.trust_direction = PyInt_AsLong(py_tmp);
3055 py_tmp = PyDict_GetItemString(py_td_info, "trust_type");
3056 td_info.trust_type = PyInt_AsLong(py_tmp);
3058 py_tmp = PyDict_GetItemString(py_td_info, "trust_attributes");
3059 td_info.trust_attributes = PyInt_AsLong(py_tmp);
3061 py_tmp = PyDict_GetItemString(py_td_info, "trust_forest_trust_info");
3062 PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_forest_trust_info.data, &len);
3063 td_info.trust_forest_trust_info.length = len;
3065 methods = pytalloc_get_ptr(self);
3067 if ((tframe = talloc_stackframe()) == NULL) {
3072 status = methods->set_trusted_domain(methods, domain, &td_info);
3073 if (!NT_STATUS_IS_OK(status)) {
3074 PyErr_Format(py_pdb_error, "Unable to set trusted domain information, (%d,%s)",
3075 NT_STATUS_V(status),
3076 get_friendly_nt_error_msg(status));
3077 talloc_free(tframe);
3081 talloc_free(tframe);
3087 static PyObject *py_pdb_del_trusted_domain(pytalloc_Object *self, PyObject *args)
3090 struct pdb_methods *methods;
3094 if (!PyArg_ParseTuple(args, "s:del_trusted_domain", &domain)) {
3098 methods = pytalloc_get_ptr(self);
3100 if ((tframe = talloc_stackframe()) == NULL) {
3105 status = methods->del_trusted_domain(methods, domain);
3106 if (!NT_STATUS_IS_OK(status)) {
3107 PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
3108 NT_STATUS_V(status),
3109 get_friendly_nt_error_msg(status));
3110 talloc_free(tframe);
3114 talloc_free(tframe);
3120 static PyObject *py_pdb_enum_trusted_domains(pytalloc_Object *self)
3123 struct pdb_methods *methods;
3125 uint32_t num_domains;
3126 struct pdb_trusted_domain **td_info, *td;
3127 PyObject *py_td_info, *py_domain_info;
3130 methods = pytalloc_get_ptr(self);
3132 if ((tframe = talloc_stackframe()) == NULL) {
3137 status = methods->enum_trusted_domains(methods, tframe, &num_domains, &td_info);
3138 if (!NT_STATUS_IS_OK(status)) {
3139 PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
3140 NT_STATUS_V(status),
3141 get_friendly_nt_error_msg(status));
3142 talloc_free(tframe);
3146 py_td_info = PyList_New(0);
3147 if (py_td_info == NULL) {
3149 talloc_free(tframe);
3153 for (i=0; i<num_domains; i++) {
3155 py_domain_info = PyDict_New();
3156 if (py_domain_info == NULL) {
3158 Py_DECREF(py_td_info);
3159 talloc_free(tframe);
3165 PyDict_SetItemString(py_domain_info, "domain_name",
3166 PyString_FromString(td->domain_name));
3167 PyDict_SetItemString(py_domain_info, "netbios_name",
3168 PyString_FromString(td->netbios_name));
3169 PyDict_SetItemString(py_domain_info, "security_identifier",
3170 pytalloc_steal(dom_sid_Type, &td->security_identifier));
3171 PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
3172 PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
3173 td->trust_auth_incoming.length));
3174 PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
3175 PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
3176 td->trust_auth_outgoing.length));
3177 PyDict_SetItemString(py_domain_info, "trust_direction",
3178 PyInt_FromLong(td->trust_direction));
3179 PyDict_SetItemString(py_domain_info, "trust_type",
3180 PyInt_FromLong(td->trust_type));
3181 PyDict_SetItemString(py_domain_info, "trust_attributes",
3182 PyInt_FromLong(td->trust_attributes));
3183 PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
3184 PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
3185 td->trust_forest_trust_info.length));
3186 PyList_Append(py_td_info, py_domain_info);
3189 talloc_free(tframe);
3195 static PyObject *py_pdb_get_secret(pytalloc_Object *self, PyObject *args)
3198 struct pdb_methods *methods;
3200 const char *secret_name;
3201 DATA_BLOB secret_current, secret_old;
3202 NTTIME secret_current_lastchange, secret_old_lastchange;
3204 struct security_descriptor *sd;
3205 PyObject *py_secret;
3207 if (!PyArg_ParseTuple(args, "s:get_secret_name", &secret_name)) {
3211 methods = pytalloc_get_ptr(self);
3213 if ((tframe = talloc_stackframe()) == NULL) {
3218 py_sd = pytalloc_new(struct security_descriptor, security_Type);
3219 if (py_sd == NULL) {
3221 talloc_free(tframe);
3224 sd = pytalloc_get_ptr(py_sd);
3226 status = methods->get_secret(methods, tframe, secret_name,
3228 &secret_current_lastchange,
3230 &secret_old_lastchange,
3232 if (!NT_STATUS_IS_OK(status)) {
3233 PyErr_Format(py_pdb_error, "Unable to get information for secret (%s), (%d,%s)",
3235 NT_STATUS_V(status),
3236 get_friendly_nt_error_msg(status));
3237 talloc_free(tframe);
3241 py_secret = PyDict_New();
3242 if (py_secret == NULL) {
3245 talloc_free(tframe);
3249 PyDict_SetItemString(py_secret, "secret_current",
3250 PyString_FromStringAndSize((char *)secret_current.data, secret_current.length));
3251 PyDict_SetItemString(py_secret, "secret_current_lastchange",
3252 PyLong_FromUnsignedLongLong(secret_current_lastchange));
3253 PyDict_SetItemString(py_secret, "secret_old",
3254 PyString_FromStringAndSize((char *)secret_old.data, secret_old.length));
3255 PyDict_SetItemString(py_secret, "secret_old_lastchange",
3256 PyLong_FromUnsignedLongLong(secret_old_lastchange));
3257 PyDict_SetItemString(py_secret, "sd", py_sd);
3259 talloc_free(tframe);
3265 static PyObject *py_pdb_set_secret(pytalloc_Object *self, PyObject *args)
3268 struct pdb_methods *methods;
3270 const char *secret_name;
3271 PyObject *py_secret;
3272 PyObject *py_secret_cur, *py_secret_old, *py_sd;
3273 DATA_BLOB secret_current, secret_old;
3274 struct security_descriptor *sd;
3277 if (!PyArg_ParseTuple(args, "sO!:set_secret_name", &secret_name, PyDict_Type, &py_secret)) {
3281 py_secret_cur = PyDict_GetItemString(py_secret, "secret_current");
3282 py_secret_old = PyDict_GetItemString(py_secret, "secret_old");
3283 py_sd = PyDict_GetItemString(py_secret, "sd");
3285 PY_CHECK_TYPE(&PyString_Type, py_secret_cur, return NULL;);
3286 PY_CHECK_TYPE(&PyString_Type, py_secret_old, return NULL;);
3287 PY_CHECK_TYPE(security_Type, py_sd, return NULL;);
3289 methods = pytalloc_get_ptr(self);
3291 if ((tframe = talloc_stackframe()) == NULL) {
3296 PyString_AsStringAndSize(py_secret_cur, (char **)&secret_current.data, &len);
3297 secret_current.length = len;
3298 PyString_AsStringAndSize(py_secret_old, (char **)&secret_old.data, &len);
3299 secret_current.length = len;
3300 sd = pytalloc_get_ptr(py_sd);
3302 status = methods->set_secret(methods, secret_name, &secret_current, &secret_old, sd);
3303 if (!NT_STATUS_IS_OK(status)) {
3304 PyErr_Format(py_pdb_error, "Unable to set information for secret (%s), (%d,%s)",
3306 NT_STATUS_V(status),
3307 get_friendly_nt_error_msg(status));
3308 talloc_free(tframe);
3312 talloc_free(tframe);
3318 static PyObject *py_pdb_delete_secret(pytalloc_Object *self, PyObject *args)
3321 struct pdb_methods *methods;
3323 const char *secret_name;
3325 if (!PyArg_ParseTuple(args, "s:delete_secret", &secret_name)) {
3329 methods = pytalloc_get_ptr(self);
3331 if ((tframe = talloc_stackframe()) == NULL) {
3336 status = methods->delete_secret(methods, secret_name);
3337 if (!NT_STATUS_IS_OK(status)) {
3338 PyErr_Format(py_pdb_error, "Unable to delete secret (%s), (%d,%s)",
3340 NT_STATUS_V(status),
3341 get_friendly_nt_error_msg(status));
3342 talloc_free(tframe);
3346 talloc_free(tframe);
3351 static PyMethodDef py_pdb_methods[] = {
3352 { "domain_info", (PyCFunction)py_pdb_domain_info, METH_NOARGS,
3353 "domain_info() -> str\n\n \
3354 Get domain information for the database." },
3355 { "getsampwnam", (PyCFunction)py_pdb_getsampwnam, METH_VARARGS,
3356 "getsampwnam(username) -> samu object\n\n \
3357 Get user information by name." },
3358 { "getsampwsid", (PyCFunction)py_pdb_getsampwsid, METH_VARARGS,
3359 "getsampwsid(user_sid) -> samu object\n\n \
3360 Get user information by sid (dcerpc.security.dom_sid object)." },
3361 { "create_user", (PyCFunction)py_pdb_create_user, METH_VARARGS,
3362 "create_user(username, acct_flags) -> rid\n\n \
3363 Create user. acct_flags are samr account control flags." },
3364 { "delete_user", (PyCFunction)py_pdb_delete_user, METH_VARARGS,
3365 "delete_user(samu object) -> None\n\n \
3367 { "add_sam_account", (PyCFunction)py_pdb_add_sam_account, METH_VARARGS,
3368 "add_sam_account(samu object) -> None\n\n \
3369 Add SAM account." },
3370 { "update_sam_account", (PyCFunction)py_pdb_update_sam_account, METH_VARARGS,
3371 "update_sam_account(samu object) -> None\n\n \
3372 Update SAM account." },
3373 { "delete_sam_account", (PyCFunction)py_pdb_delete_sam_account, METH_VARARGS,
3374 "delete_sam_account(samu object) -> None\n\n \
3375 Delete SAM account." },
3376 { "rename_sam_account", (PyCFunction)py_pdb_rename_sam_account, METH_VARARGS,
3377 "rename_sam_account(samu object1, new_username) -> None\n\n \
3378 Rename SAM account." },
3379 /* update_login_attempts */
3380 { "getgrsid", (PyCFunction)py_pdb_getgrsid, METH_VARARGS,
3381 "getgrsid(group_sid) -> groupmap object\n\n \
3382 Get group information by sid (dcerpc.security.dom_sid object)." },
3383 { "getgrgid", (PyCFunction)py_pdb_getgrgid, METH_VARARGS,
3384 "getgrsid(gid) -> groupmap object\n\n \
3385 Get group information by gid." },
3386 { "getgrnam", (PyCFunction)py_pdb_getgrnam, METH_VARARGS,
3387 "getgrsid(groupname) -> groupmap object\n\n \
3388 Get group information by name." },
3389 { "create_dom_group", (PyCFunction)py_pdb_create_dom_group, METH_VARARGS,
3390 "create_dom_group(groupname) -> group_rid\n\n \
3391 Create new domain group by name." },
3392 { "delete_dom_group", (PyCFunction)py_pdb_delete_dom_group, METH_VARARGS,
3393 "delete_dom_group(group_rid) -> None\n\n \
3394 Delete domain group identified by rid" },
3395 { "add_group_mapping_entry", (PyCFunction)py_pdb_add_group_mapping_entry, METH_VARARGS,
3396 "add_group_mapping_entry(groupmap) -> None\n \
3397 Add group mapping entry for groupmap object." },
3398 { "update_group_mapping_entry", (PyCFunction)py_pdb_update_group_mapping_entry, METH_VARARGS,
3399 "update_group_mapping_entry(groupmap) -> None\n\n \
3400 Update group mapping entry for groupmap object." },
3401 { "delete_group_mapping_entry", (PyCFunction)py_pdb_delete_group_mapping_entry, METH_VARARGS,
3402 "delete_group_mapping_entry(groupmap) -> None\n\n \
3403 Delete group mapping entry for groupmap object." },
3404 { "enum_group_mapping", (PyCFunction)py_pdb_enum_group_mapping, METH_VARARGS,
3405 "enum_group_mapping([domain_sid, [type, [unix_only]]]) -> List\n\n \
3406 Return list of group mappings as groupmap objects. Optional arguments are domain_sid object, type of group, unix only flag." },
3407 { "enum_group_members", (PyCFunction)py_pdb_enum_group_members, METH_VARARGS,
3408 "enum_group_members(group_sid) -> List\n\n \
3409 Return list of users (dom_sid object) in group." },
3410 /* enum_group_memberships */
3411 /* set_unix_primary_group */
3412 { "add_groupmem", (PyCFunction)py_pdb_add_groupmem, METH_VARARGS,
3413 "add_groupmem(group_rid, member_rid) -> None\n\n \
3414 Add user to group." },
3415 { "del_groupmem", (PyCFunction)py_pdb_del_groupmem, METH_VARARGS,
3416 "del_groupmem(group_rid, member_rid) -> None\n\n \
3417 Remove user from from group." },
3418 { "create_alias", (PyCFunction)py_pdb_create_alias, METH_VARARGS,
3419 "create_alias(alias_name) -> alias_rid\n\n \
3420 Create alias entry." },
3421 { "delete_alias", (PyCFunction)py_pdb_delete_alias, METH_VARARGS,
3422 "delete_alias(alias_sid) -> None\n\n \
3423 Delete alias entry." },
3424 { "get_aliasinfo", (PyCFunction)py_pdb_get_aliasinfo, METH_VARARGS,
3425 "get_aliasinfo(alias_sid) -> Mapping\n\n \
3426 Get alias information as a dictionary with keys - acct_name, acct_desc, rid." },
3427 { "set_aliasinfo", (PyCFunction)py_pdb_set_aliasinfo, METH_VARARGS,
3428 "set_alias_info(alias_sid, Mapping) -> None\n\n \
3429 Set alias information from a dictionary with keys - acct_name, acct_desc." },
3430 { "add_aliasmem", (PyCFunction)py_pdb_add_aliasmem, METH_VARARGS,
3431 "add_aliasmem(alias_sid, member_sid) -> None\n\n \
3432 Add user to alias entry." },
3433 { "del_aliasmem", (PyCFunction)py_pdb_del_aliasmem, METH_VARARGS,
3434 "del_aliasmem(alias_sid, member_sid) -> None\n\n \
3435 Remove a user from alias entry." },
3436 { "enum_aliasmem", (PyCFunction)py_pdb_enum_aliasmem, METH_VARARGS,
3437 "enum_aliasmem(alias_sid) -> List\n\n \
3438 Return a list of members (dom_sid object) for alias entry." },
3439 /* enum_alias_memberships */
3442 { "get_account_policy", (PyCFunction)py_pdb_get_account_policy, METH_NOARGS,
3443 "get_account_policy() -> Mapping\n\n \
3444 Get account policy information as a dictionary." },
3445 { "set_account_policy", (PyCFunction)py_pdb_set_account_policy, METH_VARARGS,
3446 "get_account_policy(Mapping) -> None\n\n \
3447 Set account policy settings from a dicionary." },
3449 { "search_users", (PyCFunction)py_pdb_search_users, METH_VARARGS,
3450 "search_users(acct_flags) -> List\n\n \
3451 Search users. acct_flags are samr account control flags.\n \
3452 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3453 { "search_groups", (PyCFunction)py_pdb_search_groups, METH_NOARGS,
3454 "search_groups() -> List\n\n \
3455 Search unix only groups. \n \
3456 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3457 { "search_aliases", (PyCFunction)py_pdb_search_aliases, METH_VARARGS,
3458 "search_aliases([domain_sid]) -> List\n\n \
3459 Search aliases. domain_sid is dcerpc.security.dom_sid object.\n \
3460 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3461 { "uid_to_sid", (PyCFunction)py_pdb_uid_to_sid, METH_VARARGS,
3462 "uid_to_sid(uid) -> sid\n\n \
3463 Return sid for given user id." },
3464 { "gid_to_sid", (PyCFunction)py_pdb_gid_to_sid, METH_VARARGS,
3465 "gid_to_sid(gid) -> sid\n\n \
3466 Return sid for given group id." },
3467 { "sid_to_id", (PyCFunction)py_pdb_sid_to_id, METH_VARARGS,
3468 "sid_to_id(sid) -> Tuple\n\n \
3469 Return id and type for given sid." },
3471 { "new_rid", (PyCFunction)py_pdb_new_rid, METH_NOARGS,
3472 "new_rid() -> rid\n\n \
3474 { "get_trusteddom_pw", (PyCFunction)py_pdb_get_trusteddom_pw, METH_VARARGS,
3475 "get_trusteddom_pw(domain) -> Mapping\n\n \
3476 Get trusted domain password, sid and last set time in a dictionary." },
3477 { "set_trusteddom_pw", (PyCFunction)py_pdb_set_trusteddom_pw, METH_VARARGS,
3478 "set_trusteddom_pw(domain, pwd, sid) -> None\n\n \
3479 Set trusted domain password." },
3480 { "del_trusteddom_pw", (PyCFunction)py_pdb_del_trusteddom_pw, METH_VARARGS,
3481 "del_trusteddom_pw(domain) -> None\n\n \
3482 Delete trusted domain password." },
3483 { "enum_trusteddoms", (PyCFunction)py_pdb_enum_trusteddoms, METH_NOARGS,
3484 "enum_trusteddoms() -> List\n\n \
3485 Get list of trusted domains. Each item is a dictionary with name and sid keys" },
3486 { "get_trusted_domain", (PyCFunction)py_pdb_get_trusted_domain, METH_VARARGS,
3487 "get_trusted_domain(domain) -> Mapping\n\n \
3488 Get trusted domain information by name. Information is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info." },
3489 { "get_trusted_domain_by_sid", (PyCFunction)py_pdb_get_trusted_domain_by_sid, METH_VARARGS,
3490 "get_trusted_domain_by_sid(domain_sid) -> Mapping\n\n \
3491 Get trusted domain information by sid. Information is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info" },
3492 { "set_trusted_domain", (PyCFunction)py_pdb_set_trusted_domain, METH_VARARGS,
3493 "set_trusted_domain(domain, Mapping) -> None\n\n \
3494 Set trusted domain information for domain. Mapping is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info." },
3495 { "del_trusted_domain", (PyCFunction)py_pdb_del_trusted_domain, METH_VARARGS,
3496 "del_trusted_domain(domain) -> None\n\n \
3497 Delete trusted domain." },
3498 { "enum_trusted_domains", (PyCFunction)py_pdb_enum_trusted_domains, METH_VARARGS,
3499 "enum_trusted_domains() -> List\n\n \
3500 Get list of trusted domains. Each entry is a dictionary with keys - domain_name, netbios_name, security_identifier, trust_auth_incoming, trust_auth_outgoing, trust_direction, trust_type, trust_attributes, trust_forest_trust_info." },
3501 { "get_secret", (PyCFunction)py_pdb_get_secret, METH_VARARGS,
3502 "get_secret(secret_name) -> Mapping\n\n \
3503 Get secret information for secret_name. Information is a dictionary with keys - secret_current, secret_current_lastchange, secret_old, secret_old_lastchange, sd." },
3504 { "set_secret", (PyCFunction)py_pdb_set_secret, METH_VARARGS,
3505 "set_secret(secret_name, Mapping) -> None\n\n \
3506 Set secret information for secret_name using dictionary with keys - secret_current, sd." },
3507 { "delete_secret", (PyCFunction)py_pdb_delete_secret, METH_VARARGS,
3508 "delete_secret(secret_name) -> None\n\n \
3509 Delete secret information for secret_name." },
3514 static PyObject *py_pdb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3516 const char *url = NULL;
3519 struct pdb_methods *methods;
3521 if (!PyArg_ParseTuple(args, "s", &url)) {
3525 /* Initalize list of methods */
3526 status = make_pdb_method_name(&methods, url);
3527 if (!NT_STATUS_IS_OK(status)) {
3528 PyErr_Format(py_pdb_error, "Cannot load backend methods for '%s' backend (%d,%s)",
3530 NT_STATUS_V(status),
3531 get_friendly_nt_error_msg(status));
3535 if ((pypdb = pytalloc_steal(type, methods)) == NULL) {
3544 static PyTypeObject PyPDB = {
3545 .tp_name = "passdb.PDB",
3546 .tp_basicsize = sizeof(pytalloc_Object),
3547 .tp_new = py_pdb_new,
3548 .tp_flags = Py_TPFLAGS_DEFAULT,
3549 .tp_methods = py_pdb_methods,
3550 .tp_doc = "PDB(url[, read_write_flags]) -> Password DB object\n",
3555 * Return a list of passdb backends
3557 static PyObject *py_passdb_backends(PyObject *self)
3560 const struct pdb_init_function_entry *entry;
3563 if ((tframe = talloc_stackframe()) == NULL) {
3568 entry = pdb_get_backends();
3573 if((py_blist = PyList_New(0)) == NULL) {
3579 PyList_Append(py_blist, PyString_FromString(entry->name));
3580 entry = entry->next;
3583 talloc_free(tframe);
3589 static PyObject *py_set_smb_config(PyObject *self, PyObject *args)
3591 const char *smb_config;
3594 if (!PyArg_ParseTuple(args, "s", &smb_config)) {
3598 if ((tframe = talloc_stackframe()) == NULL) {
3603 /* Load smbconf parameters */
3604 if (!lp_load_global(smb_config)) {
3605 PyErr_Format(py_pdb_error, "Cannot open '%s'", smb_config);
3609 talloc_free(tframe);
3615 static PyObject *py_set_secrets_dir(PyObject *self, PyObject *args)
3617 const char *private_dir;
3620 if (!PyArg_ParseTuple(args, "s", &private_dir)) {
3624 if ((tframe = talloc_stackframe()) == NULL) {
3629 /* Initialize secrets database */
3630 if (!secrets_init_path(private_dir)) {
3631 PyErr_Format(py_pdb_error, "Cannot open secrets file database in '%s'",
3636 talloc_free(tframe);
3641 static PyObject *py_get_global_sam_sid(PyObject *self)
3643 struct dom_sid *domain_sid, *domain_sid_copy;
3645 PyObject *py_dom_sid;
3647 tframe = talloc_stackframe();
3648 if (tframe == NULL) {
3653 domain_sid = get_global_sam_sid();
3655 domain_sid_copy = dom_sid_dup(tframe, domain_sid);
3656 if (domain_sid_copy == NULL) {
3658 talloc_free(tframe);
3662 py_dom_sid = pytalloc_steal(dom_sid_Type, domain_sid_copy);
3664 talloc_free(tframe);
3670 static PyMethodDef py_passdb_methods[] = {
3671 { "get_backends", (PyCFunction)py_passdb_backends, METH_NOARGS,
3672 "get_backends() -> list\n\n \
3673 Get a list of password database backends supported." },
3674 { "set_smb_config", (PyCFunction)py_set_smb_config, METH_VARARGS,
3675 "set_smb_config(path) -> None\n\n \
3676 Set path to smb.conf file to load configuration parameters." },
3677 { "set_secrets_dir", (PyCFunction)py_set_secrets_dir, METH_VARARGS,
3678 "set_secrets_dir(private_dir) -> None\n\n \
3679 Set path to private directory to load secrets database from non-default location." },
3680 { "get_global_sam_sid", (PyCFunction)py_get_global_sam_sid, METH_NOARGS,
3681 "get_global_sam_sid() -> dom_sid\n\n \
3682 Return domain SID." },
3686 void initpassdb(void)
3689 char exception_name[] = "passdb.error";
3691 PyTypeObject *talloc_type = pytalloc_GetObjectType();
3692 if (talloc_type == NULL) {
3696 PyPDB.tp_base = talloc_type;
3697 if (PyType_Ready(&PyPDB) < 0) {
3701 PySamu.tp_base = talloc_type;
3702 if (PyType_Ready(&PySamu) < 0) {
3706 PyGroupmap.tp_base = talloc_type;
3707 if (PyType_Ready(&PyGroupmap) < 0) {
3711 m = Py_InitModule3("passdb", py_passdb_methods, "SAMBA Password Database");
3716 /* Create new exception for passdb module */
3717 py_pdb_error = PyErr_NewException(exception_name, NULL, NULL);
3718 Py_INCREF(py_pdb_error);
3719 PyModule_AddObject(m, "error", py_pdb_error);
3722 PyModule_AddObject(m, "PDB", (PyObject *)&PyPDB);
3725 PyModule_AddObject(m, "Samu", (PyObject *)&PySamu);
3727 Py_INCREF(&PyGroupmap);
3728 PyModule_AddObject(m, "Groupmap", (PyObject *)&PyGroupmap);
3730 /* Import dom_sid type from dcerpc.security */
3731 mod = PyImport_ImportModule("samba.dcerpc.security");
3736 dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "dom_sid");
3737 if (dom_sid_Type == NULL) {
3741 /* Import security_descriptor type from dcerpc.security */
3742 security_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "descriptor");
3744 if (security_Type == NULL) {
3748 /* Import GUID type from dcerpc.misc */
3749 mod = PyImport_ImportModule("samba.dcerpc.misc");
3754 guid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "GUID");
3756 if (guid_Type == NULL) {