diff options
| -rw-r--r-- | source4/pidl/lib/Parse/Pidl/Samba4/Python.pm | 24 | ||||
| -rw-r--r-- | source4/py_echo.c | 818 | ||||
| -rw-r--r-- | source4/py_echo.h | 8 | ||||
| -rw-r--r-- | source4/scripting/python/pytalloc.c | 10 | ||||
| -rw-r--r-- | source4/scripting/python/pytalloc.h | 3 |
5 files changed, 855 insertions, 8 deletions
diff --git a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm index 545d233d08e..a5f80538340 100644 --- a/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm +++ b/source4/pidl/lib/Parse/Pidl/Samba4/Python.pm @@ -214,6 +214,7 @@ sub PythonStruct($$$$) $self->pidl(".tp_dealloc = py_talloc_dealloc,"); $self->pidl(".tp_getattr = py_$name\_getattr,"); $self->pidl(".tp_setattr = py_$name\_setattr,"); + $self->pidl(".tp_repr = py_talloc_default_repr,"); $self->deindent; $self->pidl("};"); @@ -559,6 +560,8 @@ sub ConvertScalarToPython($$$) { my ($self, $ctypename, $cvar) = @_; + die("expected string for $cvar, not $ctypename") if (ref($ctypename) eq "HASH"); + $ctypename = expandAlias($ctypename); if ($ctypename =~ /^(int|long|char|u?int[0-9]+|hyper|dlong|udlong|udlongr|time_t|NTTIME_hyper|NTTIME|NTTIME_1sec)$/) { @@ -583,7 +586,7 @@ sub ConvertScalarToPython($$$) if ($ctypename eq "string_array") { return "FIXME($cvar)"; } - if ($$ctypename eq "ipv4address") { return "FIXME($cvar)"; } + if ($ctypename eq "ipv4address") { return "FIXME($cvar)"; } if ($ctypename eq "pointer") { return "PyCObject_FromVoidPtr($cvar, talloc_free)"; } @@ -614,8 +617,15 @@ sub ConvertObjectToPython($$$) $actual_ctype = $ctype->{DATA}; } - if ($actual_ctype->{TYPE} eq "ENUM" or $actual_ctype->{TYPE} eq "BITMAP" or - ($actual_ctype->{TYPE} eq "SCALAR") { + if ($actual_ctype->{TYPE} eq "ENUM") { + return $self->ConvertScalarToPython(Parse::Pidl::Typelist::enum_type_fn($actual_ctype), $cvar); + } + + if ($actual_ctype->{TYPE} eq "BITMAP") { + return $self->ConvertScalarToPython(Parse::Pidl::Typelist::bitmap_type_fn($actual_ctype), $cvar); + } + + if ($actual_ctype->{TYPE} eq "SCALAR") { return $self->ConvertScalarToPython($actual_ctype->{NAME}, $cvar); } @@ -675,18 +685,18 @@ sub Parse($$$$$) $self->indent; $self->pidl("PyObject *m;"); $self->pidl("m = Py_InitModule(\"$basename\", $basename\_methods);"); - foreach (keys %{$self->{constants}}) { + foreach my $name (keys %{$self->{constants}}) { my $py_obj; - my ($ctype, $cvar) = @{$self->{constants}->{$_}}; + my ($ctype, $cvar) = @{$self->{constants}->{$name}}; if ($cvar =~ /^[0-9]+$/ or $cvar =~ /^0x[0-9a-fA-F]+$/) { $py_obj = "PyInt_FromLong($cvar)"; } elsif ($cvar =~ /^".*"$/) { $py_obj = "PyString_FromString($cvar)"; } else { - $py_obj = $self->ConvertScalarToPython($ctype, $cvar); + $py_obj = $self->ConvertObjectToPython($ctype, $cvar); } - $self->pidl("PyModule_AddObject(m, \"$_\", $py_obj);"); + $self->pidl("PyModule_AddObject(m, \"$name\", $py_obj);"); } $self->deindent; $self->pidl("}"); diff --git a/source4/py_echo.c b/source4/py_echo.c new file mode 100644 index 00000000000..f9cf77deacb --- /dev/null +++ b/source4/py_echo.c @@ -0,0 +1,818 @@ + +/* Python wrapper functions auto-generated by pidl */ +#include "includes.h" +#include <Python.h> +#include "librpc/rpc/dcerpc.h" +#include "scripting/python/pytalloc.h" +#include "./ndr_echo.h" +#include "./ndr_echo_c.h" +#include "./py_echo.h" + + +staticforward PyTypeObject echo_info1_ObjectType; + +static PyObject *py_echo_info1_getattr(PyObject *obj, char *name) +{ + struct echo_info1 *object = py_talloc_get_type(obj, struct echo_info1); + if (!strcmp(name, "v")) { + return PyInt_FromLong(object->v); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info1_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info1 *object = py_talloc_get_type(py_obj, struct echo_info1); + if (!strcmp(name, "v")) { + /* FIXME: talloc_free(object->v) if necessary */ + object->v = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info1_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info1", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info1_getattr, + .tp_setattr = py_echo_info1_setattr, +}; + +static PyObject *py_echo_info1(PyObject *self, PyObject *args) +{ + struct echo_info1 *ret = talloc_zero(NULL, struct echo_info1); + return py_talloc_import(&echo_info1_ObjectType, ret); +} + +staticforward PyTypeObject echo_info2_ObjectType; + +static PyObject *py_echo_info2_getattr(PyObject *obj, char *name) +{ + struct echo_info2 *object = py_talloc_get_type(obj, struct echo_info2); + if (!strcmp(name, "v")) { + return PyInt_FromLong(object->v); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info2_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info2 *object = py_talloc_get_type(py_obj, struct echo_info2); + if (!strcmp(name, "v")) { + /* FIXME: talloc_free(object->v) if necessary */ + object->v = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info2_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info2", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info2_getattr, + .tp_setattr = py_echo_info2_setattr, +}; + +static PyObject *py_echo_info2(PyObject *self, PyObject *args) +{ + struct echo_info2 *ret = talloc_zero(NULL, struct echo_info2); + return py_talloc_import(&echo_info2_ObjectType, ret); +} + +staticforward PyTypeObject echo_info3_ObjectType; + +static PyObject *py_echo_info3_getattr(PyObject *obj, char *name) +{ + struct echo_info3 *object = py_talloc_get_type(obj, struct echo_info3); + if (!strcmp(name, "v")) { + return PyInt_FromLong(object->v); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info3_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info3 *object = py_talloc_get_type(py_obj, struct echo_info3); + if (!strcmp(name, "v")) { + /* FIXME: talloc_free(object->v) if necessary */ + object->v = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info3_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info3", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info3_getattr, + .tp_setattr = py_echo_info3_setattr, +}; + +static PyObject *py_echo_info3(PyObject *self, PyObject *args) +{ + struct echo_info3 *ret = talloc_zero(NULL, struct echo_info3); + return py_talloc_import(&echo_info3_ObjectType, ret); +} + +staticforward PyTypeObject echo_info4_ObjectType; + +static PyObject *py_echo_info4_getattr(PyObject *obj, char *name) +{ + struct echo_info4 *object = py_talloc_get_type(obj, struct echo_info4); + if (!strcmp(name, "v")) { + return PyInt_FromLong(object->v); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info4_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info4 *object = py_talloc_get_type(py_obj, struct echo_info4); + if (!strcmp(name, "v")) { + /* FIXME: talloc_free(object->v) if necessary */ + object->v = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info4_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info4", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info4_getattr, + .tp_setattr = py_echo_info4_setattr, +}; + +static PyObject *py_echo_info4(PyObject *self, PyObject *args) +{ + struct echo_info4 *ret = talloc_zero(NULL, struct echo_info4); + return py_talloc_import(&echo_info4_ObjectType, ret); +} + +staticforward PyTypeObject echo_info5_ObjectType; + +static PyObject *py_echo_info5_getattr(PyObject *obj, char *name) +{ + struct echo_info5 *object = py_talloc_get_type(obj, struct echo_info5); + if (!strcmp(name, "v1")) { + return PyInt_FromLong(object->v1); + } + if (!strcmp(name, "v2")) { + return PyInt_FromLong(object->v2); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info5_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info5 *object = py_talloc_get_type(py_obj, struct echo_info5); + if (!strcmp(name, "v1")) { + /* FIXME: talloc_free(object->v1) if necessary */ + object->v1 = PyInt_AsLong(value); + return 0; + } + if (!strcmp(name, "v2")) { + /* FIXME: talloc_free(object->v2) if necessary */ + object->v2 = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info5_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info5", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info5_getattr, + .tp_setattr = py_echo_info5_setattr, +}; + +static PyObject *py_echo_info5(PyObject *self, PyObject *args) +{ + struct echo_info5 *ret = talloc_zero(NULL, struct echo_info5); + return py_talloc_import(&echo_info5_ObjectType, ret); +} + +staticforward PyTypeObject echo_info6_ObjectType; + +static PyObject *py_echo_info6_getattr(PyObject *obj, char *name) +{ + struct echo_info6 *object = py_talloc_get_type(obj, struct echo_info6); + if (!strcmp(name, "v1")) { + return PyInt_FromLong(object->v1); + } + if (!strcmp(name, "info1")) { + return py_talloc_import(&echo_info1_ObjectType, object->info1); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info6_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info6 *object = py_talloc_get_type(py_obj, struct echo_info6); + if (!strcmp(name, "v1")) { + /* FIXME: talloc_free(object->v1) if necessary */ + object->v1 = PyInt_AsLong(value); + return 0; + } + if (!strcmp(name, "info1")) { + /* FIXME: talloc_free(object->info1) if necessary */ + object->info1 = py_talloc_get_type(value, struct echo_info1); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info6_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info6", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info6_getattr, + .tp_setattr = py_echo_info6_setattr, +}; + +static PyObject *py_echo_info6(PyObject *self, PyObject *args) +{ + struct echo_info6 *ret = talloc_zero(NULL, struct echo_info6); + return py_talloc_import(&echo_info6_ObjectType, ret); +} + +staticforward PyTypeObject echo_info7_ObjectType; + +static PyObject *py_echo_info7_getattr(PyObject *obj, char *name) +{ + struct echo_info7 *object = py_talloc_get_type(obj, struct echo_info7); + if (!strcmp(name, "v1")) { + return PyInt_FromLong(object->v1); + } + if (!strcmp(name, "info4")) { + return py_talloc_import(&echo_info4_ObjectType, object->info4); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_info7_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_info7 *object = py_talloc_get_type(py_obj, struct echo_info7); + if (!strcmp(name, "v1")) { + /* FIXME: talloc_free(object->v1) if necessary */ + object->v1 = PyInt_AsLong(value); + return 0; + } + if (!strcmp(name, "info4")) { + /* FIXME: talloc_free(object->info4) if necessary */ + object->info4 = py_talloc_get_type(value, struct echo_info4); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_info7_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_info7", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_info7_getattr, + .tp_setattr = py_echo_info7_setattr, +}; + +static PyObject *py_echo_info7(PyObject *self, PyObject *args) +{ + struct echo_info7 *ret = talloc_zero(NULL, struct echo_info7); + return py_talloc_import(&echo_info7_ObjectType, ret); +} + +PyObject *py_import_echo_Info(int level, union echo_Info *in) +{ + switch (level) { + case 1: return py_talloc_import(&echo_info1_ObjectType, in->info1); + case 2: return py_talloc_import(&echo_info2_ObjectType, in->info2); + case 3: return py_talloc_import(&echo_info3_ObjectType, in->info3); + case 4: return py_talloc_import(&echo_info4_ObjectType, in->info4); + case 5: return py_talloc_import(&echo_info5_ObjectType, in->info5); + case 6: return py_talloc_import(&echo_info6_ObjectType, in->info6); + case 7: return py_talloc_import(&echo_info7_ObjectType, in->info7); + } + PyErr_SetString(PyExc_TypeError, "unknown union level"); + return NULL; +} + +union echo_Info *py_export_echo_Info(TALLOC_CTX *mem_ctx, int level, PyObject *in) +{ + union echo_Info *ret = talloc_zero(mem_ctx, union echo_Info); + switch (level) { + case 1: + ret->info1 = py_talloc_get_type(in, struct echo_info1); + break; + + case 2: + ret->info2 = py_talloc_get_type(in, struct echo_info2); + break; + + case 3: + ret->info3 = py_talloc_get_type(in, struct echo_info3); + break; + + case 4: + ret->info4 = py_talloc_get_type(in, struct echo_info4); + break; + + case 5: + ret->info5 = py_talloc_get_type(in, struct echo_info5); + break; + + case 6: + ret->info6 = py_talloc_get_type(in, struct echo_info6); + break; + + case 7: + ret->info7 = py_talloc_get_type(in, struct echo_info7); + break; + + default: + PyErr_SetString(PyExc_TypeError, "invalid union level value"); + talloc_free(ret); + ret = NULL; + } + + return ret; +} + +staticforward PyTypeObject echo_Enum2_ObjectType; + +static PyObject *py_echo_Enum2_getattr(PyObject *obj, char *name) +{ + struct echo_Enum2 *object = py_talloc_get_type(obj, struct echo_Enum2); + if (!strcmp(name, "e1")) { + return PyInt_FromLong(object->e1); + } + if (!strcmp(name, "e2")) { + return PyInt_FromLong(object->e2); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_Enum2_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_Enum2 *object = py_talloc_get_type(py_obj, struct echo_Enum2); + if (!strcmp(name, "e1")) { + /* FIXME: talloc_free(object->e1) if necessary */ + object->e1 = PyInt_AsLong(value); + return 0; + } + if (!strcmp(name, "e2")) { + /* FIXME: talloc_free(object->e2) if necessary */ + object->e2 = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_Enum2_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_Enum2", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_Enum2_getattr, + .tp_setattr = py_echo_Enum2_setattr, +}; + +static PyObject *py_echo_Enum2(PyObject *self, PyObject *args) +{ + struct echo_Enum2 *ret = talloc_zero(NULL, struct echo_Enum2); + return py_talloc_import(&echo_Enum2_ObjectType, ret); +} + +PyObject *py_import_echo_Enum3(int level, union echo_Enum3 *in) +{ + switch (level) { + case ECHO_ENUM1: return PyInt_FromLong(in->e1); + case ECHO_ENUM2: return py_talloc_import(&echo_Enum2_ObjectType, in->e2); + } + PyErr_SetString(PyExc_TypeError, "unknown union level"); + return NULL; +} + +union echo_Enum3 *py_export_echo_Enum3(TALLOC_CTX *mem_ctx, int level, PyObject *in) +{ + union echo_Enum3 *ret = talloc_zero(mem_ctx, union echo_Enum3); + switch (level) { + case ECHO_ENUM1: + ret->e1 = PyInt_AsLong(in); + break; + + case ECHO_ENUM2: + ret->e2 = py_talloc_get_type(in, struct echo_Enum2); + break; + + default: + PyErr_SetString(PyExc_TypeError, "invalid union level value"); + talloc_free(ret); + ret = NULL; + } + + return ret; +} + +staticforward PyTypeObject echo_Surrounding_ObjectType; + +static PyObject *py_echo_Surrounding_getattr(PyObject *obj, char *name) +{ + struct echo_Surrounding *object = py_talloc_get_type(obj, struct echo_Surrounding); + if (!strcmp(name, "x")) { + return PyInt_FromLong(object->x); + } + if (!strcmp(name, "surrounding")) { + return PyInt_FromLong(object->surrounding); + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return NULL; +} + +static int py_echo_Surrounding_setattr(PyObject *py_obj, char *name, PyObject *value) +{ + struct echo_Surrounding *object = py_talloc_get_type(py_obj, struct echo_Surrounding); + if (!strcmp(name, "x")) { + /* FIXME: talloc_free(object->x) if necessary */ + object->x = PyInt_AsLong(value); + return 0; + } + if (!strcmp(name, "surrounding")) { + /* FIXME: talloc_free(object->surrounding) if necessary */ + object->surrounding = PyInt_AsLong(value); + return 0; + } + PyErr_SetString(PyExc_AttributeError, "no such attribute"); + return -1; +} + +static PyTypeObject echo_Surrounding_ObjectType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "echo_Surrounding", + .tp_basicsize = sizeof(py_talloc_Object), + .tp_dealloc = py_talloc_dealloc, + .tp_getattr = py_echo_Surrounding_getattr, + .tp_setattr = py_echo_Surrounding_setattr, +}; + +static PyObject *py_echo_Surrounding(PyObject *self, PyObject *args) +{ + struct echo_Surrounding *ret = talloc_zero(NULL, struct echo_Surrounding); + return py_talloc_import(&echo_Surrounding_ObjectType, ret); +} + +staticforward PyTypeObject rpcecho_InterfaceType; +typedef struct { + PyObject_HEAD + struct dcerpc_pipe *pipe; +} rpcecho_InterfaceObject; + +static PyObject *py_echo_AddOne(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_AddOne r; + PyObject *result; + PyObject *py_in_data; + + ZERO_STRUCT(r.out); + r.in.in_data = PyInt_AsLong(py_in_data); + status = dcerpc_echo_AddOne(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.out_data)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_EchoData(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_EchoData r; + PyObject *result; + PyObject *py_len; + PyObject *py_in_data; + + ZERO_STRUCT(r.out); + r.in.len = PyInt_AsLong(py_len); + r.in.in_data = PyInt_AsLong(py_in_data); + status = dcerpc_echo_EchoData(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.out_data)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_SinkData(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_SinkData r; + PyObject *result; + PyObject *py_len; + PyObject *py_data; + r.in.len = PyInt_AsLong(py_len); + r.in.data = PyInt_AsLong(py_data); + status = dcerpc_echo_SinkData(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(0); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_SourceData(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_SourceData r; + PyObject *result; + PyObject *py_len; + + ZERO_STRUCT(r.out); + r.in.len = PyInt_AsLong(py_len); + status = dcerpc_echo_SourceData(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.data)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_TestCall(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_TestCall r; + PyObject *result; + PyObject *py_s1; + + ZERO_STRUCT(r.out); + r.in.s1 = PyInt_AsLong(py_s1); + status = dcerpc_echo_TestCall(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.s2)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_TestCall2(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_TestCall2 r; + PyObject *result; + PyObject *py_level; + + ZERO_STRUCT(r.out); + r.in.level = PyInt_AsLong(py_level); + status = dcerpc_echo_TestCall2(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(2); + PyTuple_SetItem(result, 0, py_import_echo_Info(r.out.info)); + PyTuple_SetItem(result, 1, PyInt_FromLong(NT_STATUS_V(r.out.result))); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_TestSleep(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_TestSleep r; + PyObject *result; + PyObject *py_seconds; + r.in.seconds = PyInt_AsLong(py_seconds); + status = dcerpc_echo_TestSleep(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.result)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_TestEnum(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_TestEnum r; + PyObject *result; + PyObject *py_foo1; + PyObject *py_foo2; + PyObject *py_foo3; + + ZERO_STRUCT(r.out); + r.in.foo1 = PyInt_AsLong(py_foo1); + r.in.foo2 = py_talloc_get_type(py_foo2, struct echo_Enum2); + r.in.foo3 = py_export_echo_Enum3(py_foo3); + status = dcerpc_echo_TestEnum(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(3); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.foo1)); + PyTuple_SetItem(result, 1, py_talloc_import(&echo_Enum2_ObjectType, r.out.foo2)); + PyTuple_SetItem(result, 2, py_import_echo_Enum3(r.out.foo3)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_TestSurrounding(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_TestSurrounding r; + PyObject *result; + PyObject *py_data; + + ZERO_STRUCT(r.out); + r.in.data = py_talloc_get_type(py_data, struct echo_Surrounding); + status = dcerpc_echo_TestSurrounding(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, py_talloc_import(&echo_Surrounding_ObjectType, r.out.data)); + talloc_free(mem_ctx); + return result; +} + +static PyObject *py_echo_TestDoublePointer(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *iface = (rpcecho_InterfaceObject *)self; + NTSTATUS status; + TALLOC_CTX *mem_ctx = talloc_new(NULL); + struct echo_TestDoublePointer r; + PyObject *result; + PyObject *py_data; + r.in.data = PyInt_AsLong(py_data); + status = dcerpc_echo_TestDoublePointer(iface->pipe, mem_ctx, &r); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + result = PyTuple_New(1); + PyTuple_SetItem(result, 0, PyInt_FromLong(r.out.result)); + talloc_free(mem_ctx); + return result; +} + +static PyMethodDef interface_rpcecho_methods[] = { + { "echo_AddOne", (PyCFunction)py_echo_AddOne, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_EchoData", (PyCFunction)py_echo_EchoData, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_SinkData", (PyCFunction)py_echo_SinkData, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_SourceData", (PyCFunction)py_echo_SourceData, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_TestCall", (PyCFunction)py_echo_TestCall, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_TestCall2", (PyCFunction)py_echo_TestCall2, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_TestSleep", (PyCFunction)py_echo_TestSleep, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_TestEnum", (PyCFunction)py_echo_TestEnum, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_TestSurrounding", (PyCFunction)py_echo_TestSurrounding, METH_VARARGS|METH_KEYWORDS, NULL }, + { "echo_TestDoublePointer", (PyCFunction)py_echo_TestDoublePointer, METH_VARARGS|METH_KEYWORDS, NULL }, + { NULL, NULL, 0, NULL } +}; + +static void interface_rpcecho_dealloc(PyObject* self) +{ + rpcecho_InterfaceObject *interface = (rpcecho_InterfaceObject *)self; + talloc_free(interface->pipe); + PyObject_Del(self); +} + +static PyObject *interface_rpcecho_getattr(PyObject *obj, char *name) +{ + return Py_FindMethod(interface_rpcecho_methods, obj, name); +} + +static PyTypeObject rpcecho_InterfaceType = { + PyObject_HEAD_INIT(NULL) 0, + .tp_name = "rpcecho", + .tp_basicsize = sizeof(rpcecho_InterfaceObject), + .tp_dealloc = (destructor)interface_rpcecho_dealloc, + .tp_getattr = (getattrfunc)interface_rpcecho_getattr, +}; + +static PyObject *interface_rpcecho(PyObject *self, PyObject *args) +{ + rpcecho_InterfaceObject *ret; + const char *binding_string; + struct cli_credentials *credentials; + struct loadparm_context *lp_ctx; + TALLOC_CTX *mem_ctx = NULL; + NTSTATUS status; + + ret = PyObject_New(rpcecho_InterfaceObject, &rpcecho_InterfaceType); + + status = dcerpc_pipe_connect(NULL, &ret->pipe, binding_string, + &ndr_table_rpcecho, credentials, NULL, lp_ctx); + if (NT_STATUS_IS_ERR(status)) { + PyErr_SetString(PyExc_RuntimeError, nt_errstr(status)); + talloc_free(mem_ctx); + return NULL; + } + + return (PyObject *)ret; +} + +static PyMethodDef echo_methods[] = { + { "info1", (PyCFunction)py_echo_info1, METH_NOARGS, NULL }, + { "info2", (PyCFunction)py_echo_info2, METH_NOARGS, NULL }, + { "info3", (PyCFunction)py_echo_info3, METH_NOARGS, NULL }, + { "info4", (PyCFunction)py_echo_info4, METH_NOARGS, NULL }, + { "info5", (PyCFunction)py_echo_info5, METH_NOARGS, NULL }, + { "info6", (PyCFunction)py_echo_info6, METH_NOARGS, NULL }, + { "info7", (PyCFunction)py_echo_info7, METH_NOARGS, NULL }, + { "Enum2", (PyCFunction)py_echo_Enum2, METH_NOARGS, NULL }, + { "Surrounding", (PyCFunction)py_echo_Surrounding, METH_NOARGS, NULL }, + { "rpcecho", (PyCFunction)interface_rpcecho, METH_VARARGS|METH_KEYWORDS, NULL }, + { NULL, NULL, 0, NULL } +}; + +void initecho(void) +{ + PyObject *m; + m = Py_InitModule("echo", echo_methods); + PyModule_AddObject(m, "ECHO_ENUM1", PyInt_FromLong(ECHO_ENUM1)); + PyModule_AddObject(m, "ECHO_ENUM2_32", PyInt_FromLong(ECHO_ENUM2_32)); + PyModule_AddObject(m, "ECHO_ENUM2", PyInt_FromLong(ECHO_ENUM2)); + PyModule_AddObject(m, "ECHO_ENUM1_32", PyInt_FromLong(ECHO_ENUM1_32)); +} diff --git a/source4/py_echo.h b/source4/py_echo.h new file mode 100644 index 00000000000..426bce3b3d3 --- /dev/null +++ b/source4/py_echo.h @@ -0,0 +1,8 @@ +/* header auto-generated by pidl */ + +#ifndef _HEADER_PYTHON_rpcecho +#define _HEADER_PYTHON_rpcecho + + + +#endif /* _HEADER_NDR_rpcecho */ diff --git a/source4/scripting/python/pytalloc.c b/source4/scripting/python/pytalloc.c index 55ed56a6278..4032ff75a4b 100644 --- a/source4/scripting/python/pytalloc.c +++ b/source4/scripting/python/pytalloc.c @@ -22,7 +22,7 @@ void py_talloc_dealloc(PyObject* self) { py_talloc_Object *obj = (py_talloc_Object *)self; - talloc_free(obj->object); + talloc_free(obj->talloc_ptr); PyObject_Del(self); } @@ -32,3 +32,11 @@ PyObject *py_talloc_import(PyTypeObject *py_type, void *ptr) ret->talloc_ptr = talloc_reference(NULL, ptr); return ret; } + +PyObject *py_talloc_default_repr(PyObject *py_obj) +{ + py_talloc_Object *obj = (py_talloc_Object *)py_obj; + + return PyString_FromFormat("<talloc: %s>", + talloc_get_name(obj->talloc_ptr)); +} diff --git a/source4/scripting/python/pytalloc.h b/source4/scripting/python/pytalloc.h index 93f6b48d829..735829bfcba 100644 --- a/source4/scripting/python/pytalloc.h +++ b/source4/scripting/python/pytalloc.h @@ -40,4 +40,7 @@ void py_talloc_dealloc(PyObject* self); PyObject *py_talloc_import(PyTypeObject *py_type, void *ptr); +/* Sane default implementation of reprfunc. */ +PyObject *py_talloc_default_repr(PyObject *py_obj); + #endif /* _PY_TALLOC_H_ */ |