9259fe658958b881317c9dfbe5f582cec3481184
[samba.git] / 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 <pyldb.h>
25 #include <pytalloc.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/resolve/resolve.h"
34 #include "libcli/finddc.h"
35 #include "dsdb/samdb/samdb.h"
36 #include "py_net.h"
37 #include "librpc/rpc/pyrpc_util.h"
38
39 void initnet(void);
40
41 static PyObject *py_net_join_member(py_net_Object *self, PyObject *args, PyObject *kwargs)
42 {
43         struct libnet_Join_member r;
44         int _level = 0;
45         NTSTATUS status;
46         PyObject *result;
47         TALLOC_CTX *mem_ctx;
48         const char *kwnames[] = { "domain_name", "netbios_name", "level", "machinepass", NULL };
49
50         ZERO_STRUCT(r);
51
52         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ssi|z:Join", discard_const_p(char *, kwnames),
53                                          &r.in.domain_name, &r.in.netbios_name, 
54                                          &_level,
55                                          &r.in.account_pass)) {
56                 return NULL;
57         }
58         r.in.level = _level;
59
60         mem_ctx = talloc_new(self->mem_ctx);
61         if (mem_ctx == NULL) {
62                 PyErr_NoMemory();
63                 return NULL;
64         }
65
66         status = libnet_Join_member(self->libnet_ctx, mem_ctx, &r);
67         if (NT_STATUS_IS_ERR(status)) {
68                 PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
69                 talloc_free(mem_ctx);
70                 return NULL;
71         }
72
73         result = Py_BuildValue("sss", r.out.join_password,
74                                dom_sid_string(mem_ctx, r.out.domain_sid),
75                                r.out.domain_name);
76
77         talloc_free(mem_ctx);
78
79         return result;
80 }
81
82 static const char py_net_join_member_doc[] = "join_member(domain_name, netbios_name, level) -> (join_password, domain_sid, domain_name)\n\n" \
83 "Join the domain with the specified name.";
84
85 static PyObject *py_net_change_password(py_net_Object *self, PyObject *args, PyObject *kwargs)
86 {
87         union libnet_ChangePassword r;
88         NTSTATUS status;
89         TALLOC_CTX *mem_ctx;
90         struct tevent_context *ev;
91         const char *kwnames[] = { "newpassword", NULL };
92
93         ZERO_STRUCT(r);
94
95         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s:change_password",
96                                         discard_const_p(char *, kwnames),
97                                         &r.generic.in.newpassword)) {
98                 return NULL;
99         }
100
101         r.generic.level = LIBNET_CHANGE_PASSWORD_GENERIC;
102         r.generic.in.account_name = cli_credentials_get_username(self->libnet_ctx->cred);
103         r.generic.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
104         r.generic.in.oldpassword = cli_credentials_get_password(self->libnet_ctx->cred);
105
106         /* FIXME: we really need to get a context from the caller or we may end
107          * up with 2 event contexts */
108         ev = s4_event_context_init(NULL);
109
110         mem_ctx = talloc_new(ev);
111         if (mem_ctx == NULL) {
112                 PyErr_NoMemory();
113                 return NULL;
114         }
115
116         status = libnet_ChangePassword(self->libnet_ctx, mem_ctx, &r);
117         if (NT_STATUS_IS_ERR(status)) {
118                 PyErr_SetString(PyExc_RuntimeError,
119                                 r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
120                 talloc_free(mem_ctx);
121                 return NULL;
122         }
123
124         talloc_free(mem_ctx);
125
126         Py_RETURN_NONE;
127 }
128
129 static const char py_net_change_password_doc[] = "change_password(newpassword) -> True\n\n" \
130 "Change password for a user. You must supply credential with enough rights to do this.\n\n" \
131 "Sample usage is:\n" \
132 "net.change_password(newpassword=<new_password>)\n";
133
134
135 static PyObject *py_net_set_password(py_net_Object *self, PyObject *args, PyObject *kwargs)
136 {
137         union libnet_SetPassword r;
138         NTSTATUS status;
139         TALLOC_CTX *mem_ctx;
140         struct tevent_context *ev;
141         const char *kwnames[] = { "account_name", "domain_name", "newpassword", NULL };
142
143         ZERO_STRUCT(r);
144
145         r.generic.level = LIBNET_SET_PASSWORD_GENERIC;
146
147         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sss:set_password",
148                                         discard_const_p(char *, kwnames),
149                                          &r.generic.in.account_name,
150                                          &r.generic.in.domain_name,
151                                          &r.generic.in.newpassword)) {
152                 return NULL;
153         }
154
155         /* FIXME: we really need to get a context from the caller or we may end
156          * up with 2 event contexts */
157         ev = s4_event_context_init(NULL);
158
159         mem_ctx = talloc_new(ev);
160         if (mem_ctx == NULL) {
161                 PyErr_NoMemory();
162                 return NULL;
163         }
164
165         status = libnet_SetPassword(self->libnet_ctx, mem_ctx, &r);
166         if (NT_STATUS_IS_ERR(status)) {
167                 PyErr_SetString(PyExc_RuntimeError,
168                                 r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
169                 talloc_free(mem_ctx);
170                 return NULL;
171         }
172
173         talloc_free(mem_ctx);
174
175         Py_RETURN_NONE;
176 }
177
178 static const char py_net_set_password_doc[] = "set_password(account_name, domain_name, newpassword) -> True\n\n" \
179 "Set password for a user. You must supply credential with enough rights to do this.\n\n" \
180 "Sample usage is:\n" \
181 "net.set_password(account_name=account_name, domain_name=domain_name, newpassword=new_pass)\n";
182
183
184 static PyObject *py_net_time(py_net_Object *self, PyObject *args, PyObject *kwargs)
185 {
186         const char *kwnames[] = { "server_name", NULL };
187         union libnet_RemoteTOD r;
188         NTSTATUS status;
189         TALLOC_CTX *mem_ctx;
190         char timestr[64];
191         PyObject *ret;
192         struct tm *tm;
193
194         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s",
195                 discard_const_p(char *, kwnames), &r.generic.in.server_name))
196                 return NULL;
197
198         r.generic.level                 = LIBNET_REMOTE_TOD_GENERIC;
199
200         mem_ctx = talloc_new(NULL);
201         if (mem_ctx == NULL) {
202                 PyErr_NoMemory();
203                 return NULL;
204         }
205
206         status = libnet_RemoteTOD(self->libnet_ctx, mem_ctx, &r);
207         if (!NT_STATUS_IS_OK(status)) {
208                 PyErr_SetString(PyExc_RuntimeError,
209                                 r.generic.out.error_string?r.generic.out.error_string:nt_errstr(status));
210                 talloc_free(mem_ctx);
211                 return NULL;
212         }
213
214         ZERO_STRUCT(timestr);
215         tm = localtime(&r.generic.out.time);
216         strftime(timestr, sizeof(timestr)-1, "%c %Z",tm);
217         
218         ret = PyString_FromString(timestr);
219
220         talloc_free(mem_ctx);
221
222         return ret;
223 }
224
225 static const char py_net_time_doc[] = "time(server_name) -> timestr\n"
226 "Retrieve the remote time on a server";
227
228 static PyObject *py_net_user_create(py_net_Object *self, PyObject *args, PyObject *kwargs)
229 {
230         const char *kwnames[] = { "username", NULL };
231         NTSTATUS status;
232         TALLOC_CTX *mem_ctx;
233         struct libnet_CreateUser r;
234
235         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", discard_const_p(char *, kwnames), 
236                                                                          &r.in.user_name))
237                 return NULL;
238
239         r.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
240
241         mem_ctx = talloc_new(NULL);
242         if (mem_ctx == NULL) {
243                 PyErr_NoMemory();
244                 return NULL;
245         }
246
247         status = libnet_CreateUser(self->libnet_ctx, mem_ctx, &r);
248         if (!NT_STATUS_IS_OK(status)) {
249                 PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
250                 talloc_free(mem_ctx);
251                 return NULL;
252         }
253
254         talloc_free(mem_ctx);
255         
256         Py_RETURN_NONE;
257 }
258
259 static const char py_net_create_user_doc[] = "create_user(username)\n"
260 "Create a new user.";
261
262 static PyObject *py_net_user_delete(py_net_Object *self, PyObject *args, PyObject *kwargs)
263 {
264         const char *kwnames[] = { "username", NULL };
265         NTSTATUS status;
266         TALLOC_CTX *mem_ctx;
267         struct libnet_DeleteUser r;
268
269         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", discard_const_p(char *, kwnames), 
270                                                                          &r.in.user_name))
271                 return NULL;
272
273         r.in.domain_name = cli_credentials_get_domain(self->libnet_ctx->cred);
274
275         mem_ctx = talloc_new(NULL);
276         if (mem_ctx == NULL) {
277                 PyErr_NoMemory();
278                 return NULL;
279         }
280
281         status = libnet_DeleteUser(self->libnet_ctx, mem_ctx, &r);
282         if (!NT_STATUS_IS_OK(status)) {
283                 PyErr_SetString(PyExc_RuntimeError, r.out.error_string?r.out.error_string:nt_errstr(status));
284                 talloc_free(mem_ctx);
285                 return NULL;
286         }
287
288         talloc_free(mem_ctx);
289         
290         Py_RETURN_NONE;
291 }
292
293 static const char py_net_delete_user_doc[] = "delete_user(username)\n"
294 "Delete a user.";
295
296 struct replicate_state {
297         void *vampire_state;
298         dcerpc_InterfaceObject *drs_pipe;
299         struct libnet_BecomeDC_StoreChunk chunk;
300         DATA_BLOB gensec_skey;
301         struct libnet_BecomeDC_Partition partition;
302         struct libnet_BecomeDC_Forest forest;
303         struct libnet_BecomeDC_DestDSA dest_dsa;
304 };
305
306 /*
307   setup for replicate_chunk() calls
308  */
309 static PyObject *py_net_replicate_init(py_net_Object *self, PyObject *args, PyObject *kwargs)
310 {
311         const char *kwnames[] = { "samdb", "lp", "drspipe", "invocation_id", NULL };
312         PyObject *py_ldb, *py_lp, *py_drspipe, *py_invocation_id;
313         struct ldb_context *samdb;
314         struct loadparm_context *lp;
315         struct replicate_state *s;
316         NTSTATUS status;
317
318         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO",
319                                          discard_const_p(char *, kwnames),
320                                          &py_ldb, &py_lp, &py_drspipe,
321                                          &py_invocation_id)) {
322                 return NULL;
323         }
324
325         s = talloc_zero(NULL, struct replicate_state);
326         if (!s) return NULL;
327
328         lp = lpcfg_from_py_object(s, py_lp);
329         if (lp == NULL) {
330                 PyErr_SetString(PyExc_TypeError, "Expected lp object");
331                 talloc_free(s);
332                 return NULL;
333         }
334
335         samdb = pyldb_Ldb_AsLdbContext(py_ldb);
336         if (samdb == NULL) {
337                 PyErr_SetString(PyExc_TypeError, "Expected ldb object");
338                 talloc_free(s);
339                 return NULL;
340         }
341         if (!py_check_dcerpc_type(py_invocation_id, "samba.dcerpc.misc", "GUID")) {
342                 
343                 talloc_free(s);
344                 return NULL;
345         }
346         s->dest_dsa.invocation_id = *pytalloc_get_type(py_invocation_id, struct GUID);
347
348         s->drs_pipe = (dcerpc_InterfaceObject *)(py_drspipe);
349
350         s->vampire_state = libnet_vampire_replicate_init(s, samdb, lp);
351         if (s->vampire_state == NULL) {
352                 PyErr_SetString(PyExc_TypeError, "Failed to initialise vampire_state");
353                 talloc_free(s);
354                 return NULL;
355         }
356
357         status = gensec_session_key(s->drs_pipe->pipe->conn->security_state.generic_state,
358                                     s,
359                                     &s->gensec_skey);
360         if (!NT_STATUS_IS_OK(status)) {
361                 PyErr_Format(PyExc_RuntimeError, "Unable to get session key from drspipe: %s",
362                              nt_errstr(status));
363                 talloc_free(s);
364                 return NULL;
365         }
366
367         s->forest.dns_name = samdb_dn_to_dns_domain(s, ldb_get_root_basedn(samdb));
368         s->forest.root_dn_str = ldb_dn_get_linearized(ldb_get_root_basedn(samdb));
369         s->forest.config_dn_str = ldb_dn_get_linearized(ldb_get_config_basedn(samdb));
370         s->forest.schema_dn_str = ldb_dn_get_linearized(ldb_get_schema_basedn(samdb));
371
372         s->chunk.gensec_skey = &s->gensec_skey;
373         s->chunk.partition = &s->partition;
374         s->chunk.forest = &s->forest;
375         s->chunk.dest_dsa = &s->dest_dsa;
376
377         return pytalloc_CObject_FromTallocPtr(s);
378 }
379
380
381 /*
382   process one replication chunk
383  */
384 static PyObject *py_net_replicate_chunk(py_net_Object *self, PyObject *args, PyObject *kwargs)
385 {
386         const char *kwnames[] = { "state", "level", "ctr",
387                                   "schema", "req_level", "req",
388                                   NULL };
389         PyObject *py_state, *py_ctr, *py_schema = Py_None, *py_req = Py_None;
390         struct replicate_state *s;
391         unsigned level;
392         unsigned req_level = 0;
393         WERROR (*chunk_handler)(void *private_data, const struct libnet_BecomeDC_StoreChunk *c);
394         WERROR werr;
395
396         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OIO|OIO",
397                                          discard_const_p(char *, kwnames),
398                                          &py_state, &level, &py_ctr,
399                                          &py_schema, &req_level, &py_req)) {
400                 return NULL;
401         }
402
403         s = talloc_get_type(PyCObject_AsVoidPtr(py_state), struct replicate_state);
404         if (!s) {
405                 PyErr_SetString(PyExc_TypeError, "Expected replication_state");
406                 return NULL;
407         }
408
409         switch (level) {
410         case 1:
411                 if (!py_check_dcerpc_type(py_ctr, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr1")) {
412                         return NULL;
413                 }
414                 s->chunk.ctr1                         = pytalloc_get_ptr(py_ctr);
415                 s->partition.nc                       = *s->chunk.ctr1->naming_context;
416                 s->partition.more_data                = s->chunk.ctr1->more_data;
417                 s->partition.source_dsa_guid          = s->chunk.ctr1->source_dsa_guid;
418                 s->partition.source_dsa_invocation_id = s->chunk.ctr1->source_dsa_invocation_id;
419                 s->partition.highwatermark            = s->chunk.ctr1->new_highwatermark;
420                 break;
421         case 6:
422                 if (!py_check_dcerpc_type(py_ctr, "samba.dcerpc.drsuapi", "DsGetNCChangesCtr6")) {
423                         return NULL;
424                 }
425                 s->chunk.ctr6                         = pytalloc_get_ptr(py_ctr);
426                 s->partition.nc                       = *s->chunk.ctr6->naming_context;
427                 s->partition.more_data                = s->chunk.ctr6->more_data;
428                 s->partition.source_dsa_guid          = s->chunk.ctr6->source_dsa_guid;
429                 s->partition.source_dsa_invocation_id = s->chunk.ctr6->source_dsa_invocation_id;
430                 s->partition.highwatermark            = s->chunk.ctr6->new_highwatermark;
431                 break;
432         default:
433                 PyErr_Format(PyExc_TypeError, "Bad level %u in replicate_chunk", level);
434                 return NULL;
435         }
436
437         s->chunk.req5 = NULL;
438         s->chunk.req8 = NULL;
439         s->chunk.req10 = NULL;
440         if (py_req) {
441                 switch (req_level) {
442                 case 0:
443                         break;
444                 case 5:
445                         if (!py_check_dcerpc_type(py_req, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest5")) {
446                                 return NULL;
447                         }
448
449                         s->chunk.req5 = pytalloc_get_ptr(py_req);
450                         break;
451                 case 8:
452                         if (!py_check_dcerpc_type(py_req, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest8")) {
453                                 return NULL;
454                         }
455
456                         s->chunk.req8 = pytalloc_get_ptr(py_req);
457                         break;
458                 case 10:
459                         if (!py_check_dcerpc_type(py_req, "samba.dcerpc.drsuapi", "DsGetNCChangesRequest10")) {
460                                 return NULL;
461                         }
462
463                         s->chunk.req10 = pytalloc_get_ptr(py_req);
464                         break;
465                 default:
466                         PyErr_Format(PyExc_TypeError, "Bad req_level %u in replicate_chunk", req_level);
467                         return NULL;
468                 }
469         }
470         s->chunk.req_level = req_level;
471
472         chunk_handler = libnet_vampire_cb_store_chunk;
473         if (py_schema) {
474                 if (!PyBool_Check(py_schema)) {
475                         PyErr_SetString(PyExc_TypeError, "Expected boolean schema");
476                         return NULL;
477                 }
478                 if (py_schema == Py_True) {
479                         chunk_handler = libnet_vampire_cb_schema_chunk;
480                 }
481         }
482
483         s->chunk.ctr_level = level;
484
485         werr = chunk_handler(s->vampire_state, &s->chunk);
486         if (!W_ERROR_IS_OK(werr)) {
487                 PyErr_Format(PyExc_TypeError, "Failed to process chunk: %s", win_errstr(werr));
488                 return NULL;
489         }
490
491         Py_RETURN_NONE;
492 }
493
494
495 /*
496   find a DC given a domain name and server type
497  */
498 static PyObject *py_net_finddc(py_net_Object *self, PyObject *args, PyObject *kwargs)
499 {
500         const char *domain = NULL, *address = NULL;
501         unsigned server_type;
502         NTSTATUS status;
503         struct finddcs *io;
504         TALLOC_CTX *mem_ctx;
505         PyObject *ret;
506         const char * const kwnames[] = { "flags", "domain", "address", NULL };
507
508         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "I|zz",
509                                          discard_const_p(char *, kwnames),
510                                          &server_type, &domain, &address)) {
511                 return NULL;
512         }
513
514         mem_ctx = talloc_new(self->mem_ctx);
515
516         io = talloc_zero(mem_ctx, struct finddcs);
517         if (domain != NULL) {
518                 io->in.domain_name = domain;
519         }
520         if (address != NULL) {
521                 io->in.server_address = address;
522         }
523         io->in.minimum_dc_flags = server_type;
524
525         status = finddcs_cldap(io, io,
526                                lpcfg_resolve_context(self->libnet_ctx->lp_ctx), self->ev);
527         if (NT_STATUS_IS_ERR(status)) {
528                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
529                 talloc_free(mem_ctx);
530                 return NULL;
531         }
532
533         ret = py_return_ndr_struct("samba.dcerpc.nbt", "NETLOGON_SAM_LOGON_RESPONSE_EX",
534                                    io, &io->out.netlogon.data.nt5_ex);
535         talloc_free(mem_ctx);
536
537         return ret;
538 }
539
540
541 static const char py_net_replicate_init_doc[] = "replicate_init(samdb, lp, drspipe)\n"
542                                          "Setup for replicate_chunk calls.";
543
544 static const char py_net_replicate_chunk_doc[] = "replicate_chunk(state, level, ctr, schema)\n"
545                                          "Process replication for one chunk";
546
547 static const char py_net_finddc_doc[] = "finddc(flags=server_type, domain=None, address=None)\n"
548                                          "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";
549
550 static PyMethodDef net_obj_methods[] = {
551         {"join_member", (PyCFunction)py_net_join_member, METH_VARARGS|METH_KEYWORDS, py_net_join_member_doc},
552         {"change_password", (PyCFunction)py_net_change_password, METH_VARARGS|METH_KEYWORDS, py_net_change_password_doc},
553         {"set_password", (PyCFunction)py_net_set_password, METH_VARARGS|METH_KEYWORDS, py_net_set_password_doc},
554         {"time", (PyCFunction)py_net_time, METH_VARARGS|METH_KEYWORDS, py_net_time_doc},
555         {"create_user", (PyCFunction)py_net_user_create, METH_VARARGS|METH_KEYWORDS, py_net_create_user_doc},
556         {"delete_user", (PyCFunction)py_net_user_delete, METH_VARARGS|METH_KEYWORDS, py_net_delete_user_doc},
557         {"replicate_init", (PyCFunction)py_net_replicate_init, METH_VARARGS|METH_KEYWORDS, py_net_replicate_init_doc},
558         {"replicate_chunk", (PyCFunction)py_net_replicate_chunk, METH_VARARGS|METH_KEYWORDS, py_net_replicate_chunk_doc},
559         {"finddc", (PyCFunction)py_net_finddc, METH_KEYWORDS, py_net_finddc_doc},
560         { NULL }
561 };
562
563 static void py_net_dealloc(py_net_Object *self)
564 {
565         talloc_free(self->mem_ctx);
566         PyObject_Del(self);
567 }
568
569 static PyObject *net_obj_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
570 {
571         PyObject *py_creds, *py_lp = Py_None;
572         const char *kwnames[] = { "creds", "lp", "server", NULL };
573         py_net_Object *ret;
574         struct loadparm_context *lp;
575         const char *server_address = NULL;
576
577         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|Oz",
578                                          discard_const_p(char *, kwnames), &py_creds, &py_lp,
579                                          &server_address))
580                 return NULL;
581
582         ret = PyObject_New(py_net_Object, type);
583         if (ret == NULL) {
584                 return NULL;
585         }
586
587         /* FIXME: we really need to get a context from the caller or we may end
588          * up with 2 event contexts */
589         ret->ev = s4_event_context_init(NULL);
590         ret->mem_ctx = talloc_new(ret->ev);
591
592         lp = lpcfg_from_py_object(ret->mem_ctx, py_lp);
593         if (lp == NULL) {
594                 Py_DECREF(ret);
595                 return NULL;
596         }
597
598         ret->libnet_ctx = libnet_context_init(ret->ev, lp);
599         if (ret->libnet_ctx == NULL) {
600                 PyErr_SetString(PyExc_RuntimeError, "Unable to initialize net");
601                 Py_DECREF(ret);
602                 return NULL;
603         }
604
605         ret->libnet_ctx->server_address = server_address;
606
607         ret->libnet_ctx->cred = cli_credentials_from_py_object(py_creds);
608         if (ret->libnet_ctx->cred == NULL) {
609                 PyErr_SetString(PyExc_TypeError, "Expected credentials object");
610                 Py_DECREF(ret);
611                 return NULL;
612         }
613
614         return (PyObject *)ret;
615 }
616
617
618 PyTypeObject py_net_Type = {
619         PyObject_HEAD_INIT(NULL) 0,
620         .tp_name = "net.Net",
621         .tp_basicsize = sizeof(py_net_Object),
622         .tp_dealloc = (destructor)py_net_dealloc,
623         .tp_methods = net_obj_methods,
624         .tp_new = net_obj_new,
625 };
626
627 void initnet(void)
628 {
629         PyObject *m;
630
631         if (PyType_Ready(&py_net_Type) < 0)
632                 return;
633
634         m = Py_InitModule3("net", NULL, NULL);
635         if (m == NULL)
636                 return;
637
638         Py_INCREF(&py_net_Type);
639         PyModule_AddObject(m, "Net", (PyObject *)&py_net_Type);
640         PyModule_AddObject(m, "LIBNET_JOINDOMAIN_AUTOMATIC", PyInt_FromLong(LIBNET_JOINDOMAIN_AUTOMATIC));
641         PyModule_AddObject(m, "LIBNET_JOINDOMAIN_SPECIFIED", PyInt_FromLong(LIBNET_JOINDOMAIN_SPECIFIED));
642         PyModule_AddObject(m, "LIBNET_JOIN_AUTOMATIC", PyInt_FromLong(LIBNET_JOIN_AUTOMATIC));
643         PyModule_AddObject(m, "LIBNET_JOIN_SPECIFIED", PyInt_FromLong(LIBNET_JOIN_SPECIFIED));
644 }