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