python: Allow wrapping pointers within talloc'ed memory that are not talloc contexts.
[ira/wip.git] / source / py_echo.c
1
2 /* Python wrapper functions auto-generated by pidl */
3 #include "includes.h"
4 #include <Python.h>
5 #include "librpc/rpc/dcerpc.h"
6 #include "scripting/python/pytalloc.h"
7 #include "./ndr_echo.h"
8 #include "./ndr_echo_c.h"
9 #include "./py_echo.h"
10
11
12 staticforward PyTypeObject echo_info1_ObjectType;
13
14 static PyObject *py_echo_info1_getattr(PyObject *obj, char *name)
15 {
16         struct echo_info1 *object = py_talloc_get_type(obj, struct echo_info1);
17         if (!strcmp(name, "v")) {
18                 return PyInt_FromLong(object->v);
19         }
20         PyErr_SetString(PyExc_AttributeError, "no such attribute");
21         return NULL;
22 }
23
24 static int py_echo_info1_setattr(PyObject *py_obj, char *name, PyObject *value)
25 {
26         struct echo_info1 *object = py_talloc_get_type(py_obj, struct echo_info1);
27         if (!strcmp(name, "v")) {
28                 /* FIXME: talloc_free(object->v) if necessary */
29                 object->v = PyInt_AsLong(value);
30                 return 0;
31         }
32         PyErr_SetString(PyExc_AttributeError, "no such attribute");
33         return -1;
34 }
35
36 static PyTypeObject echo_info1_ObjectType = {
37         PyObject_HEAD_INIT(NULL) 0,
38         .tp_name = "echo_info1",
39         .tp_basicsize = sizeof(py_talloc_Object),
40         .tp_dealloc = py_talloc_dealloc,
41         .tp_getattr = py_echo_info1_getattr,
42         .tp_setattr = py_echo_info1_setattr,
43 };
44
45 static PyObject *py_echo_info1(PyObject *self, PyObject *args)
46 {
47         struct echo_info1 *ret = talloc_zero(NULL, struct echo_info1);
48         return py_talloc_import(&echo_info1_ObjectType, ret);
49 }
50
51 staticforward PyTypeObject echo_info2_ObjectType;
52
53 static PyObject *py_echo_info2_getattr(PyObject *obj, char *name)
54 {
55         struct echo_info2 *object = py_talloc_get_type(obj, struct echo_info2);
56         if (!strcmp(name, "v")) {
57                 return PyInt_FromLong(object->v);
58         }
59         PyErr_SetString(PyExc_AttributeError, "no such attribute");
60         return NULL;
61 }
62
63 static int py_echo_info2_setattr(PyObject *py_obj, char *name, PyObject *value)
64 {
65         struct echo_info2 *object = py_talloc_get_type(py_obj, struct echo_info2);
66         if (!strcmp(name, "v")) {
67                 /* FIXME: talloc_free(object->v) if necessary */
68                 object->v = PyInt_AsLong(value);
69                 return 0;
70         }
71         PyErr_SetString(PyExc_AttributeError, "no such attribute");
72         return -1;
73 }
74
75 static PyTypeObject echo_info2_ObjectType = {
76         PyObject_HEAD_INIT(NULL) 0,
77         .tp_name = "echo_info2",
78         .tp_basicsize = sizeof(py_talloc_Object),
79         .tp_dealloc = py_talloc_dealloc,
80         .tp_getattr = py_echo_info2_getattr,
81         .tp_setattr = py_echo_info2_setattr,
82 };
83
84 static PyObject *py_echo_info2(PyObject *self, PyObject *args)
85 {
86         struct echo_info2 *ret = talloc_zero(NULL, struct echo_info2);
87         return py_talloc_import(&echo_info2_ObjectType, ret);
88 }
89
90 staticforward PyTypeObject echo_info3_ObjectType;
91
92 static PyObject *py_echo_info3_getattr(PyObject *obj, char *name)
93 {
94         struct echo_info3 *object = py_talloc_get_type(obj, struct echo_info3);
95         if (!strcmp(name, "v")) {
96                 return PyInt_FromLong(object->v);
97         }
98         PyErr_SetString(PyExc_AttributeError, "no such attribute");
99         return NULL;
100 }
101
102 static int py_echo_info3_setattr(PyObject *py_obj, char *name, PyObject *value)
103 {
104         struct echo_info3 *object = py_talloc_get_type(py_obj, struct echo_info3);
105         if (!strcmp(name, "v")) {
106                 /* FIXME: talloc_free(object->v) if necessary */
107                 object->v = PyInt_AsLong(value);
108                 return 0;
109         }
110         PyErr_SetString(PyExc_AttributeError, "no such attribute");
111         return -1;
112 }
113
114 static PyTypeObject echo_info3_ObjectType = {
115         PyObject_HEAD_INIT(NULL) 0,
116         .tp_name = "echo_info3",
117         .tp_basicsize = sizeof(py_talloc_Object),
118         .tp_dealloc = py_talloc_dealloc,
119         .tp_getattr = py_echo_info3_getattr,
120         .tp_setattr = py_echo_info3_setattr,
121 };
122
123 static PyObject *py_echo_info3(PyObject *self, PyObject *args)
124 {
125         struct echo_info3 *ret = talloc_zero(NULL, struct echo_info3);
126         return py_talloc_import(&echo_info3_ObjectType, ret);
127 }
128
129 staticforward PyTypeObject echo_info4_ObjectType;
130
131 static PyObject *py_echo_info4_getattr(PyObject *obj, char *name)
132 {
133         struct echo_info4 *object = py_talloc_get_type(obj, struct echo_info4);
134         if (!strcmp(name, "v")) {
135                 return PyInt_FromLong(object->v);
136         }
137         PyErr_SetString(PyExc_AttributeError, "no such attribute");
138         return NULL;
139 }
140
141 static int py_echo_info4_setattr(PyObject *py_obj, char *name, PyObject *value)
142 {
143         struct echo_info4 *object = py_talloc_get_type(py_obj, struct echo_info4);
144         if (!strcmp(name, "v")) {
145                 /* FIXME: talloc_free(object->v) if necessary */
146                 object->v = PyInt_AsLong(value);
147                 return 0;
148         }
149         PyErr_SetString(PyExc_AttributeError, "no such attribute");
150         return -1;
151 }
152
153 static PyTypeObject echo_info4_ObjectType = {
154         PyObject_HEAD_INIT(NULL) 0,
155         .tp_name = "echo_info4",
156         .tp_basicsize = sizeof(py_talloc_Object),
157         .tp_dealloc = py_talloc_dealloc,
158         .tp_getattr = py_echo_info4_getattr,
159         .tp_setattr = py_echo_info4_setattr,
160 };
161
162 static PyObject *py_echo_info4(PyObject *self, PyObject *args)
163 {
164         struct echo_info4 *ret = talloc_zero(NULL, struct echo_info4);
165         return py_talloc_import(&echo_info4_ObjectType, ret);
166 }
167
168 staticforward PyTypeObject echo_info5_ObjectType;
169
170 static PyObject *py_echo_info5_getattr(PyObject *obj, char *name)
171 {
172         struct echo_info5 *object = py_talloc_get_type(obj, struct echo_info5);
173         if (!strcmp(name, "v1")) {
174                 return PyInt_FromLong(object->v1);
175         }
176         if (!strcmp(name, "v2")) {
177                 return PyInt_FromLong(object->v2);
178         }
179         PyErr_SetString(PyExc_AttributeError, "no such attribute");
180         return NULL;
181 }
182
183 static int py_echo_info5_setattr(PyObject *py_obj, char *name, PyObject *value)
184 {
185         struct echo_info5 *object = py_talloc_get_type(py_obj, struct echo_info5);
186         if (!strcmp(name, "v1")) {
187                 /* FIXME: talloc_free(object->v1) if necessary */
188                 object->v1 = PyInt_AsLong(value);
189                 return 0;
190         }
191         if (!strcmp(name, "v2")) {
192                 /* FIXME: talloc_free(object->v2) if necessary */
193                 object->v2 = PyInt_AsLong(value);
194                 return 0;
195         }
196         PyErr_SetString(PyExc_AttributeError, "no such attribute");
197         return -1;
198 }
199
200 static PyTypeObject echo_info5_ObjectType = {
201         PyObject_HEAD_INIT(NULL) 0,
202         .tp_name = "echo_info5",
203         .tp_basicsize = sizeof(py_talloc_Object),
204         .tp_dealloc = py_talloc_dealloc,
205         .tp_getattr = py_echo_info5_getattr,
206         .tp_setattr = py_echo_info5_setattr,
207 };
208
209 static PyObject *py_echo_info5(PyObject *self, PyObject *args)
210 {
211         struct echo_info5 *ret = talloc_zero(NULL, struct echo_info5);
212         return py_talloc_import(&echo_info5_ObjectType, ret);
213 }
214
215 staticforward PyTypeObject echo_info6_ObjectType;
216
217 static PyObject *py_echo_info6_getattr(PyObject *obj, char *name)
218 {
219         struct echo_info6 *object = py_talloc_get_type(obj, struct echo_info6);
220         if (!strcmp(name, "v1")) {
221                 return PyInt_FromLong(object->v1);
222         }
223         if (!strcmp(name, "info1")) {
224                 return py_talloc_import(&echo_info1_ObjectType, object->info1);
225         }
226         PyErr_SetString(PyExc_AttributeError, "no such attribute");
227         return NULL;
228 }
229
230 static int py_echo_info6_setattr(PyObject *py_obj, char *name, PyObject *value)
231 {
232         struct echo_info6 *object = py_talloc_get_type(py_obj, struct echo_info6);
233         if (!strcmp(name, "v1")) {
234                 /* FIXME: talloc_free(object->v1) if necessary */
235                 object->v1 = PyInt_AsLong(value);
236                 return 0;
237         }
238         if (!strcmp(name, "info1")) {
239                 /* FIXME: talloc_free(object->info1) if necessary */
240                 object->info1 = py_talloc_get_type(value, struct echo_info1);
241                 return 0;
242         }
243         PyErr_SetString(PyExc_AttributeError, "no such attribute");
244         return -1;
245 }
246
247 static PyTypeObject echo_info6_ObjectType = {
248         PyObject_HEAD_INIT(NULL) 0,
249         .tp_name = "echo_info6",
250         .tp_basicsize = sizeof(py_talloc_Object),
251         .tp_dealloc = py_talloc_dealloc,
252         .tp_getattr = py_echo_info6_getattr,
253         .tp_setattr = py_echo_info6_setattr,
254 };
255
256 static PyObject *py_echo_info6(PyObject *self, PyObject *args)
257 {
258         struct echo_info6 *ret = talloc_zero(NULL, struct echo_info6);
259         return py_talloc_import(&echo_info6_ObjectType, ret);
260 }
261
262 staticforward PyTypeObject echo_info7_ObjectType;
263
264 static PyObject *py_echo_info7_getattr(PyObject *obj, char *name)
265 {
266         struct echo_info7 *object = py_talloc_get_type(obj, struct echo_info7);
267         if (!strcmp(name, "v1")) {
268                 return PyInt_FromLong(object->v1);
269         }
270         if (!strcmp(name, "info4")) {
271                 return py_talloc_import(&echo_info4_ObjectType, object->info4);
272         }
273         PyErr_SetString(PyExc_AttributeError, "no such attribute");
274         return NULL;
275 }
276
277 static int py_echo_info7_setattr(PyObject *py_obj, char *name, PyObject *value)
278 {
279         struct echo_info7 *object = py_talloc_get_type(py_obj, struct echo_info7);
280         if (!strcmp(name, "v1")) {
281                 /* FIXME: talloc_free(object->v1) if necessary */
282                 object->v1 = PyInt_AsLong(value);
283                 return 0;
284         }
285         if (!strcmp(name, "info4")) {
286                 /* FIXME: talloc_free(object->info4) if necessary */
287                 object->info4 = py_talloc_get_type(value, struct echo_info4);
288                 return 0;
289         }
290         PyErr_SetString(PyExc_AttributeError, "no such attribute");
291         return -1;
292 }
293
294 static PyTypeObject echo_info7_ObjectType = {
295         PyObject_HEAD_INIT(NULL) 0,
296         .tp_name = "echo_info7",
297         .tp_basicsize = sizeof(py_talloc_Object),
298         .tp_dealloc = py_talloc_dealloc,
299         .tp_getattr = py_echo_info7_getattr,
300         .tp_setattr = py_echo_info7_setattr,
301 };
302
303 static PyObject *py_echo_info7(PyObject *self, PyObject *args)
304 {
305         struct echo_info7 *ret = talloc_zero(NULL, struct echo_info7);
306         return py_talloc_import(&echo_info7_ObjectType, ret);
307 }
308
309 PyObject *py_import_echo_Info(int level, union echo_Info *in)
310 {
311         switch (level) {
312                 case 1: return py_talloc_import(&echo_info1_ObjectType, in->info1);
313                 case 2: return py_talloc_import(&echo_info2_ObjectType, in->info2);
314                 case 3: return py_talloc_import(&echo_info3_ObjectType, in->info3);
315                 case 4: return py_talloc_import(&echo_info4_ObjectType, in->info4);
316                 case 5: return py_talloc_import(&echo_info5_ObjectType, in->info5);
317                 case 6: return py_talloc_import(&echo_info6_ObjectType, in->info6);
318                 case 7: return py_talloc_import(&echo_info7_ObjectType, in->info7);
319         }
320         PyErr_SetString(PyExc_TypeError, "unknown union level");
321         return NULL;
322 }
323
324 union echo_Info *py_export_echo_Info(TALLOC_CTX *mem_ctx, int level, PyObject *in)
325 {
326         union echo_Info *ret = talloc_zero(mem_ctx, union echo_Info);
327         switch (level) {
328                 case 1:
329                         ret->info1 = py_talloc_get_type(in, struct echo_info1);
330                         break;
331
332                 case 2:
333                         ret->info2 = py_talloc_get_type(in, struct echo_info2);
334                         break;
335
336                 case 3:
337                         ret->info3 = py_talloc_get_type(in, struct echo_info3);
338                         break;
339
340                 case 4:
341                         ret->info4 = py_talloc_get_type(in, struct echo_info4);
342                         break;
343
344                 case 5:
345                         ret->info5 = py_talloc_get_type(in, struct echo_info5);
346                         break;
347
348                 case 6:
349                         ret->info6 = py_talloc_get_type(in, struct echo_info6);
350                         break;
351
352                 case 7:
353                         ret->info7 = py_talloc_get_type(in, struct echo_info7);
354                         break;
355
356                 default:
357                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
358                         talloc_free(ret);
359                         ret = NULL;
360         }
361
362         return ret;
363 }
364
365 staticforward PyTypeObject echo_Enum2_ObjectType;
366
367 static PyObject *py_echo_Enum2_getattr(PyObject *obj, char *name)
368 {
369         struct echo_Enum2 *object = py_talloc_get_type(obj, struct echo_Enum2);
370         if (!strcmp(name, "e1")) {
371                 return PyInt_FromLong(object->e1);
372         }
373         if (!strcmp(name, "e2")) {
374                 return PyInt_FromLong(object->e2);
375         }
376         PyErr_SetString(PyExc_AttributeError, "no such attribute");
377         return NULL;
378 }
379
380 static int py_echo_Enum2_setattr(PyObject *py_obj, char *name, PyObject *value)
381 {
382         struct echo_Enum2 *object = py_talloc_get_type(py_obj, struct echo_Enum2);
383         if (!strcmp(name, "e1")) {
384                 /* FIXME: talloc_free(object->e1) if necessary */
385                 object->e1 = PyInt_AsLong(value);
386                 return 0;
387         }
388         if (!strcmp(name, "e2")) {
389                 /* FIXME: talloc_free(object->e2) if necessary */
390                 object->e2 = PyInt_AsLong(value);
391                 return 0;
392         }
393         PyErr_SetString(PyExc_AttributeError, "no such attribute");
394         return -1;
395 }
396
397 static PyTypeObject echo_Enum2_ObjectType = {
398         PyObject_HEAD_INIT(NULL) 0,
399         .tp_name = "echo_Enum2",
400         .tp_basicsize = sizeof(py_talloc_Object),
401         .tp_dealloc = py_talloc_dealloc,
402         .tp_getattr = py_echo_Enum2_getattr,
403         .tp_setattr = py_echo_Enum2_setattr,
404 };
405
406 static PyObject *py_echo_Enum2(PyObject *self, PyObject *args)
407 {
408         struct echo_Enum2 *ret = talloc_zero(NULL, struct echo_Enum2);
409         return py_talloc_import(&echo_Enum2_ObjectType, ret);
410 }
411
412 PyObject *py_import_echo_Enum3(int level, union echo_Enum3 *in)
413 {
414         switch (level) {
415                 case ECHO_ENUM1: return PyInt_FromLong(in->e1);
416                 case ECHO_ENUM2: return py_talloc_import(&echo_Enum2_ObjectType, in->e2);
417         }
418         PyErr_SetString(PyExc_TypeError, "unknown union level");
419         return NULL;
420 }
421
422 union echo_Enum3 *py_export_echo_Enum3(TALLOC_CTX *mem_ctx, int level, PyObject *in)
423 {
424         union echo_Enum3 *ret = talloc_zero(mem_ctx, union echo_Enum3);
425         switch (level) {
426                 case ECHO_ENUM1:
427                         ret->e1 = PyInt_AsLong(in);
428                         break;
429
430                 case ECHO_ENUM2:
431                         ret->e2 = py_talloc_get_type(in, struct echo_Enum2);
432                         break;
433
434                 default:
435                         PyErr_SetString(PyExc_TypeError, "invalid union level value");
436                         talloc_free(ret);
437                         ret = NULL;
438         }
439
440         return ret;
441 }
442
443 staticforward PyTypeObject echo_Surrounding_ObjectType;
444
445 static PyObject *py_echo_Surrounding_getattr(PyObject *obj, char *name)
446 {
447         struct echo_Surrounding *object = py_talloc_get_type(obj, struct echo_Surrounding);
448         if (!strcmp(name, "x")) {
449                 return PyInt_FromLong(object->x);
450         }
451         if (!strcmp(name, "surrounding")) {
452                 return PyInt_FromLong(object->surrounding);
453         }
454         PyErr_SetString(PyExc_AttributeError, "no such attribute");
455         return NULL;
456 }
457
458 static int py_echo_Surrounding_setattr(PyObject *py_obj, char *name, PyObject *value)
459 {
460         struct echo_Surrounding *object = py_talloc_get_type(py_obj, struct echo_Surrounding);
461         if (!strcmp(name, "x")) {
462                 /* FIXME: talloc_free(object->x) if necessary */
463                 object->x = PyInt_AsLong(value);
464                 return 0;
465         }
466         if (!strcmp(name, "surrounding")) {
467                 /* FIXME: talloc_free(object->surrounding) if necessary */
468                 object->surrounding = PyInt_AsLong(value);
469                 return 0;
470         }
471         PyErr_SetString(PyExc_AttributeError, "no such attribute");
472         return -1;
473 }
474
475 static PyTypeObject echo_Surrounding_ObjectType = {
476         PyObject_HEAD_INIT(NULL) 0,
477         .tp_name = "echo_Surrounding",
478         .tp_basicsize = sizeof(py_talloc_Object),
479         .tp_dealloc = py_talloc_dealloc,
480         .tp_getattr = py_echo_Surrounding_getattr,
481         .tp_setattr = py_echo_Surrounding_setattr,
482 };
483
484 static PyObject *py_echo_Surrounding(PyObject *self, PyObject *args)
485 {
486         struct echo_Surrounding *ret = talloc_zero(NULL, struct echo_Surrounding);
487         return py_talloc_import(&echo_Surrounding_ObjectType, ret);
488 }
489
490 staticforward PyTypeObject rpcecho_InterfaceType;
491 typedef struct {
492         PyObject_HEAD
493         struct dcerpc_pipe *pipe;
494 } rpcecho_InterfaceObject;
495
496 static PyObject *py_echo_AddOne(PyObject *self, PyObject *args)
497 {
498         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
499         NTSTATUS status;
500         TALLOC_CTX *mem_ctx = talloc_new(NULL);
501         struct echo_AddOne r;
502         PyObject *result;
503         PyObject *py_in_data;
504
505         ZERO_STRUCT(r.out);
506         r.in.in_data = PyInt_AsLong(py_in_data);
507         status = dcerpc_echo_AddOne(iface->pipe, mem_ctx, &r);
508         if (NT_STATUS_IS_ERR(status)) {
509                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
510                 talloc_free(mem_ctx);
511                 return NULL;
512         }
513
514         result = PyTuple_New(1);
515         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.out_data));
516         talloc_free(mem_ctx);
517         return result;
518 }
519
520 static PyObject *py_echo_EchoData(PyObject *self, PyObject *args)
521 {
522         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
523         NTSTATUS status;
524         TALLOC_CTX *mem_ctx = talloc_new(NULL);
525         struct echo_EchoData r;
526         PyObject *result;
527         PyObject *py_len;
528         PyObject *py_in_data;
529
530         ZERO_STRUCT(r.out);
531         r.in.len = PyInt_AsLong(py_len);
532         r.in.in_data = PyInt_AsLong(py_in_data);
533         status = dcerpc_echo_EchoData(iface->pipe, mem_ctx, &r);
534         if (NT_STATUS_IS_ERR(status)) {
535                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
536                 talloc_free(mem_ctx);
537                 return NULL;
538         }
539
540         result = PyTuple_New(1);
541         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.out_data));
542         talloc_free(mem_ctx);
543         return result;
544 }
545
546 static PyObject *py_echo_SinkData(PyObject *self, PyObject *args)
547 {
548         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
549         NTSTATUS status;
550         TALLOC_CTX *mem_ctx = talloc_new(NULL);
551         struct echo_SinkData r;
552         PyObject *result;
553         PyObject *py_len;
554         PyObject *py_data;
555         r.in.len = PyInt_AsLong(py_len);
556         r.in.data = PyInt_AsLong(py_data);
557         status = dcerpc_echo_SinkData(iface->pipe, mem_ctx, &r);
558         if (NT_STATUS_IS_ERR(status)) {
559                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
560                 talloc_free(mem_ctx);
561                 return NULL;
562         }
563
564         result = PyTuple_New(0);
565         talloc_free(mem_ctx);
566         return result;
567 }
568
569 static PyObject *py_echo_SourceData(PyObject *self, PyObject *args)
570 {
571         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
572         NTSTATUS status;
573         TALLOC_CTX *mem_ctx = talloc_new(NULL);
574         struct echo_SourceData r;
575         PyObject *result;
576         PyObject *py_len;
577
578         ZERO_STRUCT(r.out);
579         r.in.len = PyInt_AsLong(py_len);
580         status = dcerpc_echo_SourceData(iface->pipe, mem_ctx, &r);
581         if (NT_STATUS_IS_ERR(status)) {
582                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
583                 talloc_free(mem_ctx);
584                 return NULL;
585         }
586
587         result = PyTuple_New(1);
588         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.data));
589         talloc_free(mem_ctx);
590         return result;
591 }
592
593 static PyObject *py_echo_TestCall(PyObject *self, PyObject *args)
594 {
595         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
596         NTSTATUS status;
597         TALLOC_CTX *mem_ctx = talloc_new(NULL);
598         struct echo_TestCall r;
599         PyObject *result;
600         PyObject *py_s1;
601
602         ZERO_STRUCT(r.out);
603         r.in.s1 = PyInt_AsLong(py_s1);
604         status = dcerpc_echo_TestCall(iface->pipe, mem_ctx, &r);
605         if (NT_STATUS_IS_ERR(status)) {
606                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
607                 talloc_free(mem_ctx);
608                 return NULL;
609         }
610
611         result = PyTuple_New(1);
612         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.s2));
613         talloc_free(mem_ctx);
614         return result;
615 }
616
617 static PyObject *py_echo_TestCall2(PyObject *self, PyObject *args)
618 {
619         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
620         NTSTATUS status;
621         TALLOC_CTX *mem_ctx = talloc_new(NULL);
622         struct echo_TestCall2 r;
623         PyObject *result;
624         PyObject *py_level;
625
626         ZERO_STRUCT(r.out);
627         r.in.level = PyInt_AsLong(py_level);
628         status = dcerpc_echo_TestCall2(iface->pipe, mem_ctx, &r);
629         if (NT_STATUS_IS_ERR(status)) {
630                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
631                 talloc_free(mem_ctx);
632                 return NULL;
633         }
634
635         result = PyTuple_New(2);
636         PyTuple_SetItem(result, 0, py_import_echo_Info(r.out.info));
637         PyTuple_SetItem(result, 1, PyInt_FromLong(NT_STATUS_V(r.out.result)));
638         talloc_free(mem_ctx);
639         return result;
640 }
641
642 static PyObject *py_echo_TestSleep(PyObject *self, PyObject *args)
643 {
644         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
645         NTSTATUS status;
646         TALLOC_CTX *mem_ctx = talloc_new(NULL);
647         struct echo_TestSleep r;
648         PyObject *result;
649         PyObject *py_seconds;
650         r.in.seconds = PyInt_AsLong(py_seconds);
651         status = dcerpc_echo_TestSleep(iface->pipe, mem_ctx, &r);
652         if (NT_STATUS_IS_ERR(status)) {
653                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
654                 talloc_free(mem_ctx);
655                 return NULL;
656         }
657
658         result = PyTuple_New(1);
659         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.result));
660         talloc_free(mem_ctx);
661         return result;
662 }
663
664 static PyObject *py_echo_TestEnum(PyObject *self, PyObject *args)
665 {
666         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
667         NTSTATUS status;
668         TALLOC_CTX *mem_ctx = talloc_new(NULL);
669         struct echo_TestEnum r;
670         PyObject *result;
671         PyObject *py_foo1;
672         PyObject *py_foo2;
673         PyObject *py_foo3;
674
675         ZERO_STRUCT(r.out);
676         r.in.foo1 = PyInt_AsLong(py_foo1);
677         r.in.foo2 = py_talloc_get_type(py_foo2, struct echo_Enum2);
678         r.in.foo3 = py_export_echo_Enum3(py_foo3);
679         status = dcerpc_echo_TestEnum(iface->pipe, mem_ctx, &r);
680         if (NT_STATUS_IS_ERR(status)) {
681                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
682                 talloc_free(mem_ctx);
683                 return NULL;
684         }
685
686         result = PyTuple_New(3);
687         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.foo1));
688         PyTuple_SetItem(result, 1, py_talloc_import(&echo_Enum2_ObjectType, r.out.foo2));
689         PyTuple_SetItem(result, 2, py_import_echo_Enum3(r.out.foo3));
690         talloc_free(mem_ctx);
691         return result;
692 }
693
694 static PyObject *py_echo_TestSurrounding(PyObject *self, PyObject *args)
695 {
696         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
697         NTSTATUS status;
698         TALLOC_CTX *mem_ctx = talloc_new(NULL);
699         struct echo_TestSurrounding r;
700         PyObject *result;
701         PyObject *py_data;
702
703         ZERO_STRUCT(r.out);
704         r.in.data = py_talloc_get_type(py_data, struct echo_Surrounding);
705         status = dcerpc_echo_TestSurrounding(iface->pipe, mem_ctx, &r);
706         if (NT_STATUS_IS_ERR(status)) {
707                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
708                 talloc_free(mem_ctx);
709                 return NULL;
710         }
711
712         result = PyTuple_New(1);
713         PyTuple_SetItem(result, 0, py_talloc_import(&echo_Surrounding_ObjectType, r.out.data));
714         talloc_free(mem_ctx);
715         return result;
716 }
717
718 static PyObject *py_echo_TestDoublePointer(PyObject *self, PyObject *args)
719 {
720         rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self;
721         NTSTATUS status;
722         TALLOC_CTX *mem_ctx = talloc_new(NULL);
723         struct echo_TestDoublePointer r;
724         PyObject *result;
725         PyObject *py_data;
726         r.in.data = PyInt_AsLong(py_data);
727         status = dcerpc_echo_TestDoublePointer(iface->pipe, mem_ctx, &r);
728         if (NT_STATUS_IS_ERR(status)) {
729                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
730                 talloc_free(mem_ctx);
731                 return NULL;
732         }
733
734         result = PyTuple_New(1);
735         PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.result));
736         talloc_free(mem_ctx);
737         return result;
738 }
739
740 static PyMethodDef interface_rpcecho_methods[] = {
741         { "echo_AddOne", (PyCFunction)py_echo_AddOne, METH_VARARGS|METH_KEYWORDS, NULL },
742         { "echo_EchoData", (PyCFunction)py_echo_EchoData, METH_VARARGS|METH_KEYWORDS, NULL },
743         { "echo_SinkData", (PyCFunction)py_echo_SinkData, METH_VARARGS|METH_KEYWORDS, NULL },
744         { "echo_SourceData", (PyCFunction)py_echo_SourceData, METH_VARARGS|METH_KEYWORDS, NULL },
745         { "echo_TestCall", (PyCFunction)py_echo_TestCall, METH_VARARGS|METH_KEYWORDS, NULL },
746         { "echo_TestCall2", (PyCFunction)py_echo_TestCall2, METH_VARARGS|METH_KEYWORDS, NULL },
747         { "echo_TestSleep", (PyCFunction)py_echo_TestSleep, METH_VARARGS|METH_KEYWORDS, NULL },
748         { "echo_TestEnum", (PyCFunction)py_echo_TestEnum, METH_VARARGS|METH_KEYWORDS, NULL },
749         { "echo_TestSurrounding", (PyCFunction)py_echo_TestSurrounding, METH_VARARGS|METH_KEYWORDS, NULL },
750         { "echo_TestDoublePointer", (PyCFunction)py_echo_TestDoublePointer, METH_VARARGS|METH_KEYWORDS, NULL },
751         { NULL, NULL, 0, NULL }
752 };
753
754 static void interface_rpcecho_dealloc(PyObject* self)
755 {
756         rpcecho_InterfaceObject *interface = (rpcecho_InterfaceObject *)self;
757         talloc_free(interface->pipe);
758         PyObject_Del(self);
759 }
760
761 static PyObject *interface_rpcecho_getattr(PyObject *obj, char *name)
762 {
763         return Py_FindMethod(interface_rpcecho_methods, obj, name);
764 }
765
766 static PyTypeObject rpcecho_InterfaceType = {
767         PyObject_HEAD_INIT(NULL) 0,
768         .tp_name = "rpcecho",
769         .tp_basicsize = sizeof(rpcecho_InterfaceObject),
770         .tp_dealloc = (destructor)interface_rpcecho_dealloc,
771         .tp_getattr = (getattrfunc)interface_rpcecho_getattr,
772 };
773
774 static PyObject *interface_rpcecho(PyObject *self, PyObject *args)
775 {
776         rpcecho_InterfaceObject *ret;
777         const char *binding_string;
778         struct cli_credentials *credentials;
779         struct loadparm_context *lp_ctx;
780         TALLOC_CTX *mem_ctx = NULL;
781         NTSTATUS status;
782
783         ret = PyObject_New(rpcecho_InterfaceObject, &rpcecho_InterfaceType);
784
785         status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, 
786                      &ndr_table_rpcecho, credentials, NULL, lp_ctx);
787         if (NT_STATUS_IS_ERR(status)) {
788                 PyErr_SetString(PyExc_RuntimeError, nt_errstr(status));
789                 talloc_free(mem_ctx);
790                 return NULL;
791         }
792
793         return (PyObject *)ret;
794 }
795
796 static PyMethodDef echo_methods[] = {
797         { "info1", (PyCFunction)py_echo_info1, METH_NOARGS, NULL },
798         { "info2", (PyCFunction)py_echo_info2, METH_NOARGS, NULL },
799         { "info3", (PyCFunction)py_echo_info3, METH_NOARGS, NULL },
800         { "info4", (PyCFunction)py_echo_info4, METH_NOARGS, NULL },
801         { "info5", (PyCFunction)py_echo_info5, METH_NOARGS, NULL },
802         { "info6", (PyCFunction)py_echo_info6, METH_NOARGS, NULL },
803         { "info7", (PyCFunction)py_echo_info7, METH_NOARGS, NULL },
804         { "Enum2", (PyCFunction)py_echo_Enum2, METH_NOARGS, NULL },
805         { "Surrounding", (PyCFunction)py_echo_Surrounding, METH_NOARGS, NULL },
806         { "rpcecho", (PyCFunction)interface_rpcecho, METH_VARARGS|METH_KEYWORDS, NULL },
807         { NULL, NULL, 0, NULL }
808 };
809
810 void initecho(void)
811 {
812         PyObject *m;
813         m = Py_InitModule("echo", echo_methods);
814         PyModule_AddObject(m, "ECHO_ENUM1", PyInt_FromLong(ECHO_ENUM1));
815         PyModule_AddObject(m, "ECHO_ENUM2_32", PyInt_FromLong(ECHO_ENUM2_32));
816         PyModule_AddObject(m, "ECHO_ENUM2", PyInt_FromLong(ECHO_ENUM2));
817         PyModule_AddObject(m, "ECHO_ENUM1_32", PyInt_FromLong(ECHO_ENUM1_32));
818 }