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         {
1056                 .name = discard_const_p(char, "logon_time"),
1057                 .get  = py_samu_get_logon_time,
1058                 .set  = py_samu_set_logon_time,
1059         },
1060         {
1061                 .name = discard_const_p(char, "logoff_time"),
1062                 .get  = py_samu_get_logoff_time,
1063                 .set  = py_samu_set_logoff_time,
1064         },
1065         {
1066                 .name = discard_const_p(char, "kickoff_time"),
1067                 .get  = py_samu_get_kickoff_time,
1068                 .set  = py_samu_set_kickoff_time,
1069         },
1070         {
1071                 .name = discard_const_p(char, "bad_password_time"),
1072                 .get  = py_samu_get_bad_password_time,
1073                 .set  = py_samu_set_bad_password_time,
1074         },
1075         {
1076                 .name = discard_const_p(char, "pass_last_set_time"),
1077                 .get  = py_samu_get_pass_last_set_time,
1078                 .set  = py_samu_set_pass_last_set_time,
1079         },
1080         {
1081                 .name = discard_const_p(char, "pass_can_change_time"),
1082                 .get  = py_samu_get_pass_can_change_time,
1083                 .set  = py_samu_set_pass_can_change_time,
1084         },
1085         {
1086                 .name = discard_const_p(char, "pass_must_change_time"),
1087                 .get  = py_samu_get_pass_must_change_time,
1088                 .set  = py_samu_set_pass_must_change_time,
1089         },
1090         {
1091                 .name = discard_const_p(char, "username"),
1092                 .get  = py_samu_get_username,
1093                 .set  = py_samu_set_username,
1094         },
1095         {
1096                 .name = discard_const_p(char, "domain"),
1097                 .get  = py_samu_get_domain,
1098                 .set  = py_samu_set_domain,
1099         },
1100         {
1101                 .name = discard_const_p(char, "nt_username"),
1102                 .get  = py_samu_get_nt_username,
1103                 .set  = py_samu_set_nt_username,
1104         },
1105         {
1106                 .name = discard_const_p(char, "full_name"),
1107                 .get  = py_samu_get_full_name,
1108                 .set  = py_samu_set_full_name,
1109         },
1110         {
1111                 .name = discard_const_p(char, "home_dir"),
1112                 .get  = py_samu_get_home_dir,
1113                 .set  = py_samu_set_home_dir,
1114         },
1115         {
1116                 .name = discard_const_p(char, "dir_drive"),
1117                 .get  = py_samu_get_dir_drive,
1118                 .set  = py_samu_set_dir_drive,
1119         },
1120         {
1121                 .name = discard_const_p(char, "logon_script"),
1122                 .get  = py_samu_get_logon_script,
1123                 .set  = py_samu_set_logon_script,
1124         },
1125         {
1126                 .name = discard_const_p(char, "profile_path"),
1127                 .get  = py_samu_get_profile_path,
1128                 .set  = py_samu_set_profile_path,
1129         },
1130         {
1131                 .name = discard_const_p(char, "acct_desc"),
1132                 .get  = py_samu_get_acct_desc,
1133                 .set  = py_samu_set_acct_desc,
1134         },
1135         {
1136                 .name = discard_const_p(char, "workstations"),
1137                 .get  = py_samu_get_workstations,
1138                 .set  = py_samu_set_workstations,
1139         },
1140         {
1141                 .name = discard_const_p(char, "comment"),
1142                 .get  = py_samu_get_comment,
1143                 .set  = py_samu_set_comment,
1144         },
1145         {
1146                 .name = discard_const_p(char, "munged_dial"),
1147                 .get  = py_samu_get_munged_dial,
1148                 .set  = py_samu_set_munged_dial,
1149         },
1150         {
1151                 .name = discard_const_p(char, "user_sid"),
1152                 .get  = py_samu_get_user_sid,
1153                 .set  = py_samu_set_user_sid,
1154         },
1155         {
1156                 .name = discard_const_p(char, "group_sid"),
1157                 .get  = py_samu_get_group_sid,
1158                 .set  = py_samu_set_group_sid,
1159         },
1160         {
1161                 .name = discard_const_p(char, "lanman_passwd"),
1162                 .get  = py_samu_get_lanman_passwd,
1163                 .set  = py_samu_set_lanman_passwd,
1164         },
1165         {
1166                 .name = discard_const_p(char, "nt_passwd"),
1167                 .get  = py_samu_get_nt_passwd,
1168                 .set  = py_samu_set_nt_passwd,
1169         },
1170         {
1171                 .name = discard_const_p(char, "pw_history"),
1172                 .get  = py_samu_get_pw_history,
1173                 .set  = py_samu_set_pw_history,
1174         },
1175         {
1176                 .name = discard_const_p(char, "plaintext_passwd"),
1177                 .get  = py_samu_get_plaintext_passwd,
1178                 .set  = py_samu_set_plaintext_passwd,
1179         },
1180         {
1181                 .name = discard_const_p(char, "acct_ctrl"),
1182                 .get  = py_samu_get_acct_ctrl,
1183                 .set  = py_samu_set_acct_ctrl,
1184         },
1185         {
1186                 .name = discard_const_p(char, "logon_divs"),
1187                 .get  = py_samu_get_logon_divs,
1188                 .set  = py_samu_set_logon_divs,
1189         },
1190         {
1191                 .name = discard_const_p(char, "hours_len"),
1192                 .get  = py_samu_get_hours_len,
1193                 .set  = py_samu_set_hours_len,
1194         },
1195         {
1196                 .name = discard_const_p(char, "hours"),
1197                 .get  = py_samu_get_hours,
1198                 .set  = py_samu_set_hours,
1199         },
1200         {
1201                 .name = discard_const_p(char, "bad_password_count"),
1202                 .get  = py_samu_get_bad_password_count,
1203                 .set  = py_samu_set_bad_password_count,
1204         },
1205         {
1206                 .name = discard_const_p(char, "logon_count"),
1207                 .get  = py_samu_get_logon_count,
1208                 .set  = py_samu_set_logon_count,
1209         },
1210         {
1211                 .name = discard_const_p(char, "country_code"),
1212                 .get  = py_samu_get_country_code,
1213                 .set  = py_samu_set_country_code,
1214         },
1215         {
1216                 .name = discard_const_p(char, "code_page"),
1217                 .get  = py_samu_get_code_page,
1218                 .set  = py_samu_set_code_page,
1219         },
1220         {
1221                 .name = NULL,
1222         }
1223 };
1224
1225
1226 /************************** PIDL Autogeneratd ******************************/
1227
1228 static PyObject *py_samu_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1229 {
1230         TALLOC_CTX *frame = talloc_stackframe();
1231         struct samu *sam_acct;
1232
1233         sam_acct = samu_new(NULL);
1234         if (!sam_acct) {
1235                 PyErr_NoMemory();
1236                 talloc_free(frame);
1237                 return NULL;
1238         }
1239
1240         talloc_free(frame);
1241         return pytalloc_steal(type, sam_acct);
1242 }
1243
1244 static PyTypeObject PySamu = {
1245         .tp_name = "passdb.Samu",
1246         .tp_getset = py_samu_getsetters,
1247         .tp_methods = NULL,
1248         .tp_new = py_samu_new,
1249         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1250         .tp_doc = "Samu() -> samu object\n",
1251 };
1252
1253
1254 static PyObject *py_groupmap_get_gid(PyObject *obj, void *closure)
1255 {
1256         TALLOC_CTX *frame = talloc_stackframe();
1257         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1258         PyObject *py_gid;
1259
1260         py_gid = Py_BuildValue("i", group_map->gid);
1261         talloc_free(frame);
1262         return py_gid;
1263 }
1264
1265 static int py_groupmap_set_gid(PyObject *obj, PyObject *value, void *closure)
1266 {
1267         TALLOC_CTX *frame = talloc_stackframe();
1268         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1269
1270         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1271         group_map->gid = PyInt_AsLong(value);
1272         talloc_free(frame);
1273         return 0;
1274 }
1275
1276 static PyObject *py_groupmap_get_sid(PyObject *obj, void *closure)
1277 {
1278         TALLOC_CTX *frame = talloc_stackframe();
1279         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1280         PyObject *py_sid;
1281         struct dom_sid *group_sid;
1282         TALLOC_CTX *mem_ctx;
1283
1284         mem_ctx = talloc_new(NULL);
1285         if (mem_ctx == NULL) {
1286                 PyErr_NoMemory();
1287                 talloc_free(frame);
1288                 return NULL;
1289         }
1290
1291         group_sid = dom_sid_dup(mem_ctx, &group_map->sid);
1292         if (group_sid == NULL) {
1293                 PyErr_NoMemory();
1294                 talloc_free(mem_ctx);
1295                 talloc_free(frame);
1296                 return NULL;
1297         }
1298
1299         py_sid = pytalloc_steal(dom_sid_Type, group_sid);
1300
1301         talloc_free(mem_ctx);
1302
1303         talloc_free(frame);
1304         return py_sid;
1305 }
1306
1307 static int py_groupmap_set_sid(PyObject *obj, PyObject *value, void *closure)
1308 {
1309         TALLOC_CTX *frame = talloc_stackframe();
1310         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1311
1312         PY_CHECK_TYPE(dom_sid_Type, value, return -1;);
1313         group_map->sid = *pytalloc_get_type(value, struct dom_sid);
1314         talloc_free(frame);
1315         return 0;
1316 }
1317
1318 static PyObject *py_groupmap_get_sid_name_use(PyObject *obj, void *closure)
1319 {
1320         TALLOC_CTX *frame = talloc_stackframe();
1321         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1322         PyObject *py_sid_name_use;
1323
1324         py_sid_name_use = PyInt_FromLong(group_map->sid_name_use);
1325         talloc_free(frame);
1326         return py_sid_name_use;
1327 }
1328
1329 static int py_groupmap_set_sid_name_use(PyObject *obj, PyObject *value, void *closure)
1330 {
1331         TALLOC_CTX *frame = talloc_stackframe();
1332         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1333
1334         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1335         group_map->sid_name_use = PyInt_AsLong(value);
1336         talloc_free(frame);
1337         return 0;
1338 }
1339
1340 static PyObject *py_groupmap_get_nt_name(PyObject *obj, void *closure)
1341 {
1342         TALLOC_CTX *frame = talloc_stackframe();
1343         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1344         PyObject *py_nt_name;
1345         if (group_map->nt_name == NULL) {
1346                 py_nt_name = Py_None;
1347                 Py_INCREF(py_nt_name);
1348         } else {
1349                 py_nt_name = PyStr_FromString(group_map->nt_name);
1350         }
1351         talloc_free(frame);
1352         return py_nt_name;
1353 }
1354
1355 static int py_groupmap_set_nt_name(PyObject *obj, PyObject *value, void *closure)
1356 {
1357         TALLOC_CTX *frame = talloc_stackframe();
1358         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1359
1360         PY_CHECK_TYPE(&PyStr_Type, value, return -1;);
1361         if (value == Py_None) {
1362                 fstrcpy(group_map->nt_name, NULL);
1363         } else {
1364                 fstrcpy(group_map->nt_name, PyStr_AsString(value));
1365         }
1366         talloc_free(frame);
1367         return 0;
1368 }
1369
1370 static PyObject *py_groupmap_get_comment(PyObject *obj, void *closure)
1371 {
1372         TALLOC_CTX *frame = talloc_stackframe();
1373         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1374         PyObject *py_comment;
1375         if (group_map->comment == NULL) {
1376                 py_comment = Py_None;
1377                 Py_INCREF(py_comment);
1378         } else {
1379                 py_comment = PyStr_FromString(group_map->comment);
1380         }
1381         talloc_free(frame);
1382         return py_comment;
1383 }
1384
1385 static int py_groupmap_set_comment(PyObject *obj, PyObject *value, void *closure)
1386 {
1387         TALLOC_CTX *frame = talloc_stackframe();
1388         GROUP_MAP *group_map = (GROUP_MAP *)pytalloc_get_ptr(obj);
1389
1390         PY_CHECK_TYPE(&PyStr_Type, value, return -1;);
1391         if (value == Py_None) {
1392                 fstrcpy(group_map->comment, NULL);
1393         } else {
1394                 fstrcpy(group_map->comment, PyStr_AsString(value));
1395         }
1396         talloc_free(frame);
1397         return 0;
1398 }
1399
1400 static PyGetSetDef py_groupmap_getsetters[] = {
1401         {
1402                 .name = discard_const_p(char, "gid"),
1403                 .get  = py_groupmap_get_gid,
1404                 .set  = py_groupmap_set_gid,
1405         },
1406         {
1407                 .name = discard_const_p(char, "sid"),
1408                 .get  = py_groupmap_get_sid,
1409                 .set  = py_groupmap_set_sid,
1410         },
1411         {
1412                 .name = discard_const_p(char, "sid_name_use"),
1413                 .get  = py_groupmap_get_sid_name_use,
1414                 .set  = py_groupmap_set_sid_name_use,
1415         },
1416         {
1417                 .name = discard_const_p(char, "nt_name"),
1418                 .get  = py_groupmap_get_nt_name,
1419                 .set  = py_groupmap_set_nt_name,
1420         },
1421         {
1422                 .name = discard_const_p(char, "comment"),
1423                 .get  = py_groupmap_get_comment,
1424                 .set  = py_groupmap_set_comment,
1425         },
1426         {
1427                 .name = NULL,
1428         },
1429 };
1430
1431 static PyObject *py_groupmap_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1432 {
1433         TALLOC_CTX *frame = talloc_stackframe();
1434         GROUP_MAP *group_map;
1435         TALLOC_CTX *mem_ctx;
1436         PyObject *py_group_map;
1437
1438         mem_ctx = talloc_new(NULL);
1439         if (mem_ctx == NULL) {
1440                 PyErr_NoMemory();
1441                 talloc_free(frame);
1442                 return NULL;
1443         }
1444
1445         group_map = talloc_zero(mem_ctx, GROUP_MAP);
1446         if (group_map == NULL) {
1447                 PyErr_NoMemory();
1448                 talloc_free(mem_ctx);
1449                 talloc_free(frame);
1450                 return NULL;
1451         }
1452
1453         py_group_map = pytalloc_steal(type, group_map);
1454         if (py_group_map == NULL) {
1455                 PyErr_NoMemory();
1456                 talloc_free(mem_ctx);
1457                 talloc_free(frame);
1458                 return NULL;
1459         }
1460
1461         talloc_free(mem_ctx);
1462
1463         talloc_free(frame);
1464         return py_group_map;
1465 }
1466
1467
1468 static PyTypeObject PyGroupmap = {
1469         .tp_name = "passdb.Groupmap",
1470         .tp_getset = py_groupmap_getsetters,
1471         .tp_methods = NULL,
1472         .tp_new = py_groupmap_new,
1473         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1474         .tp_doc = "Groupmap() -> group map object\n",
1475 };
1476
1477
1478 static PyObject *py_pdb_domain_info(PyObject *self, PyObject *args)
1479 {
1480         TALLOC_CTX *frame = talloc_stackframe();
1481         struct pdb_methods *methods;
1482         struct pdb_domain_info *domain_info;
1483         PyObject *py_domain_info;
1484         struct dom_sid *sid;
1485         struct GUID *guid;
1486
1487         methods = pytalloc_get_ptr(self);
1488
1489         domain_info = methods->get_domain_info(methods, frame);
1490         if (! domain_info) {
1491                 Py_RETURN_NONE;
1492         }
1493
1494         sid = dom_sid_dup(frame, &domain_info->sid);
1495         if (sid == NULL) {
1496                 PyErr_NoMemory();
1497                 talloc_free(frame);
1498                 return NULL;
1499         }
1500
1501         guid = talloc(frame, struct GUID);
1502         if (guid == NULL) {
1503                 PyErr_NoMemory();
1504                 talloc_free(frame);
1505                 return NULL;
1506         }
1507         *guid = domain_info->guid;
1508
1509         if ((py_domain_info = PyDict_New()) == NULL) {
1510                 PyErr_NoMemory();
1511                 talloc_free(frame);
1512                 return NULL;
1513         }
1514
1515         PyDict_SetItemString(py_domain_info, "name", PyStr_FromString(domain_info->name));
1516         PyDict_SetItemString(py_domain_info, "dns_domain", PyStr_FromString(domain_info->dns_domain));
1517         PyDict_SetItemString(py_domain_info, "dns_forest", PyStr_FromString(domain_info->dns_forest));
1518         PyDict_SetItemString(py_domain_info, "dom_sid", pytalloc_steal(dom_sid_Type, sid));
1519         PyDict_SetItemString(py_domain_info, "guid", pytalloc_steal(guid_Type, guid));
1520
1521         talloc_free(frame);
1522         return py_domain_info;
1523 }
1524
1525
1526 static PyObject *py_pdb_getsampwnam(PyObject *self, PyObject *args)
1527 {
1528         TALLOC_CTX *frame = talloc_stackframe();
1529         NTSTATUS status;
1530         const char *username;
1531         struct pdb_methods *methods;
1532         struct samu *sam_acct;
1533         PyObject *py_sam_acct;
1534
1535         if (!PyArg_ParseTuple(args, "s:getsampwnam", &username)) {
1536                 talloc_free(frame);
1537                 return NULL;
1538         }
1539
1540         methods = pytalloc_get_ptr(self);
1541
1542         py_sam_acct = py_samu_new(&PySamu, NULL, NULL);
1543         if (py_sam_acct == NULL) {
1544                 PyErr_NoMemory();
1545                 talloc_free(frame);
1546                 return NULL;
1547         }
1548         sam_acct = (struct samu *)pytalloc_get_ptr(py_sam_acct);
1549
1550         status = methods->getsampwnam(methods, sam_acct, username);
1551         if (!NT_STATUS_IS_OK(status)) {
1552                 PyErr_Format(py_pdb_error, "Unable to get user information for '%s', (%d,%s)",
1553                                 username,
1554                                 NT_STATUS_V(status),
1555                                 get_friendly_nt_error_msg(status));
1556                 Py_DECREF(py_sam_acct);
1557                 talloc_free(frame);
1558                 return NULL;
1559         }
1560
1561         talloc_free(frame);
1562         return py_sam_acct;
1563 }
1564
1565 static PyObject *py_pdb_getsampwsid(PyObject *self, PyObject *args)
1566 {
1567         TALLOC_CTX *frame = talloc_stackframe();
1568         NTSTATUS status;
1569         struct pdb_methods *methods;
1570         struct samu *sam_acct;
1571         PyObject *py_sam_acct;
1572         PyObject *py_user_sid;
1573
1574         if (!PyArg_ParseTuple(args, "O:getsampwsid", &py_user_sid)) {
1575                 talloc_free(frame);
1576                 return NULL;
1577         }
1578
1579         methods = pytalloc_get_ptr(self);
1580
1581         py_sam_acct = py_samu_new(&PySamu, NULL, NULL);
1582         if (py_sam_acct == NULL) {
1583                 PyErr_NoMemory();
1584                 talloc_free(frame);
1585                 return NULL;
1586         }
1587         sam_acct = (struct samu *)pytalloc_get_ptr(py_sam_acct);
1588
1589         status = methods->getsampwsid(methods, sam_acct, pytalloc_get_ptr(py_user_sid));
1590         if (!NT_STATUS_IS_OK(status)) {
1591                 PyErr_Format(py_pdb_error, "Unable to get user information from SID, (%d,%s)",
1592                                 NT_STATUS_V(status),
1593                                 get_friendly_nt_error_msg(status));
1594                 Py_DECREF(py_sam_acct);
1595                 talloc_free(frame);
1596                 return NULL;
1597         }
1598
1599         talloc_free(frame);
1600         return py_sam_acct;
1601 }
1602
1603 static PyObject *py_pdb_create_user(PyObject *self, PyObject *args)
1604 {
1605         TALLOC_CTX *frame = talloc_stackframe();
1606         NTSTATUS status;
1607         struct pdb_methods *methods;
1608         const char *username;
1609         unsigned int acct_flags;
1610         unsigned int rid;
1611
1612         if (!PyArg_ParseTuple(args, "sI:create_user", &username, &acct_flags)) {
1613                 talloc_free(frame);
1614                 return NULL;
1615         }
1616
1617         methods = pytalloc_get_ptr(self);
1618
1619         status = methods->create_user(methods, frame, username, acct_flags, &rid);
1620         if (!NT_STATUS_IS_OK(status)) {
1621                 PyErr_Format(py_pdb_error, "Unable to create user (%s), (%d,%s)",
1622                                 username,
1623                                 NT_STATUS_V(status),
1624                                 get_friendly_nt_error_msg(status));
1625                 talloc_free(frame);
1626                 return NULL;
1627         }
1628
1629         talloc_free(frame);
1630         return PyInt_FromLong(rid);
1631 }
1632
1633 static PyObject *py_pdb_delete_user(PyObject *self, PyObject *args)
1634 {
1635         TALLOC_CTX *frame = talloc_stackframe();
1636         NTSTATUS status;
1637         struct pdb_methods *methods;
1638         struct samu *sam_acct;
1639         PyObject *py_sam_acct;
1640
1641         if (!PyArg_ParseTuple(args, "O!:delete_user", &PySamu, &py_sam_acct)) {
1642                 talloc_free(frame);
1643                 return NULL;
1644         }
1645
1646         methods = pytalloc_get_ptr(self);
1647
1648         sam_acct = pytalloc_get_ptr(py_sam_acct);
1649
1650         status = methods->delete_user(methods, frame, sam_acct);
1651         if (!NT_STATUS_IS_OK(status)) {
1652                 PyErr_Format(py_pdb_error, "Unable to delete user, (%d,%s)",
1653                                 NT_STATUS_V(status),
1654                                 get_friendly_nt_error_msg(status));
1655                 talloc_free(frame);
1656                 return NULL;
1657         }
1658
1659         talloc_free(frame);
1660         Py_RETURN_NONE;
1661 }
1662
1663 static PyObject *py_pdb_add_sam_account(PyObject *self, PyObject *args)
1664 {
1665         TALLOC_CTX *frame = talloc_stackframe();
1666         NTSTATUS status;
1667         struct pdb_methods *methods;
1668         struct samu *sam_acct;
1669         PyObject *py_sam_acct;
1670
1671         if (!PyArg_ParseTuple(args, "O!:add_sam_account", &PySamu, &py_sam_acct)) {
1672                 talloc_free(frame);
1673                 return NULL;
1674         }
1675
1676         methods = pytalloc_get_ptr(self);
1677
1678         sam_acct = pytalloc_get_ptr(py_sam_acct);
1679
1680         status = methods->add_sam_account(methods, sam_acct);
1681         if (!NT_STATUS_IS_OK(status)) {
1682                 PyErr_Format(py_pdb_error, "Unable to add sam account '%s', (%d,%s)",
1683                                 sam_acct->username,
1684                                 NT_STATUS_V(status),
1685                                 get_friendly_nt_error_msg(status));
1686                 talloc_free(frame);
1687                 return NULL;
1688         }
1689
1690         talloc_free(frame);
1691         Py_RETURN_NONE;
1692 }
1693
1694 static PyObject *py_pdb_update_sam_account(PyObject *self, PyObject *args)
1695 {
1696         TALLOC_CTX *frame = talloc_stackframe();
1697         NTSTATUS status;
1698         struct pdb_methods *methods;
1699         struct samu *sam_acct;
1700         PyObject *py_sam_acct;
1701
1702         if (!PyArg_ParseTuple(args, "O!:update_sam_account", &PySamu, &py_sam_acct)) {
1703                 talloc_free(frame);
1704                 return NULL;
1705         }
1706
1707         methods = pytalloc_get_ptr(self);
1708
1709         sam_acct = pytalloc_get_ptr(py_sam_acct);
1710
1711         status = methods->update_sam_account(methods, sam_acct);
1712         if (!NT_STATUS_IS_OK(status)) {
1713                 PyErr_Format(py_pdb_error, "Unable to update sam account, (%d,%s)",
1714                                 NT_STATUS_V(status),
1715                                 get_friendly_nt_error_msg(status));
1716                 talloc_free(frame);
1717                 return NULL;
1718         }
1719
1720         talloc_free(frame);
1721         Py_RETURN_NONE;
1722 }
1723
1724 static PyObject *py_pdb_delete_sam_account(PyObject *self, PyObject *args)
1725 {
1726         TALLOC_CTX *frame = talloc_stackframe();
1727         NTSTATUS status;
1728         struct pdb_methods *methods;
1729         struct samu *sam_acct;
1730         PyObject *py_sam_acct;
1731
1732         if (!PyArg_ParseTuple(args, "O!:delete_sam_account", &PySamu, &py_sam_acct)) {
1733                 talloc_free(frame);
1734                 return NULL;
1735         }
1736
1737         methods = pytalloc_get_ptr(self);
1738
1739         sam_acct = pytalloc_get_ptr(py_sam_acct);
1740
1741         status = methods->delete_sam_account(methods, sam_acct);
1742         if (!NT_STATUS_IS_OK(status)) {
1743                 PyErr_Format(py_pdb_error, "Unable to delete sam account, (%d,%s)",
1744                                 NT_STATUS_V(status),
1745                                 get_friendly_nt_error_msg(status));
1746                 talloc_free(frame);
1747                 return NULL;
1748         }
1749
1750         talloc_free(frame);
1751         Py_RETURN_NONE;
1752 }
1753
1754 static PyObject *py_pdb_rename_sam_account(PyObject *self, PyObject *args)
1755 {
1756         TALLOC_CTX *frame = talloc_stackframe();
1757         NTSTATUS status;
1758         struct pdb_methods *methods;
1759         struct samu *sam_acct;
1760         const char *new_username;
1761         PyObject *py_sam_acct;
1762
1763         if (!PyArg_ParseTuple(args, "O!s:rename_sam_account", &PySamu, &py_sam_acct,
1764                                         &new_username)) {
1765                 talloc_free(frame);
1766                 return NULL;
1767         }
1768
1769         methods = pytalloc_get_ptr(self);
1770
1771         sam_acct = pytalloc_get_ptr(py_sam_acct);
1772
1773         status = methods->rename_sam_account(methods, sam_acct, new_username);
1774         if (!NT_STATUS_IS_OK(status)) {
1775                 PyErr_Format(py_pdb_error, "Unable to rename sam account, (%d,%s)",
1776                                 NT_STATUS_V(status),
1777                                 get_friendly_nt_error_msg(status));
1778                 talloc_free(frame);
1779                 return NULL;
1780         }
1781
1782         talloc_free(frame);
1783         Py_RETURN_NONE;
1784 }
1785
1786
1787 static PyObject *py_pdb_getgrsid(PyObject *self, PyObject *args)
1788 {
1789         TALLOC_CTX *frame = talloc_stackframe();
1790         NTSTATUS status;
1791         struct pdb_methods *methods;
1792         GROUP_MAP *group_map;
1793         struct dom_sid *domain_sid;
1794         PyObject *py_domain_sid, *py_group_map;
1795
1796         if (!PyArg_ParseTuple(args, "O!:getgrsid", dom_sid_Type, &py_domain_sid)) {
1797                 talloc_free(frame);
1798                 return NULL;
1799         }
1800
1801         methods = pytalloc_get_ptr(self);
1802
1803         domain_sid = pytalloc_get_ptr(py_domain_sid);
1804
1805         py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1806         if (py_group_map == NULL) {
1807                 PyErr_NoMemory();
1808                 talloc_free(frame);
1809                 return NULL;
1810         }
1811
1812         group_map = pytalloc_get_ptr(py_group_map);
1813
1814         status = methods->getgrsid(methods, group_map, *domain_sid);
1815         if (!NT_STATUS_IS_OK(status)) {
1816                 PyErr_Format(py_pdb_error, "Unable to get group information by sid, (%d,%s)",
1817                                 NT_STATUS_V(status),
1818                                 get_friendly_nt_error_msg(status));
1819                 talloc_free(frame);
1820                 return NULL;
1821         }
1822
1823         talloc_free(frame);
1824         return py_group_map;
1825 }
1826
1827
1828 static PyObject *py_pdb_getgrgid(PyObject *self, PyObject *args)
1829 {
1830         TALLOC_CTX *frame = talloc_stackframe();
1831         NTSTATUS status;
1832         struct pdb_methods *methods;
1833         GROUP_MAP *group_map;
1834         PyObject *py_group_map;
1835         unsigned int gid_value;
1836
1837         if (!PyArg_ParseTuple(args, "I:getgrgid", &gid_value)) {
1838                 talloc_free(frame);
1839                 return NULL;
1840         }
1841
1842         methods = pytalloc_get_ptr(self);
1843
1844         py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1845         if (py_group_map == NULL) {
1846                 PyErr_NoMemory();
1847                 talloc_free(frame);
1848                 return NULL;
1849         }
1850
1851         group_map = pytalloc_get_ptr(py_group_map);
1852
1853         status = methods->getgrgid(methods, group_map, gid_value);
1854         if (!NT_STATUS_IS_OK(status)) {
1855                 PyErr_Format(py_pdb_error, "Unable to get group information by gid, (%d,%s)",
1856                                 NT_STATUS_V(status),
1857                                 get_friendly_nt_error_msg(status));
1858                 talloc_free(frame);
1859                 return NULL;
1860         }
1861
1862         talloc_free(frame);
1863         return py_group_map;
1864 }
1865
1866
1867 static PyObject *py_pdb_getgrnam(PyObject *self, PyObject *args)
1868 {
1869         TALLOC_CTX *frame = talloc_stackframe();
1870         NTSTATUS status;
1871         struct pdb_methods *methods;
1872         GROUP_MAP *group_map;
1873         PyObject *py_group_map;
1874         const char *groupname;
1875
1876         if (!PyArg_ParseTuple(args, "s:getgrnam", &groupname)) {
1877                 talloc_free(frame);
1878                 return NULL;
1879         }
1880
1881         methods = pytalloc_get_ptr(self);
1882
1883         py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
1884         if (py_group_map == NULL) {
1885                 PyErr_NoMemory();
1886                 talloc_free(frame);
1887                 return NULL;
1888         }
1889
1890         group_map = pytalloc_get_ptr(py_group_map);
1891
1892         status = methods->getgrnam(methods, group_map, groupname);
1893         if (!NT_STATUS_IS_OK(status)) {
1894                 PyErr_Format(py_pdb_error, "Unable to get group information by name, (%d,%s)",
1895                                 NT_STATUS_V(status),
1896                                 get_friendly_nt_error_msg(status));
1897                 talloc_free(frame);
1898                 return NULL;
1899         }
1900
1901         talloc_free(frame);
1902         return py_group_map;
1903 }
1904
1905
1906 static PyObject *py_pdb_create_dom_group(PyObject *self, PyObject *args)
1907 {
1908         TALLOC_CTX *frame = talloc_stackframe();
1909         NTSTATUS status;
1910         struct pdb_methods *methods;
1911         const char *groupname;
1912         uint32_t group_rid;
1913
1914         if (!PyArg_ParseTuple(args, "s:create_dom_group", &groupname)) {
1915                 talloc_free(frame);
1916                 return NULL;
1917         }
1918
1919         methods = pytalloc_get_ptr(self);
1920
1921         status = methods->create_dom_group(methods, frame, groupname, &group_rid);
1922         if (!NT_STATUS_IS_OK(status)) {
1923                 PyErr_Format(py_pdb_error, "Unable to create domain group (%s), (%d,%s)",
1924                                 groupname,
1925                                 NT_STATUS_V(status),
1926                                 get_friendly_nt_error_msg(status));
1927                 talloc_free(frame);
1928                 return NULL;
1929         }
1930
1931         talloc_free(frame);
1932         return PyInt_FromLong(group_rid);
1933 }
1934
1935
1936 static PyObject *py_pdb_delete_dom_group(PyObject *self, PyObject *args)
1937 {
1938         TALLOC_CTX *frame = talloc_stackframe();
1939         NTSTATUS status;
1940         struct pdb_methods *methods;
1941         unsigned int group_rid;
1942
1943         if (!PyArg_ParseTuple(args, "I:delete_dom_group", &group_rid)) {
1944                 talloc_free(frame);
1945                 return NULL;
1946         }
1947
1948         methods = pytalloc_get_ptr(self);
1949
1950         status = methods->delete_dom_group(methods, frame, group_rid);
1951         if (!NT_STATUS_IS_OK(status)) {
1952                 PyErr_Format(py_pdb_error, "Unable to delete domain group (rid=%d), (%d,%s)",
1953                                 group_rid,
1954                                 NT_STATUS_V(status),
1955                                 get_friendly_nt_error_msg(status));
1956                 talloc_free(frame);
1957                 return NULL;
1958         }
1959
1960         talloc_free(frame);
1961         Py_RETURN_NONE;
1962 }
1963
1964
1965 static PyObject *py_pdb_add_group_mapping_entry(PyObject *self, PyObject *args)
1966 {
1967         TALLOC_CTX *frame = talloc_stackframe();
1968         NTSTATUS status;
1969         struct pdb_methods *methods;
1970         PyObject *py_group_map;
1971         GROUP_MAP *group_map;
1972
1973         if (!PyArg_ParseTuple(args, "O!:add_group_mapping_entry", &PyGroupmap, &py_group_map)) {
1974                 talloc_free(frame);
1975                 return NULL;
1976         }
1977
1978         methods = pytalloc_get_ptr(self);
1979
1980         group_map = pytalloc_get_ptr(py_group_map);
1981
1982         status = methods->add_group_mapping_entry(methods, group_map);
1983         if (!NT_STATUS_IS_OK(status)) {
1984                 PyErr_Format(py_pdb_error, "Unable to add group mapping entry, (%d,%s)",
1985                                 NT_STATUS_V(status),
1986                                 get_friendly_nt_error_msg(status));
1987                 talloc_free(frame);
1988                 return NULL;
1989         }
1990
1991         talloc_free(frame);
1992         Py_RETURN_NONE;
1993 }
1994
1995
1996 static PyObject *py_pdb_update_group_mapping_entry(PyObject *self, PyObject *args)
1997 {
1998         TALLOC_CTX *frame = talloc_stackframe();
1999         NTSTATUS status;
2000         struct pdb_methods *methods;
2001         PyObject *py_group_map;
2002         GROUP_MAP *group_map;
2003
2004         if (!PyArg_ParseTuple(args, "O!:update_group_mapping_entry", &PyGroupmap, &py_group_map)) {
2005                 talloc_free(frame);
2006                 return NULL;
2007         }
2008
2009         methods = pytalloc_get_ptr(self);
2010
2011         group_map = pytalloc_get_ptr(py_group_map);
2012
2013         status = methods->update_group_mapping_entry(methods, group_map);
2014         if (!NT_STATUS_IS_OK(status)) {
2015                 PyErr_Format(py_pdb_error, "Unable to update group mapping entry, (%d,%s)",
2016                                 NT_STATUS_V(status),
2017                                 get_friendly_nt_error_msg(status));
2018                 talloc_free(frame);
2019                 return NULL;
2020         }
2021
2022         talloc_free(frame);
2023         Py_RETURN_NONE;
2024 }
2025
2026
2027 static PyObject *py_pdb_delete_group_mapping_entry(PyObject *self, PyObject *args)
2028 {
2029         TALLOC_CTX *frame = talloc_stackframe();
2030         NTSTATUS status;
2031         struct pdb_methods *methods;
2032         PyObject *py_group_sid;
2033         struct dom_sid *group_sid;
2034
2035         if (!PyArg_ParseTuple(args, "O!:delete_group_mapping_entry", dom_sid_Type, &py_group_sid)) {
2036                 talloc_free(frame);
2037                 return NULL;
2038         }
2039
2040         methods = pytalloc_get_ptr(self);
2041
2042         group_sid = pytalloc_get_ptr(py_group_sid);
2043
2044         status = methods->delete_group_mapping_entry(methods, *group_sid);
2045         if (!NT_STATUS_IS_OK(status)) {
2046                 PyErr_Format(py_pdb_error, "Unable to delete group mapping entry, (%d,%s)",
2047                                 NT_STATUS_V(status),
2048                                 get_friendly_nt_error_msg(status));
2049                 talloc_free(frame);
2050                 return NULL;
2051         }
2052
2053         talloc_free(frame);
2054         Py_RETURN_NONE;
2055 }
2056
2057
2058 static PyObject *py_pdb_enum_group_mapping(PyObject *self, PyObject *args)
2059 {
2060         TALLOC_CTX *frame = talloc_stackframe();
2061         NTSTATUS status;
2062         struct pdb_methods *methods;
2063         enum lsa_SidType sid_name_use;
2064         int lsa_sidtype_value = SID_NAME_UNKNOWN;
2065         int unix_only = 0;
2066         PyObject *py_domain_sid = Py_None;
2067         struct dom_sid *domain_sid = NULL;
2068         GROUP_MAP **gmap = NULL;
2069         GROUP_MAP *group_map;
2070         size_t num_entries;
2071         PyObject *py_gmap_list, *py_group_map;
2072         int i;
2073
2074         Py_INCREF(Py_None);
2075
2076         if (!PyArg_ParseTuple(args, "|O!ii:enum_group_mapping", dom_sid_Type, &py_domain_sid,
2077                                         &lsa_sidtype_value, &unix_only)) {
2078                 talloc_free(frame);
2079                 return NULL;
2080         }
2081
2082         methods = pytalloc_get_ptr(self);
2083
2084         sid_name_use = lsa_sidtype_value;
2085
2086         if (py_domain_sid != Py_None) {
2087                 domain_sid = pytalloc_get_ptr(py_domain_sid);
2088         }
2089
2090         status = methods->enum_group_mapping(methods, domain_sid, sid_name_use,
2091                                                 &gmap, &num_entries, unix_only);
2092         if (!NT_STATUS_IS_OK(status)) {
2093                 PyErr_Format(py_pdb_error, "Unable to enumerate group mappings, (%d,%s)",
2094                                 NT_STATUS_V(status),
2095                                 get_friendly_nt_error_msg(status));
2096                 talloc_free(frame);
2097                 return NULL;
2098         }
2099
2100         py_gmap_list = PyList_New(0);
2101         if (py_gmap_list == NULL) {
2102                 PyErr_NoMemory();
2103                 talloc_free(frame);
2104                 return NULL;
2105         }
2106
2107         for(i=0; i<num_entries; i++) {
2108                 py_group_map = py_groupmap_new(&PyGroupmap, NULL, NULL);
2109                 if (py_group_map) {
2110                         group_map = pytalloc_get_ptr(py_group_map);
2111                         *group_map = *gmap[i];
2112                         talloc_steal(group_map, gmap[i]->nt_name);
2113                         talloc_steal(group_map, gmap[i]->comment);
2114
2115                         PyList_Append(py_gmap_list, py_group_map);
2116                 }
2117         }
2118
2119         talloc_free(gmap);
2120
2121         talloc_free(frame);
2122         return py_gmap_list;
2123 }
2124
2125
2126 static PyObject *py_pdb_enum_group_members(PyObject *self, PyObject *args)
2127 {
2128         TALLOC_CTX *frame = talloc_stackframe();
2129         NTSTATUS status;
2130         struct pdb_methods *methods;
2131         PyObject *py_group_sid;
2132         struct dom_sid *group_sid;
2133         uint32_t *member_rids;
2134         size_t num_members;
2135         PyObject *py_sid_list;
2136         struct dom_sid *domain_sid, *member_sid;
2137         int i;
2138
2139         if (!PyArg_ParseTuple(args, "O!:enum_group_members", dom_sid_Type, &py_group_sid)) {
2140                 talloc_free(frame);
2141                 return NULL;
2142         }
2143
2144         methods = pytalloc_get_ptr(self);
2145
2146         group_sid = pytalloc_get_ptr(py_group_sid);
2147
2148         status = methods->enum_group_members(methods, frame, group_sid,
2149                                                 &member_rids, &num_members);
2150         if (!NT_STATUS_IS_OK(status)) {
2151                 PyErr_Format(py_pdb_error, "Unable to enumerate group members, (%d,%s)",
2152                                 NT_STATUS_V(status),
2153                                 get_friendly_nt_error_msg(status));
2154                 talloc_free(frame);
2155                 return NULL;
2156         }
2157
2158         py_sid_list = PyList_New(0);
2159         if (py_sid_list == NULL) {
2160                 PyErr_NoMemory();
2161                 talloc_free(frame);
2162                 return NULL;
2163         }
2164
2165         domain_sid = get_global_sam_sid();
2166
2167         for(i=0; i<num_members; i++) {
2168                 member_sid = dom_sid_add_rid(frame, domain_sid, member_rids[i]);
2169                 PyList_Append(py_sid_list, pytalloc_steal(dom_sid_Type, member_sid));
2170         }
2171
2172         talloc_free(frame);
2173         return py_sid_list;
2174 }
2175
2176
2177 static PyObject *py_pdb_enum_group_memberships(PyObject *self, PyObject *args)
2178 {
2179         TALLOC_CTX *frame = talloc_stackframe();
2180         NTSTATUS status;
2181         struct pdb_methods *methods;
2182         int i;
2183
2184         struct samu *sam_acct;
2185         PyObject *py_sam_acct;
2186         PyObject *py_sid_list;
2187         struct dom_sid *user_group_sids = NULL;
2188         gid_t *user_group_ids = NULL;
2189         uint32_t num_groups = 0;
2190
2191         if (!PyArg_ParseTuple(args, "O!:enum_group_memberships", &PySamu, &py_sam_acct)) {
2192                 talloc_free(frame);
2193                 return NULL;
2194         }
2195
2196         methods = pytalloc_get_ptr(self);
2197
2198         sam_acct = pytalloc_get_ptr(py_sam_acct);
2199
2200         status = methods->enum_group_memberships(methods, frame, sam_acct,
2201                                                  &user_group_sids, &user_group_ids, &num_groups);
2202         if (!NT_STATUS_IS_OK(status)) {
2203                 PyErr_Format(py_pdb_error, "Unable to enumerate group memberships, (%d,%s)",
2204                                 NT_STATUS_V(status),
2205                                 get_friendly_nt_error_msg(status));
2206                 talloc_free(frame);
2207                 return NULL;
2208         }
2209
2210         py_sid_list = PyList_New(0);
2211         if (py_sid_list == NULL) {
2212                 PyErr_NoMemory();
2213                 talloc_free(frame);
2214                 return NULL;
2215         }
2216
2217         for(i=0; i<num_groups; i++) {
2218                 PyList_Append(py_sid_list, pytalloc_steal(dom_sid_Type, dom_sid_dup(NULL, &user_group_sids[i])));
2219         }
2220
2221         talloc_free(frame);
2222         return py_sid_list;
2223 }
2224
2225
2226 static PyObject *py_pdb_add_groupmem(PyObject *self, PyObject *args)
2227 {
2228         TALLOC_CTX *frame = talloc_stackframe();
2229         NTSTATUS status;
2230         struct pdb_methods *methods;
2231         uint32_t group_rid, member_rid;
2232
2233         if (!PyArg_ParseTuple(args, "II:add_groupmem", &group_rid, &member_rid)) {
2234                 talloc_free(frame);
2235                 return NULL;
2236         }
2237
2238         methods = pytalloc_get_ptr(self);
2239
2240         status = methods->add_groupmem(methods, frame, group_rid, member_rid);
2241         if (!NT_STATUS_IS_OK(status)) {
2242                 PyErr_Format(py_pdb_error, "Unable to add group member, (%d,%s)",
2243                                 NT_STATUS_V(status),
2244                                 get_friendly_nt_error_msg(status));
2245                 talloc_free(frame);
2246                 return NULL;
2247         }
2248
2249         talloc_free(frame);
2250         Py_RETURN_NONE;
2251 }
2252
2253
2254 static PyObject *py_pdb_del_groupmem(PyObject *self, PyObject *args)
2255 {
2256         TALLOC_CTX *frame = talloc_stackframe();
2257         NTSTATUS status;
2258         struct pdb_methods *methods;
2259         uint32_t group_rid, member_rid;
2260
2261         if (!PyArg_ParseTuple(args, "II:del_groupmem", &group_rid, &member_rid)) {
2262                 talloc_free(frame);
2263                 return NULL;
2264         }
2265
2266         methods = pytalloc_get_ptr(self);
2267
2268         status = methods->del_groupmem(methods, frame, group_rid, member_rid);
2269         if (!NT_STATUS_IS_OK(status)) {
2270                 PyErr_Format(py_pdb_error, "Unable to rename sam account, (%d,%s)",
2271                                 NT_STATUS_V(status),
2272                                 get_friendly_nt_error_msg(status));
2273                 talloc_free(frame);
2274                 return NULL;
2275         }
2276
2277         talloc_free(frame);
2278         Py_RETURN_NONE;
2279 }
2280
2281
2282 static PyObject *py_pdb_create_alias(PyObject *self, PyObject *args)
2283 {
2284         TALLOC_CTX *frame = talloc_stackframe();
2285         NTSTATUS status;
2286         struct pdb_methods *methods;
2287         const char *alias_name;
2288         uint32_t rid;
2289
2290         if (!PyArg_ParseTuple(args, "s:create_alias", &alias_name)) {
2291                 talloc_free(frame);
2292                 return NULL;
2293         }
2294
2295         methods = pytalloc_get_ptr(self);
2296
2297         status = methods->create_alias(methods, alias_name, &rid);
2298         if (!NT_STATUS_IS_OK(status)) {
2299                 PyErr_Format(py_pdb_error, "Unable to create alias (%s), (%d,%s)",
2300                                 alias_name,
2301                                 NT_STATUS_V(status),
2302                                 get_friendly_nt_error_msg(status));
2303                 talloc_free(frame);
2304                 return NULL;
2305         }
2306
2307         talloc_free(frame);
2308         return PyInt_FromLong(rid);
2309 }
2310
2311
2312 static PyObject *py_pdb_delete_alias(PyObject *self, PyObject *args)
2313 {
2314         TALLOC_CTX *frame = talloc_stackframe();
2315         NTSTATUS status;
2316         struct pdb_methods *methods;
2317         PyObject *py_alias_sid;
2318         struct dom_sid *alias_sid;
2319
2320         if (!PyArg_ParseTuple(args, "O!:delete_alias", dom_sid_Type, &py_alias_sid)) {
2321                 talloc_free(frame);
2322                 return NULL;
2323         }
2324
2325         methods = pytalloc_get_ptr(self);
2326
2327         alias_sid = pytalloc_get_ptr(py_alias_sid);
2328
2329         status = methods->delete_alias(methods, alias_sid);
2330         if (!NT_STATUS_IS_OK(status)) {
2331                 PyErr_Format(py_pdb_error, "Unable to delete alias, (%d,%s)",
2332                                 NT_STATUS_V(status),
2333                                 get_friendly_nt_error_msg(status));
2334                 talloc_free(frame);
2335                 return NULL;
2336         }
2337
2338         talloc_free(frame);
2339         Py_RETURN_NONE;
2340 }
2341
2342
2343 static PyObject *py_pdb_get_aliasinfo(PyObject *self, PyObject *args)
2344 {
2345         TALLOC_CTX *frame = talloc_stackframe();
2346         NTSTATUS status;
2347         struct pdb_methods *methods;
2348         PyObject *py_alias_sid;
2349         struct dom_sid *alias_sid;
2350         struct acct_info *alias_info;
2351         PyObject *py_alias_info;
2352
2353         if (!PyArg_ParseTuple(args, "O!:get_aliasinfo", dom_sid_Type, &py_alias_sid)) {
2354                 talloc_free(frame);
2355                 return NULL;
2356         }
2357
2358         methods = pytalloc_get_ptr(self);
2359
2360         alias_sid = pytalloc_get_ptr(py_alias_sid);
2361
2362         alias_info = talloc_zero(frame, struct acct_info);
2363         if (!alias_info) {
2364                 PyErr_NoMemory();
2365                 talloc_free(frame);
2366                 return NULL;
2367         }
2368
2369         status = methods->get_aliasinfo(methods, alias_sid, alias_info);
2370         if (!NT_STATUS_IS_OK(status)) {
2371                 PyErr_Format(py_pdb_error, "Unable to get alias information, (%d,%s)",
2372                                 NT_STATUS_V(status),
2373                                 get_friendly_nt_error_msg(status));
2374                 talloc_free(frame);
2375                 return NULL;
2376         }
2377
2378         py_alias_info = PyDict_New();
2379         if (py_alias_info == NULL) {
2380                 PyErr_NoMemory();
2381                 talloc_free(frame);
2382                 return NULL;
2383         }
2384
2385         PyDict_SetItemString(py_alias_info, "acct_name",
2386                              PyStr_FromString(alias_info->acct_name));
2387         PyDict_SetItemString(py_alias_info, "acct_desc",
2388                              PyStr_FromString(alias_info->acct_desc));
2389         PyDict_SetItemString(py_alias_info, "rid",
2390                              PyInt_FromLong(alias_info->rid));
2391
2392         talloc_free(frame);
2393         return py_alias_info;
2394 }
2395
2396
2397 static PyObject *py_pdb_set_aliasinfo(PyObject *self, PyObject *args)
2398 {
2399         TALLOC_CTX *frame = talloc_stackframe();
2400         NTSTATUS status;
2401         struct pdb_methods *methods;
2402         PyObject *py_alias_sid, *py_alias_info;
2403         struct dom_sid *alias_sid;
2404         struct acct_info alias_info;
2405
2406         if (!PyArg_ParseTuple(args, "O!O:set_alias_info", dom_sid_Type, &py_alias_sid,
2407                                 &py_alias_info)) {
2408                 talloc_free(frame);
2409                 return NULL;
2410         }
2411
2412         methods = pytalloc_get_ptr(self);
2413
2414         alias_sid = pytalloc_get_ptr(py_alias_sid);
2415
2416         alias_info.acct_name = talloc_strdup(frame, PyStr_AsString(PyDict_GetItemString(py_alias_info, "acct_name")));
2417         if (alias_info.acct_name == NULL) {
2418                 PyErr_Format(py_pdb_error, "Unable to allocate memory");
2419                 talloc_free(frame);
2420                 return NULL;
2421         }
2422         alias_info.acct_desc = talloc_strdup(frame, PyStr_AsString(PyDict_GetItemString(py_alias_info, "acct_desc")));
2423         if (alias_info.acct_desc == NULL) {
2424                 PyErr_Format(py_pdb_error, "Unable to allocate memory");
2425                 talloc_free(frame);
2426                 return NULL;
2427         }
2428
2429         status = methods->set_aliasinfo(methods, alias_sid, &alias_info);
2430         if (!NT_STATUS_IS_OK(status)) {
2431                 PyErr_Format(py_pdb_error, "Unable to set alias information, (%d,%s)",
2432                                 NT_STATUS_V(status),
2433                                 get_friendly_nt_error_msg(status));
2434                 talloc_free(frame);
2435                 return NULL;
2436         }
2437
2438         talloc_free(frame);
2439         Py_RETURN_NONE;
2440 }
2441
2442
2443 static PyObject *py_pdb_add_aliasmem(PyObject *self, PyObject *args)
2444 {
2445         TALLOC_CTX *frame = talloc_stackframe();
2446         NTSTATUS status;
2447         struct pdb_methods *methods;
2448         PyObject *py_alias_sid, *py_member_sid;
2449         struct dom_sid *alias_sid, *member_sid;
2450
2451         if (!PyArg_ParseTuple(args, "O!O!:add_aliasmem", dom_sid_Type, &py_alias_sid,
2452                                         dom_sid_Type, &py_member_sid)) {
2453                 talloc_free(frame);
2454                 return NULL;
2455         }
2456
2457         methods = pytalloc_get_ptr(self);
2458
2459         alias_sid = pytalloc_get_ptr(py_alias_sid);
2460         member_sid = pytalloc_get_ptr(py_member_sid);
2461
2462         status = methods->add_aliasmem(methods, alias_sid, member_sid);
2463         if (!NT_STATUS_IS_OK(status)) {
2464                 PyErr_Format(py_pdb_error, "Unable to add member to alias, (%d,%s)",
2465                                 NT_STATUS_V(status),
2466                                 get_friendly_nt_error_msg(status));
2467                 talloc_free(frame);
2468                 return NULL;
2469         }
2470
2471         talloc_free(frame);
2472         Py_RETURN_NONE;
2473 }
2474
2475
2476 static PyObject *py_pdb_del_aliasmem(PyObject *self, PyObject *args)
2477 {
2478         TALLOC_CTX *frame = talloc_stackframe();
2479         NTSTATUS status;
2480         struct pdb_methods *methods;
2481         PyObject *py_alias_sid, *py_member_sid;
2482         const struct dom_sid *alias_sid, *member_sid;
2483
2484         if (!PyArg_ParseTuple(args, "O!O!:del_aliasmem", dom_sid_Type, &py_alias_sid,
2485                                         dom_sid_Type, &py_member_sid)) {
2486                 talloc_free(frame);
2487                 return NULL;
2488         }
2489
2490         methods = pytalloc_get_ptr(self);
2491
2492         alias_sid = pytalloc_get_ptr(py_alias_sid);
2493         member_sid = pytalloc_get_ptr(py_member_sid);
2494
2495         status = methods->del_aliasmem(methods, alias_sid, member_sid);
2496         if (!NT_STATUS_IS_OK(status)) {
2497                 PyErr_Format(py_pdb_error, "Unable to delete member from alias, (%d,%s)",
2498                                 NT_STATUS_V(status),
2499                                 get_friendly_nt_error_msg(status));
2500                 talloc_free(frame);
2501                 return NULL;
2502         }
2503
2504         talloc_free(frame);
2505         Py_RETURN_NONE;
2506 }
2507
2508
2509 static PyObject *py_pdb_enum_aliasmem(PyObject *self, PyObject *args)
2510 {
2511         TALLOC_CTX *frame = talloc_stackframe();
2512         NTSTATUS status;
2513         struct pdb_methods *methods;
2514         PyObject *py_alias_sid;
2515         struct dom_sid *alias_sid, *member_sid, *tmp_sid;
2516         PyObject *py_member_list, *py_member_sid;
2517         size_t num_members;
2518         int i;
2519
2520         if (!PyArg_ParseTuple(args, "O!:enum_aliasmem", dom_sid_Type, &py_alias_sid)) {
2521                 talloc_free(frame);
2522                 return NULL;
2523         }
2524
2525         methods = pytalloc_get_ptr(self);
2526
2527         alias_sid = pytalloc_get_ptr(py_alias_sid);
2528
2529         status = methods->enum_aliasmem(methods, alias_sid, frame, &member_sid, &num_members);
2530         if (!NT_STATUS_IS_OK(status)) {
2531                 PyErr_Format(py_pdb_error, "Unable to enumerate members for alias, (%d,%s)",
2532                                 NT_STATUS_V(status),
2533                                 get_friendly_nt_error_msg(status));
2534                 talloc_free(frame);
2535                 return NULL;
2536         }
2537
2538         py_member_list = PyList_New(0);
2539         if (py_member_list == NULL) {
2540                 PyErr_NoMemory();
2541                 talloc_free(frame);
2542                 return NULL;
2543         }
2544
2545         for(i=0; i<num_members; i++) {
2546                 py_member_sid = pytalloc_new(struct dom_sid, dom_sid_Type);
2547                 if (py_member_sid == NULL) {
2548                         PyErr_NoMemory();
2549                         talloc_free(frame);
2550                         return NULL;
2551                 }
2552                 tmp_sid = pytalloc_get_ptr(py_member_sid);
2553                 *tmp_sid = member_sid[i];
2554                 PyList_Append(py_member_list, py_member_sid);
2555         }
2556
2557         talloc_free(frame);
2558         return py_member_list;
2559 }
2560
2561
2562 static PyObject *py_pdb_get_account_policy(PyObject *self, PyObject *unused)
2563 {
2564         TALLOC_CTX *frame = talloc_stackframe();
2565         NTSTATUS status;
2566         struct pdb_methods *methods;
2567         PyObject *py_acct_policy;
2568         uint32_t value;
2569         const char **names;
2570         int count, i;
2571         enum pdb_policy_type type;
2572
2573         methods = pytalloc_get_ptr(self);
2574
2575         py_acct_policy = PyDict_New();
2576         if (py_acct_policy == NULL) {
2577                 PyErr_NoMemory();
2578                 talloc_free(frame);
2579                 return NULL;
2580         }
2581
2582         account_policy_names_list(frame, &names, &count);
2583         for (i=0; i<count; i++) {
2584                 type = account_policy_name_to_typenum(names[i]);
2585                 status = methods->get_account_policy(methods, type, &value);
2586                 if (NT_STATUS_IS_OK(status)) {
2587                         PyDict_SetItemString(py_acct_policy, names[i], Py_BuildValue("i", value));
2588                 }
2589         }
2590
2591         talloc_free(frame);
2592         return py_acct_policy;
2593 }
2594
2595
2596 static PyObject *py_pdb_set_account_policy(PyObject *self, PyObject *args)
2597 {
2598         TALLOC_CTX *frame = talloc_stackframe();
2599         NTSTATUS status;
2600         struct pdb_methods *methods;
2601         PyObject *py_acct_policy, *py_value;
2602         const char **names;
2603         int count, i;
2604         enum pdb_policy_type type;
2605
2606         if (!PyArg_ParseTuple(args, "O!:set_account_policy", PyDict_Type, &py_acct_policy)) {
2607                 talloc_free(frame);
2608                 return NULL;
2609         }
2610
2611         methods = pytalloc_get_ptr(self);
2612
2613         account_policy_names_list(frame, &names, &count);
2614         for (i=0; i<count; i++) {
2615                 if ((py_value = PyDict_GetItemString(py_acct_policy, names[i])) != NULL) {
2616                         type = account_policy_name_to_typenum(names[i]);
2617                         status = methods->set_account_policy(methods, type, PyInt_AsLong(py_value));
2618                         if (!NT_STATUS_IS_OK(status)) {
2619                                 PyErr_Format(py_pdb_error, "Error setting account policy (%s), (%d,%s)",
2620                                                 names[i],
2621                                                 NT_STATUS_V(status),
2622                                                 get_friendly_nt_error_msg(status));
2623                         }
2624                 }
2625         }
2626
2627         talloc_free(frame);
2628         Py_RETURN_NONE;
2629 }
2630
2631 static PyObject *py_pdb_search_users(PyObject *self, PyObject *args)
2632 {
2633         TALLOC_CTX *frame = talloc_stackframe();
2634         struct pdb_methods *methods;
2635         unsigned int acct_flags;
2636         struct pdb_search *search;
2637         struct samr_displayentry *entry;
2638         PyObject *py_userlist, *py_dict;
2639
2640         if (!PyArg_ParseTuple(args, "I:search_users", &acct_flags)) {
2641                 talloc_free(frame);
2642                 return NULL;
2643         }
2644
2645         methods = pytalloc_get_ptr(self);
2646
2647         search = talloc_zero(frame, struct pdb_search);
2648         if (search == NULL) {
2649                 PyErr_NoMemory();
2650                 talloc_free(frame);
2651                 return NULL;
2652         }
2653
2654         if (!methods->search_users(methods, search, acct_flags)) {
2655                 PyErr_Format(py_pdb_error, "Unable to search users");
2656                 talloc_free(frame);
2657                 return NULL;
2658         }
2659
2660         entry = talloc_zero(frame, struct samr_displayentry);
2661         if (entry == NULL) {
2662                 PyErr_NoMemory();
2663                 talloc_free(frame);
2664                 return NULL;
2665         }
2666
2667         py_userlist = PyList_New(0);
2668         if (py_userlist == NULL) {
2669                 PyErr_NoMemory();
2670                 talloc_free(frame);
2671                 return NULL;
2672         }
2673
2674         while (search->next_entry(search, entry)) {
2675                 py_dict = PyDict_New();
2676                 if (py_dict == NULL) {
2677                         PyErr_NoMemory();
2678                 } else {
2679                         PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2680                         PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2681                         PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2682                         PyDict_SetItemString(py_dict, "account_name", PyStr_FromString(entry->account_name));
2683                         PyDict_SetItemString(py_dict, "fullname", PyStr_FromString(entry->fullname));
2684                         PyDict_SetItemString(py_dict, "description", PyStr_FromString(entry->description));
2685                         PyList_Append(py_userlist, py_dict);
2686                 }
2687         }
2688         search->search_end(search);
2689
2690         talloc_free(frame);
2691         return py_userlist;
2692 }
2693
2694
2695 static PyObject *py_pdb_search_groups(PyObject *self, PyObject *unused)
2696 {
2697         TALLOC_CTX *frame = talloc_stackframe();
2698         struct pdb_methods *methods;
2699         struct pdb_search *search;
2700         struct samr_displayentry *entry;
2701         PyObject *py_grouplist, *py_dict;
2702
2703         methods = pytalloc_get_ptr(self);
2704
2705         search = talloc_zero(frame, struct pdb_search);
2706         if (search == NULL) {
2707                 PyErr_NoMemory();
2708                 talloc_free(frame);
2709                 return NULL;
2710         }
2711
2712         if (!methods->search_groups(methods, search)) {
2713                 PyErr_Format(py_pdb_error, "Unable to search groups");
2714                 talloc_free(frame);
2715                 return NULL;
2716         }
2717
2718         entry = talloc_zero(frame, struct samr_displayentry);
2719         if (entry == NULL) {
2720                 PyErr_NoMemory();
2721                 talloc_free(frame);
2722                 return NULL;
2723         }
2724
2725         py_grouplist = PyList_New(0);
2726         if (py_grouplist == NULL) {
2727                 PyErr_NoMemory();
2728                 talloc_free(frame);
2729                 return NULL;
2730         }
2731
2732         while (search->next_entry(search, entry)) {
2733                 py_dict = PyDict_New();
2734                 if (py_dict == NULL) {
2735                         PyErr_NoMemory();
2736                 } else {
2737                         PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2738                         PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2739                         PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2740                         PyDict_SetItemString(py_dict, "account_name", PyStr_FromString(entry->account_name));
2741                         PyDict_SetItemString(py_dict, "fullname", PyStr_FromString(entry->fullname));
2742                         PyDict_SetItemString(py_dict, "description", PyStr_FromString(entry->description));
2743                         PyList_Append(py_grouplist, py_dict);
2744                 }
2745         }
2746         search->search_end(search);
2747
2748         talloc_free(frame);
2749         return py_grouplist;
2750 }
2751
2752
2753 static PyObject *py_pdb_search_aliases(PyObject *self, PyObject *args)
2754 {
2755         TALLOC_CTX *frame = talloc_stackframe();
2756         struct pdb_methods *methods;
2757         struct pdb_search *search;
2758         struct samr_displayentry *entry;
2759         PyObject *py_aliaslist, *py_dict;
2760         PyObject *py_domain_sid = Py_None;
2761         struct dom_sid *domain_sid = NULL;
2762
2763         Py_INCREF(Py_None);
2764
2765         if (!PyArg_ParseTuple(args, "|O!:search_aliases", dom_sid_Type, &py_domain_sid)) {
2766                 talloc_free(frame);
2767                 return NULL;
2768         }
2769
2770         methods = pytalloc_get_ptr(self);
2771
2772         if (py_domain_sid != Py_None) {
2773                 domain_sid = pytalloc_get_ptr(py_domain_sid);
2774         }
2775
2776         search = talloc_zero(frame, struct pdb_search);
2777         if (search == NULL) {
2778                 PyErr_NoMemory();
2779                 talloc_free(frame);
2780                 return NULL;
2781         }
2782
2783         if (!methods->search_aliases(methods, search, domain_sid)) {
2784                 PyErr_Format(py_pdb_error, "Unable to search aliases");
2785                 talloc_free(frame);
2786                 return NULL;
2787         }
2788
2789         entry = talloc_zero(frame, struct samr_displayentry);
2790         if (entry == NULL) {
2791                 PyErr_NoMemory();
2792                 talloc_free(frame);
2793                 return NULL;
2794         }
2795
2796         py_aliaslist = PyList_New(0);
2797         if (py_aliaslist == NULL) {
2798                 PyErr_NoMemory();
2799                 talloc_free(frame);
2800                 return NULL;
2801         }
2802
2803         while (search->next_entry(search, entry)) {
2804                 py_dict = PyDict_New();
2805                 if (py_dict == NULL) {
2806                         PyErr_NoMemory();
2807                 } else {
2808                         PyDict_SetItemString(py_dict, "idx", PyInt_FromLong(entry->idx));
2809                         PyDict_SetItemString(py_dict, "rid", PyInt_FromLong(entry->rid));
2810                         PyDict_SetItemString(py_dict, "acct_flags", PyInt_FromLong(entry->acct_flags));
2811                         PyDict_SetItemString(py_dict, "account_name", PyStr_FromString(entry->account_name));
2812                         PyDict_SetItemString(py_dict, "fullname", PyStr_FromString(entry->fullname));
2813                         PyDict_SetItemString(py_dict, "description", PyStr_FromString(entry->description));
2814                         PyList_Append(py_aliaslist, py_dict);
2815                 }
2816         }
2817         search->search_end(search);
2818
2819         talloc_free(frame);
2820         return py_aliaslist;
2821 }
2822
2823
2824 static PyObject *py_pdb_uid_to_sid(PyObject *self, PyObject *args)
2825 {
2826         TALLOC_CTX *frame = talloc_stackframe();
2827         struct pdb_methods *methods;
2828         struct unixid id;
2829         unsigned int uid;
2830         struct dom_sid user_sid, *copy_user_sid;
2831         PyObject *py_user_sid;
2832
2833         if (!PyArg_ParseTuple(args, "I:uid_to_sid", &uid)) {
2834                 talloc_free(frame);
2835                 return NULL;
2836         }
2837
2838         methods = pytalloc_get_ptr(self);
2839
2840         id.id = uid;
2841         id.type = ID_TYPE_UID;
2842
2843         if (!methods->id_to_sid(methods, &id, &user_sid)) {
2844                 PyErr_Format(py_pdb_error, "Unable to get sid for uid=%d", uid);
2845                 talloc_free(frame);
2846                 return NULL;
2847         }
2848
2849         copy_user_sid = dom_sid_dup(frame, &user_sid);
2850         if (copy_user_sid == NULL) {
2851                 PyErr_NoMemory();
2852                 talloc_free(frame);
2853                 return NULL;
2854         }
2855
2856         py_user_sid = pytalloc_steal(dom_sid_Type, copy_user_sid);
2857
2858         talloc_free(frame);
2859         return py_user_sid;
2860 }
2861
2862
2863 static PyObject *py_pdb_gid_to_sid(PyObject *self, PyObject *args)
2864 {
2865         TALLOC_CTX *frame = talloc_stackframe();
2866         struct pdb_methods *methods;
2867         struct unixid id;
2868         unsigned int gid;
2869         struct dom_sid group_sid, *copy_group_sid;
2870         PyObject *py_group_sid;
2871
2872         if (!PyArg_ParseTuple(args, "I:gid_to_sid", &gid)) {
2873                 talloc_free(frame);
2874                 return NULL;
2875         }
2876
2877         id.id = gid;
2878         id.type = ID_TYPE_GID;
2879
2880         methods = pytalloc_get_ptr(self);
2881
2882         if (!methods->id_to_sid(methods, &id, &group_sid)) {
2883                 PyErr_Format(py_pdb_error, "Unable to get sid for gid=%d", gid);
2884                 talloc_free(frame);
2885                 return NULL;
2886         }
2887
2888         copy_group_sid = dom_sid_dup(frame, &group_sid);
2889         if (copy_group_sid == NULL) {
2890                 PyErr_NoMemory();
2891                 talloc_free(frame);
2892                 return NULL;
2893         }
2894
2895         py_group_sid = pytalloc_steal(dom_sid_Type, copy_group_sid);
2896
2897         talloc_free(frame);
2898         return py_group_sid;
2899 }
2900
2901
2902 static PyObject *py_pdb_sid_to_id(PyObject *self, PyObject *args)
2903 {
2904         TALLOC_CTX *frame = talloc_stackframe();
2905         struct pdb_methods *methods;
2906         PyObject *py_sid;
2907         struct dom_sid *sid;
2908         struct unixid id;
2909
2910         if (!PyArg_ParseTuple(args, "O!:sid_to_id", dom_sid_Type, &py_sid)) {
2911                 talloc_free(frame);
2912                 return NULL;
2913         }
2914
2915         methods = pytalloc_get_ptr(self);
2916
2917         sid = pytalloc_get_ptr(py_sid);
2918
2919         if (!methods->sid_to_id(methods, sid, &id)) {
2920                 PyErr_Format(py_pdb_error, "Unable to get id for sid");
2921                 talloc_free(frame);
2922                 return NULL;
2923         }
2924
2925         talloc_free(frame);
2926         return Py_BuildValue("(II)", id.id, id.type);
2927 }
2928
2929
2930 static PyObject *py_pdb_new_rid(PyObject *self, PyObject *unused)
2931 {
2932         TALLOC_CTX *frame = talloc_stackframe();
2933         struct pdb_methods *methods;
2934         uint32_t rid;
2935
2936         methods = pytalloc_get_ptr(self);
2937
2938         if (!methods->new_rid(methods, &rid)) {
2939                 PyErr_Format(py_pdb_error, "Unable to get new rid");
2940                 talloc_free(frame);
2941                 return NULL;
2942         }
2943
2944         talloc_free(frame);
2945         return PyInt_FromLong(rid);
2946 }
2947
2948
2949 static PyObject *py_pdb_get_trusteddom_pw(PyObject *self, PyObject *args)
2950 {
2951         TALLOC_CTX *frame = talloc_stackframe();
2952         struct pdb_methods *methods;
2953         const char *domain;
2954         char *pwd;
2955         struct dom_sid sid, *copy_sid;
2956         PyObject *py_sid;
2957         time_t last_set_time;
2958         PyObject *py_value;
2959
2960         if (!PyArg_ParseTuple(args, "s:get_trusteddom_pw", &domain)) {
2961                 talloc_free(frame);
2962                 return NULL;
2963         }
2964
2965         methods = pytalloc_get_ptr(self);
2966
2967         if (!methods->get_trusteddom_pw(methods, domain, &pwd, &sid, &last_set_time)) {
2968                 PyErr_Format(py_pdb_error, "Unable to get trusted domain password");
2969                 talloc_free(frame);
2970                 return NULL;
2971         }
2972
2973         copy_sid = dom_sid_dup(frame, &sid);
2974         if (copy_sid == NULL) {
2975                 PyErr_NoMemory();
2976                 talloc_free(frame);
2977                 return NULL;
2978         }
2979
2980         py_sid = pytalloc_steal(dom_sid_Type, copy_sid);
2981         if (py_sid == NULL) {
2982                 PyErr_NoMemory();
2983                 talloc_free(frame);
2984                 return NULL;
2985         }
2986
2987         py_value = PyDict_New();
2988         if (py_value == NULL) {
2989                 PyErr_NoMemory();
2990                 talloc_free(frame);
2991                 return NULL;
2992         }
2993
2994         PyDict_SetItemString(py_value, "pwd", PyStr_FromString(pwd));
2995         PyDict_SetItemString(py_value, "sid", py_sid);
2996         PyDict_SetItemString(py_value, "last_set_tim", PyInt_FromLong(last_set_time));
2997
2998         talloc_free(frame);
2999         return py_value;
3000 }
3001
3002
3003 static PyObject *py_pdb_set_trusteddom_pw(PyObject *self, PyObject *args)
3004 {
3005         TALLOC_CTX *frame = talloc_stackframe();
3006         struct pdb_methods *methods;
3007         const char *domain;
3008         const char *pwd;
3009         const struct dom_sid *domain_sid;
3010         PyObject *py_domain_sid;
3011
3012         if (!PyArg_ParseTuple(args, "ssO!:set_trusteddom_pw", &domain, &pwd,
3013                                         dom_sid_Type, &py_domain_sid)) {
3014                 talloc_free(frame);
3015                 return NULL;
3016         }
3017
3018         methods = pytalloc_get_ptr(self);
3019
3020         domain_sid = pytalloc_get_ptr(py_domain_sid);
3021
3022         if (!methods->set_trusteddom_pw(methods, domain, pwd, domain_sid)) {
3023                 PyErr_Format(py_pdb_error, "Unable to set trusted domain password");
3024                 talloc_free(frame);
3025                 return NULL;
3026         }
3027
3028         talloc_free(frame);
3029         Py_RETURN_NONE;
3030 }
3031
3032
3033 static PyObject *py_pdb_del_trusteddom_pw(PyObject *self, PyObject *args)
3034 {
3035         TALLOC_CTX *frame = talloc_stackframe();
3036         struct pdb_methods *methods;
3037         const char *domain;
3038
3039         if (!PyArg_ParseTuple(args, "s:del_trusteddom_pw", &domain)) {
3040                 talloc_free(frame);
3041                 return NULL;
3042         }
3043
3044         methods = pytalloc_get_ptr(self);
3045
3046         if (!methods->del_trusteddom_pw(methods, domain)) {
3047                 PyErr_Format(py_pdb_error, "Unable to delete trusted domain password");
3048                 talloc_free(frame);
3049                 return NULL;
3050         }
3051
3052         talloc_free(frame);
3053         Py_RETURN_NONE;
3054 }
3055
3056
3057 static PyObject *py_pdb_enum_trusteddoms(PyObject *self, PyObject *unused)
3058 {
3059         TALLOC_CTX *frame = talloc_stackframe();
3060         NTSTATUS status;
3061         struct pdb_methods *methods;
3062         uint32_t num_domains;
3063         struct trustdom_info **domains;
3064         PyObject *py_domain_list, *py_dict;
3065         int i;
3066
3067         methods = pytalloc_get_ptr(self);
3068
3069         status = methods->enum_trusteddoms(methods, frame, &num_domains, &domains);
3070         if (!NT_STATUS_IS_OK(status)) {
3071                 PyErr_Format(py_pdb_error, "Unable to enumerate trusted domains, (%d,%s)",
3072                                 NT_STATUS_V(status),
3073                                 get_friendly_nt_error_msg(status));
3074                 talloc_free(frame);
3075                 return NULL;
3076         }
3077
3078         py_domain_list = PyList_New(0);
3079         if (py_domain_list == NULL) {
3080                 PyErr_NoMemory();
3081                 talloc_free(frame);
3082                 return NULL;
3083         }
3084
3085         for(i=0; i<num_domains; i++) {
3086                 py_dict = PyDict_New();
3087                 if (py_dict) {
3088                         PyDict_SetItemString(py_dict, "name",
3089                                         PyStr_FromString(domains[i]->name));
3090                         PyDict_SetItemString(py_dict, "sid",
3091                                         pytalloc_steal(dom_sid_Type, &domains[i]->sid));
3092                 }
3093
3094                 PyList_Append(py_domain_list, py_dict);
3095         }
3096
3097         talloc_free(frame);
3098         return py_domain_list;
3099 }
3100
3101
3102 static PyObject *py_pdb_get_trusted_domain(PyObject *self, PyObject *args)
3103 {
3104         TALLOC_CTX *frame = talloc_stackframe();
3105         NTSTATUS status;
3106         struct pdb_methods *methods;
3107         const char *domain;
3108         struct pdb_trusted_domain *td;
3109         PyObject *py_domain_info;
3110
3111         if (!PyArg_ParseTuple(args, "s:get_trusted_domain", &domain)) {
3112                 talloc_free(frame);
3113                 return NULL;
3114         }
3115
3116         methods = pytalloc_get_ptr(self);
3117
3118         status = methods->get_trusted_domain(methods, frame, domain, &td);
3119         if (!NT_STATUS_IS_OK(status)) {
3120                 PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
3121                                 NT_STATUS_V(status),
3122                                 get_friendly_nt_error_msg(status));
3123                 talloc_free(frame);
3124                 return NULL;
3125         }
3126
3127         py_domain_info = PyDict_New();
3128         if (py_domain_info == NULL) {
3129                 PyErr_NoMemory();
3130                 talloc_free(frame);
3131                 return NULL;
3132         }
3133
3134         PyDict_SetItemString(py_domain_info, "domain_name",
3135                         PyStr_FromString(td->domain_name));
3136         PyDict_SetItemString(py_domain_info, "netbios_name",
3137                         PyStr_FromString(td->netbios_name));
3138         PyDict_SetItemString(py_domain_info, "security_identifier",
3139                         pytalloc_steal(dom_sid_Type, &td->security_identifier));
3140         PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
3141                         PyBytes_FromStringAndSize((const char *)td->trust_auth_incoming.data,
3142                                                 td->trust_auth_incoming.length));
3143         PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
3144                         PyBytes_FromStringAndSize((const char *)td->trust_auth_outgoing.data,
3145                                                 td->trust_auth_outgoing.length));
3146         PyDict_SetItemString(py_domain_info, "trust_direction",
3147                         PyInt_FromLong(td->trust_direction));
3148         PyDict_SetItemString(py_domain_info, "trust_type",
3149                         PyInt_FromLong(td->trust_type));
3150         PyDict_SetItemString(py_domain_info, "trust_attributes",
3151                         PyInt_FromLong(td->trust_attributes));
3152         PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
3153                         PyBytes_FromStringAndSize((const char *)td->trust_forest_trust_info.data,
3154                                                 td->trust_forest_trust_info.length));
3155
3156         talloc_free(frame);
3157         return py_domain_info;
3158 }
3159
3160
3161 static PyObject *py_pdb_get_trusted_domain_by_sid(PyObject *self, PyObject *args)
3162 {
3163         TALLOC_CTX *frame = talloc_stackframe();
3164         NTSTATUS status;
3165         struct pdb_methods *methods;
3166         PyObject *py_domain_sid;
3167         struct dom_sid *domain_sid;
3168         struct pdb_trusted_domain *td;
3169         PyObject *py_domain_info;
3170
3171         if (!PyArg_ParseTuple(args, "O!:get_trusted_domain_by_sid", dom_sid_Type, &py_domain_sid)) {
3172                 talloc_free(frame);
3173                 return NULL;
3174         }
3175
3176         methods = pytalloc_get_ptr(self);
3177
3178         domain_sid = pytalloc_get_ptr(py_domain_sid);
3179
3180         status = methods->get_trusted_domain_by_sid(methods, frame, domain_sid, &td);
3181         if (!NT_STATUS_IS_OK(status)) {
3182                 PyErr_Format(py_pdb_error, "Unable to get trusted domain information, (%d,%s)",
3183                                 NT_STATUS_V(status),
3184                                 get_friendly_nt_error_msg(status));
3185                 talloc_free(frame);
3186                 return NULL;
3187         }
3188
3189         py_domain_info = PyDict_New();
3190         if (py_domain_info == NULL) {
3191                 PyErr_NoMemory();
3192                 talloc_free(frame);
3193                 return NULL;
3194         }
3195
3196         PyDict_SetItemString(py_domain_info, "domain_name",
3197                         PyStr_FromString(td->domain_name));
3198         PyDict_SetItemString(py_domain_info, "netbios_name",
3199                         PyStr_FromString(td->netbios_name));
3200         PyDict_SetItemString(py_domain_info, "security_identifier",
3201                         pytalloc_steal(dom_sid_Type, &td->security_identifier));
3202         PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
3203                         PyBytes_FromStringAndSize((char *)td->trust_auth_incoming.data,
3204                                                 td->trust_auth_incoming.length));
3205         PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
3206                         PyBytes_FromStringAndSize((char *)td->trust_auth_outgoing.data,
3207                                                 td->trust_auth_outgoing.length));
3208         PyDict_SetItemString(py_domain_info, "trust_direction",
3209                         PyInt_FromLong(td->trust_direction));
3210         PyDict_SetItemString(py_domain_info, "trust_type",
3211                         PyInt_FromLong(td->trust_type));
3212         PyDict_SetItemString(py_domain_info, "trust_attributes",
3213                         PyInt_FromLong(td->trust_attributes));
3214         PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
3215                         PyBytes_FromStringAndSize((char *)td->trust_forest_trust_info.data,
3216                                                 td->trust_forest_trust_info.length));
3217
3218         talloc_free(frame);
3219         return py_domain_info;
3220 }
3221
3222
3223 static PyObject *py_pdb_set_trusted_domain(PyObject *self, PyObject *args)
3224 {
3225         TALLOC_CTX *frame = talloc_stackframe();
3226         NTSTATUS status;
3227         struct pdb_methods *methods;
3228         const char *domain;
3229         PyObject *py_td_info;
3230         struct pdb_trusted_domain td_info;
3231         PyObject *py_tmp;
3232         Py_ssize_t len;
3233
3234         if (!PyArg_ParseTuple(args, "sO!:set_trusted_domain", &domain, &PyDict_Type, &py_td_info)) {
3235                 talloc_free(frame);
3236                 return NULL;
3237         }
3238
3239         py_tmp = PyDict_GetItemString(py_td_info, "domain_name");
3240         td_info.domain_name = discard_const_p(char, PyStr_AsString(py_tmp));
3241
3242         py_tmp = PyDict_GetItemString(py_td_info, "netbios_name");
3243         td_info.netbios_name = discard_const_p(char, PyStr_AsString(py_tmp));
3244
3245         py_tmp = PyDict_GetItemString(py_td_info, "security_identifier");
3246         td_info.security_identifier = *pytalloc_get_type(py_tmp, struct dom_sid);
3247
3248         py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_incoming");
3249         PyBytes_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_incoming.data, &len);
3250         td_info.trust_auth_incoming.length = len;
3251
3252         py_tmp = PyDict_GetItemString(py_td_info, "trust_auth_outgoing");
3253         PyBytes_AsStringAndSize(py_tmp, (char **)&td_info.trust_auth_outgoing.data, &len);
3254         td_info.trust_auth_outgoing.length = len;
3255
3256         py_tmp = PyDict_GetItemString(py_td_info, "trust_direction");
3257         td_info.trust_direction = PyInt_AsLong(py_tmp);
3258
3259         py_tmp = PyDict_GetItemString(py_td_info, "trust_type");
3260         td_info.trust_type = PyInt_AsLong(py_tmp);
3261
3262         py_tmp = PyDict_GetItemString(py_td_info, "trust_attributes");
3263         td_info.trust_attributes = PyInt_AsLong(py_tmp);
3264
3265         py_tmp = PyDict_GetItemString(py_td_info, "trust_forest_trust_info");
3266         PyBytes_AsStringAndSize(py_tmp, (char **)&td_info.trust_forest_trust_info.data, &len);
3267         td_info.trust_forest_trust_info.length = len;
3268
3269         methods = pytalloc_get_ptr(self);
3270
3271         status = methods->set_trusted_domain(methods, domain, &td_info);
3272         if (!NT_STATUS_IS_OK(status)) {
3273                 PyErr_Format(py_pdb_error, "Unable to set trusted domain information, (%d,%s)",
3274                                 NT_STATUS_V(status),
3275                                 get_friendly_nt_error_msg(status));
3276                 talloc_free(frame);
3277                 return NULL;
3278         }
3279
3280         talloc_free(frame);
3281         Py_RETURN_NONE;
3282 }
3283
3284
3285 static PyObject *py_pdb_del_trusted_domain(PyObject *self, PyObject *args)
3286 {
3287         TALLOC_CTX *frame = talloc_stackframe();
3288         NTSTATUS status;
3289         struct pdb_methods *methods;
3290         const char *domain;
3291
3292         if (!PyArg_ParseTuple(args, "s:del_trusted_domain", &domain)) {
3293                 talloc_free(frame);
3294                 return NULL;
3295         }
3296
3297         methods = pytalloc_get_ptr(self);
3298
3299         status = methods->del_trusted_domain(methods, domain);
3300         if (!NT_STATUS_IS_OK(status)) {
3301                 PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
3302                                 NT_STATUS_V(status),
3303                                 get_friendly_nt_error_msg(status));
3304                 talloc_free(frame);
3305                 return NULL;
3306         }
3307
3308         talloc_free(frame);
3309         Py_RETURN_NONE;
3310 }
3311
3312
3313 static PyObject *py_pdb_enum_trusted_domains(PyObject *self, PyObject *args)
3314 {
3315         TALLOC_CTX *frame = talloc_stackframe();
3316         NTSTATUS status;
3317         struct pdb_methods *methods;
3318         uint32_t num_domains;
3319         struct pdb_trusted_domain **td_info, *td;
3320         PyObject *py_td_info, *py_domain_info;
3321         int i;
3322
3323         methods = pytalloc_get_ptr(self);
3324
3325         status = methods->enum_trusted_domains(methods, frame, &num_domains, &td_info);
3326         if (!NT_STATUS_IS_OK(status)) {
3327                 PyErr_Format(py_pdb_error, "Unable to delete trusted domain, (%d,%s)",
3328                                 NT_STATUS_V(status),
3329                                 get_friendly_nt_error_msg(status));
3330                 talloc_free(frame);
3331                 return NULL;
3332         }
3333
3334         py_td_info = PyList_New(0);
3335         if (py_td_info == NULL) {
3336                 PyErr_NoMemory();
3337                 talloc_free(frame);
3338                 return NULL;
3339         }
3340
3341         for (i=0; i<num_domains; i++) {
3342
3343                 py_domain_info = PyDict_New();
3344                 if (py_domain_info == NULL) {
3345                         PyErr_NoMemory();
3346                         Py_DECREF(py_td_info);
3347                         talloc_free(frame);
3348                         return NULL;
3349                 }
3350
3351                 td = td_info[i];
3352
3353                 PyDict_SetItemString(py_domain_info, "domain_name",
3354                                 PyStr_FromString(td->domain_name));
3355                 PyDict_SetItemString(py_domain_info, "netbios_name",
3356                                 PyStr_FromString(td->netbios_name));
3357                 PyDict_SetItemString(py_domain_info, "security_identifier",
3358                                 pytalloc_steal(dom_sid_Type, &td->security_identifier));
3359                 PyDict_SetItemString(py_domain_info, "trust_auth_incoming",
3360                                 PyBytes_FromStringAndSize((const char *)td->trust_auth_incoming.data,
3361                                                         td->trust_auth_incoming.length));
3362                 PyDict_SetItemString(py_domain_info, "trust_auth_outgoing",
3363                                 PyBytes_FromStringAndSize((const char *)td->trust_auth_outgoing.data,
3364                                                         td->trust_auth_outgoing.length));
3365                 PyDict_SetItemString(py_domain_info, "trust_direction",
3366                                 PyInt_FromLong(td->trust_direction));
3367                 PyDict_SetItemString(py_domain_info, "trust_type",
3368                                 PyInt_FromLong(td->trust_type));
3369                 PyDict_SetItemString(py_domain_info, "trust_attributes",
3370                                 PyInt_FromLong(td->trust_attributes));
3371                 PyDict_SetItemString(py_domain_info, "trust_forest_trust_info",
3372                                 PyBytes_FromStringAndSize((const char *)td->trust_forest_trust_info.data,
3373                                                         td->trust_forest_trust_info.length));
3374                 PyList_Append(py_td_info, py_domain_info);
3375         }
3376
3377         talloc_free(frame);
3378         return py_td_info;
3379 }
3380
3381
3382 static PyObject *py_pdb_get_secret(PyObject *self, PyObject *args)
3383 {
3384         TALLOC_CTX *frame = talloc_stackframe();
3385         NTSTATUS status;
3386         struct pdb_methods *methods;
3387         const char *secret_name;
3388         DATA_BLOB secret_current, secret_old;
3389         NTTIME secret_current_lastchange, secret_old_lastchange;
3390         PyObject *py_sd;
3391         struct security_descriptor *sd;
3392         PyObject *py_secret;
3393
3394         if (!PyArg_ParseTuple(args, "s:get_secret_name", &secret_name)) {
3395                 talloc_free(frame);
3396                 return NULL;
3397         }
3398
3399         methods = pytalloc_get_ptr(self);
3400
3401         py_sd = pytalloc_new(struct security_descriptor, security_Type);
3402         if (py_sd == NULL) {
3403                 PyErr_NoMemory();
3404                 talloc_free(frame);
3405                 return NULL;
3406         }
3407         sd = pytalloc_get_ptr(py_sd);
3408
3409         status = methods->get_secret(methods, frame, secret_name,
3410                                         &secret_current,
3411                                         &secret_current_lastchange,
3412                                         &secret_old,
3413                                         &secret_old_lastchange,
3414                                         &sd);
3415         if (!NT_STATUS_IS_OK(status)) {
3416                 PyErr_Format(py_pdb_error, "Unable to get information for secret (%s), (%d,%s)",
3417                                 secret_name,
3418                                 NT_STATUS_V(status),
3419                                 get_friendly_nt_error_msg(status));
3420                 talloc_free(frame);
3421                 return NULL;
3422         }
3423
3424         py_secret = PyDict_New();
3425         if (py_secret == NULL) {
3426                 PyErr_NoMemory();
3427                 Py_DECREF(py_sd);
3428                 talloc_free(frame);
3429                 return NULL;
3430         }
3431
3432         PyDict_SetItemString(py_secret, "secret_current",
3433                         PyBytes_FromStringAndSize((const char*)secret_current.data, secret_current.length));
3434         PyDict_SetItemString(py_secret, "secret_current_lastchange",
3435                         PyLong_FromUnsignedLongLong(secret_current_lastchange));
3436         PyDict_SetItemString(py_secret, "secret_old",
3437                         PyBytes_FromStringAndSize((const char*)secret_old.data, secret_old.length));
3438         PyDict_SetItemString(py_secret, "secret_old_lastchange",
3439                         PyLong_FromUnsignedLongLong(secret_old_lastchange));
3440         PyDict_SetItemString(py_secret, "sd", py_sd);
3441
3442         talloc_free(frame);
3443         return py_secret;
3444 }
3445
3446
3447 static PyObject *py_pdb_set_secret(PyObject *self, PyObject *args)
3448 {
3449         TALLOC_CTX *frame = talloc_stackframe();
3450         NTSTATUS status;
3451         struct pdb_methods *methods;
3452         const char *secret_name;
3453         PyObject *py_secret;
3454         PyObject *py_secret_cur, *py_secret_old, *py_sd;
3455         DATA_BLOB secret_current, secret_old;
3456         struct security_descriptor *sd;
3457         Py_ssize_t len;
3458
3459         if (!PyArg_ParseTuple(args, "sO!:set_secret_name", &secret_name, PyDict_Type, &py_secret)) {
3460                 talloc_free(frame);
3461                 return NULL;
3462         }
3463
3464         py_secret_cur = PyDict_GetItemString(py_secret, "secret_current");
3465         py_secret_old = PyDict_GetItemString(py_secret, "secret_old");
3466         py_sd = PyDict_GetItemString(py_secret, "sd");
3467
3468         PY_CHECK_TYPE(&PyBytes_Type, py_secret_cur, return NULL;);
3469         PY_CHECK_TYPE(&PyBytes_Type, py_secret_old, return NULL;);
3470         PY_CHECK_TYPE(security_Type, py_sd, return NULL;);
3471
3472         methods = pytalloc_get_ptr(self);
3473
3474         PyBytes_AsStringAndSize(py_secret_cur, (char **)&secret_current.data, &len);
3475         secret_current.length = len;
3476         PyBytes_AsStringAndSize(py_secret_old, (char **)&secret_old.data, &len);
3477         secret_current.length = len;
3478         sd = pytalloc_get_ptr(py_sd);
3479
3480         status = methods->set_secret(methods, secret_name, &secret_current, &secret_old, sd);
3481         if (!NT_STATUS_IS_OK(status)) {
3482                 PyErr_Format(py_pdb_error, "Unable to set information for secret (%s), (%d,%s)",
3483                                 secret_name,
3484                                 NT_STATUS_V(status),
3485                                 get_friendly_nt_error_msg(status));
3486                 talloc_free(frame);
3487                 return NULL;
3488         }
3489
3490         talloc_free(frame);
3491         Py_RETURN_NONE;
3492 }
3493
3494
3495 static PyObject *py_pdb_delete_secret(PyObject *self, PyObject *args)
3496 {
3497         TALLOC_CTX *frame = talloc_stackframe();
3498         NTSTATUS status;
3499         struct pdb_methods *methods;
3500         const char *secret_name;
3501
3502         if (!PyArg_ParseTuple(args, "s:delete_secret", &secret_name)) {
3503                 talloc_free(frame);
3504                 return NULL;
3505         }
3506
3507         methods = pytalloc_get_ptr(self);
3508
3509         status = methods->delete_secret(methods, secret_name);
3510         if (!NT_STATUS_IS_OK(status)) {
3511                 PyErr_Format(py_pdb_error, "Unable to delete secret (%s), (%d,%s)",
3512                                 secret_name,
3513                                 NT_STATUS_V(status),
3514                                 get_friendly_nt_error_msg(status));
3515                 talloc_free(frame);
3516                 return NULL;
3517         }
3518
3519         talloc_free(frame);
3520         Py_RETURN_NONE;
3521 }
3522
3523 static PyMethodDef py_pdb_methods[] = {
3524         { "domain_info", py_pdb_domain_info, METH_NOARGS,
3525                 "domain_info() -> str\n\n \
3526                 Get domain information for the database." },
3527         { "getsampwnam", py_pdb_getsampwnam, METH_VARARGS,
3528                 "getsampwnam(username) -> samu object\n\n \
3529                 Get user information by name." },
3530         { "getsampwsid", py_pdb_getsampwsid, METH_VARARGS,
3531                 "getsampwsid(user_sid) -> samu object\n\n \
3532                 Get user information by sid (dcerpc.security.dom_sid object)." },
3533         { "create_user", py_pdb_create_user, METH_VARARGS,
3534                 "create_user(username, acct_flags) -> rid\n\n \
3535                 Create user. acct_flags are samr account control flags." },
3536         { "delete_user", py_pdb_delete_user, METH_VARARGS,
3537                 "delete_user(samu object) -> None\n\n \
3538                 Delete user." },
3539         { "add_sam_account", py_pdb_add_sam_account, METH_VARARGS,
3540                 "add_sam_account(samu object) -> None\n\n \
3541                 Add SAM account." },
3542         { "update_sam_account", py_pdb_update_sam_account, METH_VARARGS,
3543                 "update_sam_account(samu object) -> None\n\n \
3544                 Update SAM account." },
3545         { "delete_sam_account", py_pdb_delete_sam_account, METH_VARARGS,
3546                 "delete_sam_account(samu object) -> None\n\n \
3547                 Delete SAM account." },
3548         { "rename_sam_account", py_pdb_rename_sam_account, METH_VARARGS,
3549                 "rename_sam_account(samu object1, new_username) -> None\n\n \
3550                 Rename SAM account." },
3551         /* update_login_attempts */
3552         { "getgrsid", py_pdb_getgrsid, METH_VARARGS,
3553                 "getgrsid(group_sid) -> groupmap object\n\n \
3554                 Get group information by sid (dcerpc.security.dom_sid object)." },
3555         { "getgrgid", py_pdb_getgrgid, METH_VARARGS,
3556                 "getgrsid(gid) -> groupmap object\n\n \
3557                 Get group information by gid." },
3558         { "getgrnam", py_pdb_getgrnam, METH_VARARGS,
3559                 "getgrsid(groupname) -> groupmap object\n\n \
3560                 Get group information by name." },
3561         { "create_dom_group", py_pdb_create_dom_group, METH_VARARGS,
3562                 "create_dom_group(groupname) -> group_rid\n\n \
3563                 Create new domain group by name." },
3564         { "delete_dom_group", py_pdb_delete_dom_group, METH_VARARGS,
3565                 "delete_dom_group(group_rid) -> None\n\n \
3566                 Delete domain group identified by rid" },
3567         { "add_group_mapping_entry", py_pdb_add_group_mapping_entry, METH_VARARGS,
3568                 "add_group_mapping_entry(groupmap) -> None\n \
3569                 Add group mapping entry for groupmap object." },
3570         { "update_group_mapping_entry", py_pdb_update_group_mapping_entry, METH_VARARGS,
3571                 "update_group_mapping_entry(groupmap) -> None\n\n \
3572                 Update group mapping entry for groupmap object." },
3573         { "delete_group_mapping_entry", py_pdb_delete_group_mapping_entry, METH_VARARGS,
3574                 "delete_group_mapping_entry(groupmap) -> None\n\n \
3575                 Delete group mapping entry for groupmap object." },
3576         { "enum_group_mapping", py_pdb_enum_group_mapping, METH_VARARGS,
3577                 "enum_group_mapping([domain_sid, [type, [unix_only]]]) -> List\n\n \
3578                 Return list of group mappings as groupmap objects. Optional arguments are domain_sid object, type of group, unix only flag." },
3579         { "enum_group_members", py_pdb_enum_group_members, METH_VARARGS,
3580                 "enum_group_members(group_sid) -> List\n\n \
3581                 Return list of users (dom_sid object) in group." },
3582         { "enum_group_memberships", py_pdb_enum_group_memberships, METH_VARARGS,
3583                 "enum_group_memberships(samu object) -> List\n\n \
3584                 Return list of groups (dom_sid object) this user is part of." },
3585         /* set_unix_primary_group */
3586         { "add_groupmem", py_pdb_add_groupmem, METH_VARARGS,
3587                 "add_groupmem(group_rid, member_rid) -> None\n\n \
3588                 Add user to group." },
3589         { "del_groupmem", py_pdb_del_groupmem, METH_VARARGS,
3590                 "del_groupmem(group_rid, member_rid) -> None\n\n \
3591                 Remove user from from group." },
3592         { "create_alias", py_pdb_create_alias, METH_VARARGS,
3593                 "create_alias(alias_name) -> alias_rid\n\n \
3594                 Create alias entry." },
3595         { "delete_alias", py_pdb_delete_alias, METH_VARARGS,
3596                 "delete_alias(alias_sid) -> None\n\n \
3597                 Delete alias entry." },
3598         { "get_aliasinfo", py_pdb_get_aliasinfo, METH_VARARGS,
3599                 "get_aliasinfo(alias_sid) -> Mapping\n\n \
3600                 Get alias information as a dictionary with keys - acct_name, acct_desc, rid." },
3601         { "set_aliasinfo", py_pdb_set_aliasinfo, METH_VARARGS,
3602                 "set_alias_info(alias_sid, Mapping) -> None\n\n \
3603                 Set alias information from a dictionary with keys - acct_name, acct_desc." },
3604         { "add_aliasmem", py_pdb_add_aliasmem, METH_VARARGS,
3605                 "add_aliasmem(alias_sid, member_sid) -> None\n\n \
3606                 Add user to alias entry." },
3607         { "del_aliasmem", py_pdb_del_aliasmem, METH_VARARGS,
3608                 "del_aliasmem(alias_sid, member_sid) -> None\n\n \
3609                 Remove a user from alias entry." },
3610         { "enum_aliasmem", py_pdb_enum_aliasmem, METH_VARARGS,
3611                 "enum_aliasmem(alias_sid) -> List\n\n \
3612                 Return a list of members (dom_sid object) for alias entry." },
3613         /* enum_alias_memberships */
3614         /* lookup_rids */
3615         /* lookup_names */
3616         { "get_account_policy", py_pdb_get_account_policy, METH_NOARGS,
3617                 "get_account_policy() -> Mapping\n\n \
3618                 Get account policy information as a dictionary." },
3619         { "set_account_policy", py_pdb_set_account_policy, METH_VARARGS,
3620                 "get_account_policy(Mapping) -> None\n\n \
3621                 Set account policy settings from a dicionary." },
3622         /* get_seq_num */
3623         { "search_users", py_pdb_search_users, METH_VARARGS,
3624                 "search_users(acct_flags) -> List\n\n \
3625                 Search users. acct_flags are samr account control flags.\n \
3626                 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3627         { "search_groups", py_pdb_search_groups, METH_NOARGS,
3628                 "search_groups() -> List\n\n \
3629                 Search unix only groups. \n \
3630                 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3631         { "search_aliases", py_pdb_search_aliases, METH_VARARGS,
3632                 "search_aliases([domain_sid]) -> List\n\n \
3633                 Search aliases. domain_sid is dcerpc.security.dom_sid object.\n \
3634                 Each list entry is dictionary with keys - idx, rid, acct_flags, account_name, fullname, description." },
3635         { "uid_to_sid", py_pdb_uid_to_sid, METH_VARARGS,
3636                 "uid_to_sid(uid) -> sid\n\n \
3637                 Return sid for given user id." },
3638         { "gid_to_sid", py_pdb_gid_to_sid, METH_VARARGS,
3639                 "gid_to_sid(gid) -> sid\n\n \
3640                 Return sid for given group id." },
3641         { "sid_to_id", py_pdb_sid_to_id, METH_VARARGS,
3642                 "sid_to_id(sid) -> Tuple\n\n \
3643                 Return id and type for given sid." },
3644         /* capabilities */
3645         { "new_rid", py_pdb_new_rid, METH_NOARGS,
3646                 "new_rid() -> rid\n\n \
3647                 Get a new rid." },
3648         { "get_trusteddom_pw", py_pdb_get_trusteddom_pw, METH_VARARGS,
3649                 "get_trusteddom_pw(domain) -> Mapping\n\n \
3650                 Get trusted domain password, sid and last set time in a dictionary." },
3651         { "set_trusteddom_pw", py_pdb_set_trusteddom_pw, METH_VARARGS,
3652                 "set_trusteddom_pw(domain, pwd, sid) -> None\n\n \
3653                 Set trusted domain password." },
3654         { "del_trusteddom_pw", py_pdb_del_trusteddom_pw, METH_VARARGS,
3655                 "del_trusteddom_pw(domain) -> None\n\n \
3656                 Delete trusted domain password." },
3657         { "enum_trusteddoms", py_pdb_enum_trusteddoms, METH_NOARGS,
3658                 "enum_trusteddoms() -> List\n\n \
3659                 Get list of trusted domains. Each item is a dictionary with name and sid keys" },
3660         { "get_trusted_domain", py_pdb_get_trusted_domain, METH_VARARGS,
3661                 "get_trusted_domain(domain) -> Mapping\n\n \
3662                 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." },
3663         { "get_trusted_domain_by_sid", py_pdb_get_trusted_domain_by_sid, METH_VARARGS,
3664                 "get_trusted_domain_by_sid(domain_sid) -> Mapping\n\n \
3665                 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" },
3666         { "set_trusted_domain", py_pdb_set_trusted_domain, METH_VARARGS,
3667                 "set_trusted_domain(domain, Mapping) -> None\n\n \
3668                 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." },
3669         { "del_trusted_domain", py_pdb_del_trusted_domain, METH_VARARGS,
3670                 "del_trusted_domain(domain) -> None\n\n \
3671                 Delete trusted domain." },
3672         { "enum_trusted_domains", py_pdb_enum_trusted_domains, METH_VARARGS,
3673                 "enum_trusted_domains() -> List\n\n \
3674                 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." },
3675         { "get_secret", py_pdb_get_secret, METH_VARARGS,
3676                 "get_secret(secret_name) -> Mapping\n\n \
3677                 Get secret information for secret_name. Information is a dictionary with keys - secret_current, secret_current_lastchange, secret_old, secret_old_lastchange, sd." },
3678         { "set_secret", py_pdb_set_secret, METH_VARARGS,
3679                 "set_secret(secret_name, Mapping) -> None\n\n \
3680                 Set secret information for secret_name using dictionary with keys - secret_current, sd." },
3681         { "delete_secret", py_pdb_delete_secret, METH_VARARGS,
3682                 "delete_secret(secret_name) -> None\n\n \
3683                 Delete secret information for secret_name." },
3684         { NULL },
3685 };
3686
3687
3688 static PyObject *py_pdb_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
3689 {
3690         TALLOC_CTX *frame = talloc_stackframe();
3691         const char *url = NULL;
3692         PyObject *pypdb;
3693         NTSTATUS status;
3694         struct pdb_methods *methods;
3695
3696         if (!PyArg_ParseTuple(args, "s", &url)) {
3697                 talloc_free(frame);
3698                 return NULL;
3699         }
3700
3701         /* Initialize list of methods */
3702         status = make_pdb_method_name(&methods, url);
3703         if (!NT_STATUS_IS_OK(status)) {
3704                 PyErr_Format(py_pdb_error, "Cannot load backend methods for '%s' backend (%d,%s)",
3705                                 url,
3706                                 NT_STATUS_V(status),
3707                                 get_friendly_nt_error_msg(status));
3708                 talloc_free(frame);
3709                 return NULL;
3710         }
3711
3712         if ((pypdb = pytalloc_steal(type, methods)) == NULL) {
3713                 PyErr_NoMemory();
3714                 talloc_free(frame);
3715                 return NULL;
3716         }
3717
3718         talloc_free(frame);
3719         return pypdb;
3720 }
3721
3722
3723 static PyTypeObject PyPDB = {
3724         .tp_name = "passdb.PDB",
3725         .tp_new = py_pdb_new,
3726         .tp_flags = Py_TPFLAGS_DEFAULT,
3727         .tp_methods = py_pdb_methods,
3728         .tp_doc = "PDB(url[, read_write_flags]) -> Password DB object\n",
3729 };
3730
3731
3732 /*
3733  * Return a list of passdb backends
3734  */
3735 static PyObject *py_passdb_backends(PyObject *self, PyObject *unused)
3736 {
3737         TALLOC_CTX *frame = talloc_stackframe();
3738         PyObject *py_blist;
3739         const struct pdb_init_function_entry *entry;
3740
3741         entry = pdb_get_backends();
3742         if(! entry) {
3743                 Py_RETURN_NONE;
3744         }
3745
3746         if((py_blist = PyList_New(0)) == NULL) {
3747                 PyErr_NoMemory();
3748                 talloc_free(frame);
3749                 return NULL;
3750         }
3751
3752         while(entry) {
3753                 PyList_Append(py_blist, PyStr_FromString(entry->name));
3754                 entry = entry->next;
3755         }
3756
3757         talloc_free(frame);
3758         return py_blist;
3759 }
3760
3761
3762 static PyObject *py_set_smb_config(PyObject *self, PyObject *args)
3763 {
3764         TALLOC_CTX *frame = talloc_stackframe();
3765         const char *smb_config;
3766
3767         if (!PyArg_ParseTuple(args, "s", &smb_config)) {
3768                 talloc_free(frame);
3769                 return NULL;
3770         }
3771
3772         /* Load smbconf parameters */
3773         if (!lp_load_global(smb_config)) {
3774                 PyErr_Format(py_pdb_error, "Cannot open '%s'", smb_config);
3775                 talloc_free(frame);
3776                 return NULL;
3777         }
3778
3779         talloc_free(frame);
3780         Py_RETURN_NONE;
3781 }
3782
3783
3784 static PyObject *py_set_secrets_dir(PyObject *self, PyObject *args)
3785 {
3786         TALLOC_CTX *frame = talloc_stackframe();
3787         const char *private_dir;
3788
3789         if (!PyArg_ParseTuple(args, "s", &private_dir)) {
3790                 talloc_free(frame);
3791                 return NULL;
3792         }
3793
3794         /* Initialize secrets database */
3795         if (!secrets_init_path(private_dir)) {
3796                 PyErr_Format(py_pdb_error, "Cannot open secrets file database in '%s'",
3797                                 private_dir);
3798                 talloc_free(frame);
3799                 return NULL;
3800         }
3801
3802         talloc_free(frame);
3803         Py_RETURN_NONE;
3804 }
3805
3806 static PyObject *py_reload_static_pdb(PyObject *self, PyObject *args)
3807 {
3808         TALLOC_CTX *frame = talloc_stackframe();
3809
3810         /* Initialize secrets database */
3811         if (!initialize_password_db(true, NULL)) {
3812                 PyErr_Format(py_pdb_error, "Cannot re-open passdb backend %s", lp_passdb_backend());
3813                 talloc_free(frame);
3814                 return NULL;
3815         }
3816
3817         talloc_free(frame);
3818         Py_RETURN_NONE;
3819 }
3820
3821 static PyObject *py_get_domain_sid(PyObject *self, PyObject *unused)
3822 {
3823         TALLOC_CTX *frame = talloc_stackframe();
3824         struct dom_sid domain_sid, *domain_sid_copy;
3825         PyObject *py_dom_sid = Py_None;
3826         bool ret = false;
3827
3828         ret = secrets_fetch_domain_sid(lp_workgroup(), &domain_sid);
3829         if (!ret) {
3830                 talloc_free(frame);
3831                 return PyErr_NoMemory();
3832         }
3833
3834         domain_sid_copy = dom_sid_dup(frame, &domain_sid);
3835         if (domain_sid_copy == NULL) {
3836                 talloc_free(frame);
3837                 return PyErr_NoMemory();
3838         }
3839
3840         py_dom_sid = pytalloc_steal(dom_sid_Type, domain_sid_copy);
3841
3842         talloc_free(frame);
3843         return py_dom_sid;
3844 }
3845
3846 static PyObject *py_get_global_sam_sid(PyObject *self, PyObject *unused)
3847 {
3848         TALLOC_CTX *frame = talloc_stackframe();
3849         struct dom_sid *domain_sid, *domain_sid_copy;
3850         PyObject *py_dom_sid;
3851
3852         domain_sid = get_global_sam_sid();
3853
3854         domain_sid_copy = dom_sid_dup(frame, domain_sid);
3855         if (domain_sid_copy == NULL) {
3856                 PyErr_NoMemory();
3857                 talloc_free(frame);
3858                 return NULL;
3859         }
3860
3861         py_dom_sid = pytalloc_steal(dom_sid_Type, domain_sid_copy);
3862
3863         talloc_free(frame);
3864         return py_dom_sid;
3865 }
3866
3867
3868 static PyMethodDef py_passdb_methods[] = {
3869         { "get_backends", py_passdb_backends, METH_NOARGS,
3870                 "get_backends() -> list\n\n \
3871                 Get a list of password database backends supported." },
3872         { "set_smb_config", py_set_smb_config, METH_VARARGS,
3873                 "set_smb_config(path) -> None\n\n \
3874                 Set path to smb.conf file to load configuration parameters." },
3875         { "set_secrets_dir", py_set_secrets_dir, METH_VARARGS,
3876                 "set_secrets_dir(private_dir) -> None\n\n \
3877                 Set path to private directory to load secrets database from non-default location." },
3878         { "get_global_sam_sid", py_get_global_sam_sid, METH_NOARGS,
3879                 "get_global_sam_sid() -> dom_sid\n\n \
3880                 Return domain SID." },
3881         { "get_domain_sid", py_get_domain_sid, METH_NOARGS,
3882                 "get_domain_sid() -> dom_sid\n\n \
3883                 Return domain SID from secrets database." },
3884         { "reload_static_pdb", py_reload_static_pdb, METH_NOARGS,
3885                 "reload_static_pdb() -> None\n\n \
3886                 Re-initialise the static pdb used internally.  Needed if 'passdb backend' is changed." },
3887         { NULL },
3888 };
3889
3890 static struct PyModuleDef moduledef = {
3891     PyModuleDef_HEAD_INIT,
3892     .m_name = "passdb",
3893     .m_doc = "SAMBA Password Database",
3894     .m_size = -1,
3895     .m_methods = py_passdb_methods,
3896 };
3897
3898 MODULE_INIT_FUNC(passdb)
3899 {
3900         TALLOC_CTX *frame = talloc_stackframe();
3901         PyObject *m = NULL, *mod = NULL;
3902         char exception_name[] = "passdb.error";
3903
3904         if (pytalloc_BaseObject_PyType_Ready(&PyPDB) < 0) {
3905                 talloc_free(frame);
3906                 return NULL;
3907         }
3908
3909         if (pytalloc_BaseObject_PyType_Ready(&PySamu) < 0) {
3910                 talloc_free(frame);
3911                 return NULL;
3912         }
3913
3914         if (pytalloc_BaseObject_PyType_Ready(&PyGroupmap) < 0) {
3915                 talloc_free(frame);
3916                 return NULL;
3917         }
3918
3919         m = PyModule_Create(&moduledef);
3920         if (m == NULL) {
3921             talloc_free(frame);
3922             return NULL;
3923         }
3924
3925         /* Create new exception for passdb module */
3926         py_pdb_error = PyErr_NewException(exception_name, NULL, NULL);
3927         Py_INCREF(py_pdb_error);
3928         PyModule_AddObject(m, "error", py_pdb_error);
3929
3930         Py_INCREF(&PyPDB);
3931         PyModule_AddObject(m, "PDB", (PyObject *)&PyPDB);
3932
3933         Py_INCREF(&PySamu);
3934         PyModule_AddObject(m, "Samu", (PyObject *)&PySamu);
3935
3936         Py_INCREF(&PyGroupmap);
3937         PyModule_AddObject(m, "Groupmap", (PyObject *)&PyGroupmap);
3938
3939         /* Import dom_sid type from dcerpc.security */
3940         mod = PyImport_ImportModule("samba.dcerpc.security");
3941         if (mod == NULL) {
3942                 talloc_free(frame);
3943                 return NULL;
3944         }
3945
3946         dom_sid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "dom_sid");
3947         if (dom_sid_Type == NULL) {
3948                 Py_DECREF(mod);
3949                 talloc_free(frame);
3950                 return NULL;
3951         }
3952
3953         /* Import security_descriptor type from dcerpc.security */
3954         security_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "descriptor");
3955         Py_DECREF(mod);
3956         if (security_Type == NULL) {
3957                 Py_DECREF(dom_sid_Type);
3958                 talloc_free(frame);
3959                 return NULL;
3960         }
3961
3962         /* Import GUID type from dcerpc.misc */
3963         mod = PyImport_ImportModule("samba.dcerpc.misc");
3964         if (mod == NULL) {
3965                 Py_DECREF(security_Type);
3966                 Py_DECREF(dom_sid_Type);
3967                 talloc_free(frame);
3968                 return NULL;
3969         }
3970
3971         guid_Type = (PyTypeObject *)PyObject_GetAttrString(mod, "GUID");
3972         Py_DECREF(mod);
3973         if (guid_Type == NULL) {
3974                 Py_DECREF(security_Type);
3975                 Py_DECREF(dom_sid_Type);
3976                 talloc_free(frame);
3977                 return NULL;
3978         }
3979         talloc_free(frame);
3980         return m;
3981 }