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
;
158 TALLOC_CTX
*mem_ctx
= NULL
;
159 struct tevent_context
*ev
= NULL
;
160 const char *kwnames
[] = { "newpassword", "oldpassword", "domain", "username", NULL
};
161 const char *newpass
= NULL
;
162 const char *oldpass
= NULL
;
164 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, PYARG_STR_UNI
165 "|"PYARG_STR_UNI
"ss:change_password",
166 discard_const_p(char *, kwnames
),
171 &r
.generic
.in
.domain_name
,
172 &r
.generic
.in
.account_name
)) {
176 r
.generic
.in
.newpassword
= newpass
;
177 r
.generic
.in
.oldpassword
= oldpass
;
179 r
.generic
.level
= LIBNET_CHANGE_PASSWORD_GENERIC
;
180 if (r
.generic
.in
.account_name
== NULL
) {
181 r
.generic
.in
.account_name
182 = cli_credentials_get_username(self
->libnet_ctx
->cred
);
184 if (r
.generic
.in
.domain_name
== NULL
) {
185 r
.generic
.in
.domain_name
186 = cli_credentials_get_domain(self
->libnet_ctx
->cred
);
188 if (r
.generic
.in
.oldpassword
== NULL
) {
189 r
.generic
.in
.oldpassword
190 = cli_credentials_get_password(self
->libnet_ctx
->cred
);
193 /* FIXME: we really need to get a context from the caller or we may end
194 * up with 2 event contexts */
195 ev
= s4_event_context_init(NULL
);
197 mem_ctx
= talloc_new(ev
);
198 if (mem_ctx
== NULL
) {
199 PyMem_Free(discard_const_p(char, newpass
));
200 PyMem_Free(discard_const_p(char, oldpass
));
205 status
= libnet_ChangePassword(self
->libnet_ctx
, mem_ctx
, &r
);
207 PyMem_Free(discard_const_p(char, newpass
));
208 PyMem_Free(discard_const_p(char, oldpass
));
210 if (NT_STATUS_IS_ERR(status
)) {
211 PyErr_SetNTSTATUS_and_string(status
,
212 r
.generic
.out
.error_string
213 ? r
.generic
.out
.error_string
214 : nt_errstr(status
));
215 talloc_free(mem_ctx
);
219 talloc_free(mem_ctx
);
223 static const char py_net_change_password_doc
[] = "change_password(newpassword) -> True\n\n" \
224 "Change password for a user. You must supply credential with enough rights to do this.\n\n" \
225 "Sample usage is:\n" \
226 "net.change_password(newpassword=<new_password>)\n";
229 static PyObject
*py_net_set_password(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
231 union libnet_SetPassword r
;
234 struct tevent_context
*ev
;
235 const char *kwnames
[] = { "account_name", "domain_name", "newpassword", NULL
};
239 r
.generic
.level
= LIBNET_SET_PASSWORD_GENERIC
;
241 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "sss:set_password",
242 discard_const_p(char *, kwnames
),
243 &r
.generic
.in
.account_name
,
244 &r
.generic
.in
.domain_name
,
245 &r
.generic
.in
.newpassword
)) {
249 /* FIXME: we really need to get a context from the caller or we may end
250 * up with 2 event contexts */
251 ev
= s4_event_context_init(NULL
);
253 mem_ctx
= talloc_new(ev
);
254 if (mem_ctx
== NULL
) {
259 status
= libnet_SetPassword(self
->libnet_ctx
, mem_ctx
, &r
);
260 if (NT_STATUS_IS_ERR(status
)) {
261 PyErr_SetNTSTATUS_and_string(status
,
262 r
.generic
.out
.error_string
263 ? r
.generic
.out
.error_string
264 : nt_errstr(status
));
265 talloc_free(mem_ctx
);
269 talloc_free(mem_ctx
);
274 static const char py_net_set_password_doc
[] = "set_password(account_name, domain_name, newpassword) -> True\n\n" \
275 "Set password for a user. You must supply credential with enough rights to do this.\n\n" \
276 "Sample usage is:\n" \
277 "net.set_password(account_name=account_name, domain_name=domain_name, newpassword=new_pass)\n";
280 static PyObject
*py_net_time(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
282 const char *kwnames
[] = { "server_name", NULL
};
283 union libnet_RemoteTOD r
;
290 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s",
291 discard_const_p(char *, kwnames
), &r
.generic
.in
.server_name
))
294 r
.generic
.level
= LIBNET_REMOTE_TOD_GENERIC
;
296 mem_ctx
= talloc_new(NULL
);
297 if (mem_ctx
== NULL
) {
302 status
= libnet_RemoteTOD(self
->libnet_ctx
, mem_ctx
, &r
);
303 if (!NT_STATUS_IS_OK(status
)) {
304 PyErr_SetNTSTATUS_and_string(status
,
305 r
.generic
.out
.error_string
306 ? r
.generic
.out
.error_string
307 : nt_errstr(status
));
308 talloc_free(mem_ctx
);
312 ZERO_STRUCT(timestr
);
313 tm
= localtime(&r
.generic
.out
.time
);
314 strftime(timestr
, sizeof(timestr
)-1, "%c %Z",tm
);
316 ret
= PyStr_FromString(timestr
);
318 talloc_free(mem_ctx
);
323 static const char py_net_time_doc
[] = "time(server_name) -> timestr\n"
324 "Retrieve the remote time on a server";
326 static PyObject
*py_net_user_create(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
328 const char *kwnames
[] = { "username", NULL
};
331 struct libnet_CreateUser r
;
333 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s", discard_const_p(char *, kwnames
),
337 r
.in
.domain_name
= cli_credentials_get_domain(self
->libnet_ctx
->cred
);
339 mem_ctx
= talloc_new(NULL
);
340 if (mem_ctx
== NULL
) {
345 status
= libnet_CreateUser(self
->libnet_ctx
, mem_ctx
, &r
);
346 if (!NT_STATUS_IS_OK(status
)) {
347 PyErr_SetNTSTATUS_and_string(status
,
350 : nt_errstr(status
));
351 talloc_free(mem_ctx
);
355 talloc_free(mem_ctx
);
360 static const char py_net_create_user_doc
[] = "create_user(username)\n"
361 "Create a new user.";
363 static PyObject
*py_net_user_delete(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
365 const char *kwnames
[] = { "username", NULL
};
368 struct libnet_DeleteUser r
;
370 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "s", discard_const_p(char *, kwnames
),
374 r
.in
.domain_name
= cli_credentials_get_domain(self
->libnet_ctx
->cred
);
376 mem_ctx
= talloc_new(NULL
);
377 if (mem_ctx
== NULL
) {
382 status
= libnet_DeleteUser(self
->libnet_ctx
, mem_ctx
, &r
);
383 if (!NT_STATUS_IS_OK(status
)) {
384 PyErr_SetNTSTATUS_and_string(status
,
387 : nt_errstr(status
));
388 talloc_free(mem_ctx
);
392 talloc_free(mem_ctx
);
397 static const char py_net_delete_user_doc
[] = "delete_user(username)\n"
400 struct replicate_state
{
402 dcerpc_InterfaceObject
*drs_pipe
;
403 struct libnet_BecomeDC_StoreChunk chunk
;
404 DATA_BLOB gensec_skey
;
405 struct libnet_BecomeDC_Partition partition
;
406 struct libnet_BecomeDC_Forest forest
;
407 struct libnet_BecomeDC_DestDSA dest_dsa
;
411 setup for replicate_chunk() calls
413 static PyObject
*py_net_replicate_init(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
415 const char *kwnames
[] = { "samdb", "lp", "drspipe", "invocation_id", NULL
};
416 PyObject
*py_ldb
, *py_lp
, *py_drspipe
, *py_invocation_id
;
417 struct ldb_context
*samdb
;
418 struct loadparm_context
*lp
;
419 struct replicate_state
*s
;
422 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "OOOO",
423 discard_const_p(char *, kwnames
),
424 &py_ldb
, &py_lp
, &py_drspipe
,
425 &py_invocation_id
)) {
429 s
= talloc_zero(NULL
, struct replicate_state
);
432 lp
= lpcfg_from_py_object(s
, py_lp
);
434 PyErr_SetString(PyExc_TypeError
, "Expected lp object");
439 samdb
= pyldb_Ldb_AsLdbContext(py_ldb
);
441 PyErr_SetString(PyExc_TypeError
, "Expected ldb object");
445 if (!py_check_dcerpc_type(py_invocation_id
, "samba.dcerpc.misc", "GUID")) {
450 s
->dest_dsa
.invocation_id
= *pytalloc_get_type(py_invocation_id
, struct GUID
);
452 s
->drs_pipe
= (dcerpc_InterfaceObject
*)(py_drspipe
);
454 s
->vampire_state
= libnet_vampire_replicate_init(s
, samdb
, lp
);
455 if (s
->vampire_state
== NULL
) {
456 PyErr_SetString(PyExc_TypeError
, "Failed to initialise vampire_state");
461 status
= gensec_session_key(s
->drs_pipe
->pipe
->conn
->security_state
.generic_state
,
464 if (!NT_STATUS_IS_OK(status
)) {
465 char *error_string
= talloc_asprintf(s
,
466 "Unable to get session key from drspipe: %s",
468 PyErr_SetNTSTATUS_and_string(status
, error_string
);
473 s
->forest
.dns_name
= samdb_dn_to_dns_domain(s
, ldb_get_root_basedn(samdb
));
474 s
->forest
.root_dn_str
= ldb_dn_get_linearized(ldb_get_root_basedn(samdb
));
475 s
->forest
.config_dn_str
= ldb_dn_get_linearized(ldb_get_config_basedn(samdb
));
476 s
->forest
.schema_dn_str
= ldb_dn_get_linearized(ldb_get_schema_basedn(samdb
));
478 s
->chunk
.gensec_skey
= &s
->gensec_skey
;
479 s
->chunk
.partition
= &s
->partition
;
480 s
->chunk
.forest
= &s
->forest
;
481 s
->chunk
.dest_dsa
= &s
->dest_dsa
;
483 return pytalloc_GenericObject_steal(s
);
488 process one replication chunk
490 static PyObject
*py_net_replicate_chunk(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
492 const char *kwnames
[] = { "state", "level", "ctr",
493 "schema", "req_level", "req",
495 PyObject
*py_state
, *py_ctr
, *py_schema
= Py_None
, *py_req
= Py_None
;
496 struct replicate_state
*s
;
498 unsigned req_level
= 0;
499 WERROR (*chunk_handler
)(void *private_data
, const struct libnet_BecomeDC_StoreChunk
*c
);
501 enum drsuapi_DsExtendedError extended_ret
= DRSUAPI_EXOP_ERR_NONE
;
502 enum drsuapi_DsExtendedOperation exop
= DRSUAPI_EXOP_NONE
;
504 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "OIO|OIO",
505 discard_const_p(char *, kwnames
),
506 &py_state
, &level
, &py_ctr
,
507 &py_schema
, &req_level
, &py_req
)) {
511 s
= pytalloc_get_type(py_state
, struct replicate_state
);
518 if (!py_check_dcerpc_type(py_ctr
, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr1")) {
521 s
->chunk
.ctr1
= pytalloc_get_ptr(py_ctr
);
522 if (s
->chunk
.ctr1
->naming_context
!= NULL
) {
523 s
->partition
.nc
= *s
->chunk
.ctr1
->naming_context
;
525 extended_ret
= s
->chunk
.ctr1
->extended_ret
;
526 s
->partition
.more_data
= s
->chunk
.ctr1
->more_data
;
527 s
->partition
.source_dsa_guid
= s
->chunk
.ctr1
->source_dsa_guid
;
528 s
->partition
.source_dsa_invocation_id
= s
->chunk
.ctr1
->source_dsa_invocation_id
;
529 s
->partition
.highwatermark
= s
->chunk
.ctr1
->new_highwatermark
;
532 if (!py_check_dcerpc_type(py_ctr
, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr6")) {
535 s
->chunk
.ctr6
= pytalloc_get_ptr(py_ctr
);
536 if (s
->chunk
.ctr6
->naming_context
!= NULL
) {
537 s
->partition
.nc
= *s
->chunk
.ctr6
->naming_context
;
539 extended_ret
= s
->chunk
.ctr6
->extended_ret
;
540 s
->partition
.more_data
= s
->chunk
.ctr6
->more_data
;
541 s
->partition
.source_dsa_guid
= s
->chunk
.ctr6
->source_dsa_guid
;
542 s
->partition
.source_dsa_invocation_id
= s
->chunk
.ctr6
->source_dsa_invocation_id
;
543 s
->partition
.highwatermark
= s
->chunk
.ctr6
->new_highwatermark
;
546 PyErr_Format(PyExc_TypeError
, "Bad level %u in replicate_chunk", level
);
550 s
->chunk
.req5
= NULL
;
551 s
->chunk
.req8
= NULL
;
552 s
->chunk
.req10
= NULL
;
558 if (!py_check_dcerpc_type(py_req
, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest5")) {
562 s
->chunk
.req5
= pytalloc_get_ptr(py_req
);
563 exop
= s
->chunk
.req5
->extended_op
;
566 if (!py_check_dcerpc_type(py_req
, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest8")) {
570 s
->chunk
.req8
= pytalloc_get_ptr(py_req
);
571 exop
= s
->chunk
.req8
->extended_op
;
574 if (!py_check_dcerpc_type(py_req
, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest10")) {
578 s
->chunk
.req10
= pytalloc_get_ptr(py_req
);
579 exop
= s
->chunk
.req10
->extended_op
;
582 PyErr_Format(PyExc_TypeError
, "Bad req_level %u in replicate_chunk", req_level
);
587 if (exop
!= DRSUAPI_EXOP_NONE
&& extended_ret
!= DRSUAPI_EXOP_ERR_SUCCESS
) {
588 PyErr_SetDsExtendedError(extended_ret
, NULL
);
592 s
->chunk
.req_level
= req_level
;
594 chunk_handler
= libnet_vampire_cb_store_chunk
;
596 if (!PyBool_Check(py_schema
)) {
597 PyErr_SetString(PyExc_TypeError
, "Expected boolean schema");
600 if (py_schema
== Py_True
) {
601 chunk_handler
= libnet_vampire_cb_schema_chunk
;
605 s
->chunk
.ctr_level
= level
;
607 werr
= chunk_handler(s
->vampire_state
, &s
->chunk
);
608 if (!W_ERROR_IS_OK(werr
)) {
610 = talloc_asprintf(NULL
,
611 "Failed to process 'chunk' of DRS replicated objects: %s",
613 PyErr_SetWERROR_and_string(werr
, error_string
);
614 TALLOC_FREE(error_string
);
623 just do the decryption of a DRS replicated attribute
625 static PyObject
*py_net_replicate_decrypt(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
627 const char *kwnames
[] = { "drspipe", "attribute", "rid", NULL
};
628 PyObject
*py_drspipe
, *py_attribute
;
630 dcerpc_InterfaceObject
*drs_pipe
;
633 DATA_BLOB gensec_skey
;
635 struct drsuapi_DsReplicaAttribute
*attribute
;
638 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "OOI",
639 discard_const_p(char *, kwnames
),
641 &py_attribute
, &rid
)) {
645 frame
= talloc_stackframe();
647 if (!py_check_dcerpc_type(py_drspipe
,
649 "ClientConnection")) {
652 drs_pipe
= (dcerpc_InterfaceObject
*)(py_drspipe
);
654 status
= gensec_session_key(drs_pipe
->pipe
->conn
->security_state
.generic_state
,
657 if (!NT_STATUS_IS_OK(status
)) {
659 = talloc_asprintf(frame
,
660 "Unable to get session key from drspipe: %s",
662 PyErr_SetNTSTATUS_and_string(status
, error_string
);
667 if (!py_check_dcerpc_type(py_attribute
, "samba.dcerpc.drsuapi",
668 "DsReplicaAttribute")) {
672 attribute
= pytalloc_get_ptr(py_attribute
);
673 context
= pytalloc_get_mem_ctx(py_attribute
);
674 werr
= drsuapi_decrypt_attribute(context
, &gensec_skey
,
676 if (!W_ERROR_IS_OK(werr
)) {
677 char *error_string
= talloc_asprintf(frame
,
678 "Unable to get decrypt attribute: %s",
680 PyErr_SetWERROR_and_string(werr
, error_string
);
692 find a DC given a domain name and server type
694 static PyObject
*py_net_finddc(py_net_Object
*self
, PyObject
*args
, PyObject
*kwargs
)
696 const char *domain
= NULL
, *address
= NULL
;
697 unsigned server_type
;
702 const char * const kwnames
[] = { "flags", "domain", "address", NULL
};
704 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "I|zz",
705 discard_const_p(char *, kwnames
),
706 &server_type
, &domain
, &address
)) {
710 mem_ctx
= talloc_new(self
->mem_ctx
);
711 if (mem_ctx
== NULL
) {
716 io
= talloc_zero(mem_ctx
, struct finddcs
);
718 TALLOC_FREE(mem_ctx
);
723 if (domain
!= NULL
) {
724 io
->in
.domain_name
= domain
;
726 if (address
!= NULL
) {
727 io
->in
.server_address
= address
;
729 io
->in
.minimum_dc_flags
= server_type
;
731 status
= finddcs_cldap(io
, io
,
732 lpcfg_resolve_context(self
->libnet_ctx
->lp_ctx
), self
->ev
);
733 if (NT_STATUS_IS_ERR(status
)) {
734 PyErr_SetNTSTATUS(status
);
735 talloc_free(mem_ctx
);
739 ret
= py_return_ndr_struct("samba.dcerpc.nbt", "NETLOGON_SAM_LOGON_RESPONSE_EX",
740 io
, &io
->out
.netlogon
.data
.nt5_ex
);
741 talloc_free(mem_ctx
);
747 static const char py_net_replicate_init_doc
[] = "replicate_init(samdb, lp, drspipe)\n"
748 "Setup for replicate_chunk calls.";
750 static const char py_net_replicate_chunk_doc
[] = "replicate_chunk(state, level, ctr, schema)\n"
751 "Process replication for one chunk";
753 static const char py_net_replicate_decrypt_doc
[] = "replicate_decrypt(drs, attribute, rid)\n"
754 "Decrypt (in place) a DsReplicaAttribute replicated with drs.GetNCChanges()";
756 static const char py_net_finddc_doc
[] = "finddc(flags=server_type, domain=None, address=None)\n"
757 "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";
759 static PyMethodDef net_obj_methods
[] = {
760 {"join_member", (PyCFunction
)py_net_join_member
, METH_VARARGS
|METH_KEYWORDS
, py_net_join_member_doc
},
761 {"change_password", (PyCFunction
)py_net_change_password
, METH_VARARGS
|METH_KEYWORDS
, py_net_change_password_doc
},
762 {"set_password", (PyCFunction
)py_net_set_password
, METH_VARARGS
|METH_KEYWORDS
, py_net_set_password_doc
},
763 {"time", (PyCFunction
)py_net_time
, METH_VARARGS
|METH_KEYWORDS
, py_net_time_doc
},
764 {"create_user", (PyCFunction
)py_net_user_create
, METH_VARARGS
|METH_KEYWORDS
, py_net_create_user_doc
},
765 {"delete_user", (PyCFunction
)py_net_user_delete
, METH_VARARGS
|METH_KEYWORDS
, py_net_delete_user_doc
},
766 {"replicate_init", (PyCFunction
)py_net_replicate_init
, METH_VARARGS
|METH_KEYWORDS
, py_net_replicate_init_doc
},
767 {"replicate_chunk", (PyCFunction
)py_net_replicate_chunk
, METH_VARARGS
|METH_KEYWORDS
, py_net_replicate_chunk_doc
},
768 {"replicate_decrypt", (PyCFunction
)py_net_replicate_decrypt
, METH_VARARGS
|METH_KEYWORDS
, py_net_replicate_decrypt_doc
},
769 {"finddc", (PyCFunction
)py_net_finddc
, METH_VARARGS
|METH_KEYWORDS
, py_net_finddc_doc
},
773 static void py_net_dealloc(py_net_Object
*self
)
775 talloc_free(self
->mem_ctx
);
779 static PyObject
*net_obj_new(PyTypeObject
*type
, PyObject
*args
, PyObject
*kwargs
)
781 PyObject
*py_creds
, *py_lp
= Py_None
;
782 const char *kwnames
[] = { "creds", "lp", "server", NULL
};
784 struct loadparm_context
*lp
;
785 const char *server_address
= NULL
;
787 if (!PyArg_ParseTupleAndKeywords(args
, kwargs
, "O|Oz",
788 discard_const_p(char *, kwnames
), &py_creds
, &py_lp
,
792 ret
= PyObject_New(py_net_Object
, type
);
797 /* FIXME: we really need to get a context from the caller or we may end
798 * up with 2 event contexts */
799 ret
->ev
= s4_event_context_init(NULL
);
800 ret
->mem_ctx
= talloc_new(ret
->ev
);
802 lp
= lpcfg_from_py_object(ret
->mem_ctx
, py_lp
);
808 ret
->libnet_ctx
= libnet_context_init(ret
->ev
, lp
);
809 if (ret
->libnet_ctx
== NULL
) {
810 PyErr_SetString(PyExc_RuntimeError
, "Unable to initialize net");
815 ret
->libnet_ctx
->server_address
= server_address
;
817 ret
->libnet_ctx
->cred
= cli_credentials_from_py_object(py_creds
);
818 if (ret
->libnet_ctx
->cred
== NULL
) {
819 PyErr_SetString(PyExc_TypeError
, "Expected credentials object");
824 return (PyObject
*)ret
;
828 PyTypeObject py_net_Type
= {
829 PyVarObject_HEAD_INIT(NULL
, 0)
830 .tp_name
= "net.Net",
831 .tp_basicsize
= sizeof(py_net_Object
),
832 .tp_dealloc
= (destructor
)py_net_dealloc
,
833 .tp_methods
= net_obj_methods
,
834 .tp_new
= net_obj_new
,
837 static struct PyModuleDef moduledef
= {
838 PyModuleDef_HEAD_INIT
,
843 MODULE_INIT_FUNC(net
)
847 if (PyType_Ready(&py_net_Type
) < 0)
850 m
= PyModule_Create(&moduledef
);
854 Py_INCREF(&py_net_Type
);
855 PyModule_AddObject(m
, "Net", (PyObject
*)&py_net_Type
);
856 PyModule_AddIntConstant(m
, "LIBNET_JOINDOMAIN_AUTOMATIC", LIBNET_JOINDOMAIN_AUTOMATIC
);
857 PyModule_AddIntConstant(m
, "LIBNET_JOINDOMAIN_SPECIFIED", LIBNET_JOINDOMAIN_SPECIFIED
);
858 PyModule_AddIntConstant(m
, "LIBNET_JOIN_AUTOMATIC", LIBNET_JOIN_AUTOMATIC
);
859 PyModule_AddIntConstant(m
, "LIBNET_JOIN_SPECIFIED", LIBNET_JOIN_SPECIFIED
);