2 Unix SMB/CIFS implementation.
3 Samba utility functions
5 Copyright (C) Jelmer Vernooij <jelmer@samba.org> 2008-2010
6 Copyright (C) Kamen Mazdrashki <kamen.mazdrashki@postpath.com> 2009
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.
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.
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/>.
23 #include "python/py3compat.h"
28 #include "auth/credentials/pycredentials.h"
29 #include "libcli/security/security.h"
30 #include "lib/events/events.h"
31 #include "param/pyparam.h"
32 #include "auth/gensec/gensec.h"
33 #include "librpc/rpc/pyrpc_util.h"
34 #include "libcli/resolve/resolve.h"
35 #include "libcli/finddc.h"
36 #include "dsdb/samdb/samdb.h"
38 #include "librpc/rpc/pyrpc_util.h"
39 #include "libcli/drsuapi/drsuapi.h"
41 static void PyErr_SetDsExtendedError(enum drsuapi_DsExtendedError ext_err
, const char *error_description
)
43 PyObject
*error
= PyObject_GetAttrString(PyImport_ImportModule("samba"),
45 if (error_description
== NULL
) {
47 /* Copied out of ndr_drsuapi.c:ndr_print_drsuapi_DsExtendedError() */
48 case DRSUAPI_EXOP_ERR_NONE
:
49 error_description
= "DRSUAPI_EXOP_ERR_NONE";
51 case DRSUAPI_EXOP_ERR_SUCCESS
:
52 error_description
= "DRSUAPI_EXOP_ERR_SUCCESS";
54 case DRSUAPI_EXOP_ERR_UNKNOWN_OP
:
55 error_description
= "DRSUAPI_EXOP_ERR_UNKNOWN_OP";
57 case DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER
:
58 error_description
= "DRSUAPI_EXOP_ERR_FSMO_NOT_OWNER";
60 case DRSUAPI_EXOP_ERR_UPDATE_ERR
:
61 error_description
= "DRSUAPI_EXOP_ERR_UPDATE_ERR";
63 case DRSUAPI_EXOP_ERR_EXCEPTION
:
64 error_description
= "DRSUAPI_EXOP_ERR_EXCEPTION";
66 case DRSUAPI_EXOP_ERR_UNKNOWN_CALLER
:
67 error_description
= "DRSUAPI_EXOP_ERR_UNKNOWN_CALLER";
69 case DRSUAPI_EXOP_ERR_RID_ALLOC
:
70 error_description
= "DRSUAPI_EXOP_ERR_RID_ALLOC";
72 case DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED
:
73 error_description
= "DRSUAPI_EXOP_ERR_FSMO_OWNER_DELETED";
75 case DRSUAPI_EXOP_ERR_FMSO_PENDING_OP
:
76 error_description
= "DRSUAPI_EXOP_ERR_FMSO_PENDING_OP";
78 case DRSUAPI_EXOP_ERR_MISMATCH
:
79 error_description
= "DRSUAPI_EXOP_ERR_MISMATCH";
81 case DRSUAPI_EXOP_ERR_COULDNT_CONTACT
:
82 error_description
= "DRSUAPI_EXOP_ERR_COULDNT_CONTACT";
84 case DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES
:
85 error_description
= "DRSUAPI_EXOP_ERR_FSMO_REFUSING_ROLES";
87 case DRSUAPI_EXOP_ERR_DIR_ERROR
:
88 error_description
= "DRSUAPI_EXOP_ERR_DIR_ERROR";
90 case DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS
:
91 error_description
= "DRSUAPI_EXOP_ERR_FSMO_MISSING_SETTINGS";
93 case DRSUAPI_EXOP_ERR_ACCESS_DENIED
:
94 error_description
= "DRSUAPI_EXOP_ERR_ACCESS_DENIED";
96 case DRSUAPI_EXOP_ERR_PARAM_ERROR
:
97 error_description
= "DRSUAPI_EXOP_ERR_PARAM_ERROR";
101 PyErr_SetObject(error
,
102 Py_BuildValue(discard_const_p(char, "(i,s)"),
107 static PyObject
*py_net_join_member(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
109 struct libnet_Join_member r
;
114 const char *kwnames
[] = { "domain_name", "netbios_name", "level", "machinepass", NULL
};
118 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "ssi|z:Join", discard_const_p(char *, kwnames
),
119 &r
.in
.domain_name
, &r
.in
.netbios_name
,
121 &r
.in
.account_pass
)) {
126 mem_ctx
= talloc_new(self
->mem_ctx
);
127 if (mem_ctx
== NULL
) {
132 status
= libnet_Join_member(self
->libnet_ctx
, mem_ctx
, &r
);
133 if (NT_STATUS_IS_ERR(status
)) {
134 PyErr_SetNTSTATUS_and_string(status
,
137 : nt_errstr(status
));
138 talloc_free(mem_ctx
);
142 result
= Py_BuildValue("sss", r
.out
.join_password
,
143 dom_sid_string(mem_ctx
, r
.out
.domain_sid
),
146 talloc_free(mem_ctx
);
151 static const char py_net_join_member_doc
[] = "join_member(domain_name, netbios_name, level) -> (join_password, domain_sid, domain_name)\n\n" \
152 "Join the domain with the specified name.";
154 static PyObject
*py_net_change_password(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
156 union libnet_ChangePassword r
;
159 struct tevent_context
*ev
;
160 const char *kwnames
[] = { "newpassword", "oldpassword", "domain", "username", NULL
};
164 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s|sss:change_password",
165 discard_const_p(char *, kwnames
),
166 &r
.generic
.in
.newpassword
,
167 &r
.generic
.in
.oldpassword
,
168 &r
.generic
.in
.domain_name
,
169 &r
.generic
.in
.account_name
)) {
173 r
.generic
.level
= LIBNET_CHANGE_PASSWORD_GENERIC
;
174 if (r
.generic
.in
.account_name
== NULL
) {
175 r
.generic
.in
.account_name
176 = cli_credentials_get_username(self
->libnet_ctx
->cred
);
178 if (r
.generic
.in
.domain_name
== NULL
) {
179 r
.generic
.in
.domain_name
180 = cli_credentials_get_domain(self
->libnet_ctx
->cred
);
182 if (r
.generic
.in
.oldpassword
== NULL
) {
183 r
.generic
.in
.oldpassword
184 = cli_credentials_get_password(self
->libnet_ctx
->cred
);
187 /* FIXME: we really need to get a context from the caller or we may end
188 * up with 2 event contexts */
189 ev
= s4_event_context_init(NULL
);
191 mem_ctx
= talloc_new(ev
);
192 if (mem_ctx
== NULL
) {
197 status
= libnet_ChangePassword(self
->libnet_ctx
, mem_ctx
, &r
);
198 if (NT_STATUS_IS_ERR(status
)) {
199 PyErr_SetNTSTATUS_and_string(status
,
200 r
.generic
.out
.error_string
201 ? r
.generic
.out
.error_string
202 : nt_errstr(status
));
203 talloc_free(mem_ctx
);
207 talloc_free(mem_ctx
);
212 static const char py_net_change_password_doc
[] = "change_password(newpassword) -> True\n\n" \
213 "Change password for a user. You must supply credential with enough rights to do this.\n\n" \
214 "Sample usage is:\n" \
215 "net.change_password(newpassword=<new_password>)\n";
218 static PyObject
*py_net_set_password(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
220 union libnet_SetPassword r
;
223 struct tevent_context
*ev
;
224 const char *kwnames
[] = { "account_name", "domain_name", "newpassword", NULL
};
228 r
.generic
.level
= LIBNET_SET_PASSWORD_GENERIC
;
230 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "sss:set_password",
231 discard_const_p(char *, kwnames
),
232 &r
.generic
.in
.account_name
,
233 &r
.generic
.in
.domain_name
,
234 &r
.generic
.in
.newpassword
)) {
238 /* FIXME: we really need to get a context from the caller or we may end
239 * up with 2 event contexts */
240 ev
= s4_event_context_init(NULL
);
242 mem_ctx
= talloc_new(ev
);
243 if (mem_ctx
== NULL
) {
248 status
= libnet_SetPassword(self
->libnet_ctx
, mem_ctx
, &r
);
249 if (NT_STATUS_IS_ERR(status
)) {
250 PyErr_SetNTSTATUS_and_string(status
,
251 r
.generic
.out
.error_string
252 ? r
.generic
.out
.error_string
253 : nt_errstr(status
));
254 talloc_free(mem_ctx
);
258 talloc_free(mem_ctx
);
263 static const char py_net_set_password_doc
[] = "set_password(account_name, domain_name, newpassword) -> True\n\n" \
264 "Set password for a user. You must supply credential with enough rights to do this.\n\n" \
265 "Sample usage is:\n" \
266 "net.set_password(account_name=account_name, domain_name=domain_name, newpassword=new_pass)\n";
269 static PyObject
*py_net_time(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
271 const char *kwnames
[] = { "server_name", NULL
};
272 union libnet_RemoteTOD r
;
279 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s",
280 discard_const_p(char *, kwnames
), &r
.generic
.in
.server_name
))
283 r
.generic
.level
= LIBNET_REMOTE_TOD_GENERIC
;
285 mem_ctx
= talloc_new(NULL
);
286 if (mem_ctx
== NULL
) {
291 status
= libnet_RemoteTOD(self
->libnet_ctx
, mem_ctx
, &r
);
292 if (!NT_STATUS_IS_OK(status
)) {
293 PyErr_SetNTSTATUS_and_string(status
,
294 r
.generic
.out
.error_string
295 ? r
.generic
.out
.error_string
296 : nt_errstr(status
));
297 talloc_free(mem_ctx
);
301 ZERO_STRUCT(timestr
);
302 tm
= localtime(&r
.generic
.out
.time
);
303 strftime(timestr
, sizeof(timestr
)-1, "%c %Z",tm
);
305 ret
= PyStr_FromString(timestr
);
307 talloc_free(mem_ctx
);
312 static const char py_net_time_doc
[] = "time(server_name) -> timestr\n"
313 "Retrieve the remote time on a server";
315 static PyObject
*py_net_user_create(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
317 const char *kwnames
[] = { "username", NULL
};
320 struct libnet_CreateUser r
;
322 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s", discard_const_p(char *, kwnames
),
326 r
.in
.domain_name
= cli_credentials_get_domain(self
->libnet_ctx
->cred
);
328 mem_ctx
= talloc_new(NULL
);
329 if (mem_ctx
== NULL
) {
334 status
= libnet_CreateUser(self
->libnet_ctx
, mem_ctx
, &r
);
335 if (!NT_STATUS_IS_OK(status
)) {
336 PyErr_SetNTSTATUS_and_string(status
,
339 : nt_errstr(status
));
340 talloc_free(mem_ctx
);
344 talloc_free(mem_ctx
);
349 static const char py_net_create_user_doc
[] = "create_user(username)\n"
350 "Create a new user.";
352 static PyObject
*py_net_user_delete(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
354 const char *kwnames
[] = { "username", NULL
};
357 struct libnet_DeleteUser r
;
359 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s", discard_const_p(char *, kwnames
),
363 r
.in
.domain_name
= cli_credentials_get_domain(self
->libnet_ctx
->cred
);
365 mem_ctx
= talloc_new(NULL
);
366 if (mem_ctx
== NULL
) {
371 status
= libnet_DeleteUser(self
->libnet_ctx
, mem_ctx
, &r
);
372 if (!NT_STATUS_IS_OK(status
)) {
373 PyErr_SetNTSTATUS_and_string(status
,
376 : nt_errstr(status
));
377 talloc_free(mem_ctx
);
381 talloc_free(mem_ctx
);
386 static const char py_net_delete_user_doc
[] = "delete_user(username)\n"
389 struct replicate_state
{
391 dcerpc_InterfaceObject
*drs_pipe
;
392 struct libnet_BecomeDC_StoreChunk chunk
;
393 DATA_BLOB gensec_skey
;
394 struct libnet_BecomeDC_Partition partition
;
395 struct libnet_BecomeDC_Forest forest
;
396 struct libnet_BecomeDC_DestDSA dest_dsa
;
400 setup for replicate_chunk() calls
402 static PyObject
*py_net_replicate_init(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
404 const char *kwnames
[] = { "samdb", "lp", "drspipe", "invocation_id", NULL
};
405 PyObject
*py_ldb
, *py_lp
, *py_drspipe
, *py_invocation_id
;
406 struct ldb_context
*samdb
;
407 struct loadparm_context
*lp
;
408 struct replicate_state
*s
;
411 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "OOOO",
412 discard_const_p(char *, kwnames
),
413 &py_ldb
, &py_lp
, &py_drspipe
,
414 &py_invocation_id
)) {
418 s
= talloc_zero(NULL
, struct replicate_state
);
421 lp
= lpcfg_from_py_object(s
, py_lp
);
423 PyErr_SetString(PyExc_TypeError
, "Expected lp object");
428 samdb
= pyldb_Ldb_AsLdbContext(py_ldb
);
430 PyErr_SetString(PyExc_TypeError
, "Expected ldb object");
434 if (!py_check_dcerpc_type(py_invocation_id
, "samba.dcerpc.misc", "GUID")) {
439 s
->dest_dsa
.invocation_id
= *pytalloc_get_type(py_invocation_id
, struct GUID
);
441 s
->drs_pipe
= (dcerpc_InterfaceObject
*)(py_drspipe
);
443 s
->vampire_state
= libnet_vampire_replicate_init(s
, samdb
, lp
);
444 if (s
->vampire_state
== NULL
) {
445 PyErr_SetString(PyExc_TypeError
, "Failed to initialise vampire_state");
450 status
= gensec_session_key(s
->drs_pipe
->pipe
->conn
->security_state
.generic_state
,
453 if (!NT_STATUS_IS_OK(status
)) {
454 char *error_string
= talloc_asprintf(s
,
455 "Unable to get session key from drspipe: %s",
457 PyErr_SetNTSTATUS_and_string(status
, error_string
);
462 s
->forest
.dns_name
= samdb_dn_to_dns_domain(s
, ldb_get_root_basedn(samdb
));
463 s
->forest
.root_dn_str
= ldb_dn_get_linearized(ldb_get_root_basedn(samdb
));
464 s
->forest
.config_dn_str
= ldb_dn_get_linearized(ldb_get_config_basedn(samdb
));
465 s
->forest
.schema_dn_str
= ldb_dn_get_linearized(ldb_get_schema_basedn(samdb
));
467 s
->chunk
.gensec_skey
= &s
->gensec_skey
;
468 s
->chunk
.partition
= &s
->partition
;
469 s
->chunk
.forest
= &s
->forest
;
470 s
->chunk
.dest_dsa
= &s
->dest_dsa
;
472 return pytalloc_GenericObject_steal(s
);
477 process one replication chunk
479 static PyObject
*py_net_replicate_chunk(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
481 const char *kwnames
[] = { "state", "level", "ctr",
482 "schema", "req_level", "req",
484 PyObject
*py_state
, *py_ctr
, *py_schema
= Py_None
, *py_req
= Py_None
;
485 struct replicate_state
*s
;
487 unsigned req_level
= 0;
488 WERROR (*chunk_handler
)(void *private_data
, const struct libnet_BecomeDC_StoreChunk
*c
);
490 enum drsuapi_DsExtendedError extended_ret
= DRSUAPI_EXOP_ERR_NONE
;
491 enum drsuapi_DsExtendedOperation exop
= DRSUAPI_EXOP_NONE
;
493 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "OIO|OIO",
494 discard_const_p(char *, kwnames
),
495 &py_state
, &level
, &py_ctr
,
496 &py_schema
, &req_level
, &py_req
)) {
500 s
= pytalloc_get_type(py_state
, struct replicate_state
);
507 if (!py_check_dcerpc_type(py_ctr
, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr1")) {
510 s
->chunk
.ctr1
= pytalloc_get_ptr(py_ctr
);
511 if (s
->chunk
.ctr1
->naming_context
!= NULL
) {
512 s
->partition
.nc
= *s
->chunk
.ctr1
->naming_context
;
514 extended_ret
= s
->chunk
.ctr1
->extended_ret
;
515 s
->partition
.more_data
= s
->chunk
.ctr1
->more_data
;
516 s
->partition
.source_dsa_guid
= s
->chunk
.ctr1
->source_dsa_guid
;
517 s
->partition
.source_dsa_invocation_id
= s
->chunk
.ctr1
->source_dsa_invocation_id
;
518 s
->partition
.highwatermark
= s
->chunk
.ctr1
->new_highwatermark
;
521 if (!py_check_dcerpc_type(py_ctr
, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr6")) {
524 s
->chunk
.ctr6
= pytalloc_get_ptr(py_ctr
);
525 if (s
->chunk
.ctr6
->naming_context
!= NULL
) {
526 s
->partition
.nc
= *s
->chunk
.ctr6
->naming_context
;
528 extended_ret
= s
->chunk
.ctr6
->extended_ret
;
529 s
->partition
.more_data
= s
->chunk
.ctr6
->more_data
;
530 s
->partition
.source_dsa_guid
= s
->chunk
.ctr6
->source_dsa_guid
;
531 s
->partition
.source_dsa_invocation_id
= s
->chunk
.ctr6
->source_dsa_invocation_id
;
532 s
->partition
.highwatermark
= s
->chunk
.ctr6
->new_highwatermark
;
535 PyErr_Format(PyExc_TypeError
, "Bad level %u in replicate_chunk", level
);
539 s
->chunk
.req5
= NULL
;
540 s
->chunk
.req8
= NULL
;
541 s
->chunk
.req10
= NULL
;
547 if (!py_check_dcerpc_type(py_req
, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest5")) {
551 s
->chunk
.req5
= pytalloc_get_ptr(py_req
);
552 exop
= s
->chunk
.req5
->extended_op
;
555 if (!py_check_dcerpc_type(py_req
, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest8")) {
559 s
->chunk
.req8
= pytalloc_get_ptr(py_req
);
560 exop
= s
->chunk
.req8
->extended_op
;
563 if (!py_check_dcerpc_type(py_req
, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest10")) {
567 s
->chunk
.req10
= pytalloc_get_ptr(py_req
);
568 exop
= s
->chunk
.req10
->extended_op
;
571 PyErr_Format(PyExc_TypeError
, "Bad req_level %u in replicate_chunk", req_level
);
576 if (exop
!= DRSUAPI_EXOP_NONE
&& extended_ret
!= DRSUAPI_EXOP_ERR_SUCCESS
) {
577 PyErr_SetDsExtendedError(extended_ret
, NULL
);
581 s
->chunk
.req_level
= req_level
;
583 chunk_handler
= libnet_vampire_cb_store_chunk
;
585 if (!PyBool_Check(py_schema
)) {
586 PyErr_SetString(PyExc_TypeError
, "Expected boolean schema");
589 if (py_schema
== Py_True
) {
590 chunk_handler
= libnet_vampire_cb_schema_chunk
;
594 s
->chunk
.ctr_level
= level
;
596 werr
= chunk_handler(s
->vampire_state
, &s
->chunk
);
597 if (!W_ERROR_IS_OK(werr
)) {
599 = talloc_asprintf(NULL
,
600 "Failed to process 'chunk' of DRS replicated objects: %s",
602 PyErr_SetWERROR_and_string(werr
, error_string
);
603 TALLOC_FREE(error_string
);
612 just do the decryption of a DRS replicated attribute
614 static PyObject
*py_net_replicate_decrypt(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
616 const char *kwnames
[] = { "drspipe", "attribute", "rid", NULL
};
617 PyObject
*py_drspipe
, *py_attribute
;
619 dcerpc_InterfaceObject
*drs_pipe
;
622 DATA_BLOB gensec_skey
;
624 struct drsuapi_DsReplicaAttribute
*attribute
;
627 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "OOI",
628 discard_const_p(char *, kwnames
),
630 &py_attribute
, &rid
)) {
634 frame
= talloc_stackframe();
636 if (!py_check_dcerpc_type(py_drspipe
,
638 "ClientConnection")) {
641 drs_pipe
= (dcerpc_InterfaceObject
*)(py_drspipe
);
643 status
= gensec_session_key(drs_pipe
->pipe
->conn
->security_state
.generic_state
,
646 if (!NT_STATUS_IS_OK(status
)) {
648 = talloc_asprintf(frame
,
649 "Unable to get session key from drspipe: %s",
651 PyErr_SetNTSTATUS_and_string(status
, error_string
);
656 if (!py_check_dcerpc_type(py_attribute
, "samba.dcerpc.drsuapi",
657 "DsReplicaAttribute")) {
661 attribute
= pytalloc_get_ptr(py_attribute
);
662 context
= pytalloc_get_mem_ctx(py_attribute
);
663 werr
= drsuapi_decrypt_attribute(context
, &gensec_skey
,
665 if (!W_ERROR_IS_OK(werr
)) {
666 char *error_string
= talloc_asprintf(frame
,
667 "Unable to get decrypt attribute: %s",
669 PyErr_SetWERROR_and_string(werr
, error_string
);
681 find a DC given a domain name and server type
683 static PyObject
*py_net_finddc(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
685 const char *domain
= NULL
, *address
= NULL
;
686 unsigned server_type
;
691 const char * const kwnames
[] = { "flags", "domain", "address", NULL
};
693 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "I|zz",
694 discard_const_p(char *, kwnames
),
695 &server_type
, &domain
, &address
)) {
699 mem_ctx
= talloc_new(self
->mem_ctx
);
701 io
= talloc_zero(mem_ctx
, struct finddcs
);
702 if (domain
!= NULL
) {
703 io
->in
.domain_name
= domain
;
705 if (address
!= NULL
) {
706 io
->in
.server_address
= address
;
708 io
->in
.minimum_dc_flags
= server_type
;
710 status
= finddcs_cldap(io
, io
,
711 lpcfg_resolve_context(self
->libnet_ctx
->lp_ctx
), self
->ev
);
712 if (NT_STATUS_IS_ERR(status
)) {
713 PyErr_SetNTSTATUS(status
);
714 talloc_free(mem_ctx
);
718 ret
= py_return_ndr_struct("samba.dcerpc.nbt", "NETLOGON_SAM_LOGON_RESPONSE_EX",
719 io
, &io
->out
.netlogon
.data
.nt5_ex
);
720 talloc_free(mem_ctx
);
726 static const char py_net_replicate_init_doc
[] = "replicate_init(samdb, lp, drspipe)\n"
727 "Setup for replicate_chunk calls.";
729 static const char py_net_replicate_chunk_doc
[] = "replicate_chunk(state, level, ctr, schema)\n"
730 "Process replication for one chunk";
732 static const char py_net_replicate_decrypt_doc
[] = "replicate_decrypt(drs, attribute, rid)\n"
733 "Decrypt (in place) a DsReplicaAttribute replicated with drs.GetNCChanges()";
735 static const char py_net_finddc_doc
[] = "finddc(flags=server_type, domain=None, address=None)\n"
736 "Find a DC with the specified 'server_type' bits. The 'domain' and/or 'address' have to be used as additional search criteria. Returns the whole netlogon struct";
738 static PyMethodDef net_obj_methods
[] = {
739 {"join_member", (PyCFunction
)py_net_join_member
, METH_VARARGS
|METH_KEYWORDS
, py_net_join_member_doc
},
740 {"change_password", (PyCFunction
)py_net_change_password
, METH_VARARGS
|METH_KEYWORDS
, py_net_change_password_doc
},
741 {"set_password", (PyCFunction
)py_net_set_password
, METH_VARARGS
|METH_KEYWORDS
, py_net_set_password_doc
},
742 {"time", (PyCFunction
)py_net_time
, METH_VARARGS
|METH_KEYWORDS
, py_net_time_doc
},
743 {"create_user", (PyCFunction
)py_net_user_create
, METH_VARARGS
|METH_KEYWORDS
, py_net_create_user_doc
},
744 {"delete_user", (PyCFunction
)py_net_user_delete
, METH_VARARGS
|METH_KEYWORDS
, py_net_delete_user_doc
},
745 {"replicate_init", (PyCFunction
)py_net_replicate_init
, METH_VARARGS
|METH_KEYWORDS
, py_net_replicate_init_doc
},
746 {"replicate_chunk", (PyCFunction
)py_net_replicate_chunk
, METH_VARARGS
|METH_KEYWORDS
, py_net_replicate_chunk_doc
},
747 {"replicate_decrypt", (PyCFunction
)py_net_replicate_decrypt
, METH_VARARGS
|METH_KEYWORDS
, py_net_replicate_decrypt_doc
},
748 {"finddc", (PyCFunction
)py_net_finddc
, METH_VARARGS
|METH_KEYWORDS
, py_net_finddc_doc
},
752 static void py_net_dealloc(py_net_Object
*self
)
754 talloc_free(self
->mem_ctx
);
758 static PyObject
*net_obj_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwargs
)
760 PyObject
*py_creds
, *py_lp
= Py_None
;
761 const char *kwnames
[] = { "creds", "lp", "server", NULL
};
763 struct loadparm_context
*lp
;
764 const char *server_address
= NULL
;
766 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "O|Oz",
767 discard_const_p(char *, kwnames
), &py_creds
, &py_lp
,
771 ret
= PyObject_New(py_net_Object
, type
);
776 /* FIXME: we really need to get a context from the caller or we may end
777 * up with 2 event contexts */
778 ret
->ev
= s4_event_context_init(NULL
);
779 ret
->mem_ctx
= talloc_new(ret
->ev
);
781 lp
= lpcfg_from_py_object(ret
->mem_ctx
, py_lp
);
787 ret
->libnet_ctx
= libnet_context_init(ret
->ev
, lp
);
788 if (ret
->libnet_ctx
== NULL
) {
789 PyErr_SetString(PyExc_RuntimeError
, "Unable to initialize net");
794 ret
->libnet_ctx
->server_address
= server_address
;
796 ret
->libnet_ctx
->cred
= cli_credentials_from_py_object(py_creds
);
797 if (ret
->libnet_ctx
->cred
== NULL
) {
798 PyErr_SetString(PyExc_TypeError
, "Expected credentials object");
803 return (PyObject
*)ret
;
807 PyTypeObject py_net_Type
= {
808 PyVarObject_HEAD_INIT(NULL
, 0)
809 .tp_name
= "net.Net",
810 .tp_basicsize
= sizeof(py_net_Object
),
811 .tp_dealloc
= (destructor
)py_net_dealloc
,
812 .tp_methods
= net_obj_methods
,
813 .tp_new
= net_obj_new
,
816 static struct PyModuleDef moduledef
= {
817 PyModuleDef_HEAD_INIT
,
822 MODULE_INIT_FUNC(net
)
826 if (PyType_Ready(&py_net_Type
) < 0)
829 m
= PyModule_Create(&moduledef
);
833 Py_INCREF(&py_net_Type
);
834 PyModule_AddObject(m
, "Net", (PyObject
*)&py_net_Type
);
835 PyModule_AddIntConstant(m
, "LIBNET_JOINDOMAIN_AUTOMATIC", LIBNET_JOINDOMAIN_AUTOMATIC
);
836 PyModule_AddIntConstant(m
, "LIBNET_JOINDOMAIN_SPECIFIED", LIBNET_JOINDOMAIN_SPECIFIED
);
837 PyModule_AddIntConstant(m
, "LIBNET_JOIN_AUTOMATIC", LIBNET_JOIN_AUTOMATIC
);
838 PyModule_AddIntConstant(m
, "LIBNET_JOIN_SPECIFIED", LIBNET_JOIN_SPECIFIED
);