source4/libnet/py_net.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Samba utility functions
   4
   5    Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008-2010
   6    Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include <Python.h>
  23 #include "includes.h"
  24 #include <ldb.h>
  25 #include <pyldb.h>
  26 #include "libnet.h"
  27 #include "auth/credentials/pycredentials.h"
  28 #include "libcli/security/security.h"
  29 #include "lib/events/events.h"
  30 #include "param/pyparam.h"
  31 #include "auth/gensec/gensec.h"
  32 #include "librpc/rpc/pyrpc_util.h"
  33 #include "libcli/finddc.h"
  34 #include "libcli/resolve/resolve.h"
  35
  36 void initnet(void);
  37
  38 typedef struct {
  39         PyObject_HEAD
  40         TALLOC_CTX *mem_ctx;
  41         struct libnet_context *libnet_ctx;
  42         struct tevent_context *ev;
  43 } py_net_Object;
  44
  45 static PyObject *py_net_join_member(py_net_Object *self, PyObject *args, PyObject *kwargs)
  46 {
  47         struct libnet_Join_member r;
  48         int _level = 0;
  49         NTSTATUS status;
  50         PyObject *result;
  51         TALLOC_CTX *mem_ctx;
  52         const char *kwnames[] = { "domain_name", "netbios_name", "level", NULL };
  53
  54         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ssi:Join", discard_const_p(char *, kwnames),
  55                                          &r.in.domain_name, &r.in.netbios_name,
  56                                          &_level)) {
  57                 return NULL;
  58         }
  59         r.in.level = _level;
  60
  61         mem_ctx = talloc_new(self->mem_ctx);
  62         if (mem_ctx == NULL) {
  63                 PyErr_NoMemory();
  64                 return NULL;
  65         }
  66
  67         status = libnet_Join_member(self->libnet_ctx, mem_ctx, &r);
  68         if (NT_STATUS_IS_ERR(status)) {
  69                 PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
  70                 talloc_free(mem_ctx);
  71                 return NULL;
  72         }
  73
  74         result = Py_BuildValue("sss", r.out.join_password,
  75                                dom_sid_string(mem_ctx, r.out.domain_sid),
  76                                r.out.domain_name);
  77
  78         talloc_free(mem_ctx);
  79
  80         return result;
  81 }
  82
  83 static const char py_net_join_member_doc[] = "join_member(domain_name, netbios_name, level) -> (join_password, domain_sid, domain_name)\n\n" \
  84 "Join the domain with the specified name.";
  85
  86 static PyObject *py_net_change_password(py_net_Object *self, PyObject *args, PyObject *kwargs)
  87 {
  88         union libnet_ChangePassword r;
  89         NTSTATUS status;
  90         TALLOC_CTX *mem_ctx;
  91         struct tevent_context *ev;
  92         const char *kwnames[] = { "newpassword", NULL };
  93
  94         ZERO_STRUCT(r);
  95
  96         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:change_password",
  97                                         discard_const_p(char *, kwnames),
  98                                         &r.generic.in.newpassword)) {
  99                 return NULL;
 100         }
 101
 102         r.generic.level = LIBNET_CHANGE_PASSWORD_GENERIC;
 103         r.generic.in.account_name = cli_credentials_get_username(self->libnet_ctx->cred);
 104         r.generic.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
 105         r.generic.in.oldpassword = cli_credentials_get_password(self->libnet_ctx->cred);
 106
 107         /* FIXME: we really need to get a context from the caller or we may end
 108          * up with 2 event contexts */
 109         ev = s4_event_context_init(NULL);
 110
 111         mem_ctx = talloc_new(ev);
 112         if (mem_ctx == NULL) {
 113                 PyErr_NoMemory();
 114                 return NULL;
 115         }
 116
 117         status = libnet_ChangePassword(self->libnet_ctx, mem_ctx, &r);
 118         if (NT_STATUS_IS_ERR(status)) {
 119                 PyErr_SetString(PyExc_RuntimeError,
 120                                 r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
 121                 talloc_free(mem_ctx);
 122                 return NULL;
 123         }
 124
 125         talloc_free(mem_ctx);
 126
 127         Py_RETURN_NONE;
 128 }
 129
 130 static const char py_net_change_password_doc[] = "change_password(newpassword) -> True\n\n" \
 131 "Change password for a user. You must supply credential with enough rights to do this.\n\n" \
 132 "Sample usage is:\n" \
 133 "net.set_password(newpassword=<new_password>\n";
 134
 135
 136 static PyObject *py_net_set_password(py_net_Object *self, PyObject *args, PyObject *kwargs)
 137 {
 138         union libnet_SetPassword r;
 139         NTSTATUS status;
 140         TALLOC_CTX *mem_ctx;
 141         struct tevent_context *ev;
 142         const char *kwnames[] = { "account_name", "domain_name", "newpassword", NULL };
 143
 144         ZERO_STRUCT(r);
 145
 146         r.generic.level = LIBNET_SET_PASSWORD_GENERIC;
 147
 148         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sss:set_password",
 149                                         discard_const_p(char *, kwnames),
 150                                          &r.generic.in.account_name,
 151                                          &r.generic.in.domain_name,
 152                                          &r.generic.in.newpassword)) {
 153                 return NULL;
 154         }
 155
 156         /* FIXME: we really need to get a context from the caller or we may end
 157          * up with 2 event contexts */
 158         ev = s4_event_context_init(NULL);
 159
 160         mem_ctx = talloc_new(ev);
 161         if (mem_ctx == NULL) {
 162                 PyErr_NoMemory();
 163                 return NULL;
 164         }
 165
 166         status = libnet_SetPassword(self->libnet_ctx, mem_ctx, &r);
 167         if (NT_STATUS_IS_ERR(status)) {
 168                 PyErr_SetString(PyExc_RuntimeError,
 169                                 r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
 170                 talloc_free(mem_ctx);
 171                 return NULL;
 172         }
 173
 174         talloc_free(mem_ctx);
 175
 176         Py_RETURN_NONE;
 177 }
 178
 179 static const char py_net_set_password_doc[] = "set_password(account_name, domain_name, newpassword) -> True\n\n" \
 180 "Set password for a user. You must supply credential with enough rights to do this.\n\n" \
 181 "Sample usage is:\n" \
 182 "net.set_password(account_name=<account_name>,\n" \
 183 "                domain_name=domain_name,\n" \
 184 "                newpassword=new_pass)\n";
 185
 186
 187 static PyObject *py_net_export_keytab(py_net_Object *self, PyObject *args, PyObject *kwargs)
 188 {
 189         struct libnet_export_keytab r;
 190         TALLOC_CTX *mem_ctx;
 191         const char *kwnames[] = { "keytab", NULL };
 192         NTSTATUS status;
 193
 194         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:export_keytab", discard_const_p(char *, kwnames),
 195                                          &r.in.keytab_name)) {
 196                 return NULL;
 197         }
 198
 199         mem_ctx = talloc_new(self->mem_ctx);
 200         if (mem_ctx == NULL) {
 201                 PyErr_NoMemory();
 202                 return NULL;
 203         }
 204
 205         status = libnet_export_keytab(self->libnet_ctx, mem_ctx, &r);
 206         if (NT_STATUS_IS_ERR(status)) {
 207                 PyErr_SetString(PyExc_RuntimeError,
 208                                 r.out.error_string?r.out.error_string:nt_errstr(status));
 209                 talloc_free(mem_ctx);
 210                 return NULL;
 211         }
 212
 213         talloc_free(mem_ctx);
 214
 215         Py_RETURN_NONE;
 216 }
 217
 218 static const char py_net_export_keytab_doc[] = "export_keytab(keytab, name)\n\n"
 219 "Export the DC keytab to a keytab file.";
 220
 221 static PyObject *py_net_time(py_net_Object *self, PyObject *args, PyObject *kwargs)
 222 {
 223         const char *kwnames[] = { "server_name", NULL };
 224         union libnet_RemoteTOD r;
 225         NTSTATUS status;
 226         TALLOC_CTX *mem_ctx;
 227         char timestr[64];
 228         PyObject *ret;
 229         struct tm *tm;
 230
 231         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s",
 232                 discard_const_p(char *, kwnames), &r.generic.in.server_name))
 233                 return NULL;
 234
 235         r.generic.level                 = LIBNET_REMOTE_TOD_GENERIC;
 236
 237         mem_ctx = talloc_new(NULL);
 238         if (mem_ctx == NULL) {
 239                 PyErr_NoMemory();
 240                 return NULL;
 241         }
 242
 243         status = libnet_RemoteTOD(self->libnet_ctx, mem_ctx, &r);
 244         if (!NT_STATUS_IS_OK(status)) {
 245                 PyErr_SetString(PyExc_RuntimeError,
 246                                 r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
 247                 talloc_free(mem_ctx);
 248                 return NULL;
 249         }
 250
 251         ZERO_STRUCT(timestr);
 252         tm = localtime(&r.generic.out.time);
 253         strftime(timestr, sizeof(timestr)-1, "%c %Z",tm);
 254
 255         ret = PyString_FromString(timestr);
 256
 257         talloc_free(mem_ctx);
 258
 259         return ret;
 260 }
 261
 262 static const char py_net_time_doc[] = "time(server_name) -> timestr\n"
 263 "Retrieve the remote time on a server";
 264
 265 static PyObject *py_net_user_create(py_net_Object *self, PyObject *args, PyObject *kwargs)
 266 {
 267         const char *kwnames[] = { "username", NULL };
 268         NTSTATUS status;
 269         TALLOC_CTX *mem_ctx;
 270         struct libnet_CreateUser r;
 271
 272         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", discard_const_p(char *, kwnames),
 273                                                                          &r.in.user_name))
 274                 return NULL;
 275
 276         r.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
 277
 278         mem_ctx = talloc_new(NULL);
 279         if (mem_ctx == NULL) {
 280                 PyErr_NoMemory();
 281                 return NULL;
 282         }
 283
 284         status = libnet_CreateUser(self->libnet_ctx, mem_ctx, &r);
 285         if (!NT_STATUS_IS_OK(status)) {
 286                 PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
 287                 talloc_free(mem_ctx);
 288                 return NULL;
 289         }
 290
 291         talloc_free(mem_ctx);
 292
 293         Py_RETURN_NONE;
 294 }
 295
 296 static const char py_net_create_user_doc[] = "create_user(username)\n"
 297 "Create a new user.";
 298
 299 static PyObject *py_net_user_delete(py_net_Object *self, PyObject *args, PyObject *kwargs)
 300 {
 301         const char *kwnames[] = { "username", NULL };
 302         NTSTATUS status;
 303         TALLOC_CTX *mem_ctx;
 304         struct libnet_DeleteUser r;
 305
 306         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", discard_const_p(char *, kwnames),
 307                                                                          &r.in.user_name))
 308                 return NULL;
 309
 310         r.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
 311
 312         mem_ctx = talloc_new(NULL);
 313         if (mem_ctx == NULL) {
 314                 PyErr_NoMemory();
 315                 return NULL;
 316         }
 317
 318         status = libnet_DeleteUser(self->libnet_ctx, mem_ctx, &r);
 319         if (!NT_STATUS_IS_OK(status)) {
 320                 PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
 321                 talloc_free(mem_ctx);
 322                 return NULL;
 323         }
 324
 325         talloc_free(mem_ctx);
 326
 327         Py_RETURN_NONE;
 328 }
 329
 330 static const char py_net_delete_user_doc[] = "delete_user(username)\n"
 331 "Delete a user.";
 332
 333 static PyObject *py_dom_sid_FromSid(struct dom_sid *sid)
 334 {
 335         PyObject *mod_security, *dom_sid_Type;
 336
 337         mod_security = PyImport_ImportModule("samba.dcerpc.security");
 338         if (mod_security == NULL)
 339                 return NULL;
 340
 341         dom_sid_Type = PyObject_GetAttrString(mod_security, "dom_sid");
 342         if (dom_sid_Type == NULL)
 343                 return NULL;
 344
 345         return pytalloc_reference((PyTypeObject *)dom_sid_Type, sid);
 346 }
 347
 348 static PyObject *py_net_vampire(py_net_Object *self, PyObject *args, PyObject *kwargs)
 349 {
 350         const char *kwnames[] = { "domain", "target_dir", NULL };
 351         NTSTATUS status;
 352         TALLOC_CTX *mem_ctx;
 353         PyObject *ret;
 354         struct libnet_Vampire r;
 355
 356         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|z", discard_const_p(char *, kwnames),
 357                                          &r.in.domain_name, &r.in.targetdir)) {
 358                 return NULL;
 359         }
 360
 361         r.in.netbios_name  = lpcfg_netbios_name(self->libnet_ctx->lp_ctx);
 362         r.out.error_string = NULL;
 363
 364         mem_ctx = talloc_new(NULL);
 365         if (mem_ctx == NULL) {
 366                 PyErr_NoMemory();
 367                 return NULL;
 368         }
 369
 370         status = libnet_Vampire(self->libnet_ctx, mem_ctx, &r);
 371
 372         if (!NT_STATUS_IS_OK(status)) {
 373                 PyErr_SetString(PyExc_RuntimeError,
 374                                 r.out.error_string ? r.out.error_string : nt_errstr(status));
 375                 talloc_free(mem_ctx);
 376                 return NULL;
 377         }
 378
 379         ret = Py_BuildValue("(sO)", r.out.domain_name, py_dom_sid_FromSid(r.out.domain_sid));
 380
 381         talloc_free(mem_ctx);
 382
 383         return ret;
 384 }
 385
 386 struct replicate_state {
 387         void *vampire_state;
 388         dcerpc_InterfaceObject *drs_pipe;
 389         struct libnet_BecomeDC_StoreChunk chunk;
 390         DATA_BLOB gensec_skey;
 391         struct libnet_BecomeDC_Partition partition;
 392         struct libnet_BecomeDC_Forest forest;
 393         struct libnet_BecomeDC_DestDSA dest_dsa;
 394 };
 395
 396 /*
 397   setup for replicate_chunk() calls
 398  */
 399 static PyObject *py_net_replicate_init(py_net_Object *self, PyObject *args, PyObject *kwargs)
 400 {
 401         const char *kwnames[] = { "samdb", "lp", "drspipe", NULL };
 402         PyObject *py_ldb, *py_lp, *py_drspipe;
 403         struct ldb_context *samdb;
 404         struct loadparm_context *lp;
 405         struct replicate_state *s;
 406         NTSTATUS status;
 407
 408         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO",
 409                                          discard_const_p(char *, kwnames),
 410                                          &py_ldb, &py_lp, &py_drspipe)) {
 411                 return NULL;
 412         }
 413
 414         s = talloc_zero(NULL, struct replicate_state);
 415         if (!s) return NULL;
 416
 417         lp = lpcfg_from_py_object(s, py_lp);
 418         if (lp == NULL) {
 419                 PyErr_SetString(PyExc_TypeError, "Expected lp object");
 420                 talloc_free(s);
 421                 return NULL;
 422         }
 423
 424         samdb = pyldb_Ldb_AsLdbContext(py_ldb);
 425         if (samdb == NULL) {
 426                 PyErr_SetString(PyExc_TypeError, "Expected ldb object");
 427                 talloc_free(s);
 428                 return NULL;
 429         }
 430
 431         s->drs_pipe = (dcerpc_InterfaceObject *)(py_drspipe);
 432
 433         s->vampire_state = libnet_vampire_replicate_init(s, samdb, lp);
 434         if (s->vampire_state == NULL) {
 435                 PyErr_SetString(PyExc_TypeError, "Failed to initialise vampire_state");
 436                 talloc_free(s);
 437                 return NULL;
 438         }
 439
 440         status = gensec_session_key(s->drs_pipe->pipe->conn->security_state.generic_state,
 441                                     s,
 442                                     &s->gensec_skey);
 443         if (!NT_STATUS_IS_OK(status)) {
 444                 PyErr_Format(PyExc_RuntimeError, "Unable to get session key from drspipe: %s",
 445                              nt_errstr(status));
 446                 talloc_free(s);
 447                 return NULL;
 448         }
 449
 450         s->forest.dns_name = lpcfg_dnsdomain(lp);
 451
 452         s->chunk.gensec_skey = &s->gensec_skey;
 453         s->chunk.partition = &s->partition;
 454         s->chunk.forest = &s->forest;
 455         s->chunk.dest_dsa = &s->dest_dsa;
 456
 457         return pytalloc_CObject_FromTallocPtr(s);
 458 }
 459
 460
 461 /*
 462   process one replication chunk
 463  */
 464 static PyObject *py_net_replicate_chunk(py_net_Object *self, PyObject *args, PyObject *kwargs)
 465 {
 466         const char *kwnames[] = { "state", "level", "ctr",
 467                                   "schema", "req_level", "req",
 468                                   NULL };
 469         PyObject *py_state, *py_ctr, *py_schema, *py_req;
 470         struct replicate_state *s;
 471         unsigned level;
 472         unsigned req_level = 0;
 473         NTSTATUS (*chunk_handler)(void *private_data, const struct libnet_BecomeDC_StoreChunk *c);
 474         NTSTATUS status;
 475
 476         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OIO|OIO",
 477                                          discard_const_p(char *, kwnames),
 478                                          &py_state, &level, &py_ctr,
 479                                          &py_schema, &req_level, &py_req)) {
 480                 return NULL;
 481         }
 482
 483         s = talloc_get_type(PyCObject_AsVoidPtr(py_state), struct replicate_state);
 484         if (!s) {
 485                 PyErr_SetString(PyExc_TypeError, "Expected replication_state");
 486                 return NULL;
 487         }
 488
 489         switch (level) {
 490         case 1:
 491                 if (!py_check_dcerpc_type(py_ctr, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr1")) {
 492                         return NULL;
 493                 }
 494                 s->chunk.ctr1                         = pytalloc_get_ptr(py_ctr);
 495                 s->partition.nc                       = *s->chunk.ctr1->naming_context;
 496                 s->partition.more_data                = s->chunk.ctr1->more_data;
 497                 s->partition.source_dsa_guid          = s->chunk.ctr1->source_dsa_guid;
 498                 s->partition.source_dsa_invocation_id = s->chunk.ctr1->source_dsa_invocation_id;
 499                 s->partition.highwatermark            = s->chunk.ctr1->new_highwatermark;
 500                 break;
 501         case 6:
 502                 if (!py_check_dcerpc_type(py_ctr, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr6")) {
 503                         return NULL;
 504                 }
 505                 s->chunk.ctr6                         = pytalloc_get_ptr(py_ctr);
 506                 s->partition.nc                       = *s->chunk.ctr6->naming_context;
 507                 s->partition.more_data                = s->chunk.ctr6->more_data;
 508                 s->partition.source_dsa_guid          = s->chunk.ctr6->source_dsa_guid;
 509                 s->partition.source_dsa_invocation_id = s->chunk.ctr6->source_dsa_invocation_id;
 510                 s->partition.highwatermark            = s->chunk.ctr6->new_highwatermark;
 511                 break;
 512         default:
 513                 PyErr_Format(PyExc_TypeError, "Bad level %u in replicate_chunk", level);
 514                 return NULL;
 515         }
 516
 517         s->chunk.req5 = NULL;
 518         s->chunk.req8 = NULL;
 519         s->chunk.req10 = NULL;
 520         if (py_req) {
 521                 switch (req_level) {
 522                 case 0:
 523                         break;
 524                 case 5:
 525                         if (!py_check_dcerpc_type(py_req, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest5")) {
 526                                 return NULL;
 527                         }
 528
 529                         s->chunk.req5 = pytalloc_get_ptr(py_req);
 530                         break;
 531                 case 8:
 532                         if (!py_check_dcerpc_type(py_req, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest8")) {
 533                                 return NULL;
 534                         }
 535
 536                         s->chunk.req8 = pytalloc_get_ptr(py_req);
 537                         break;
 538                 case 10:
 539                         if (!py_check_dcerpc_type(py_req, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest10")) {
 540                                 return NULL;
 541                         }
 542
 543                         s->chunk.req10 = pytalloc_get_ptr(py_req);
 544                         break;
 545                 default:
 546                         PyErr_Format(PyExc_TypeError, "Bad req_level %u in replicate_chunk", req_level);
 547                         return NULL;
 548                 }
 549         }
 550         s->chunk.req_level = req_level;
 551
 552         chunk_handler = libnet_vampire_cb_store_chunk;
 553         if (py_schema) {
 554                 if (!PyBool_Check(py_schema)) {
 555                         PyErr_SetString(PyExc_TypeError, "Expected boolean schema");
 556                         return NULL;
 557                 }
 558                 if (py_schema == Py_True) {
 559                         chunk_handler = libnet_vampire_cb_schema_chunk;
 560                 }
 561         }
 562
 563         s->chunk.ctr_level = level;
 564
 565         status = chunk_handler(s->vampire_state, &s->chunk);
 566         if (!NT_STATUS_IS_OK(status)) {
 567                 PyErr_Format(PyExc_TypeError, "Failed to process chunk: %s", nt_errstr(status));
 568                 return NULL;
 569         }
 570
 571         Py_RETURN_NONE;
 572 }
 573
 574
 575 /*
 576   find a DC given a domain name and server type
 577  */
 578 static PyObject *py_net_finddc(py_net_Object *self, PyObject *args)
 579 {
 580         const char *domain_name;
 581         unsigned server_type;
 582         NTSTATUS status;
 583         struct finddcs *io;
 584         TALLOC_CTX *mem_ctx;
 585         PyObject *ret;
 586
 587         if (!PyArg_ParseTuple(args, "sI", &domain_name, &server_type)) {
 588                 return NULL;
 589         }
 590
 591         mem_ctx = talloc_new(self->mem_ctx);
 592
 593         io = talloc_zero(mem_ctx, struct finddcs);
 594         io->in.domain_name = domain_name;
 595         io->in.minimum_dc_flags = server_type;
 596
 597         status = finddcs_cldap(io, io,
 598                                lpcfg_resolve_context(self->libnet_ctx->lp_ctx), self->ev);
 599         if (NT_STATUS_IS_ERR(status)) {
 600                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
 601                 talloc_free(mem_ctx);
 602                 return NULL;
 603         }
 604
 605         ret = py_return_ndr_struct("samba.dcerpc.nbt", "NETLOGON_SAM_LOGON_RESPONSE_EX",
 606                                    io, &io->out.netlogon.data.nt5_ex);
 607         talloc_free(mem_ctx);
 608
 609         return ret;
 610 }
 611
 612
 613 static const char py_net_vampire_doc[] = "vampire(domain, target_dir=None)\n"
 614                                          "Vampire a domain.";
 615
 616 static const char py_net_replicate_init_doc[] = "replicate_init(samdb, lp, drspipe)\n"
 617                                          "Setup for replicate_chunk calls.";
 618
 619 static const char py_net_replicate_chunk_doc[] = "replicate_chunk(state, level, ctr, schema)\n"
 620                                          "Process replication for one chunk";
 621
 622 static const char py_net_finddc_doc[] = "finddc(domain, server_type)\n"
 623                                          "find a DC with the specified server_type bits. Return the DNS name";
 624
 625 static PyMethodDef net_obj_methods[] = {
 626         {"join_member", (PyCFunction)py_net_join_member, METH_VARARGS|METH_KEYWORDS, py_net_join_member_doc},
 627         {"change_password", (PyCFunction)py_net_change_password, METH_VARARGS|METH_KEYWORDS, py_net_change_password_doc},
 628         {"set_password", (PyCFunction)py_net_set_password, METH_VARARGS|METH_KEYWORDS, py_net_set_password_doc},
 629         {"export_keytab", (PyCFunction)py_net_export_keytab, METH_VARARGS|METH_KEYWORDS, py_net_export_keytab_doc},
 630         {"time", (PyCFunction)py_net_time, METH_VARARGS|METH_KEYWORDS, py_net_time_doc},
 631         {"create_user", (PyCFunction)py_net_user_create, METH_VARARGS|METH_KEYWORDS, py_net_create_user_doc},
 632         {"delete_user", (PyCFunction)py_net_user_delete, METH_VARARGS|METH_KEYWORDS, py_net_delete_user_doc},
 633         {"vampire", (PyCFunction)py_net_vampire, METH_VARARGS|METH_KEYWORDS, py_net_vampire_doc},
 634         {"replicate_init", (PyCFunction)py_net_replicate_init, METH_VARARGS|METH_KEYWORDS, py_net_replicate_init_doc},
 635         {"replicate_chunk", (PyCFunction)py_net_replicate_chunk, METH_VARARGS|METH_KEYWORDS, py_net_replicate_chunk_doc},
 636         {"finddc", (PyCFunction)py_net_finddc, METH_VARARGS, py_net_finddc_doc},
 637         { NULL }
 638 };
 639
 640 static void py_net_dealloc(py_net_Object *self)
 641 {
 642         talloc_free(self->mem_ctx);
 643         PyObject_Del(self);
 644 }
 645
 646 static PyObject *net_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 647 {
 648         PyObject *py_creds, *py_lp = Py_None;
 649         const char *kwnames[] = { "creds", "lp", "server", NULL };
 650         py_net_Object *ret;
 651         struct loadparm_context *lp;
 652         const char *server_address = NULL;
 653
 654         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oz",
 655                                          discard_const_p(char *, kwnames), &py_creds, &py_lp,
 656                                          &server_address))
 657                 return NULL;
 658
 659         ret = PyObject_New(py_net_Object, type);
 660         if (ret == NULL) {
 661                 return NULL;
 662         }
 663
 664         /* FIXME: we really need to get a context from the caller or we may end
 665          * up with 2 event contexts */
 666         ret->ev = s4_event_context_init(NULL);
 667         ret->mem_ctx = talloc_new(ret->ev);
 668
 669         lp = lpcfg_from_py_object(ret->mem_ctx, py_lp);
 670         if (lp == NULL) {
 671                 Py_DECREF(ret);
 672                 return NULL;
 673         }
 674
 675         ret->libnet_ctx = libnet_context_init(ret->ev, lp);
 676         if (ret->libnet_ctx == NULL) {
 677                 PyErr_SetString(PyExc_RuntimeError, "Unable to initialize net");
 678                 Py_DECREF(ret);
 679                 return NULL;
 680         }
 681
 682         ret->libnet_ctx->server_address = server_address;
 683
 684         ret->libnet_ctx->cred = cli_credentials_from_py_object(py_creds);
 685         if (ret->libnet_ctx->cred == NULL) {
 686                 PyErr_SetString(PyExc_TypeError, "Expected credentials object");
 687                 Py_DECREF(ret);
 688                 return NULL;
 689         }
 690
 691         return (PyObject *)ret;
 692 }
 693
 694
 695 PyTypeObject py_net_Type = {
 696         PyObject_HEAD_INIT(NULL) 0,
 697         .tp_name = "net.Net",
 698         .tp_basicsize = sizeof(py_net_Object),
 699         .tp_dealloc = (destructor)py_net_dealloc,
 700         .tp_methods = net_obj_methods,
 701         .tp_new = net_obj_new,
 702 };
 703
 704 void initnet(void)
 705 {
 706         PyObject *m;
 707
 708         if (PyType_Ready(&py_net_Type) < 0)
 709                 return;
 710
 711         m = Py_InitModule3("net", NULL, NULL);
 712         if (m == NULL)
 713                 return;
 714
 715         Py_INCREF(&py_net_Type);
 716         PyModule_AddObject(m, "Net", (PyObject *)&py_net_Type);
 717         PyModule_AddObject(m, "LIBNET_JOINDOMAIN_AUTOMATIC", PyInt_FromLong(LIBNET_JOINDOMAIN_AUTOMATIC));
 718         PyModule_AddObject(m, "LIBNET_JOINDOMAIN_SPECIFIED", PyInt_FromLong(LIBNET_JOINDOMAIN_SPECIFIED));
 719         PyModule_AddObject(m, "LIBNET_JOIN_AUTOMATIC", PyInt_FromLong(LIBNET_JOIN_AUTOMATIC));
 720         PyModule_AddObject(m, "LIBNET_JOIN_SPECIFIED", PyInt_FromLong(LIBNET_JOIN_SPECIFIED));
 721 }