source3/passdb/py_passdb.c

   1 /*
   2    Python interface to passdb
   3
   4    Copyright (C) Amitay Isaacs 2011
   5
   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.
  10
  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.
  15
  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/>.
  18 */
  19
  20 #include <Python.h>
  21 #include <pytalloc.h>
  22 #include "includes.h"
  23 #include "lib/util/talloc_stack.h"
  24 #include "libcli/security/security.h"
  25 #include "passdb.h"
  26 #include "secrets.h"
  27
  28 #ifndef Py_RETURN_NONE
  29 #define Py_RETURN_NONE  return Py_INCREF(Py_None), Py_None
  30 #endif
  31
  32 #ifndef Py_TYPE /* Py_TYPE is only available on Python > 2.6 */
  33 #define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
  34 #endif
  35
  36 #ifndef PY_CHECK_TYPE
  37 #define PY_CHECK_TYPE(type, var, fail) \
  38         if (!PyObject_TypeCheck(var, type)) {\
  39                 PyErr_Format(PyExc_TypeError, __location__ ": Expected type '%s' for '%s' of type '%s'", (type)->tp_name, #var, Py_TYPE(var)->tp_name); \
  40                 fail; \
  41         }
  42 #endif
  43
  44
  45 static PyTypeObject *dom_sid_Type = NULL;
  46 static PyTypeObject *security_Type = NULL;
  47 static PyTypeObject *guid_Type = NULL;
  48
  49 staticforward PyTypeObject PySamu;
  50 staticforward PyTypeObject PyGroupmap;
  51 staticforward PyTypeObject PyPDB;
  52
  53 static PyObject *py_pdb_error;
  54
  55 void initpassdb(void);
  56
  57
  58 /************************** PIDL Autogeneratd ******************************/
  59
  60 static PyObject *py_samu_get_logon_time(PyObject *obj, void *closure)
  61 {
  62         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
  63         PyObject *py_logon_time;
  64
  65         py_logon_time = PyInt_FromLong(pdb_get_logon_time(sam_acct));
  66         return py_logon_time;
  67 }
  68
  69 static int py_samu_set_logon_time(PyObject *obj, PyObject *value, void *closure)
  70 {
  71         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
  72
  73         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  74         if (!pdb_set_logon_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
  75                 return -1;
  76         }
  77         return 0;
  78 }
  79
  80 static PyObject *py_samu_get_logoff_time(PyObject *obj, void *closure)
  81 {
  82         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
  83         PyObject *py_logoff_time;
  84
  85         py_logoff_time = PyInt_FromLong(pdb_get_logoff_time(sam_acct));
  86         return py_logoff_time;
  87 }
  88
  89 static int py_samu_set_logoff_time(PyObject *obj, PyObject *value, void *closure)
  90 {
  91         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
  92
  93         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  94         if (!pdb_set_logoff_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
  95                 return -1;
  96         }
  97         return 0;
  98 }
  99
 100 static PyObject *py_samu_get_kickoff_time(PyObject *obj, void *closure)
 101 {
 102         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 103         PyObject *py_kickoff_time;
 104
 105         py_kickoff_time = PyInt_FromLong(pdb_get_kickoff_time(sam_acct));
 106         return py_kickoff_time;
 107 }
 108
 109 static int py_samu_set_kickoff_time(PyObject *obj, PyObject *value, void *closure)
 110 {
 111         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 112
 113         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 114         if (!pdb_set_kickoff_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 115                 return -1;
 116         }
 117         return 0;
 118 }
 119
 120 static PyObject *py_samu_get_bad_password_time(PyObject *obj, void *closure)
 121 {
 122         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 123         PyObject *py_bad_password_time;
 124
 125         py_bad_password_time = PyInt_FromLong(pdb_get_bad_password_time(sam_acct));
 126         return py_bad_password_time;
 127 }
 128
 129 static int py_samu_set_bad_password_time(PyObject *obj, PyObject *value, void *closure)
 130 {
 131         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 132
 133         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 134         if (!pdb_set_bad_password_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 135                 return -1;
 136         }
 137         return 0;
 138 }
 139
 140 static PyObject *py_samu_get_pass_last_set_time(PyObject *obj, void *closure)
 141 {
 142         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 143         PyObject *py_pass_last_set_time;
 144
 145         py_pass_last_set_time = PyInt_FromLong(pdb_get_pass_last_set_time(sam_acct));
 146         return py_pass_last_set_time;
 147 }
 148
 149 static int py_samu_set_pass_last_set_time(PyObject *obj, PyObject *value, void *closure)
 150 {
 151         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 152
 153         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 154         if (!pdb_set_pass_last_set_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 155                 return -1;
 156         }
 157         return 0;
 158 }
 159
 160 static PyObject *py_samu_get_pass_can_change_time(PyObject *obj, void *closure)
 161 {
 162         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 163         PyObject *py_pass_can_change_time;
 164
 165         py_pass_can_change_time = PyInt_FromLong(pdb_get_pass_can_change_time(sam_acct));
 166         return py_pass_can_change_time;
 167 }
 168
 169 static int py_samu_set_pass_can_change_time(PyObject *obj, PyObject *value, void *closure)
 170 {
 171         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 172
 173         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 174         if (!pdb_set_pass_can_change_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 175                 return -1;
 176         }
 177         return 0;
 178 }
 179
 180 static PyObject *py_samu_get_pass_must_change_time(PyObject *obj, void *closure)
 181 {
 182         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 183         PyObject *py_pass_must_change_time;
 184
 185         py_pass_must_change_time = PyInt_FromLong(pdb_get_pass_must_change_time(sam_acct));
 186         return py_pass_must_change_time;
 187 }
 188
 189 static int py_samu_set_pass_must_change_time(PyObject *obj, PyObject *value, void *closure)
 190 {
 191         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 192
 193         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 194         if (!pdb_set_pass_must_change_time(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 195                 return -1;
 196         }
 197         return 0;
 198 }
 199
 200 static PyObject *py_samu_get_username(PyObject *obj, void *closure)
 201 {
 202         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 203         PyObject *py_username;
 204         const char *username;
 205
 206         username = pdb_get_username(sam_acct);
 207         if (username == NULL) {
 208                 Py_RETURN_NONE;
 209         }
 210
 211         py_username = PyString_FromString(username);
 212         return py_username;
 213 }
 214
 215 static int py_samu_set_username(PyObject *obj, PyObject *value, void *closure)
 216 {
 217         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 218
 219         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 220         if (!pdb_set_username(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 221                 return -1;
 222         }
 223         return 0;
 224 }
 225
 226 static PyObject *py_samu_get_domain(PyObject *obj, void *closure)
 227 {
 228         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 229         PyObject *py_domain;
 230         const char *domain;
 231
 232         domain = pdb_get_domain(sam_acct);
 233         if (domain == NULL) {
 234                 Py_RETURN_NONE;
 235         }
 236
 237         py_domain = PyString_FromString(domain);
 238         return py_domain;
 239 }
 240
 241 static int py_samu_set_domain(PyObject *obj, PyObject *value, void *closure)
 242 {
 243         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 244
 245         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 246         if (!pdb_set_domain(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 247                 return -1;
 248         }
 249         return 0;
 250 }
 251
 252 static PyObject *py_samu_get_nt_username(PyObject *obj, void *closure)
 253 {
 254         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 255         PyObject *py_nt_username;
 256         const char *nt_username;
 257
 258         nt_username = pdb_get_nt_username(sam_acct);
 259         if (nt_username == NULL) {
 260                 Py_RETURN_NONE;
 261         }
 262
 263         py_nt_username = PyString_FromString(nt_username);
 264         return py_nt_username;
 265 }
 266
 267 static int py_samu_set_nt_username(PyObject *obj, PyObject *value, void *closure)
 268 {
 269         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 270
 271         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 272         if (!pdb_set_nt_username(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 273                 return -1;
 274         }
 275         return 0;
 276 }
 277
 278 static PyObject *py_samu_get_full_name(PyObject *obj, void *closure)
 279 {
 280         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 281         PyObject *py_full_name;
 282         const char *full_name;
 283
 284         full_name = pdb_get_fullname(sam_acct);
 285         if (full_name == NULL) {
 286                 Py_RETURN_NONE;
 287         }
 288
 289         py_full_name = PyString_FromString(full_name);
 290         return py_full_name;
 291 }
 292
 293 static int py_samu_set_full_name(PyObject *obj, PyObject *value, void *closure)
 294 {
 295         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 296
 297         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 298         if (!pdb_set_fullname(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 299                 return -1;
 300         }
 301         return 0;
 302 }
 303
 304 static PyObject *py_samu_get_home_dir(PyObject *obj, void *closure)
 305 {
 306         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 307         PyObject *py_home_dir;
 308         const char *home_dir;
 309
 310         home_dir = pdb_get_homedir(sam_acct);
 311         if (home_dir == NULL) {
 312                 Py_RETURN_NONE;
 313         }
 314
 315         py_home_dir = PyString_FromString(home_dir);
 316         return py_home_dir;
 317 }
 318
 319 static int py_samu_set_home_dir(PyObject *obj, PyObject *value, void *closure)
 320 {
 321         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 322
 323         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 324         if (!pdb_set_homedir(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 325                 return -1;
 326         }
 327         return 0;
 328 }
 329
 330 static PyObject *py_samu_get_dir_drive(PyObject *obj, void *closure)
 331 {
 332         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 333         PyObject *py_dir_drive;
 334         const char *dir_drive;
 335
 336         dir_drive = pdb_get_dir_drive(sam_acct);
 337         if (dir_drive == NULL) {
 338                 Py_RETURN_NONE;
 339         }
 340
 341         py_dir_drive = PyString_FromString(dir_drive);
 342         return py_dir_drive;
 343 }
 344
 345 static int py_samu_set_dir_drive(PyObject *obj, PyObject *value, void *closure)
 346 {
 347         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 348
 349         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 350         if (!pdb_set_dir_drive(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 351                 return -1;
 352         }
 353         return 0;
 354 }
 355
 356 static PyObject *py_samu_get_logon_script(PyObject *obj, void *closure)
 357 {
 358         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 359         PyObject *py_logon_script;
 360         const char *logon_script;
 361
 362         logon_script = pdb_get_logon_script(sam_acct);
 363         if (logon_script == NULL) {
 364                 Py_RETURN_NONE;
 365         }
 366
 367         py_logon_script = PyString_FromString(logon_script);
 368         return py_logon_script;
 369 }
 370
 371 static int py_samu_set_logon_script(PyObject *obj, PyObject *value, void *closure)
 372 {
 373         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 374
 375         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 376         if (!pdb_set_logon_script(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 377                 return -1;
 378         }
 379         return 0;
 380 }
 381
 382 static PyObject *py_samu_get_profile_path(PyObject *obj, void *closure)
 383 {
 384         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 385         PyObject *py_profile_path;
 386         const char *profile_path;
 387
 388         profile_path = pdb_get_profile_path(sam_acct);
 389         if (profile_path == NULL) {
 390                 Py_RETURN_NONE;
 391         }
 392
 393         py_profile_path = PyString_FromString(profile_path);
 394         return py_profile_path;
 395 }
 396
 397 static int py_samu_set_profile_path(PyObject *obj, PyObject *value, void *closure)
 398 {
 399         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 400
 401         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 402         if (!pdb_set_profile_path(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 403                 return -1;
 404         }
 405         return 0;
 406 }
 407
 408 static PyObject *py_samu_get_acct_desc(PyObject *obj, void *closure)
 409 {
 410         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 411         PyObject *py_acct_desc;
 412         const char *acct_desc;
 413
 414         acct_desc = pdb_get_acct_desc(sam_acct);
 415         if (acct_desc == NULL) {
 416                 Py_RETURN_NONE;
 417         }
 418
 419         py_acct_desc = PyString_FromString(acct_desc);
 420         return py_acct_desc;
 421 }
 422
 423 static int py_samu_set_acct_desc(PyObject *obj, PyObject *value, void *closure)
 424 {
 425         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 426
 427         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 428         if (!pdb_set_acct_desc(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 429                 return -1;
 430         }
 431         return 0;
 432 }
 433
 434 static PyObject *py_samu_get_workstations(PyObject *obj, void *closure)
 435 {
 436         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 437         PyObject *py_workstations;
 438         const char *workstations;
 439
 440         workstations = pdb_get_workstations(sam_acct);
 441         if (workstations == NULL) {
 442                 Py_RETURN_NONE;
 443         }
 444
 445         py_workstations = PyString_FromString(workstations);
 446         return py_workstations;
 447 }
 448
 449 static int py_samu_set_workstations(PyObject *obj, PyObject *value, void *closure)
 450 {
 451         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 452
 453         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 454         if (!pdb_set_workstations(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 455                 return -1;
 456         }
 457         return 0;
 458 }
 459
 460 static PyObject *py_samu_get_comment(PyObject *obj, void *closure)
 461 {
 462         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 463         PyObject *py_comment;
 464         const char *comment;
 465
 466         comment = pdb_get_comment(sam_acct);
 467         if (comment == NULL) {
 468                 Py_RETURN_NONE;
 469         }
 470
 471         py_comment = PyString_FromString(comment);
 472         return py_comment;
 473 }
 474
 475 static int py_samu_set_comment(PyObject *obj, PyObject *value, void *closure)
 476 {
 477         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 478
 479         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 480         if (!pdb_set_comment(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 481                 return -1;
 482         }
 483         return 0;
 484 }
 485
 486 static PyObject *py_samu_get_munged_dial(PyObject *obj, void *closure)
 487 {
 488         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 489         PyObject *py_munged_dial;
 490         const char *munged_dial;
 491
 492         munged_dial = pdb_get_munged_dial(sam_acct);
 493         if (munged_dial == NULL) {
 494                 Py_RETURN_NONE;
 495         }
 496
 497         py_munged_dial = PyString_FromString(munged_dial);
 498         return py_munged_dial;
 499 }
 500
 501 static int py_samu_set_munged_dial(PyObject *obj, PyObject *value, void *closure)
 502 {
 503         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 504
 505         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 506         if (!pdb_set_munged_dial(sam_acct, PyString_AsString(value), PDB_CHANGED)) {
 507                 return -1;
 508         }
 509         return 0;
 510 }
 511
 512 static PyObject *py_samu_get_user_sid(PyObject *obj, void *closure)
 513 {
 514         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 515         PyObject *py_user_sid;
 516         const struct dom_sid *user_sid;
 517         struct dom_sid *copy_user_sid;
 518         TALLOC_CTX *mem_ctx;
 519
 520         user_sid = pdb_get_user_sid(sam_acct);
 521         if(user_sid == NULL) {
 522                 Py_RETURN_NONE;
 523         }
 524
 525         mem_ctx = talloc_new(NULL);
 526         if (mem_ctx == NULL) {
 527                 PyErr_NoMemory();
 528                 return NULL;
 529         }
 530         copy_user_sid = dom_sid_dup(mem_ctx, user_sid);
 531         if (copy_user_sid == NULL) {
 532                 PyErr_NoMemory();
 533                 talloc_free(mem_ctx);
 534                 return NULL;
 535         }
 536
 537         py_user_sid = pytalloc_steal(dom_sid_Type, copy_user_sid);
 538
 539         talloc_free(mem_ctx);
 540
 541         return py_user_sid;
 542 }
 543
 544 static int py_samu_set_user_sid(PyObject *obj, PyObject *value, void *closure)
 545 {
 546         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 547
 548         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
 549         if (!pdb_set_user_sid(sam_acct, (struct dom_sid *)pytalloc_get_ptr(value), PDB_CHANGED)) {
 550                 return -1;
 551         }
 552         return 0;
 553 }
 554
 555 static PyObject *py_samu_get_group_sid(PyObject *obj, void *closure)
 556 {
 557         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 558         PyObject *py_group_sid;
 559         const struct dom_sid *group_sid;
 560         struct dom_sid *copy_group_sid;
 561         TALLOC_CTX *mem_ctx;
 562
 563         group_sid = pdb_get_group_sid(sam_acct);
 564         if (group_sid == NULL) {
 565                 Py_RETURN_NONE;
 566         }
 567
 568         mem_ctx = talloc_new(NULL);
 569         if (mem_ctx == NULL) {
 570                 PyErr_NoMemory();
 571                 return NULL;
 572         }
 573         copy_group_sid = dom_sid_dup(mem_ctx, group_sid);
 574         if (copy_group_sid == NULL) {
 575                 PyErr_NoMemory();
 576                 talloc_free(mem_ctx);
 577                 return NULL;
 578         }
 579
 580         py_group_sid = pytalloc_steal(dom_sid_Type, copy_group_sid);
 581
 582         talloc_free(mem_ctx);
 583
 584         return py_group_sid;
 585 }
 586
 587 static int py_samu_set_group_sid(PyObject *obj, PyObject *value, void *closure)
 588 {
 589         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 590
 591         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
 592         if (!pdb_set_group_sid(sam_acct, (struct dom_sid *)pytalloc_get_ptr(value), PDB_CHANGED)) {
 593                 return -1;
 594         }
 595         return 0;
 596 }
 597
 598 static PyObject *py_samu_get_lanman_passwd(PyObject *obj, void *closure)
 599 {
 600         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 601         PyObject *py_lm_pw;
 602         const char *lm_pw;
 603
 604         lm_pw = (const char *)pdb_get_lanman_passwd(sam_acct);
 605         if (lm_pw == NULL) {
 606                 Py_RETURN_NONE;
 607         }
 608
 609         py_lm_pw = PyString_FromString(lm_pw);
 610         return py_lm_pw;
 611 }
 612
 613 static int py_samu_set_lanman_passwd(PyObject *obj, PyObject *value, void *closure)
 614 {
 615         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 616
 617         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
 618         if (!pdb_set_lanman_passwd(sam_acct, (uint8_t *)PyString_AsString(value), PDB_CHANGED)) {
 619                 return -1;
 620         }
 621         return 0;
 622 }
 623
 624 static PyObject *py_samu_get_nt_passwd(PyObject *obj, void *closure)
 625 {
 626         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 627         PyObject *py_nt_pw;
 628         const char *nt_pw;
 629
 630         nt_pw = (const char *)pdb_get_nt_passwd(sam_acct);
 631         if (nt_pw == NULL) {
 632                 Py_RETURN_NONE;
 633         }
 634
 635         py_nt_pw = PyString_FromString(nt_pw);
 636         return py_nt_pw;
 637 }
 638
 639 static int py_samu_set_nt_passwd(PyObject *obj, PyObject *value, void *closure)
 640 {
 641         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 642
 643         if (!pdb_set_nt_passwd(sam_acct, (uint8_t *)PyString_AsString(value), PDB_CHANGED)) {
 644                 return -1;
 645         }
 646         return 0;
 647 }
 648
 649 static PyObject *py_samu_get_pw_history(PyObject *obj, void *closure)
 650 {
 651         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 652         PyObject *py_nt_pw_his;
 653         const char *nt_pw_his;
 654         uint32_t hist_len;
 655
 656         nt_pw_his = (const char *)pdb_get_pw_history(sam_acct, &hist_len);
 657         if (nt_pw_his == NULL) {
 658                 Py_RETURN_NONE;
 659         }
 660
 661         py_nt_pw_his = PyString_FromStringAndSize(nt_pw_his, hist_len);
 662         return py_nt_pw_his;
 663 }
 664
 665 static int py_samu_set_pw_history(PyObject *obj, PyObject *value, void *closure)
 666 {
 667         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 668         char *nt_pw_his;
 669         Py_ssize_t len;
 670         uint32_t hist_len;
 671
 672         PyString_AsStringAndSize(value, &nt_pw_his, &len);
 673         hist_len = len;
 674         if (!pdb_set_pw_history(sam_acct, (uint8_t *)nt_pw_his, hist_len, PDB_CHANGED)) {
 675                 return -1;
 676         }
 677         return 0;
 678 }
 679
 680 static PyObject *py_samu_get_plaintext_passwd(PyObject *obj, void *closure)
 681 {
 682         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 683         PyObject *py_plaintext_pw;
 684         const char *plaintext_pw;
 685
 686         plaintext_pw = pdb_get_plaintext_passwd(sam_acct);
 687         if (plaintext_pw == NULL) {
 688                 Py_RETURN_NONE;
 689         }
 690
 691         py_plaintext_pw = PyString_FromString(plaintext_pw);
 692         return py_plaintext_pw;
 693 }
 694
 695 static int py_samu_set_plaintext_passwd(PyObject *obj, PyObject *value, void *closure)
 696 {
 697         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 698
 699         if (!pdb_set_plaintext_passwd(sam_acct, PyString_AsString(value))) {
 700                 return -1;
 701         }
 702         return 0;
 703 }
 704
 705 static PyObject *py_samu_get_acct_ctrl(PyObject *obj, void *closure)
 706 {
 707         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 708         PyObject *py_acct_ctrl;
 709
 710         py_acct_ctrl = PyInt_FromLong(pdb_get_acct_ctrl(sam_acct));
 711         return py_acct_ctrl;
 712 }
 713
 714 static int py_samu_set_acct_ctrl(PyObject *obj, PyObject *value, void *closure)
 715 {
 716         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 717
 718         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 719         if (!pdb_set_acct_ctrl(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 720                 return -1;
 721         }
 722         return 0;
 723 }
 724
 725 static PyObject *py_samu_get_logon_divs(PyObject *obj, void *closure)
 726 {
 727         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 728         PyObject *py_logon_divs;
 729
 730         py_logon_divs = PyInt_FromLong(pdb_get_logon_divs(sam_acct));
 731         return py_logon_divs;
 732 }
 733
 734 static int py_samu_set_logon_divs(PyObject *obj, PyObject *value, void *closure)
 735 {
 736         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 737
 738         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 739         if (!pdb_set_logon_divs(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 740                 return -1;
 741         }
 742         return 0;
 743 }
 744
 745 static PyObject *py_samu_get_hours_len(PyObject *obj, void *closure)
 746 {
 747         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 748         PyObject *py_hours_len;
 749
 750         py_hours_len = PyInt_FromLong(pdb_get_hours_len(sam_acct));
 751         return py_hours_len;
 752 }
 753
 754 static int py_samu_set_hours_len(PyObject *obj, PyObject *value, void *closure)
 755 {
 756         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 757
 758         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 759         if (!pdb_set_hours_len(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 760                 return -1;
 761         }
 762         return 0;
 763 }
 764
 765 static PyObject *py_samu_get_hours(PyObject *obj, void *closure)
 766 {
 767         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 768         PyObject *py_hours;
 769         const char *hours;
 770         int i;
 771
 772         hours = (const char *)pdb_get_hours(sam_acct);
 773         if(! hours) {
 774                 Py_RETURN_NONE;
 775         }
 776
 777         if ((py_hours = PyList_New(MAX_HOURS_LEN)) == NULL) {
 778                 PyErr_NoMemory();
 779                 return NULL;
 780         }
 781
 782         for (i=0; i<MAX_HOURS_LEN; i++) {
 783                 PyList_SetItem(py_hours, i, PyInt_FromLong(hours[i]));
 784         }
 785         return py_hours;
 786 }
 787
 788 static int py_samu_set_hours(PyObject *obj, PyObject *value, void *closure)
 789 {
 790         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 791         int i;
 792         uint8_t *hours;
 793         int hours_len;
 794         bool status;
 795
 796         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 797
 798         hours_len = PyList_GET_SIZE(value);
 799
 800         hours = talloc_array(pytalloc_get_mem_ctx(obj), uint8_t, hours_len);
 801         if (!hours) {
 802                 PyErr_NoMemory();
 803                 return -1;
 804         }
 805
 806         for (i=0; i < hours_len; i++) {
 807                 PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value,i), return -1;);
 808                 hours[i] = PyInt_AsLong(PyList_GET_ITEM(value, i));
 809         }
 810
 811         status = pdb_set_hours(sam_acct, hours, hours_len, PDB_CHANGED);
 812         talloc_free(hours);
 813
 814         if(! status) {
 815                 return -1;
 816         }
 817         return 0;
 818 }
 819
 820 static PyObject *py_samu_get_bad_password_count(PyObject *obj, void *closure)
 821 {
 822         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 823         PyObject *py_bad_password_count;
 824
 825         py_bad_password_count = PyInt_FromLong(pdb_get_bad_password_count(sam_acct));
 826         return py_bad_password_count;
 827 }
 828
 829 static int py_samu_set_bad_password_count(PyObject *obj, PyObject *value, void *closure)
 830 {
 831         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 832
 833         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 834         if (!pdb_set_bad_password_count(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 835                 return -1;
 836         }
 837         return 0;
 838 }
 839
 840 static PyObject *py_samu_get_logon_count(PyObject *obj, void *closure)
 841 {
 842         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 843         PyObject *py_logon_count;
 844
 845         py_logon_count = PyInt_FromLong(pdb_get_logon_count(sam_acct));
 846         return py_logon_count;
 847 }
 848
 849 static int py_samu_set_logon_count(PyObject *obj, PyObject *value, void *closure)
 850 {
 851         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 852
 853         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 854         if (!pdb_set_logon_count(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 855                 return -1;
 856         }
 857         return 0;
 858 }
 859
 860 static PyObject *py_samu_get_country_code(PyObject *obj, void *closure)
 861 {
 862         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 863         PyObject *py_country_code;
 864
 865         py_country_code = PyInt_FromLong(pdb_get_country_code(sam_acct));
 866         return py_country_code;
 867 }
 868
 869 static int py_samu_set_country_code(PyObject *obj, PyObject *value, void *closure)
 870 {
 871         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 872
 873         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 874         if (!pdb_set_country_code(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 875                 return -1;
 876         }
 877         return 0;
 878 }
 879
 880 static PyObject *py_samu_get_code_page(PyObject *obj, void *closure)
 881 {
 882         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 883         PyObject *py_code_page;
 884
 885         py_code_page = PyInt_FromLong(pdb_get_code_page(sam_acct));
 886         return py_code_page;
 887 }
 888
 889 static int py_samu_set_code_page(PyObject *obj, PyObject *value, void *closure)
 890 {
 891         struct samu *sam_acct = (struct samu *)pytalloc_get_ptr(obj);
 892
 893         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 894         if (!pdb_set_code_page(sam_acct, PyInt_AsLong(value), PDB_CHANGED)) {
 895                 return -1;
 896         }
 897         return 0;
 898 }
 899
 900 static PyGetSetDef py_samu_getsetters[] = {
 901         { discard_const_p(char, "logon_time"), py_samu_get_logon_time, py_samu_set_logon_time },
 902         { discard_const_p(char, "logoff_time"), py_samu_get_logoff_time, py_samu_set_logoff_time },
 903         { discard_const_p(char, "kickoff_time"), py_samu_get_kickoff_time, py_samu_set_kickoff_time },
 904         { discard_const_p(char, "bad_password_time"), py_samu_get_bad_password_time, py_samu_set_bad_password_time },
 905         { discard_const_p(char, "pass_last_set_time"), py_samu_get_pass_last_set_time, py_samu_set_pass_last_set_time },
 906         { discard_const_p(char, "pass_can_change_time"), py_samu_get_pass_can_change_time, py_samu_set_pass_can_change_time },
 907         { discard_const_p(char, "pass_must_change_time"), py_samu_get_pass_must_change_time, py_samu_set_pass_must_change_time },
 908         { discard_const_p(char, "username"), py_samu_get_username, py_samu_set_username },
 909         { discard_const_p(char, "domain"), py_samu_get_domain, py_samu_set_domain },
 910         { discard_const_p(char, "nt_username"), py_samu_get_nt_username, py_samu_set_nt_username },
 911         { discard_const_p(char, "full_name"), py_samu_get_full_name, py_samu_set_full_name },
 912         { discard_const_p(char, "home_dir"), py_samu_get_home_dir, py_samu_set_home_dir },
 913         { discard_const_p(char, "dir_drive"), py_samu_get_dir_drive, py_samu_set_dir_drive },
 914         { discard_const_p(char, "logon_script"), py_samu_get_logon_script, py_samu_set_logon_script },
 915         { discard_const_p(char, "profile_path"), py_samu_get_profile_path, py_samu_set_profile_path },
 916         { discard_const_p(char, "acct_desc"), py_samu_get_acct_desc, py_samu_set_acct_desc },
 917         { discard_const_p(char, "workstations"), py_samu_get_workstations, py_samu_set_workstations },
 918         { discard_const_p(char, "comment"), py_samu_get_comment, py_samu_set_comment },
 919         { discard_const_p(char, "munged_dial"), py_samu_get_munged_dial, py_samu_set_munged_dial },
 920         { discard_const_p(char, "user_sid"), py_samu_get_user_sid, py_samu_set_user_sid },
 921         { discard_const_p(char, "group_sid"), py_samu_get_group_sid, py_samu_set_group_sid },
 922         { discard_const_p(char, "lanman_passwd"), py_samu_get_lanman_passwd, py_samu_set_lanman_passwd },
 923         { discard_const_p(char, "nt_passwd"), py_samu_get_nt_passwd, py_samu_set_nt_passwd },
 924         { discard_const_p(char, "pw_history"), py_samu_get_pw_history, py_samu_set_pw_history },
 925         { discard_const_p(char, "plaintext_passwd"), py_samu_get_plaintext_passwd, py_samu_set_plaintext_passwd },
 926         { discard_const_p(char, "acct_ctrl"), py_samu_get_acct_ctrl, py_samu_set_acct_ctrl },
 927         { discard_const_p(char, "logon_divs"), py_samu_get_logon_divs, py_samu_set_logon_divs },
 928         { discard_const_p(char, "hours_len"), py_samu_get_hours_len, py_samu_set_hours_len },
 929         { discard_const_p(char, "hours"), py_samu_get_hours, py_samu_set_hours },
 930         { discard_const_p(char, "bad_password_count"), py_samu_get_bad_password_count, py_samu_set_bad_password_count },
 931         { discard_const_p(char, "logon_count"), py_samu_get_logon_count, py_samu_set_logon_count },
 932         { discard_const_p(char, "country_code"), py_samu_get_country_code, py_samu_set_country_code },
 933         { discard_const_p(char, "code_page"), py_samu_get_code_page, py_samu_set_code_page },
 934         { NULL }
 935 };
 936
 937
 938 /************************** PIDL Autogeneratd ******************************/
 939
 940 static PyObject *py_samu_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 941 {
 942         struct samu *sam_acct;
 943
 944         sam_acct = samu_new(NULL);
 945         if (!sam_acct) {
 946                 PyErr_NoMemory();
 947                 return NULL;
 948         }
 949
 950         return pytalloc_steal(type, sam_acct);
 951 }
 952
 953 static PyTypeObject PySamu = {
 954         .tp_name = "passdb.Samu",
 955         .tp_basicsize = sizeof(pytalloc_Object),
 956         .tp_getset = py_samu_getsetters,
 957         .tp_methods = NULL,
 958         .tp_new = py_samu_new,
 959         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 960         .tp_doc = "Samu() -> samu object\n",
 961 };
 962
 963
 964 static PyObject *py_groupmap_get_gid(PyObject *obj, void *closure)
 965 {
 966         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
 967         PyObject *py_gid;
 968
 969         py_gid = PyInt_FromLong(group_map->gid);
 970         return py_gid;
 971 }
 972
 973 static int py_groupmap_set_gid(PyObject *obj, PyObject *value, void *closure)
 974 {
 975         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
 976
 977         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 978         group_map->gid = PyInt_AsLong(value);
 979         return 0;
 980 }
 981
 982 static PyObject *py_groupmap_get_sid(PyObject *obj, void *closure)
 983 {
 984         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
 985         PyObject *py_sid;
 986         struct dom_sid *group_sid;
 987         TALLOC_CTX *mem_ctx;
 988
 989         mem_ctx = talloc_new(NULL);
 990         if (mem_ctx == NULL) {
 991                 PyErr_NoMemory();
 992                 return NULL;
 993         }
 994
 995         group_sid = dom_sid_dup(mem_ctx, &group_map->sid);
 996         if (group_sid == NULL) {
 997                 PyErr_NoMemory();
 998                 talloc_free(mem_ctx);
 999                 return NULL;
1000         }
1001
1002         py_sid = pytalloc_steal(dom_sid_Type, group_sid);
1003
1004         talloc_free(mem_ctx);
1005
1006         return py_sid;
1007 }
1008
1009 static int py_groupmap_set_sid(PyObject *obj, PyObject *value, void *closure)
1010 {
1011         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1012
1013         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
1014         group_map->sid = *pytalloc_get_type(value, struct dom_sid);
1015         return 0;
1016 }
1017
1018 static PyObject *py_groupmap_get_sid_name_use(PyObject *obj, void *closure)
1019 {
1020         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1021         PyObject *py_sid_name_use;
1022
1023         py_sid_name_use = PyInt_FromLong(group_map->sid_name_use);
1024         return py_sid_name_use;
1025 }
1026
1027 static int py_groupmap_set_sid_name_use(PyObject *obj, PyObject *value, void *closure)
1028 {
1029         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1030
1031         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1032         group_map->sid_name_use = PyInt_AsLong(value);
1033         return 0;
1034 }
1035
1036 static PyObject *py_groupmap_get_nt_name(PyObject *obj, void *closure)
1037 {
1038         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1039         PyObject *py_nt_name;
1040         if (group_map->nt_name == NULL) {
1041                 py_nt_name = Py_None;
1042                 Py_INCREF(py_nt_name);
1043         } else {
1044                 py_nt_name = PyString_FromString(group_map->nt_name);
1045         }
1046         return py_nt_name;
1047 }
1048
1049 static int py_groupmap_set_nt_name(PyObject *obj, PyObject *value, void *closure)
1050 {
1051         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1052
1053         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
1054         if (value == Py_None) {
1055                 fstrcpy(group_map->nt_name, NULL);
1056         } else {
1057                 fstrcpy(group_map->nt_name, PyString_AsString(value));
1058         }
1059         return 0;
1060 }
1061
1062 static PyObject *py_groupmap_get_comment(PyObject *obj, void *closure)
1063 {
1064         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1065         PyObject *py_comment;
1066         if (group_map->comment == NULL) {
1067                 py_comment = Py_None;
1068                 Py_INCREF(py_comment);
1069         } else {
1070                 py_comment = PyString_FromString(group_map->comment);
1071         }
1072         return py_comment;
1073 }
1074
1075 static int py_groupmap_set_comment(PyObject *obj, PyObject *value, void *closure)
1076 {
1077         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1078
1079         PY_CHECK_TYPE(&PyString_Type, value, return -1;);
1080         if (value == Py_None) {
1081                 fstrcpy(group_map->comment, NULL);
1082         } else {
1083                 fstrcpy(group_map->comment, PyString_AsString(value));
1084         }
1085         return 0;
1086 }
1087
1088 static PyGetSetDef py_groupmap_getsetters[] = {
1089         { discard_const_p(char, "gid"), py_groupmap_get_gid, py_groupmap_set_gid },
1090         { discard_const_p(char, "sid"), py_groupmap_get_sid, py_groupmap_set_sid },
1091         { discard_const_p(char, "sid_name_use"), py_groupmap_get_sid_name_use, py_groupmap_set_sid_name_use },
1092         { discard_const_p(char, "nt_name"), py_groupmap_get_nt_name, py_groupmap_set_nt_name },
1093         { discard_const_p(char, "comment"), py_groupmap_get_comment, py_groupmap_set_comment },
1094         { NULL }
1095 };
1096
1097 static PyObject *py_groupmap_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1098 {
1099         GROUP_MAP *group_map;
1100         TALLOC_CTX *mem_ctx;
1101         PyObject *py_group_map;
1102
1103         mem_ctx = talloc_new(NULL);
1104         if (mem_ctx == NULL) {
1105                 PyErr_NoMemory();
1106                 return NULL;
1107         }
1108
1109         group_map = talloc_zero(mem_ctx, GROUP_MAP);
1110         if (group_map == NULL) {
1111                 PyErr_NoMemory();
1112                 talloc_free(mem_ctx);
1113                 return NULL;
1114         }
1115
1116         py_group_map = pytalloc_steal(type, group_map);
1117         if (py_group_map == NULL) {
1118                 PyErr_NoMemory();
1119                 talloc_free(mem_ctx);
1120                 return NULL;
1121         }
1122
1123         talloc_free(mem_ctx);
1124
1125         return py_group_map;
1126 }
1127
1128
1129 static PyTypeObject PyGroupmap = {
1130         .tp_name = "passdb.Groupmap",
1131         .tp_basicsize = sizeof(pytalloc_Object),
1132         .tp_getset = py_groupmap_getsetters,
1133         .tp_methods = NULL,
1134         .tp_new = py_groupmap_new,
1135         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1136         .tp_doc = "Groupmap() -> group map object\n",
1137 };
1138
1139
1140 static PyObject *py_pdb_domain_info(pytalloc_Object *self, PyObject *args)
1141 {
1142         struct pdb_methods *methods;
1143         struct pdb_domain_info *domain_info;
1144         PyObject *py_domain_info;
1145         TALLOC_CTX *tframe;
1146         struct dom_sid *sid;
1147         struct GUID *guid;
1148
1149         methods = pytalloc_get_ptr(self);
1150
1151         if ((tframe = talloc_stackframe()) == NULL) {
1152                 PyErr_NoMemory();
1153                 return NULL;
1154         }
1155
1156         domain_info = methods->get_domain_info(methods, tframe);
1157         if (! domain_info) {
1158                 Py_RETURN_NONE;
1159         }
1160
1161         sid = dom_sid_dup(tframe, &domain_info->sid);
1162         if (sid == NULL) {
1163                 PyErr_NoMemory();
1164                 talloc_free(tframe);
1165                 return NULL;
1166         }
1167
1168         guid = talloc(tframe, struct GUID);
1169         if (guid == NULL) {
1170                 PyErr_NoMemory();
1171                 talloc_free(tframe);
1172                 return NULL;
1173         }
1174         *guid = domain_info->guid;
1175
1176         if ((py_domain_info = PyDict_New()) == NULL) {
1177                 PyErr_NoMemory();
1178                 return NULL;
1179         }
1180
1181         PyDict_SetItemString(py_domain_info, "name", PyString_FromString(domain_info->name));
1182         PyDict_SetItemString(py_domain_info, "dns_domain", PyString_FromString(domain_info->name));
1183         PyDict_SetItemString(py_domain_info, "dns_forest", PyString_FromString(domain_info->name));
1184         PyDict_SetItemString(py_domain_info, "dom_sid", pytalloc_steal(dom_sid_Type, sid));
1185         PyDict_SetItemString(py_domain_info, "guid", pytalloc_steal(guid_Type, guid));
1186
1187         talloc_free(tframe);
1188
1189         return py_domain_info;
1190 }
1191
1192
1193 static PyObject *py_pdb_getsampwnam(pytalloc_Object *self, PyObject *args)
1194 {
1195         NTSTATUS status;
1196         const char *username;
1197         struct pdb_methods *methods;
1198         struct samu *sam_acct;
1199         PyObject *py_sam_acct;
1200         TALLOC_CTX *tframe;
1201
1202         if (!PyArg_ParseTuple(args, "s:getsampwnam", &username)) {
1203                 return NULL;
1204         }
1205
1206         methods = pytalloc_get_ptr(self);
1207
1208         if ((tframe = talloc_stackframe()) == NULL) {
1209                 PyErr_NoMemory();
1210                 return NULL;
1211         }
1212
1213         py_sam_acct = py_samu_new(&PySamu, NULL, NULL);
1214         if (py_sam_acct == NULL) {
1215                 PyErr_NoMemory();
1216                 talloc_free(tframe);
1217                 return NULL;
1218         }
1219         sam_acct = (struct samu *)pytalloc_get_ptr(py_sam_acct);
1220
1221         status = methods->getsampwnam(methods, sam_acct, username);
1222         if (!NT_STATUS_IS_OK(status)) {
1223                 PyErr_Format(py_pdb_error, "Unable to get user information for '%s', (%d,%s)",
1224                                 username,
1225                                 NT_STATUS_V(status),
1226                                 get_friendly_nt_error_msg(status));
1227                 Py_DECREF(py_sam_acct);
1228                 talloc_free(tframe);
1229                 return NULL;
1230         }
1231
1232         talloc_free(tframe);
1233         return py_sam_acct;
1234 }
1235
1236 static PyObject *py_pdb_getsampwsid(pytalloc_Object *self, PyObject *args)
1237 {
1238         NTSTATUS status;
1239         struct pdb_methods *methods;
1240         struct samu *sam_acct;
1241         PyObject *py_sam_acct;
1242         TALLOC_CTX *tframe;
1243         PyObject *py_user_sid;
1244
1245         if (!PyArg_ParseTuple(args, "O:getsampwsid", &py_user_sid)) {
1246                 return NULL;
1247         }
1248
1249         methods = pytalloc_get_ptr(self);
1250
1251         if ((tframe = talloc_stackframe()) == NULL) {
1252                 PyErr_NoMemory();
1253                 return NULL;
1254         }
1255
1256         py_sam_acct = py_samu_new(&PySamu, NULL, NULL);
1257         if (py_sam_acct == NULL) {
1258                 PyErr_NoMemory();
1259                 talloc_free(tframe);
1260                 return NULL;
1261         }
1262         sam_acct = (struct samu *)pytalloc_get_ptr(py_sam_acct);
1263
1264         status = methods->getsampwsid(methods, sam_acct, pytalloc_get_ptr(py_user_sid));
1265         if (!NT_STATUS_IS_OK(status)) {
1266                 PyErr_Format(py_pdb_error, "Unable to get user information from SID, (%d,%s)",
1267                                 NT_STATUS_V(status),
1268                                 get_friendly_nt_error_msg(status));
1269                 Py_DECREF(py_sam_acct);
1270                 talloc_free(tframe);
1271                 return NULL;
1272         }
1273
1274         talloc_free(tframe);
1275         return py_sam_acct;
1276 }
1277
1278 static PyObject *py_pdb_create_user(pytalloc_Object *self, PyObject *args)
1279 {
1280         NTSTATUS status;
1281         struct pdb_methods *methods;
1282         const char *username;
1283         unsigned int acct_flags;
1284         unsigned int rid;
1285         TALLOC_CTX *tframe;
1286
1287         if (!PyArg_ParseTuple(args, "sI:create_user", &username, &acct_flags)) {
1288                 return NULL;
1289         }
1290
1291         methods = pytalloc_get_ptr(self);
1292
1293         if ((tframe = talloc_stackframe()) == NULL) {
1294                 PyErr_NoMemory();
1295                 return NULL;
1296         }
1297
1298         status = methods->create_user(methods, tframe, username, acct_flags, &rid);
1299         if (!NT_STATUS_IS_OK(status)) {
1300                 PyErr_Format(py_pdb_error, "Unable to create user (%s), (%d,%s)",
1301                                 username,
1302                                 NT_STATUS_V(status),
1303                                 get_friendly_nt_error_msg(status));
1304                 talloc_free(tframe);
1305                 return NULL;
1306         }
1307
1308         talloc_free(tframe);
1309         return PyInt_FromLong(rid);
1310 }
1311
1312 static PyObject *py_pdb_delete_user(pytalloc_Object *self, PyObject *args)
1313 {
1314         NTSTATUS status;
1315         struct pdb_methods *methods;
1316         TALLOC_CTX *tframe;
1317         struct samu *sam_acct;
1318         PyObject *py_sam_acct;
1319
1320         if (!PyArg_ParseTuple(args, "O!:delete_user", &PySamu, &py_sam_acct)) {
1321                 return NULL;
1322         }
1323
1324         methods = pytalloc_get_ptr(self);
1325
1326         if ((tframe = talloc_stackframe()) == NULL) {
1327                 PyErr_NoMemory();
1328                 return NULL;
1329         }
1330
1331         sam_acct = pytalloc_get_ptr(py_sam_acct);
1332
1333         status = methods->delete_user(methods, tframe, sam_acct);
1334         if (!NT_STATUS_IS_OK(status)) {
1335                 PyErr_Format(py_pdb_error, "Unable to delete user, (%d,%s)",
1336                                 NT_STATUS_V(status),
1337                                 get_friendly_nt_error_msg(status));
1338                 talloc_free(tframe);
1339                 return NULL;
1340         }
1341
1342         talloc_free(tframe);
1343         Py_RETURN_NONE;
1344 }
1345
1346 static PyObject *py_pdb_add_sam_account(pytalloc_Object *self, PyObject *args)
1347 {
1348         NTSTATUS status;
1349         struct pdb_methods *methods;
1350         TALLOC_CTX *tframe;
1351         struct samu *sam_acct;
1352         PyObject *py_sam_acct;
1353
1354         if (!PyArg_ParseTuple(args, "O!:add_sam_account", &PySamu, &py_sam_acct)) {
1355                 return NULL;
1356         }
1357
1358         methods = pytalloc_get_ptr(self);
1359
1360         if ((tframe = talloc_stackframe()) == NULL) {
1361                 PyErr_NoMemory();
1362                 return NULL;
1363         }
1364
1365         sam_acct = pytalloc_get_ptr(py_sam_acct);
1366
1367         status = methods->add_sam_account(methods, sam_acct);
1368         if (!NT_STATUS_IS_OK(status)) {
1369                 PyErr_Format(py_pdb_error, "Unable to add sam account, (%d,%s)",
1370                                 NT_STATUS_V(status),
1371                                 get_friendly_nt_error_msg(status));
1372                 talloc_free(tframe);
1373                 return NULL;
1374         }
1375
1376         talloc_free(tframe);
1377         Py_RETURN_NONE;
1378 }
1379
1380 static PyObject *py_pdb_update_sam_account(pytalloc_Object *self, PyObject *args)
1381 {
1382         NTSTATUS status;
1383         struct pdb_methods *methods;
1384         TALLOC_CTX *tframe;
1385         struct samu *sam_acct;
1386         PyObject *py_sam_acct;
1387
1388         if (!PyArg_ParseTuple(args, "O!:update_sam_account", &PySamu, &py_sam_acct)) {
1389                 return NULL;
1390         }
1391
1392         methods = pytalloc_get_ptr(self);
1393
1394         if ((tframe = talloc_stackframe()) == NULL) {
1395                 PyErr_NoMemory();
1396                 return NULL;
1397         }
1398
1399         sam_acct = pytalloc_get_ptr(py_sam_acct);
1400
1401         status = methods->update_sam_account(methods, sam_acct);
1402         if (!NT_STATUS_IS_OK(status)) {
1403                 PyErr_Format(py_pdb_error, "Unable to update sam account, (%d,%s)",
1404                                 NT_STATUS_V(status),
1405                                 get_friendly_nt_error_msg(status));
1406                 talloc_free(tframe);
1407                 return NULL;
1408         }
1409
1410         talloc_free(tframe);
1411         Py_RETURN_NONE;
1412 }
1413
1414 static PyObject *py_pdb_delete_sam_account(pytalloc_Object *self, PyObject *args)
1415 {
1416         NTSTATUS status;
1417         struct pdb_methods *methods;
1418         TALLOC_CTX *tframe;
1419         struct samu *sam_acct;
1420         PyObject *py_sam_acct;
1421
1422         if (!PyArg_ParseTuple(args, "O!:delete_sam_account", &PySamu, &py_sam_acct)) {
1423                 return NULL;
1424         }
1425
1426         methods = pytalloc_get_ptr(self);
1427
1428         if ((tframe = talloc_stackframe()) == NULL) {
1429                 PyErr_NoMemory();
1430                 return NULL;
1431         }
1432
1433         sam_acct = pytalloc_get_ptr(py_sam_acct);
1434
1435         status = methods->delete_sam_account(methods, sam_acct);
1436         if (!NT_STATUS_IS_OK(status)) {
1437                 PyErr_Format(py_pdb_error, "Unable to delete sam account, (%d,%s)",
1438                                 NT_STATUS_V(status),
1439                                 get_friendly_nt_error_msg(status));
1440                 talloc_free(tframe);
1441                 return NULL;
1442         }
1443
1444         talloc_free(tframe);
1445         Py_RETURN_NONE;
1446 }
1447
1448 static PyObject *py_pdb_rename_sam_account(pytalloc_Object *self, PyObject *args)
1449 {
1450         NTSTATUS status;
1451         struct pdb_methods *methods;
1452         TALLOC_CTX *tframe;
1453         struct samu *sam_acct;
1454         const char *new_username;
1455         PyObject *py_sam_acct;
1456
1457         if (!PyArg_ParseTuple(args, "O!s:rename_sam_account", &PySamu, &py_sam_acct,
1458                                         &new_username)) {
1459                 return NULL;
1460         }
1461
1462         methods = pytalloc_get_ptr(self);
1463
1464         if ((tframe = talloc_stackframe()) == NULL) {
1465                 PyErr_NoMemory();
1466                 return NULL;
1467         }
1468
1469         sam_acct = pytalloc_get_ptr(py_sam_acct);
1470
1471         status = methods->rename_sam_account(methods, sam_acct, new_username);
1472         if (!NT_STATUS_IS_OK(status)) {
1473                 PyErr_Format(py_pdb_error, "Unable to rename sam account, (%d,%s)",
1474                                 NT_STATUS_V(status),
1475                                 get_friendly_nt_error_msg(status));
1476                 talloc_free(tframe);
1477                 return NULL;
1478         }
1479
1480         talloc_free(tframe);
1481         Py_RETURN_NONE;
1482 }
1483
1484
1485 static PyObject *py_pdb_getgrsid(pytalloc_Object *self, PyObject *args)
1486 {
1487         NTSTATUS status;
1488         struct pdb_methods *methods;
1489         TALLOC_CTX *tframe;
1490         GROUP_MAP *group_map;
1491         struct dom_sid *domain_sid;
1492         PyObject *py_domain_sid, *py_group_map;
1493
1494         if (!PyArg_ParseTuple(args, "O!:getgrsid", dom_sid_Type, &py_domain_sid)) {
1495                 return NULL;
1496         }
1497
1498         methods = pytalloc_get_ptr(self);
1499
1500         if ((tframe = talloc_stackframe()) == NULL) {
1501                 PyErr_NoMemory();
1502                 return NULL;
1503         }
1504
1505         domain_sid = pytalloc_get_ptr(py_domain_sid);
1506
1507         py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1508         if (py_group_map == NULL) {
1509                 PyErr_NoMemory();
1510                 talloc_free(tframe);
1511                 return NULL;
1512         }
1513
1514         group_map = pytalloc_get_ptr(py_group_map);
1515
1516         status = methods->getgrsid(methods, group_map, *domain_sid);
1517         if (!NT_STATUS_IS_OK(status)) {
1518                 PyErr_Format(py_pdb_error, "Unable to get group information by sid, (%d,%s)",
1519                                 NT_STATUS_V(status),
1520                                 get_friendly_nt_error_msg(status));
1521                 talloc_free(tframe);
1522                 return NULL;
1523         }
1524
1525         talloc_free(tframe);
1526         return py_group_map;
1527 }
1528
1529
1530 static PyObject *py_pdb_getgrgid(pytalloc_Object *self, PyObject *args)
1531 {
1532         NTSTATUS status;
1533         struct pdb_methods *methods;
1534         TALLOC_CTX *tframe;
1535         GROUP_MAP *group_map;
1536         PyObject *py_group_map;
1537         unsigned int gid_value;
1538
1539         if (!PyArg_ParseTuple(args, "I:getgrgid", &gid_value)) {
1540                 return NULL;
1541         }
1542
1543         methods = pytalloc_get_ptr(self);
1544
1545         if ((tframe = talloc_stackframe()) == NULL) {
1546                 PyErr_NoMemory();
1547                 return NULL;
1548         }
1549
1550         py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1551         if (py_group_map == NULL) {
1552                 PyErr_NoMemory();
1553                 talloc_free(tframe);
1554                 return NULL;
1555         }
1556
1557         group_map = pytalloc_get_ptr(py_group_map);
1558
1559         status = methods->getgrgid(methods, group_map, gid_value);
1560         if (!NT_STATUS_IS_OK(status)) {
1561                 PyErr_Format(py_pdb_error, "Unable to get group information by gid, (%d,%s)",
1562                                 NT_STATUS_V(status),
1563                                 get_friendly_nt_error_msg(status));
1564                 talloc_free(tframe);
1565                 return NULL;
1566         }
1567
1568         talloc_free(tframe);
1569         return py_group_map;
1570 }
1571
1572
1573 static PyObject *py_pdb_getgrnam(pytalloc_Object *self, PyObject *args)
1574 {
1575         NTSTATUS status;
1576         struct pdb_methods *methods;
1577         TALLOC_CTX *tframe;
1578         GROUP_MAP *group_map;
1579         PyObject *py_group_map;
1580         const char *groupname;
1581
1582         if (!PyArg_ParseTuple(args, "s:getgrnam", &groupname)) {
1583                 return NULL;
1584         }
1585
1586         methods = pytalloc_get_ptr(self);
1587
1588         if ((tframe = talloc_stackframe()) == NULL) {
1589                 PyErr_NoMemory();
1590                 return NULL;
1591         }
1592
1593         py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1594         if (py_group_map == NULL) {
1595                 PyErr_NoMemory();
1596                 talloc_free(tframe);
1597                 return NULL;
1598         }
1599
1600         group_map = pytalloc_get_ptr(py_group_map);
1601
1602         status = methods->getgrnam(methods, group_map, groupname);
1603         if (!NT_STATUS_IS_OK(status)) {
1604                 PyErr_Format(py_pdb_error, "Unable to get group information by name, (%d,%s)",
1605                                 NT_STATUS_V(status),
1606                                 get_friendly_nt_error_msg(status));
1607                 talloc_free(tframe);
1608                 return NULL;
1609         }
1610
1611         talloc_free(tframe);
1612         return py_group_map;
1613 }
1614
1615
1616 static PyObject *py_pdb_create_dom_group(pytalloc_Object *self, PyObject *args)
1617 {
1618         NTSTATUS status;
1619         struct pdb_methods *methods;
1620         TALLOC_CTX *tframe;
1621         const char *groupname;
1622         uint32_t group_rid;
1623
1624         if (!PyArg_ParseTuple(args, "s:create_dom_group", &groupname)) {
1625                 return NULL;
1626         }
1627
1628         methods = pytalloc_get_ptr(self);
1629
1630         if ((tframe = talloc_stackframe()) == NULL) {
1631                 PyErr_NoMemory();
1632                 return NULL;
1633         }
1634
1635         status = methods->create_dom_group(methods, tframe, groupname, &group_rid);
1636         if (!NT_STATUS_IS_OK(status)) {
1637                 PyErr_Format(py_pdb_error, "Unable to create domain group (%s), (%d,%s)",
1638                                 groupname,
1639                                 NT_STATUS_V(status),
1640                                 get_friendly_nt_error_msg(status));
1641                 talloc_free(tframe);
1642                 return NULL;
1643         }
1644
1645         talloc_free(tframe);
1646         return PyInt_FromLong(group_rid);
1647 }
1648
1649
1650 static PyObject *py_pdb_delete_dom_group(pytalloc_Object *self, PyObject *args)
1651 {
1652         NTSTATUS status;
1653         struct pdb_methods *methods;
1654         TALLOC_CTX *tframe;
1655         unsigned int group_rid;
1656
1657         if (!PyArg_ParseTuple(args, "I:delete_dom_group", &group_rid)) {
1658                 return NULL;
1659         }
1660
1661         methods = pytalloc_get_ptr(self);
1662
1663         if ((tframe = talloc_stackframe()) == NULL) {
1664                 PyErr_NoMemory();
1665                 return NULL;
1666         }
1667
1668         status = methods->delete_dom_group(methods, tframe, group_rid);
1669         if (!NT_STATUS_IS_OK(status)) {
1670                 PyErr_Format(py_pdb_error, "Unable to delete domain group (rid=%d), (%d,%s)",
1671                                 group_rid,
1672                                 NT_STATUS_V(status),
1673                                 get_friendly_nt_error_msg(status));
1674                 talloc_free(tframe);
1675                 return NULL;
1676         }
1677
1678         talloc_free(tframe);
1679         Py_RETURN_NONE;
1680 }
1681
1682
1683 static PyObject *py_pdb_add_group_mapping_entry(pytalloc_Object *self, PyObject *args)
1684 {
1685         NTSTATUS status;
1686         struct pdb_methods *methods;
1687         TALLOC_CTX *tframe;
1688         PyObject *py_group_map;
1689         GROUP_MAP *group_map;
1690
1691         if (!PyArg_ParseTuple(args, "O!:add_group_mapping_entry", &PyGroupmap, &py_group_map)) {
1692                 return NULL;
1693         }
1694
1695         methods = pytalloc_get_ptr(self);
1696
1697         if ((tframe = talloc_stackframe()) == NULL) {
1698                 PyErr_NoMemory();
1699                 return NULL;
1700         }
1701
1702         group_map = pytalloc_get_ptr(py_group_map);
1703
1704         status = methods->add_group_mapping_entry(methods, group_map);
1705         if (!NT_STATUS_IS_OK(status)) {
1706                 PyErr_Format(py_pdb_error, "Unable to add group mapping entry, (%d,%s)",
1707                                 NT_STATUS_V(status),
1708                                 get_friendly_nt_error_msg(status));
1709                 talloc_free(tframe);
1710                 return NULL;
1711         }
1712
1713         talloc_free(tframe);
1714         Py_RETURN_NONE;
1715 }
1716
1717
1718 static PyObject *py_pdb_update_group_mapping_entry(pytalloc_Object *self, PyObject *args)
1719 {
1720         NTSTATUS status;
1721         struct pdb_methods *methods;
1722         TALLOC_CTX *tframe;
1723         PyObject *py_group_map;
1724         GROUP_MAP *group_map;
1725
1726         if (!PyArg_ParseTuple(args, "O!:update_group_mapping_entry", &PyGroupmap, &py_group_map)) {
1727                 return NULL;
1728         }
1729
1730         methods = pytalloc_get_ptr(self);
1731
1732         if ((tframe = talloc_stackframe()) == NULL) {
1733                 PyErr_NoMemory();
1734                 return NULL;
1735         }
1736
1737         group_map = pytalloc_get_ptr(py_group_map);
1738
1739         status = methods->update_group_mapping_entry(methods, group_map);
1740         if (!NT_STATUS_IS_OK(status)) {
1741                 PyErr_Format(py_pdb_error, "Unable to update group mapping entry, (%d,%s)",
1742                                 NT_STATUS_V(status),
1743                                 get_friendly_nt_error_msg(status));
1744                 talloc_free(tframe);
1745                 return NULL;
1746         }
1747
1748         talloc_free(tframe);
1749         Py_RETURN_NONE;
1750 }
1751
1752
1753 static PyObject *py_pdb_delete_group_mapping_entry(pytalloc_Object *self, PyObject *args)
1754 {
1755         NTSTATUS status;
1756         struct pdb_methods *methods;
1757         TALLOC_CTX *tframe;
1758         PyObject *py_group_sid;
1759         struct dom_sid *group_sid;
1760
1761         if (!PyArg_ParseTuple(args, "O!:delete_group_mapping_entry", dom_sid_Type, &py_group_sid)) {
1762                 return NULL;
1763         }
1764
1765         methods = pytalloc_get_ptr(self);
1766
1767         if ((tframe = talloc_stackframe()) == NULL) {
1768                 PyErr_NoMemory();
1769                 return NULL;
1770         }
1771
1772         group_sid = pytalloc_get_ptr(py_group_sid);
1773
1774         status = methods->delete_group_mapping_entry(methods, *group_sid);
1775         if (!NT_STATUS_IS_OK(status)) {
1776                 PyErr_Format(py_pdb_error, "Unable to delete group mapping entry, (%d,%s)",
1777                                 NT_STATUS_V(status),
1778                                 get_friendly_nt_error_msg(status));
1779                 talloc_free(tframe);
1780                 return NULL;
1781         }
1782
1783         talloc_free(tframe);
1784         Py_RETURN_NONE;
1785 }
1786
1787
1788 static PyObject *py_pdb_enum_group_mapping(pytalloc_Object *self, PyObject *args)
1789 {
1790         NTSTATUS status;
1791         struct pdb_methods *methods;
1792         TALLOC_CTX *tframe;
1793         enum lsa_SidType sid_name_use;
1794         int lsa_sidtype_value;
1795         int unix_only;
1796         PyObject *py_domain_sid;
1797         struct dom_sid *domain_sid;
1798         GROUP_MAP *gmap, *group_map;
1799         size_t num_entries;
1800         PyObject *py_gmap_list, *py_group_map;
1801         int i;
1802
1803         if (!PyArg_ParseTuple(args, "O!ii:enum_group_mapping", dom_sid_Type, &py_domain_sid,
1804                                         &lsa_sidtype_value, &unix_only)) {
1805                 return NULL;
1806         }
1807
1808         methods = pytalloc_get_ptr(self);
1809
1810         if ((tframe = talloc_stackframe()) == NULL) {
1811                 PyErr_NoMemory();
1812                 return NULL;
1813         }
1814
1815         sid_name_use = lsa_sidtype_value;
1816
1817         domain_sid = pytalloc_get_ptr(py_domain_sid);
1818
1819         status = methods->enum_group_mapping(methods, domain_sid, sid_name_use,
1820                                                 &gmap, &num_entries, unix_only);
1821         if (!NT_STATUS_IS_OK(status)) {
1822                 PyErr_Format(py_pdb_error, "Unable to enumerate group mappings, (%d,%s)",
1823                                 NT_STATUS_V(status),
1824                                 get_friendly_nt_error_msg(status));
1825                 talloc_free(tframe);
1826                 return NULL;
1827         }
1828
1829         py_gmap_list = PyList_New(0);
1830         if (py_gmap_list == NULL) {
1831                 PyErr_NoMemory();
1832                 talloc_free(tframe);
1833                 return NULL;
1834         }
1835
1836         for(i=0; i<num_entries; i++) {
1837                 py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1838                 if (py_group_map) {
1839                         group_map = pytalloc_get_ptr(py_group_map);
1840                         *group_map = gmap[i];
1841
1842                         PyList_Append(py_gmap_list, py_group_map);
1843                 }
1844         }
1845
1846         free(gmap);
1847         talloc_free(tframe);
1848
1849         return py_gmap_list;
1850 }
1851
1852
1853 static PyObject *py_pdb_enum_group_members(pytalloc_Object *self, PyObject *args)
1854 {
1855         NTSTATUS status;
1856         struct pdb_methods *methods;
1857         TALLOC_CTX *tframe;
1858         PyObject *py_group_sid;
1859         struct dom_sid *group_sid;
1860         uint32_t *member_rids;
1861         size_t num_members;
1862         PyObject *py_rid_list;
1863         int i;
1864
1865         if (!PyArg_ParseTuple(args, "O!:enum_group_members", dom_sid_Type, &py_group_sid)) {
1866                 return NULL;
1867         }
1868
1869         methods = pytalloc_get_ptr(self);
1870
1871         if ((tframe = talloc_stackframe()) == NULL) {
1872                 PyErr_NoMemory();
1873                 return NULL;
1874         }
1875
1876         group_sid = pytalloc_get_ptr(py_group_sid);
1877
1878         status = methods->enum_group_members(methods, tframe, group_sid,
1879                                                 &member_rids, &num_members);
1880         if (!NT_STATUS_IS_OK(status)) {
1881                 PyErr_Format(py_pdb_error, "Unable to enumerate group members, (%d,%s)",
1882                                 NT_STATUS_V(status),
1883                                 get_friendly_nt_error_msg(status));
1884                 talloc_free(tframe);
1885                 return NULL;
1886         }
1887
1888         py_rid_list = PyList_New(0);
1889         if (py_rid_list == NULL) {
1890                 PyErr_NoMemory();
1891                 talloc_free(tframe);
1892                 return NULL;
1893         }
1894
1895         for(i=0; i<num_members; i++) {
1896                 PyList_Append(py_rid_list, PyInt_FromLong(member_rids[i]));
1897         }
1898
1899         talloc_free(tframe);
1900
1901         return py_rid_list;
1902 }
1903
1904
1905 static PyObject *py_pdb_add_groupmem(pytalloc_Object *self, PyObject *args)
1906 {
1907         NTSTATUS status;
1908         struct pdb_methods *methods;
1909         TALLOC_CTX *tframe;
1910         uint32_t group_rid, member_rid;
1911
1912         if (!PyArg_ParseTuple(args, "II:add_groupmem", &group_rid, &member_rid)) {
1913                 return NULL;
1914         }
1915
1916         methods = pytalloc_get_ptr(self);
1917
1918         if ((tframe = talloc_stackframe()) == NULL) {
1919                 PyErr_NoMemory();
1920                 return NULL;
1921         }
1922
1923         status = methods->add_groupmem(methods, tframe, group_rid, member_rid);
1924         if (!NT_STATUS_IS_OK(status)) {
1925                 PyErr_Format(py_pdb_error, "Unable to add group member, (%d,%s)",
1926                                 NT_STATUS_V(status),
1927                                 get_friendly_nt_error_msg(status));
1928                 talloc_free(tframe);
1929                 return NULL;
1930         }
1931
1932         talloc_free(tframe);
1933         Py_RETURN_NONE;
1934 }
1935
1936
1937 static PyObject *py_pdb_del_groupmem(pytalloc_Object *self, PyObject *args)
1938 {
1939         NTSTATUS status;
1940         struct pdb_methods *methods;
1941         TALLOC_CTX *tframe;
1942         uint32_t group_rid, member_rid;
1943
1944         if (!PyArg_ParseTuple(args, "II:del_groupmem", &group_rid, &member_rid)) {
1945                 return NULL;
1946         }
1947
1948         methods = pytalloc_get_ptr(self);
1949
1950         if ((tframe = talloc_stackframe()) == NULL) {
1951                 PyErr_NoMemory();
1952                 return NULL;
1953         }
1954
1955         status = methods->del_groupmem(methods, tframe, group_rid, member_rid);
1956         if (!NT_STATUS_IS_OK(status)) {
1957                 PyErr_Format(py_pdb_error, "Unable to rename sam account, (%d,%s)",
1958                                 NT_STATUS_V(status),
1959                                 get_friendly_nt_error_msg(status));
1960                 talloc_free(tframe);
1961                 return NULL;
1962         }
1963
1964         talloc_free(tframe);
1965         Py_RETURN_NONE;
1966 }
1967
1968
1969 static PyObject *py_pdb_create_alias(pytalloc_Object *self, PyObject *args)
1970 {
1971         NTSTATUS status;
1972         struct pdb_methods *methods;
1973         TALLOC_CTX *tframe;
1974         const char *alias_name;
1975         uint32_t rid;
1976
1977         if (!PyArg_ParseTuple(args, "s:create_alias", &alias_name)) {
1978                 return NULL;
1979         }
1980
1981         methods = pytalloc_get_ptr(self);
1982
1983         if ((tframe = talloc_stackframe()) == NULL) {
1984                 PyErr_NoMemory();
1985                 return NULL;
1986         }
1987
1988         status = methods->create_alias(methods, alias_name, &rid);
1989         if (!NT_STATUS_IS_OK(status)) {
1990                 PyErr_Format(py_pdb_error, "Unable to create alias (%s), (%d,%s)",
1991                                 alias_name,
1992                                 NT_STATUS_V(status),
1993                                 get_friendly_nt_error_msg(status));
1994                 talloc_free(tframe);
1995                 return NULL;
1996         }
1997
1998         talloc_free(tframe);
1999
2000         return PyInt_FromLong(rid);
2001 }
2002
2003
2004 static PyObject *py_pdb_delete_alias(pytalloc_Object *self, PyObject *args)
2005 {
2006         NTSTATUS status;
2007         struct pdb_methods *methods;
2008         TALLOC_CTX *tframe;
2009         PyObject *py_alias_sid;
2010         struct dom_sid *alias_sid;
2011
2012         if (!PyArg_ParseTuple(args, "O!:delete_alias", dom_sid_Type, &py_alias_sid)) {
2013                 return NULL;
2014         }
2015
2016         methods = pytalloc_get_ptr(self);
2017
2018         if ((tframe = talloc_stackframe()) == NULL) {
2019                 PyErr_NoMemory();
2020                 return NULL;
2021         }
2022
2023         alias_sid = pytalloc_get_ptr(py_alias_sid);
2024
2025         status = methods->delete_alias(methods, alias_sid);
2026         if (!NT_STATUS_IS_OK(status)) {
2027                 PyErr_Format(py_pdb_error, "Unable to delete alias, (%d,%s)",
2028                                 NT_STATUS_V(status),
2029                                 get_friendly_nt_error_msg(status));
2030                 talloc_free(tframe);
2031                 return NULL;
2032         }
2033
2034         talloc_free(tframe);
2035         Py_RETURN_NONE;
2036 }
2037
2038
2039 static PyObject *py_pdb_get_aliasinfo(pytalloc_Object *self, PyObject *args)
2040 {
2041         NTSTATUS status;
2042         struct pdb_methods *methods;
2043         TALLOC_CTX *tframe;
2044         PyObject *py_alias_sid;
2045         struct dom_sid *alias_sid;
2046         struct acct_info alias_info;
2047         PyObject *py_alias_info;
2048
2049         if (!PyArg_ParseTuple(args, "O!:get_aliasinfo", dom_sid_Type, &py_alias_sid)) {
2050                 return NULL;
2051         }
2052
2053         methods = pytalloc_get_ptr(self);
2054
2055         if ((tframe = talloc_stackframe()) == NULL) {
2056                 PyErr_NoMemory();
2057                 return NULL;
2058         }
2059
2060         alias_sid = pytalloc_get_ptr(py_alias_sid);
2061
2062         status = methods->get_aliasinfo(methods, alias_sid, &alias_info);
2063         if (!NT_STATUS_IS_OK(status)) {
2064                 PyErr_Format(py_pdb_error, "Unable to get alias information, (%d,%s)",
2065                                 NT_STATUS_V(status),
2066                                 get_friendly_nt_error_msg(status));
2067                 talloc_free(tframe);
2068                 return NULL;
2069         }
2070
2071         py_alias_info = PyDict_New();
2072         if (py_alias_info == NULL) {
2073                 PyErr_NoMemory();
2074                 talloc_free(tframe);
2075                 return NULL;
2076         }
2077
2078         PyDict_SetItemString(py_alias_info, "acct_name", PyString_FromString(alias_info.acct_name));
2079         PyDict_SetItemString(py_alias_info, "acct_desc", PyString_FromString(alias_info.acct_desc));
2080         PyDict_SetItemString(py_alias_info, "rid", PyInt_FromLong(alias_info.rid));
2081
2082         talloc_free(tframe);
2083
2084         return py_alias_info;
2085 }
2086
2087
2088 static PyObject *py_pdb_set_aliasinfo(pytalloc_Object *self, PyObject *args)
2089 {
2090         NTSTATUS status;
2091         struct pdb_methods *methods;
2092         TALLOC_CTX *tframe;
2093         PyObject *py_alias_sid, *py_alias_info;
2094         struct dom_sid *alias_sid;
2095         struct acct_info alias_info;
2096
2097         if (!PyArg_ParseTuple(args, "O!O:set_alias_info", dom_sid_Type, &py_alias_sid,
2098                                 &py_alias_info)) {
2099                 return NULL;
2100         }
2101
2102         methods = pytalloc_get_ptr(self);
2103
2104         if ((tframe = talloc_stackframe()) == NULL) {
2105                 PyErr_NoMemory();
2106                 return NULL;
2107         }
2108
2109         alias_sid = pytalloc_get_ptr(py_alias_sid);
2110
2111         fstrcpy(alias_info.acct_name, PyString_AsString(PyDict_GetItemString(py_alias_info, "acct_name")));
2112         fstrcpy(alias_info.acct_desc, PyString_AsString(PyDict_GetItemString(py_alias_info, "acct_desc")));
2113
2114         status = methods->set_aliasinfo(methods, alias_sid, &alias_info);
2115         if (!NT_STATUS_IS_OK(status)) {
2116                 PyErr_Format(py_pdb_error, "Unable to set alias information, (%d,%s)",
2117                                 NT_STATUS_V(status),
2118                                 get_friendly_nt_error_msg(status));
2119                 talloc_free(tframe);
2120                 return NULL;
2121         }
2122
2123         talloc_free(tframe);
2124         Py_RETURN_NONE;
2125 }
2126
2127
2128 static PyObject *py_pdb_add_aliasmem(pytalloc_Object *self, PyObject *args)
2129 {
2130         NTSTATUS status;
2131         struct pdb_methods *methods;
2132         TALLOC_CTX *tframe;
2133         PyObject *py_alias_sid, *py_member_sid;
2134         struct dom_sid *alias_sid, *member_sid;
2135
2136         if (!PyArg_ParseTuple(args, "O!O!:add_aliasmem", dom_sid_Type, &py_alias_sid,
2137                                         dom_sid_Type, &py_member_sid)) {
2138                 return NULL;
2139         }
2140
2141         methods = pytalloc_get_ptr(self);
2142
2143         if ((tframe = talloc_stackframe()) == NULL) {
2144                 PyErr_NoMemory();
2145                 return NULL;
2146         }
2147
2148         alias_sid = pytalloc_get_ptr(py_alias_sid);
2149         member_sid = pytalloc_get_ptr(py_member_sid);
2150
2151         status = methods->add_aliasmem(methods, alias_sid, member_sid);
2152         if (!NT_STATUS_IS_OK(status)) {
2153                 PyErr_Format(py_pdb_error, "Unable to add member to alias, (%d,%s)",
2154                                 NT_STATUS_V(status),
2155                                 get_friendly_nt_error_msg(status));
2156                 talloc_free(tframe);
2157                 return NULL;
2158         }
2159
2160         talloc_free(tframe);
2161         Py_RETURN_NONE;
2162 }
2163
2164
2165 static PyObject *py_pdb_del_aliasmem(pytalloc_Object *self, PyObject *args)
2166 {
2167         NTSTATUS status;
2168         struct pdb_methods *methods;
2169         TALLOC_CTX *tframe;
2170         PyObject *py_alias_sid, *py_member_sid;
2171         const struct dom_sid *alias_sid, *member_sid;
2172
2173         if (!PyArg_ParseTuple(args, "O!O!:del_aliasmem", dom_sid_Type, &py_alias_sid,
2174                                         dom_sid_Type, &py_member_sid)) {
2175                 return NULL;
2176         }
2177
2178         methods = pytalloc_get_ptr(self);
2179
2180         if ((tframe = talloc_stackframe()) == NULL) {
2181                 PyErr_NoMemory();
2182                 return NULL;
2183         }
2184
2185         alias_sid = pytalloc_get_ptr(py_alias_sid);
2186         member_sid = pytalloc_get_ptr(py_member_sid);
2187
2188         status = methods->del_aliasmem(methods, alias_sid, member_sid);
2189         if (!NT_STATUS_IS_OK(status)) {
2190                 PyErr_Format(py_pdb_error, "Unable to delete member from alias, (%d,%s)",
2191                                 NT_STATUS_V(status),
2192                                 get_friendly_nt_error_msg(status));
2193                 talloc_free(tframe);
2194                 return NULL;
2195         }
2196
2197         talloc_free(tframe);
2198         Py_RETURN_NONE;
2199 }
2200
2201
2202 static PyObject *py_pdb_enum_aliasmem(pytalloc_Object *self, PyObject *args)
2203 {
2204         NTSTATUS status;
2205         struct pdb_methods *methods;
2206         TALLOC_CTX *tframe;
2207         PyObject *py_alias_sid;
2208         struct dom_sid *alias_sid, *member_sid;
2209         PyObject *py_member_list, *py_member_sid;
2210         size_t num_members;
2211         int i;
2212
2213         if (!PyArg_ParseTuple(args, "O!:enum_aliasmem", dom_sid_Type, &py_alias_sid)) {
2214                 return NULL;
2215         }
2216
2217         methods = pytalloc_get_ptr(self);
2218
2219         if ((tframe = talloc_stackframe()) == NULL) {
2220                 PyErr_NoMemory();
2221                 return NULL;
2222         }
2223
2224         alias_sid = pytalloc_get_ptr(py_alias_sid);
2225
2226         status = methods->enum_aliasmem(methods, alias_sid, tframe, &member_sid, &num_members);
2227         if (!NT_STATUS_IS_OK(status)) {
2228                 PyErr_Format(py_pdb_error, "Unable to enumerate members for alias, (%d,%s)",
2229                                 NT_STATUS_V(status),
2230                                 get_friendly_nt_error_msg(status));
2231                 talloc_free(tframe);
2232                 return NULL;
2233         }
2234
2235         py_member_list = PyList_New(0);
2236         if (py_member_list == NULL) {
2237                 PyErr_NoMemory();
2238                 talloc_free(tframe);
2239                 return NULL;
2240         }
2241
2242         for(i=0; i<num_members; i++) {
2243                 py_member_sid = pytalloc_steal(dom_sid_Type, &member_sid[i]);
2244                 if (py_member_sid) {
2245                         PyList_Append(py_member_list, py_member_sid);
2246                 }
2247         }
2248
2249         talloc_free(tframe);
2250
2251         return py_member_list;
2252 }
2253
2254
2255 static PyObject *py_pdb_get_account_policy(pytalloc_Object *self)
2256 {
2257         NTSTATUS status;
2258         struct pdb_methods *methods;
2259         TALLOC_CTX *tframe;
2260         PyObject *py_acct_policy;
2261         uint32_t value;
2262         const char **names;
2263         int count, i;
2264         enum pdb_policy_type type;
2265
2266         methods = pytalloc_get_ptr(self);
2267
2268         if ((tframe = talloc_stackframe()) == NULL) {
2269                 PyErr_NoMemory();
2270                 return NULL;
2271         }
2272
2273         py_acct_policy = PyDict_New();
2274         if (py_acct_policy == NULL) {
2275                 PyErr_NoMemory();
2276                 return NULL;
2277         }
2278
2279         account_policy_names_list(tframe, &names, &count);
2280         for (i=0; i<count; i++) {
2281                 type = account_policy_name_to_typenum(names[i]);
2282                 status = methods->get_account_policy(methods, type, &value);
2283                 if (NT_STATUS_IS_OK(status)) {
2284                         PyDict_SetItemString(py_acct_policy, names[i], PyInt_FromLong(value));
2285                 }
2286         }
2287
2288         talloc_free(tframe);
2289
2290         return py_acct_policy;
2291 }
2292
2293
2294 static PyObject *py_pdb_set_account_policy(pytalloc_Object *self, PyObject *args)
2295 {
2296         NTSTATUS status;
2297         struct pdb_methods *methods;
2298         TALLOC_CTX *tframe;
2299         PyObject *py_acct_policy, *py_value;
2300         const char **names;
2301         int count, i;
2302         enum pdb_policy_type type;
2303
2304         if (!PyArg_ParseTuple(args, "O!:set_account_policy", PyDict_Type, &py_acct_policy)) {
2305                 return NULL;
2306         }
2307
2308         methods = pytalloc_get_ptr(self);
2309
2310         if ((tframe = talloc_stackframe()) == NULL) {
2311                 PyErr_NoMemory();
2312                 return NULL;
2313         }
2314
2315         account_policy_names_list(tframe, &names, &count);
2316         for (i=0; i<count; i++) {
2317                 if ((py_value = PyDict_GetItemString(py_acct_policy, names[i])) != NULL) {
2318                         type = account_policy_name_to_typenum(names[i]);
2319                         status = methods->set_account_policy(methods, type, PyInt_AsLong(py_value));
2320                         if (!NT_STATUS_IS_OK(status)) {
2321                                 PyErr_Format(py_pdb_error, "Error setting account policy (%s), (%d,%s)",
2322                                                 names[i],
2323                                                 NT_STATUS_V(status),
2324                                                 get_friendly_nt_error_msg(status));
2325                         }
2326                 }
2327         }
2328
2329
2330         talloc_free(tframe);
2331
2332         Py_RETURN_NONE;
2333 }
2334
2335 static PyObject *py_pdb_search_users(pytalloc_Object *self, PyObject *args)
2336 {
2337         NTSTATUS status;
2338         struct pdb_methods *methods;
2339         TALLOC_CTX *tframe;
2340         unsigned int acct_flags;
2341         struct pdb_search *search;
2342         struct samr_displayentry *entry;
2343         PyObject *py_userlist, *py_dict;
2344
2345         if (!PyArg_ParseTuple(args, "I:search_users", &acct_flags)) {
2346                 return NULL;
2347         }
2348
2349         methods = pytalloc_get_ptr(self);
2350
2351         if ((tframe = talloc_stackframe()) == NULL) {
2352                 PyErr_NoMemory();
2353                 return NULL;
2354         }
2355
2356         search = talloc_zero(tframe, struct pdb_search);
2357         if (search == NULL) {
2358                 PyErr_NoMemory();
2359                 talloc_free(tframe);
2360                 return NULL;
2361         }
2362
2363         if (!methods->search_users(methods, search, acct_flags)) {
2364                 PyErr_Format(py_pdb_error, "Unable to search users, (%d,%s)",
2365                                 NT_STATUS_V(status),
2366                                 get_friendly_nt_error_msg(status));
2367                 talloc_free(tframe);
2368                 return NULL;
2369         }
2370
2371         entry = talloc_zero(tframe, struct samr_displayentry);
2372         if (entry == NULL) {
2373                 PyErr_NoMemory();
2374                 talloc_free(tframe);
2375                 return NULL;
2376         }
2377
2378         py_userlist = PyList_New(0);
2379         if (py_userlist == NULL) {
2380                 PyErr_NoMemory();
2381                 talloc_free(tframe);
2382                 return NULL;
2383         }
2384
2385         while (search->next_entry(search, entry)) {
2386                 py_dict = PyDict_New();
2387                 if (py_dict == NULL) {
2388                         PyErr_NoMemory();
2389                 } else {
2390                         PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2391                         PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2392                         PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2393                         PyDict_SetItemString(py_dict, "account_name", PyString_FromString(entry->account_name));
2394                         PyDict_SetItemString(py_dict, "fullname", PyString_FromString(entry->fullname));
2395                         PyDict_SetItemString(py_dict, "description", PyString_FromString(entry->description));
2396                         PyList_Append(py_userlist, py_dict);
2397                 }
2398         }
2399         search->search_end(search);
2400
2401         talloc_free(tframe);
2402
2403         return py_userlist;
2404 }
2405
2406
2407 static PyObject *py_pdb_search_groups(pytalloc_Object *self)
2408 {
2409         NTSTATUS status;
2410         struct pdb_methods *methods;
2411         TALLOC_CTX *tframe;
2412         struct pdb_search *search;
2413         struct samr_displayentry *entry;
2414         PyObject *py_grouplist, *py_dict;
2415
2416         methods = pytalloc_get_ptr(self);
2417
2418         if ((tframe = talloc_stackframe()) == NULL) {
2419                 PyErr_NoMemory();
2420                 return NULL;
2421         }
2422
2423         search = talloc_zero(tframe, struct pdb_search);
2424         if (search == NULL) {
2425                 PyErr_NoMemory();
2426                 talloc_free(tframe);
2427                 return NULL;
2428         }
2429
2430         if (!methods->search_groups(methods, search)) {
2431                 PyErr_Format(py_pdb_error, "Unable to search groups, (%d,%s)",
2432                                 NT_STATUS_V(status),
2433                                 get_friendly_nt_error_msg(status));
2434                 talloc_free(tframe);
2435                 return NULL;
2436         }
2437
2438         entry = talloc_zero(tframe, struct samr_displayentry);
2439         if (entry == NULL) {
2440                 PyErr_NoMemory();
2441                 talloc_free(tframe);
2442                 return NULL;
2443         }
2444
2445         py_grouplist = PyList_New(0);
2446         if (py_grouplist == NULL) {
2447                 PyErr_NoMemory();
2448                 talloc_free(tframe);
2449                 return NULL;
2450         }
2451
2452         while (search->next_entry(search, entry)) {
2453                 py_dict = PyDict_New();
2454                 if (py_dict == NULL) {
2455                         PyErr_NoMemory();
2456                 } else {
2457                         PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2458                         PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2459                         PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2460                         PyDict_SetItemString(py_dict, "account_name", PyString_FromString(entry->account_name));
2461                         PyDict_SetItemString(py_dict, "fullname", PyString_FromString(entry->fullname));
2462                         PyDict_SetItemString(py_dict, "description", PyString_FromString(entry->description));
2463                         PyList_Append(py_grouplist, py_dict);
2464                 }
2465         }
2466         search->search_end(search);
2467
2468         talloc_free(tframe);
2469
2470         return py_grouplist;
2471 }
2472
2473
2474 static PyObject *py_pdb_search_aliases(pytalloc_Object *self, PyObject *args)
2475 {
2476         NTSTATUS status;
2477         struct pdb_methods *methods;
2478         TALLOC_CTX *tframe;
2479         struct pdb_search *search;
2480         struct samr_displayentry *entry;
2481         PyObject *py_aliaslist, *py_dict;
2482         PyObject *py_domain_sid;
2483         struct dom_sid *dom_sid;
2484
2485         if (!PyArg_ParseTuple(args, "O!:search_users", dom_sid_Type, &py_domain_sid)) {
2486                 return NULL;
2487         }
2488
2489         methods = pytalloc_get_ptr(self);
2490
2491         if ((tframe = talloc_stackframe()) == NULL) {
2492                 PyErr_NoMemory();
2493                 return NULL;
2494         }
2495
2496         dom_sid = pytalloc_get_ptr(py_domain_sid);
2497
2498         search = talloc_zero(tframe, struct pdb_search);
2499         if (search == NULL) {
2500                 PyErr_NoMemory();
2501                 talloc_free(tframe);
2502                 return NULL;
2503         }
2504
2505         if (!methods->search_aliases(methods, search, dom_sid)) {
2506                 PyErr_Format(py_pdb_error, "Unable to search aliases, (%d,%s)",
2507                                 NT_STATUS_V(status),
2508                                 get_friendly_nt_error_msg(status));
2509                 talloc_free(tframe);
2510                 return NULL;
2511         }
2512
2513         entry = talloc_zero(tframe, struct samr_displayentry);
2514         if (entry == NULL) {
2515                 PyErr_NoMemory();
2516                 talloc_free(tframe);
2517                 return NULL;
2518         }
2519
2520         py_aliaslist = PyList_New(0);
2521         if (py_aliaslist == NULL) {
2522                 PyErr_NoMemory();
2523                 talloc_free(tframe);
2524                 return NULL;
2525         }
2526
2527         while (search->next_entry(search, entry)) {
2528                 py_dict = PyDict_New();
2529                 if (py_dict == NULL) {
2530                         PyErr_NoMemory();
2531                 } else {
2532                         PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2533                         PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2534                         PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2535                         PyDict_SetItemString(py_dict, "account_name", PyString_FromString(entry->account_name));
2536                         PyDict_SetItemString(py_dict, "fullname", PyString_FromString(entry->fullname));
2537                         PyDict_SetItemString(py_dict, "description", PyString_FromString(entry->description));
2538                         PyList_Append(py_aliaslist, py_dict);
2539                 }
2540         }
2541         search->search_end(search);
2542
2543         talloc_free(tframe);
2544
2545         return py_aliaslist;
2546 }
2547
2548
2549 static PyObject *py_pdb_uid_to_sid(pytalloc_Object *self, PyObject *args)
2550 {
2551         struct pdb_methods *methods;
2552         TALLOC_CTX *tframe;
2553         unsigned int uid;
2554         struct dom_sid user_sid, *copy_user_sid;
2555         PyObject *py_user_sid;
2556
2557         if (!PyArg_ParseTuple(args, "I:uid_to_sid", &uid)) {
2558                 return NULL;
2559         }
2560
2561         methods = pytalloc_get_ptr(self);
2562
2563         if ((tframe = talloc_stackframe()) == NULL) {
2564                 PyErr_NoMemory();
2565                 return NULL;
2566         }
2567
2568         if (!methods->uid_to_sid(methods, uid, &user_sid)) {
2569                 PyErr_Format(py_pdb_error, "Unable to get sid for uid=%d", uid);
2570                 talloc_free(tframe);
2571                 return NULL;
2572         }
2573
2574         copy_user_sid = dom_sid_dup(tframe, &user_sid);
2575         if (copy_user_sid == NULL) {
2576                 PyErr_NoMemory();
2577                 talloc_free(tframe);
2578                 return NULL;
2579         }
2580
2581         py_user_sid = pytalloc_steal(dom_sid_Type, copy_user_sid);
2582
2583         talloc_free(tframe);
2584
2585         return py_user_sid;
2586 }
2587
2588
2589 static PyObject *py_pdb_gid_to_sid(pytalloc_Object *self, PyObject *args)
2590 {
2591         struct pdb_methods *methods;
2592         TALLOC_CTX *tframe;
2593         unsigned int gid;
2594         struct dom_sid group_sid, *copy_group_sid;
2595         PyObject *py_group_sid;
2596
2597         if (!PyArg_ParseTuple(args, "I:gid_to_sid", &gid)) {
2598                 return NULL;
2599         }
2600
2601         methods = pytalloc_get_ptr(self);
2602
2603         if ((tframe = talloc_stackframe()) == NULL) {
2604                 PyErr_NoMemory();
2605                 return NULL;
2606         }
2607
2608         if (!methods->gid_to_sid(methods, gid, &group_sid)) {
2609                 PyErr_Format(py_pdb_error, "Unable to get sid for gid=%d", gid);
2610                 talloc_free(tframe);
2611                 return NULL;
2612         }
2613
2614         copy_group_sid = dom_sid_dup(tframe, &group_sid);
2615         if (copy_group_sid == NULL) {
2616                 PyErr_NoMemory();
2617                 talloc_free(tframe);
2618                 return NULL;
2619         }
2620
2621         py_group_sid = pytalloc_steal(dom_sid_Type, copy_group_sid);
2622
2623         talloc_free(tframe);
2624
2625         return py_group_sid;
2626 }
2627
2628
2629 static PyObject *py_pdb_sid_to_id(pytalloc_Object *self, PyObject *args)
2630 {
2631         struct pdb_methods *methods;
2632         TALLOC_CTX *tframe;
2633         PyObject *py_sid;
2634         struct dom_sid *sid;
2635         union unid_t id;
2636         enum lsa_SidType type;
2637
2638         if (!PyArg_ParseTuple(args, "O!:sid_to_id", dom_sid_Type, &py_sid)) {
2639                 return NULL;
2640         }
2641
2642         methods = pytalloc_get_ptr(self);
2643
2644         if ((tframe = talloc_stackframe()) == NULL) {
2645                 PyErr_NoMemory();
2646                 return NULL;
2647         }
2648
2649         sid = pytalloc_get_ptr(py_sid);
2650
2651         if (!methods->sid_to_id(methods, sid, &id, &type)) {
2652                 PyErr_Format(py_pdb_error, "Unable to get id for sid");
2653                 talloc_free(tframe);
2654                 return NULL;
2655         }
2656
2657         talloc_free(tframe);
2658
2659         return Py_BuildValue("(II)", id.uid, type);
2660 }
2661
2662
2663 static PyObject *py_pdb_new_rid(pytalloc_Object *self)
2664 {
2665         struct pdb_methods *methods;
2666         TALLOC_CTX *tframe;
2667         uint32_t rid;
2668
2669         methods = pytalloc_get_ptr(self);
2670
2671         if ((tframe = talloc_stackframe()) == NULL) {
2672                 PyErr_NoMemory();
2673                 return NULL;
2674         }
2675
2676         if (!methods->new_rid(methods, &rid)) {
2677                 PyErr_Format(py_pdb_error, "Unable to get new rid");
2678                 talloc_free(tframe);
2679                 return NULL;
2680         }
2681
2682         talloc_free(tframe);
2683
2684         return PyInt_FromLong(rid);
2685 }
2686
2687
2688 static PyObject *py_pdb_get_trusteddom_pw(pytalloc_Object *self, PyObject *args)
2689 {
2690         struct pdb_methods *methods;
2691         TALLOC_CTX *tframe;
2692         const char *domain;
2693         char *pwd;
2694         struct dom_sid sid, *copy_sid;
2695         PyObject *py_sid;
2696         time_t last_set_time;
2697         PyObject *py_value;
2698
2699         if (!PyArg_ParseTuple(args, "s:get_trusteddom_pw", &domain)) {
2700                 return NULL;
2701         }
2702
2703         methods = pytalloc_get_ptr(self);
2704
2705         if ((tframe = talloc_stackframe()) == NULL) {
2706                 PyErr_NoMemory();
2707                 return NULL;
2708         }
2709
2710         if (!methods->get_trusteddom_pw(methods, domain, &pwd, &sid, &last_set_time)) {
2711                 PyErr_Format(py_pdb_error, "Unable to get trusted domain password");
2712                 talloc_free(tframe);
2713                 return NULL;
2714         }
2715
2716         copy_sid = dom_sid_dup(tframe, &sid);
2717         if (copy_sid == NULL) {
2718                 PyErr_NoMemory();
2719                 talloc_free(tframe);
2720                 return NULL;
2721         }
2722
2723         py_sid = pytalloc_steal(dom_sid_Type, copy_sid);
2724         if (py_sid == NULL) {
2725                 PyErr_NoMemory();
2726                 talloc_free(tframe);
2727                 return NULL;
2728         }
2729
2730         talloc_free(tframe);
2731
2732         py_value = PyDict_New();
2733         if (py_value == NULL) {
2734                 PyErr_NoMemory();
2735                 return NULL;
2736         }
2737
2738         PyDict_SetItemString(py_value, "pwd", PyString_FromString(pwd));
2739         PyDict_SetItemString(py_value, "sid", py_sid);
2740         PyDict_SetItemString(py_value, "last_set_tim", PyInt_FromLong(last_set_time));
2741
2742         return py_value;
2743 }
2744
2745
2746 static PyObject *py_pdb_set_trusteddom_pw(pytalloc_Object *self, PyObject *args)
2747 {
2748         struct pdb_methods *methods;
2749         TALLOC_CTX *tframe;
2750         const char *domain;
2751         const char *pwd;
2752         const struct dom_sid *domain_sid;
2753         PyObject *py_domain_sid;
2754
2755         if (!PyArg_ParseTuple(args, "ssO!:set_trusteddom_pw", &domain, &pwd,
2756                                         dom_sid_Type, &py_domain_sid)) {
2757                 return NULL;
2758         }
2759
2760         methods = pytalloc_get_ptr(self);
2761
2762         if ((tframe = talloc_stackframe()) == NULL) {
2763                 PyErr_NoMemory();
2764                 return NULL;
2765         }
2766
2767         domain_sid = pytalloc_get_ptr(py_domain_sid);
2768
2769         if (!methods->set_trusteddom_pw(methods, domain, pwd, domain_sid)) {
2770                 PyErr_Format(py_pdb_error, "Unable to set trusted domain password");
2771                 talloc_free(tframe);
2772                 return NULL;
2773         }
2774
2775         Py_RETURN_NONE;
2776 }
2777
2778
2779 static PyObject *py_pdb_del_trusteddom_pw(pytalloc_Object *self, PyObject *args)
2780 {
2781         struct pdb_methods *methods;
2782         TALLOC_CTX *tframe;
2783         const char *domain;
2784
2785         if (!PyArg_ParseTuple(args, "s:del_trusteddom_pw", &domain)) {
2786                 return NULL;
2787         }
2788
2789         methods = pytalloc_get_ptr(self);
2790
2791         if ((tframe = talloc_stackframe()) == NULL) {
2792                 PyErr_NoMemory();
2793                 return NULL;
2794         }
2795
2796         if (!methods->del_trusteddom_pw(methods, domain)) {
2797                 PyErr_Format(py_pdb_error, "Unable to delete trusted domain password");
2798                 talloc_free(tframe);
2799                 return NULL;
2800         }
2801
2802         Py_RETURN_NONE;
2803 }
2804
2805
2806 static PyObject *py_pdb_enum_trusteddoms(pytalloc_Object *self)
2807 {
2808         NTSTATUS status;
2809         struct pdb_methods *methods;
2810         TALLOC_CTX *tframe;
2811         uint32_t num_domains;
2812         struct trustdom_info **domains;
2813         PyObject *py_domain_list, *py_dict;
2814         int i;
2815
2816         methods = pytalloc_get_ptr(self);
2817
2818         if ((tframe = talloc_stackframe()) == NULL) {
2819                 PyErr_NoMemory();
2820                 return NULL;
2821         }
2822
2823         status = methods->enum_trusteddoms(methods, tframe, &num_domains, &domains);
2824         if (!NT_STATUS_IS_OK(status)) {
2825                 PyErr_Format(py_pdb_error, "Unable to enumerate trusted domains, (%d,%s)",
2826                                 NT_STATUS_V(status),
2827                                 get_friendly_nt_error_msg(status));
2828                 talloc_free(tframe);
2829                 return NULL;
2830         }
2831
2832         py_domain_list = PyList_New(0);
2833         if (py_domain_list == NULL) {
2834                 PyErr_NoMemory();
2835                 talloc_free(tframe);
2836                 return NULL;
2837         }
2838
2839         for(i=0; i<num_domains; i++) {
2840                 py_dict = PyDict_New();
2841                 if (py_dict) {
2842                         PyDict_SetItemString(py_dict, "name",
2843                                         PyString_FromString(domains[i]->name));
2844                         PyDict_SetItemString(py_dict, "sid",
2845                                         pytalloc_steal(dom_sid_Type, &domains[i]->sid));
2846                 }
2847
2848                 PyList_Append(py_domain_list, py_dict);
2849         }
2850
2851         talloc_free(tframe);
2852
2853         return py_domain_list;
2854 }
2855
2856
2857 static PyObject *py_pdb_get_trusted_domain(pytalloc_Object *self, PyObject *args)
2858 {
2859         NTSTATUS status;
2860         struct pdb_methods *methods;
2861         TALLOC_CTX *tframe;
2862         const char *domain;
2863         struct pdb_trusted_domain *td;
2864         PyObject *py_domain_info;
2865
2866         if (!PyArg_ParseTuple(args, "s:get_trusted_domain", &domain)) {
2867                 return NULL;
2868         }
2869
2870         methods = pytalloc_get_ptr(self);
2871
2872         if ((tframe = talloc_stackframe()) == NULL) {
2873                 PyErr_NoMemory();
2874                 return NULL;
2875         }
2876
2877         status = methods->get_trusted_domain(methods, tframe, domain, &td);
2878         if (!NT_STATUS_IS_OK(status)) {
2879                 PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
2880                                 NT_STATUS_V(status),
2881                                 get_friendly_nt_error_msg(status));
2882                 talloc_free(tframe);
2883                 return NULL;
2884         }
2885
2886         py_domain_info = PyDict_New();
2887         if (py_domain_info == NULL) {
2888                 PyErr_NoMemory();
2889                 talloc_free(tframe);
2890                 return NULL;
2891         }
2892
2893         PyDict_SetItemString(py_domain_info, "domain_name",
2894                         PyString_FromString(td->domain_name));
2895         PyDict_SetItemString(py_domain_info, "netbios_name",
2896                         PyString_FromString(td->netbios_name));
2897         PyDict_SetItemString(py_domain_info, "security_identifier",
2898                         pytalloc_steal(dom_sid_Type, &td->security_identifier));
2899         PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
2900                         PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
2901                                                 td->trust_auth_incoming.length));
2902         PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
2903                         PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
2904                                                 td->trust_auth_outgoing.length));
2905         PyDict_SetItemString(py_domain_info, "trust_direction",
2906                         PyInt_FromLong(td->trust_direction));
2907         PyDict_SetItemString(py_domain_info, "trust_type",
2908                         PyInt_FromLong(td->trust_type));
2909         PyDict_SetItemString(py_domain_info, "trust_attributes",
2910                         PyInt_FromLong(td->trust_attributes));
2911         PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
2912                         PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
2913                                                 td->trust_forest_trust_info.length));
2914
2915         talloc_free(tframe);
2916
2917         return py_domain_info;
2918 }
2919
2920
2921 static PyObject *py_pdb_get_trusted_domain_by_sid(pytalloc_Object *self, PyObject *args)
2922 {
2923         NTSTATUS status;
2924         struct pdb_methods *methods;
2925         TALLOC_CTX *tframe;
2926         PyObject *py_domain_sid;
2927         struct dom_sid *domain_sid;
2928         struct pdb_trusted_domain *td;
2929         PyObject *py_domain_info;
2930
2931         if (!PyArg_ParseTuple(args, "O!:get_trusted_domain_by_sid", dom_sid_Type, &py_domain_sid)) {
2932                 return NULL;
2933         }
2934
2935         methods = pytalloc_get_ptr(self);
2936
2937         if ((tframe = talloc_stackframe()) == NULL) {
2938                 PyErr_NoMemory();
2939                 return NULL;
2940         }
2941
2942         domain_sid = pytalloc_get_ptr(py_domain_sid);
2943
2944         status = methods->get_trusted_domain_by_sid(methods, tframe, domain_sid, &td);
2945         if (!NT_STATUS_IS_OK(status)) {
2946                 PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
2947                                 NT_STATUS_V(status),
2948                                 get_friendly_nt_error_msg(status));
2949                 talloc_free(tframe);
2950                 return NULL;
2951         }
2952
2953         py_domain_info = PyDict_New();
2954         if (py_domain_info == NULL) {
2955                 PyErr_NoMemory();
2956                 talloc_free(tframe);
2957                 return NULL;
2958         }
2959
2960         PyDict_SetItemString(py_domain_info, "domain_name",
2961                         PyString_FromString(td->domain_name));
2962         PyDict_SetItemString(py_domain_info, "netbios_name",
2963                         PyString_FromString(td->netbios_name));
2964         PyDict_SetItemString(py_domain_info, "security_identifier",
2965                         pytalloc_steal(dom_sid_Type, &td->security_identifier));
2966         PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
2967                         PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
2968                                                 td->trust_auth_incoming.length));
2969         PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
2970                         PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
2971                                                 td->trust_auth_outgoing.length));
2972         PyDict_SetItemString(py_domain_info, "trust_direction",
2973                         PyInt_FromLong(td->trust_direction));
2974         PyDict_SetItemString(py_domain_info, "trust_type",
2975                         PyInt_FromLong(td->trust_type));
2976         PyDict_SetItemString(py_domain_info, "trust_attributes",
2977                         PyInt_FromLong(td->trust_attributes));
2978         PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
2979                         PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
2980                                                 td->trust_forest_trust_info.length));
2981
2982         talloc_free(tframe);
2983
2984         return py_domain_info;
2985 }
2986
2987
2988 static PyObject *py_pdb_set_trusted_domain(pytalloc_Object *self, PyObject *args)
2989 {
2990         NTSTATUS status;
2991         struct pdb_methods *methods;
2992         TALLOC_CTX *tframe;
2993         const char *domain;
2994         PyObject *py_td_info;
2995         struct pdb_trusted_domain td_info;
2996         PyObject *py_tmp;
2997         Py_ssize_t len;
2998
2999         if (!PyArg_ParseTuple(args, "sO!:set_trusted_domain", &domain, &PyDict_Type, &py_td_info)) {
3000                 return NULL;
3001         }
3002
3003         py_tmp = PyDict_GetItemString(py_td_info, "domain_name");
3004         td_info.domain_name = PyString_AsString(py_tmp);
3005
3006         py_tmp = PyDict_GetItemString(py_td_info, "netbios_name");
3007         td_info.netbios_name = PyString_AsString(py_tmp);
3008
3009         py_tmp = PyDict_GetItemString(py_td_info, "security_identifier");
3010         td_info.security_identifier = *pytalloc_get_type(py_tmp, struct dom_sid);
3011
3012         py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_incoming");
3013         PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_incoming.data, &len);
3014         td_info.trust_auth_incoming.length = len;
3015
3016         py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_outgoing");
3017         PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_outgoing.data, &len);
3018         td_info.trust_auth_outgoing.length = len;
3019
3020         py_tmp = PyDict_GetItemString(py_td_info, "trust_direction");
3021         td_info.trust_direction = PyInt_AsLong(py_tmp);
3022
3023         py_tmp = PyDict_GetItemString(py_td_info, "trust_type");
3024         td_info.trust_type = PyInt_AsLong(py_tmp);
3025
3026         py_tmp = PyDict_GetItemString(py_td_info, "trust_attributes");
3027         td_info.trust_attributes = PyInt_AsLong(py_tmp);
3028
3029         py_tmp = PyDict_GetItemString(py_td_info, "trust_forest_trust_info");
3030         PyString_AsStringAndSize(py_tmp, (char **)&td_info.trust_forest_trust_info.data, &len);
3031         td_info.trust_forest_trust_info.length = len;
3032
3033         methods = pytalloc_get_ptr(self);
3034
3035         if ((tframe = talloc_stackframe()) == NULL) {
3036                 PyErr_NoMemory();
3037                 return NULL;
3038         }
3039
3040         status = methods->set_trusted_domain(methods, domain, &td_info);
3041         if (!NT_STATUS_IS_OK(status)) {
3042                 PyErr_Format(py_pdb_error, "Unable to set trusted domain information, (%d,%s)",
3043                                 NT_STATUS_V(status),
3044                                 get_friendly_nt_error_msg(status));
3045                 talloc_free(tframe);
3046                 return NULL;
3047         }
3048
3049         talloc_free(tframe);
3050
3051         Py_RETURN_NONE;
3052 }
3053
3054
3055 static PyObject *py_pdb_del_trusted_domain(pytalloc_Object *self, PyObject *args)
3056 {
3057         NTSTATUS status;
3058         struct pdb_methods *methods;
3059         TALLOC_CTX *tframe;
3060         const char *domain;
3061
3062         if (!PyArg_ParseTuple(args, "s:del_trusted_domain", &domain)) {
3063                 return NULL;
3064         }
3065
3066         methods = pytalloc_get_ptr(self);
3067
3068         if ((tframe = talloc_stackframe()) == NULL) {
3069                 PyErr_NoMemory();
3070                 return NULL;
3071         }
3072
3073         status = methods->del_trusted_domain(methods, domain);
3074         if (!NT_STATUS_IS_OK(status)) {
3075                 PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
3076                                 NT_STATUS_V(status),
3077                                 get_friendly_nt_error_msg(status));
3078                 talloc_free(tframe);
3079                 return NULL;
3080         }
3081
3082         talloc_free(tframe);
3083
3084         Py_RETURN_NONE;
3085 }
3086
3087
3088 static PyObject *py_pdb_enum_trusted_domains(pytalloc_Object *self)
3089 {
3090         NTSTATUS status;
3091         struct pdb_methods *methods;
3092         TALLOC_CTX *tframe;
3093         uint32_t num_domains;
3094         struct pdb_trusted_domain **td_info, *td;
3095         PyObject *py_td_info, *py_domain_info;
3096         int i;
3097
3098         methods = pytalloc_get_ptr(self);
3099
3100         if ((tframe = talloc_stackframe()) == NULL) {
3101                 PyErr_NoMemory();
3102                 return NULL;
3103         }
3104
3105         status = methods->enum_trusted_domains(methods, tframe, &num_domains, &td_info);
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);
3111                 return NULL;
3112         }
3113
3114         py_td_info = PyList_New(0);
3115         if (py_td_info == NULL) {
3116                 PyErr_NoMemory();
3117                 talloc_free(tframe);
3118                 return NULL;
3119         }
3120
3121         for (i=0; i<num_domains; i++) {
3122
3123                 py_domain_info = PyDict_New();
3124                 if (py_domain_info == NULL) {
3125                         PyErr_NoMemory();
3126                         Py_DECREF(py_td_info);
3127                         talloc_free(tframe);
3128                         return NULL;
3129                 }
3130
3131                 td = td_info[i];
3132
3133                 PyDict_SetItemString(py_domain_info, "domain_name",
3134                                 PyString_FromString(td->domain_name));
3135                 PyDict_SetItemString(py_domain_info, "netbios_name",
3136                                 PyString_FromString(td->netbios_name));
3137                 PyDict_SetItemString(py_domain_info, "security_identifier",
3138                                 pytalloc_steal(dom_sid_Type, &td->security_identifier));
3139                 PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
3140                                 PyString_FromStringAndSize((char *)td->trust_auth_incoming.data,
3141                                                         td->trust_auth_incoming.length));
3142                 PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
3143                                 PyString_FromStringAndSize((char *)td->trust_auth_outgoing.data,
3144                                                         td->trust_auth_outgoing.length));
3145                 PyDict_SetItemString(py_domain_info, "trust_direction",
3146                                 PyInt_FromLong(td->trust_direction));
3147                 PyDict_SetItemString(py_domain_info, "trust_type",
3148                                 PyInt_FromLong(td->trust_type));
3149                 PyDict_SetItemString(py_domain_info, "trust_attributes",
3150                                 PyInt_FromLong(td->trust_attributes));
3151                 PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
3152                                 PyString_FromStringAndSize((char *)td->trust_forest_trust_info.data,
3153                                                         td->trust_forest_trust_info.length));
3154                 PyList_Append(py_td_info, py_domain_info);
3155         }
3156
3157         talloc_free(tframe);
3158
3159         return py_td_info;
3160 }
3161
3162
3163 static PyObject *py_pdb_get_secret(pytalloc_Object *self, PyObject *args)
3164 {
3165         NTSTATUS status;
3166         struct pdb_methods *methods;
3167         TALLOC_CTX *tframe;
3168         const char *secret_name;
3169         DATA_BLOB secret_current, secret_old;
3170         NTTIME secret_current_lastchange, secret_old_lastchange;
3171         PyObject *py_sd;
3172         struct security_descriptor *sd;
3173         PyObject *py_secret;
3174
3175         if (!PyArg_ParseTuple(args, "s:get_secret_name", &secret_name)) {
3176                 return NULL;
3177         }
3178
3179         methods = pytalloc_get_ptr(self);
3180
3181         if ((tframe = talloc_stackframe()) == NULL) {
3182                 PyErr_NoMemory();
3183                 return NULL;
3184         }
3185
3186         py_sd = pytalloc_new(struct security_descriptor, security_Type);
3187         if (py_sd == NULL) {
3188                 PyErr_NoMemory();
3189                 talloc_free(tframe);
3190                 return NULL;
3191         }
3192         sd = pytalloc_get_ptr(py_sd);
3193
3194         status = methods->get_secret(methods, tframe, secret_name,
3195                                         &secret_current,
3196                                         &secret_current_lastchange,
3197                                         &secret_old,
3198                                         &secret_old_lastchange,
3199                                         &sd);
3200         if (!NT_STATUS_IS_OK(status)) {
3201                 PyErr_Format(py_pdb_error, "Unable to get information for secret (%s), (%d,%s)",
3202                                 secret_name,
3203                                 NT_STATUS_V(status),
3204                                 get_friendly_nt_error_msg(status));
3205                 talloc_free(tframe);
3206                 return NULL;
3207         }
3208
3209         py_secret = PyDict_New();
3210         if (py_secret == NULL) {
3211                 PyErr_NoMemory();
3212                 Py_DECREF(py_sd);
3213                 talloc_free(tframe);
3214                 return NULL;
3215         }
3216
3217         PyDict_SetItemString(py_secret, "secret_current",
3218                         PyString_FromStringAndSize((char *)secret_current.data, secret_current.length));
3219         PyDict_SetItemString(py_secret, "secret_current_lastchange",
3220                         PyLong_FromUnsignedLongLong(secret_current_lastchange));
3221         PyDict_SetItemString(py_secret, "secret_old",
3222                         PyString_FromStringAndSize((char *)secret_old.data, secret_old.length));
3223         PyDict_SetItemString(py_secret, "secret_old_lastchange",
3224                         PyLong_FromUnsignedLongLong(secret_old_lastchange));
3225         PyDict_SetItemString(py_secret, "sd", py_sd);
3226
3227         talloc_free(tframe);
3228
3229         return py_secret;
3230 }
3231
3232
3233 static PyObject *py_pdb_set_secret(pytalloc_Object *self, PyObject *args)
3234 {
3235         NTSTATUS status;
3236         struct pdb_methods *methods;
3237         TALLOC_CTX *tframe;
3238         const char *secret_name;
3239         PyObject *py_secret;
3240         PyObject *py_secret_cur, *py_secret_old, *py_sd;
3241         DATA_BLOB secret_current, secret_old;
3242         struct security_descriptor *sd;
3243         Py_ssize_t len;
3244
3245         if (!PyArg_ParseTuple(args, "sO!:set_secret_name", &secret_name, PyDict_Type, &py_secret)) {
3246                 return NULL;
3247         }
3248
3249         py_secret_cur = PyDict_GetItemString(py_secret, "secret_current");
3250         py_secret_old = PyDict_GetItemString(py_secret, "secret_old");
3251         py_sd = PyDict_GetItemString(py_secret, "sd");
3252
3253         PY_CHECK_TYPE(&PyString_Type, py_secret_cur, return NULL;);
3254         PY_CHECK_TYPE(&PyString_Type, py_secret_old, return NULL;);
3255         PY_CHECK_TYPE(security_Type, py_sd, return NULL;);
3256
3257         methods = pytalloc_get_ptr(self);
3258
3259         if ((tframe = talloc_stackframe()) == NULL) {
3260                 PyErr_NoMemory();
3261                 return NULL;
3262         }
3263
3264         PyString_AsStringAndSize(py_secret_cur, (char **)&secret_current.data, &len);
3265         secret_current.length = len;
3266         PyString_AsStringAndSize(py_secret_old, (char **)&secret_old.data, &len);
3267         secret_current.length = len;
3268         sd = pytalloc_get_ptr(py_sd);
3269
3270         status = methods->set_secret(methods, secret_name, &secret_current, &secret_old, sd);
3271         if (!NT_STATUS_IS_OK(status)) {
3272                 PyErr_Format(py_pdb_error, "Unable to set information for secret (%s), (%d,%s)",
3273                                 secret_name,
3274                                 NT_STATUS_V(status),
3275                                 get_friendly_nt_error_msg(status));
3276                 talloc_free(tframe);
3277                 return NULL;
3278         }
3279
3280         talloc_free(tframe);
3281
3282         Py_RETURN_NONE;
3283 }
3284
3285
3286 static PyObject *py_pdb_delete_secret(pytalloc_Object *self, PyObject *args)
3287 {
3288         NTSTATUS status;
3289         struct pdb_methods *methods;
3290         TALLOC_CTX *tframe;
3291         const char *secret_name;
3292
3293         if (!PyArg_ParseTuple(args, "s:delete_secret", &secret_name)) {
3294                 return NULL;
3295         }
3296
3297         methods = pytalloc_get_ptr(self);
3298
3299         if ((tframe = talloc_stackframe()) == NULL) {
3300                 PyErr_NoMemory();
3301                 return NULL;
3302         }
3303
3304         status = methods->delete_secret(methods, secret_name);
3305         if (!NT_STATUS_IS_OK(status)) {
3306                 PyErr_Format(py_pdb_error, "Unable to delete secret (%s), (%d,%s)",
3307                                 secret_name,
3308                                 NT_STATUS_V(status),
3309                                 get_friendly_nt_error_msg(status));
3310                 talloc_free(tframe);
3311                 return NULL;
3312         }
3313
3314         talloc_free(tframe);
3315
3316         Py_RETURN_NONE;
3317 }
3318
3319 static PyMethodDef py_pdb_methods[] = {
3320         { "domain_info", (PyCFunction)py_pdb_domain_info, METH_NOARGS,
3321                 "domain_info() -> str\n\n \
3322                 Get domain information for the database." },
3323         { "getsampwnam", (PyCFunction)py_pdb_getsampwnam, METH_VARARGS,
3324                 "getsampwnam(username) -> samu object\n\n \
3325                 Get user information by name." },
3326         { "getsampwsid", (PyCFunction)py_pdb_getsampwsid, METH_VARARGS,
3327                 "getsampwsid(user_sid) -> samu object\n\n \
3328                 Get user information by sid (dcerpc.security.dom_sid object)." },
3329         { "create_user", (PyCFunction)py_pdb_create_user, METH_VARARGS,
3330                 "create_user(username, acct_flags) -> rid\n\n \
3331                 Create user. acct_flags are samr account control flags." },
3332         { "delete_user", (PyCFunction)py_pdb_delete_user, METH_VARARGS,
3333                 "delete_user(samu object) -> None\n\n \
3334                 Delete user." },
3335         { "add_sam_account", (PyCFunction)py_pdb_add_sam_account, METH_VARARGS,
3336                 "add_sam_account(samu object) -> None\n\n \
3337                 Add SAM account." },
3338         { "update_sam_account", (PyCFunction)py_pdb_update_sam_account, METH_VARARGS,
3339                 "update_sam_account(samu object) -> None\n\n \
3340                 Update SAM account." },
3341         { "delete_sam_account", (PyCFunction)py_pdb_delete_sam_account, METH_VARARGS,
3342                 "delete_sam_account(samu object) -> None\n\n \
3343                 Delete SAM account." },
3344         { "rename_sam_account", (PyCFunction)py_pdb_rename_sam_account, METH_VARARGS,
3345                 "rename_sam_account(samu object1, new_username) -> None\n\n \
3346                 Rename SAM account." },
3347         /* update_login_attempts */
3348         { "getgrsid", (PyCFunction)py_pdb_getgrsid, METH_VARARGS,
3349                 "getgrsid(group_sid) -> groupmap object\n\n \
3350                 Get group information by sid (dcerpc.security.dom_sid object)." },
3351         { "getgrgid", (PyCFunction)py_pdb_getgrgid, METH_VARARGS,
3352                 "getgrsid(gid) -> groupmap object\n\n \
3353                 Get group information by gid." },
3354         { "getgrnam", (PyCFunction)py_pdb_getgrnam, METH_VARARGS,
3355                 "getgrsid(groupname) -> groupmap object\n\n \
3356                 Get group information by name." },
3357         { "create_dom_group", (PyCFunction)py_pdb_create_dom_group, METH_VARARGS,
3358                 "create_dom_group(groupname) -> group_rid\n\n \
3359                 Create new domain group by name." },
3360         { "delete_dom_group", (PyCFunction)py_pdb_delete_dom_group, METH_VARARGS,
3361                 "delete_dom_group(group_rid) -> None\n\n \
3362                 Delete domain group identified by rid" },
3363         { "add_group_mapping_entry", (PyCFunction)py_pdb_add_group_mapping_entry, METH_VARARGS,
3364                 "add_group_mapping_entry(groupmap) -> None\n \
3365                 Add group mapping entry for groupmap object." },
3366         { "update_group_mapping_entry", (PyCFunction)py_pdb_update_group_mapping_entry, METH_VARARGS,
3367                 "update_group_mapping_entry(groupmap) -> None\n\n \
3368                 Update group mapping entry for groupmap object." },
3369         { "delete_group_mapping_entry", (PyCFunction)py_pdb_delete_group_mapping_entry, METH_VARARGS,
3370                 "delete_group_mapping_entry(groupmap) -> None\n\n \
3371                 Delete group mapping entry for groupmap object." },
3372         { "enum_group_mapping", (PyCFunction)py_pdb_enum_group_mapping, METH_VARARGS,
3373                 "enum_group_mapping([domain_sid, [type, [unix_only]]]) -> List\n\n \
3374                 Return list of group mappings as groupmap objects. Optional arguments are domain_sid object, type of group, unix only flag." },
3375         { "enum_group_members", (PyCFunction)py_pdb_enum_group_members, METH_VARARGS,
3376                 "enum_group_members(group_sid) -> List\n\n \
3377                 Return list of users (dom_sid object) in group." },
3378         /* enum_group_memberships */
3379         /* set_unix_primary_group */
3380         { "add_groupmem", (PyCFunction)py_pdb_add_groupmem, METH_VARARGS,
3381                 "add_groupmem(group_rid, member_rid) -> None\n\n \
3382                 Add user to group." },
3383         { "del_groupmem", (PyCFunction)py_pdb_del_groupmem, METH_VARARGS,
3384                 "del_groupmem(group_rid, member_rid) -> None\n\n \
3385                 Remove user from from group." },
3386         { "create_alias", (PyCFunction)py_pdb_create_alias, METH_VARARGS,
3387                 "create_alias(alias_name) -> alias_rid\n\n \
3388                 Create alias entry." },
3389         { "delete_alias", (PyCFunction)py_pdb_delete_alias, METH_VARARGS,
3390                 "delete_alias(alias_sid) -> None\n\n \
3391                 Delete alias entry." },
3392         { "get_aliasinfo", (PyCFunction)py_pdb_get_aliasinfo, METH_VARARGS,
3393                 "get_aliasinfo(alias_sid) -> Mapping\n\n \
3394                 Get alias information as a dictionary with keys - acct_name, acct_desc, rid." },
3395         { "set_aliasinfo", (PyCFunction)py_pdb_set_aliasinfo, METH_VARARGS,
3396                 "set_alias_info(alias_sid, Mapping) -> None\n\n \
3397                 Set alias information from a dictionary with keys - acct_name, acct_desc." },
3398         { "add_aliasmem", (PyCFunction)py_pdb_add_aliasmem, METH_VARARGS,
3399                 "add_aliasmem(alias_sid, member_sid) -> None\n\n \
3400                 Add user to alias entry." },
3401         { "del_aliasmem", (PyCFunction)py_pdb_del_aliasmem, METH_VARARGS,
3402                 "del_aliasmem(alias_sid, member_sid) -> None\n\n \
3403                 Remove a user from alias entry." },
3404         { "enum_aliasmem", (PyCFunction)py_pdb_enum_aliasmem, METH_VARARGS,
3405                 "enum_aliasmem(alias_sid) -> List\n\n \
3406                 Return a list of members (dom_sid object) for alias entry." },
3407         /* enum_alias_memberships */
3408         /* lookup_rids */
3409         /* lookup_names */
3410         { "get_account_policy", (PyCFunction)py_pdb_get_account_policy, METH_NOARGS,
3411                 "get_account_policy() -> Mapping\n\n \
3412                 Get account policy information as a dictionary." },
3413         { "set_account_policy", (PyCFunction)py_pdb_set_account_policy, METH_VARARGS,
3414                 "get_account_policy(Mapping) -> None\n\n \
3415                 Set account policy settings from a dicionary." },
3416         /* get_seq_num */
3417         { "search_users", (PyCFunction)py_pdb_search_users, METH_VARARGS,
3418                 "search_users(acct_flags) -> List\n\n \
3419                 Search users. acct_flags are samr account control flags.\n \
3420                 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3421         { "search_groups", (PyCFunction)py_pdb_search_groups, METH_NOARGS,
3422                 "search_groups() -> List\n\n \
3423                 Search unix only groups. \n \
3424                 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3425         { "search_aliases", (PyCFunction)py_pdb_search_aliases, METH_VARARGS,
3426                 "search_aliases(domain_sid) -> List\n\n \
3427                 Search aliases. domain_sid is dcerpc.security.dom_sid object.\n \
3428                 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3429         { "uid_to_sid", (PyCFunction)py_pdb_uid_to_sid, METH_VARARGS,
3430                 "uid_to_sid(uid) -> sid\n\n \
3431                 Return sid for given user id." },
3432         { "gid_to_sid", (PyCFunction)py_pdb_gid_to_sid, METH_VARARGS,
3433                 "gid_to_sid(gid) -> sid\n\n \
3434                 Return sid for given group id." },
3435         { "sid_to_id", (PyCFunction)py_pdb_sid_to_id, METH_VARARGS,
3436                 "sid_to_id(sid) -> Tuple\n\n \
3437                 Return id and type for given sid." },
3438         /* capabilities */
3439         { "new_rid", (PyCFunction)py_pdb_new_rid, METH_NOARGS,
3440                 "new_rid() -> rid\n\n \
3441                 Get a new rid." },
3442         { "get_trusteddom_pw", (PyCFunction)py_pdb_get_trusteddom_pw, METH_VARARGS,
3443                 "get_trusteddom_pw(domain) -> Mapping\n\n \
3444                 Get trusted domain password, sid and last set time in a dictionary." },
3445         { "set_trusteddom_pw", (PyCFunction)py_pdb_set_trusteddom_pw, METH_VARARGS,
3446                 "set_trusteddom_pw(domain, pwd, sid) -> None\n\n \
3447                 Set trusted domain password." },
3448         { "del_trusteddom_pw", (PyCFunction)py_pdb_del_trusteddom_pw, METH_VARARGS,
3449                 "del_trusteddom_pw(domain) -> None\n\n \
3450                 Delete trusted domain password." },
3451         { "enum_trusteddoms", (PyCFunction)py_pdb_enum_trusteddoms, METH_NOARGS,
3452                 "enum_trusteddoms() -> List\n\n \
3453                 Get list of trusted domains. Each item is a dictionary with name and sid keys" },
3454         { "get_trusted_domain", (PyCFunction)py_pdb_get_trusted_domain, METH_VARARGS,
3455                 "get_trusted_domain(domain) -> Mapping\n\n \
3456                 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." },
3457         { "get_trusted_domain_by_sid", (PyCFunction)py_pdb_get_trusted_domain_by_sid, METH_VARARGS,
3458                 "get_trusted_domain_by_sid(domain_sid) -> Mapping\n\n \
3459                 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" },
3460         { "set_trusted_domain", (PyCFunction)py_pdb_set_trusted_domain, METH_VARARGS,
3461                 "set_trusted_domain(domain, Mapping) -> None\n\n \
3462                 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." },
3463         { "del_trusted_domain", (PyCFunction)py_pdb_del_trusted_domain, METH_VARARGS,
3464                 "del_trusted_domain(domain) -> None\n\n \
3465                 Delete trusted domain." },
3466         { "enum_trusted_domains", (PyCFunction)py_pdb_enum_trusted_domains, METH_VARARGS,
3467                 "enum_trusted_domains() -> List\n\n \
3468                 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." },
3469         { "get_secret", (PyCFunction)py_pdb_get_secret, METH_VARARGS,
3470                 "get_secret(secret_name) -> Mapping\n\n \
3471                 Get secret information for secret_name. Information is a dictionary with keys - secret_current, secret_current_lastchange, secret_old, secret_old_lastchange, sd." },
3472         { "set_secret", (PyCFunction)py_pdb_set_secret, METH_VARARGS,
3473                 "set_secret(secret_name, Mapping) -> None\n\n \
3474                 Set secret information for secret_name using dictionary with keys - secret_current, sd." },
3475         { "delete_secret", (PyCFunction)py_pdb_delete_secret, METH_VARARGS,
3476                 "delete_secret(secret_name) -> None\n\n \
3477                 Delete secret information for secret_name." },
3478         { NULL },
3479 };
3480
3481
3482 static PyObject *py_pdb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3483 {
3484         const char *url = NULL;
3485         PyObject *pypdb;
3486         NTSTATUS status;
3487         struct pdb_methods *methods;
3488
3489         if (!PyArg_ParseTuple(args, "s", &url)) {
3490                 return NULL;
3491         }
3492
3493         /* Initalize list of methods */
3494         status = make_pdb_method_name(&methods, url);
3495         if (!NT_STATUS_IS_OK(status)) {
3496                 PyErr_Format(py_pdb_error, "Cannot load backend methods for '%s' backend (%d,%s)",
3497                                 url,
3498                                 NT_STATUS_V(status),
3499                                 get_friendly_nt_error_msg(status));
3500                 return NULL;
3501         }
3502
3503         if ((pypdb = pytalloc_steal(type, methods)) == NULL) {
3504                 PyErr_NoMemory();
3505                 return NULL;
3506         }
3507
3508         return pypdb;
3509 }
3510
3511
3512 static PyTypeObject PyPDB = {
3513         .tp_name = "passdb.PDB",
3514         .tp_basicsize = sizeof(pytalloc_Object),
3515         .tp_new = py_pdb_new,
3516         .tp_flags = Py_TPFLAGS_DEFAULT,
3517         .tp_methods = py_pdb_methods,
3518         .tp_doc = "PDB(url[, read_write_flags]) -> Password DB object\n",
3519 };
3520
3521
3522 /*
3523  * Return a list of passdb backends
3524  */
3525 static PyObject *py_passdb_backends(PyObject *self)
3526 {
3527         PyObject *py_blist;
3528         const struct pdb_init_function_entry *entry;
3529         TALLOC_CTX *tframe;
3530
3531         if ((tframe = talloc_stackframe()) == NULL) {
3532                 PyErr_NoMemory();
3533                 return NULL;
3534         }
3535
3536         entry = pdb_get_backends();
3537         if(! entry) {
3538                 Py_RETURN_NONE;
3539         }
3540
3541         if((py_blist = PyList_New(0)) == NULL) {
3542                 PyErr_NoMemory();
3543                 return NULL;
3544         }
3545
3546         while(entry) {
3547                 PyList_Append(py_blist, PyString_FromString(entry->name));
3548                 entry = entry->next;
3549         }
3550
3551         talloc_free(tframe);
3552
3553         return py_blist;
3554 }
3555
3556
3557 static PyObject *py_set_smb_config(PyObject *self, PyObject *args)
3558 {
3559         const char *smb_config;
3560         TALLOC_CTX *tframe;
3561
3562         if (!PyArg_ParseTuple(args, "s", &smb_config)) {
3563                 return NULL;
3564         }
3565
3566         if ((tframe = talloc_stackframe()) == NULL) {
3567                 PyErr_NoMemory();
3568                 return NULL;
3569         }
3570
3571         /* Load smbconf parameters */
3572         if (!lp_load_global(smb_config)) {
3573                 PyErr_Format(py_pdb_error, "Cannot open '%s'", smb_config);
3574                 return NULL;
3575         }
3576
3577         talloc_free(tframe);
3578
3579         Py_RETURN_NONE;
3580 }
3581
3582
3583 static PyObject *py_set_secrets_dir(PyObject *self, PyObject *args)
3584 {
3585         const char *private_dir;
3586         TALLOC_CTX *tframe;
3587
3588         if (!PyArg_ParseTuple(args, "s", &private_dir)) {
3589                 return NULL;
3590         }
3591
3592         if ((tframe = talloc_stackframe()) == NULL) {
3593                 PyErr_NoMemory();
3594                 return NULL;
3595         }
3596
3597         /* Initialize secrets database */
3598         if (!secrets_init_path(private_dir)) {
3599                 PyErr_Format(py_pdb_error, "Cannot open secrets file database in '%s'",
3600                                 private_dir);
3601                 return NULL;
3602         }
3603
3604         talloc_free(tframe);
3605
3606         Py_RETURN_NONE;
3607 }
3608
3609 static PyObject *py_get_global_sam_sid(PyObject *self)
3610 {
3611         struct dom_sid *domain_sid, *domain_sid_copy;
3612         TALLOC_CTX *tframe;
3613         PyObject *py_dom_sid;
3614
3615         tframe = talloc_stackframe();
3616         if (tframe == NULL) {
3617                 PyErr_NoMemory();
3618                 return NULL;
3619         }
3620
3621         domain_sid = get_global_sam_sid();
3622
3623         domain_sid_copy = dom_sid_dup(tframe, domain_sid);
3624         if (domain_sid_copy == NULL) {
3625                 PyErr_NoMemory();
3626                 talloc_free(tframe);
3627                 return NULL;
3628         }
3629
3630         py_dom_sid = pytalloc_steal(dom_sid_Type, domain_sid_copy);
3631
3632         talloc_free(tframe);
3633
3634         return py_dom_sid;
3635 }
3636
3637
3638 static PyMethodDef py_passdb_methods[] = {
3639         { "get_backends", (PyCFunction)py_passdb_backends, METH_NOARGS,
3640                 "get_backends() -> list\n\n \
3641                 Get a list of password database backends supported." },
3642         { "set_smb_config", (PyCFunction)py_set_smb_config, METH_VARARGS,
3643                 "set_smb_config(path) -> None\n\n \
3644                 Set path to smb.conf file to load configuration parameters." },
3645         { "set_secrets_dir", (PyCFunction)py_set_secrets_dir, METH_VARARGS,
3646                 "set_secrets_dir(private_dir) -> None\n\n \
3647                 Set path to private directory to load secrets database from non-default location." },
3648         { "get_global_sam_sid", (PyCFunction)py_get_global_sam_sid, METH_NOARGS,
3649                 "get_global_sam_sid() -> dom_sid\n\n \
3650                 Return domain SID." },
3651         { NULL },
3652 };
3653
3654 void initpassdb(void)
3655 {
3656         PyObject *m, *mod;
3657         char exception_name[] = "passdb.error";
3658
3659         PyTypeObject *talloc_type = pytalloc_GetObjectType();
3660         if (talloc_type == NULL) {
3661                 return;
3662         }
3663
3664         PyPDB.tp_base = talloc_type;
3665         if (PyType_Ready(&PyPDB) < 0) {
3666                 return;
3667         }
3668
3669         PySamu.tp_base = talloc_type;
3670         if (PyType_Ready(&PySamu) < 0) {
3671                 return;
3672         }
3673
3674         PyGroupmap.tp_base = talloc_type;
3675         if (PyType_Ready(&PyGroupmap) < 0) {
3676                 return;
3677         }
3678
3679         m = Py_InitModule3("passdb", py_passdb_methods, "SAMBA Password Database");
3680         if (m == NULL) {
3681             return;
3682         }
3683
3684         /* Create new exception for passdb module */
3685         py_pdb_error = PyErr_NewException(exception_name, NULL, NULL);
3686         Py_INCREF(py_pdb_error);
3687         PyModule_AddObject(m, "error", py_pdb_error);
3688
3689         Py_INCREF(&PyPDB);
3690         PyModule_AddObject(m, "PDB", (PyObject *)&PyPDB);
3691
3692         Py_INCREF(&PySamu);
3693         PyModule_AddObject(m, "Samu", (PyObject *)&PySamu);
3694
3695         Py_INCREF(&PyGroupmap);
3696         PyModule_AddObject(m, "Groupmap", (PyObject *)&PyGroupmap);
3697
3698         /* Import dom_sid type from dcerpc.security */
3699         mod = PyImport_ImportModule("samba.dcerpc.security");
3700         if (mod == NULL) {
3701                 return;
3702         }
3703
3704         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "dom_sid");
3705         if (dom_sid_Type == NULL) {
3706                 return;
3707         }
3708
3709         /* Import security_descriptor type from dcerpc.security */
3710         security_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "descriptor");
3711         Py_DECREF(mod);
3712         if (security_Type == NULL) {
3713                 return;
3714         }
3715
3716         /* Import GUID type from dcerpc.misc */
3717         mod = PyImport_ImportModule("samba.dcerpc.misc");
3718         if (mod == NULL) {
3719                 return;
3720         }
3721
3722         guid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "GUID");
3723         Py_DECREF(mod);
3724         if (guid_Type == NULL) {
3725                 return;
3726         }
3727 }