/* Python wrapper functions auto-generated by pidl */ #define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */ #include #include "python/py3compat.h" #include "includes.h" #include "python/modules.h" #include #include "librpc/rpc/pyrpc.h" #include "librpc/rpc/pyrpc_util.h" #include "bin/default/librpc/gen_ndr/ndr_dfsblobs.h" /* * Suppress compiler warnings if the generated code does not call these * functions */ #ifndef _MAYBE_UNUSED_ #ifdef __has_attribute #if __has_attribute(unused) #define _MAYBE_UNUSED_ __attribute__ ((unused)) #else #define _MAYBE_UNUSED_ #endif #endif #endif /* * These functions are here to ensure they can be optimized out by * the compiler based on the constant input values */ static inline unsigned long long ndr_sizeof2uintmax(size_t var_size) { switch (var_size) { case 8: return UINT64_MAX; case 4: return UINT32_MAX; case 2: return UINT16_MAX; case 1: return UINT8_MAX; } return 0; } static inline _MAYBE_UNUSED_ long long ndr_sizeof2intmax(size_t var_size) { switch (var_size) { case 8: return INT64_MAX; case 4: return INT32_MAX; case 2: return INT16_MAX; case 1: return INT8_MAX; } return 0; } #include "librpc/gen_ndr/misc.h" static PyTypeObject dfs_referral_v1_Type; static PyTypeObject dfs_referral_v2_Type; static PyTypeObject dfs_normal_referral_Type; static PyTypeObject dfs_domain_referral_Type; static PyTypeObject dfs_referral_Type; static PyTypeObject dfs_padding_Type; static PyTypeObject dfs_referral_v3_Type; static PyTypeObject dfs_referral_version_Type; static PyTypeObject dfs_referral_type_Type; static PyTypeObject dfs_referral_resp_Type; static PyTypeObject dfs_GetDFSReferral_in_Type; static PyTypeObject dfsblobs_InterfaceType; static PyTypeObject dfs_GetDFSReferral_Type; static PyTypeObject *BaseObject_Type; static PyTypeObject *ClientConnection_Type; static PyTypeObject *ndr_syntax_id_Type; static PyObject *py_dfs_referral_v1_get_size(PyObject *obj, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj); PyObject *py_size; py_size = PyLong_FromLong((uint16_t)object->size); return py_size; } static int py_dfs_referral_v1_set_size(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->size"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->size)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->size = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v1_get_server_type(PyObject *obj, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj); PyObject *py_server_type; py_server_type = PyLong_FromLong((uint16_t)object->server_type); return py_server_type; } static int py_dfs_referral_v1_set_server_type(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->server_type"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->server_type)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->server_type = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v1_get_entry_flags(PyObject *obj, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj); PyObject *py_entry_flags; py_entry_flags = PyLong_FromLong((uint16_t)object->entry_flags); return py_entry_flags; } static int py_dfs_referral_v1_set_entry_flags(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entry_flags"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->entry_flags)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->entry_flags = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v1_get_share_name(PyObject *obj, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(obj); PyObject *py_share_name; if (object->share_name == NULL) { Py_RETURN_NONE; } if (object->share_name == NULL) { py_share_name = Py_None; Py_INCREF(py_share_name); } else { py_share_name = PyString_FromStringOrNULL(object->share_name); } return py_share_name; } static int py_dfs_referral_v1_set_share_name(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v1 *object = (struct dfs_referral_v1 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->share_name"); return -1; } if (value == Py_None) { object->share_name = NULL; } else { object->share_name = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->share_name = talloc_str; } } return 0; } static PyGetSetDef py_dfs_referral_v1_getsetters[] = { { .name = discard_const_p(char, "size"), .get = py_dfs_referral_v1_get_size, .set = py_dfs_referral_v1_set_size, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "server_type"), .get = py_dfs_referral_v1_get_server_type, .set = py_dfs_referral_v1_set_server_type, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "entry_flags"), .get = py_dfs_referral_v1_get_entry_flags, .set = py_dfs_referral_v1_set_entry_flags, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "share_name"), .get = py_dfs_referral_v1_get_share_name, .set = py_dfs_referral_v1_set_share_name, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = NULL } }; static PyObject *py_dfs_referral_v1_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_referral_v1, type); } static PyTypeObject dfs_referral_v1_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral_v1", .tp_getset = py_dfs_referral_v1_getsetters, .tp_methods = NULL, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_v1_new, }; static PyObject *py_dfs_referral_v2_get_size(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_size; py_size = PyLong_FromLong((uint16_t)object->size); return py_size; } static int py_dfs_referral_v2_set_size(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->size"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->size)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->size = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v2_get_server_type(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_server_type; py_server_type = PyLong_FromLong((uint16_t)object->server_type); return py_server_type; } static int py_dfs_referral_v2_set_server_type(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->server_type"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->server_type)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->server_type = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v2_get_entry_flags(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_entry_flags; py_entry_flags = PyLong_FromLong((uint16_t)object->entry_flags); return py_entry_flags; } static int py_dfs_referral_v2_set_entry_flags(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entry_flags"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->entry_flags)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->entry_flags = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v2_get_proximity(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_proximity; py_proximity = PyLong_FromUnsignedLongLong((uint32_t)object->proximity); return py_proximity; } static int py_dfs_referral_v2_set_proximity(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->proximity"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->proximity)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->proximity = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v2_get_ttl(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_ttl; py_ttl = PyLong_FromUnsignedLongLong((uint32_t)object->ttl); return py_ttl; } static int py_dfs_referral_v2_set_ttl(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->ttl"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ttl)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->ttl = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v2_get_DFS_path(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_DFS_path; if (object->DFS_path == NULL) { Py_RETURN_NONE; } if (object->DFS_path == NULL) { py_DFS_path = Py_None; Py_INCREF(py_DFS_path); } else { py_DFS_path = PyString_FromStringOrNULL(object->DFS_path); } return py_DFS_path; } static int py_dfs_referral_v2_set_DFS_path(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->DFS_path"); return -1; } if (value == Py_None) { object->DFS_path = NULL; } else { object->DFS_path = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->DFS_path = talloc_str; } } return 0; } static PyObject *py_dfs_referral_v2_get_DFS_alt_path(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_DFS_alt_path; if (object->DFS_alt_path == NULL) { Py_RETURN_NONE; } if (object->DFS_alt_path == NULL) { py_DFS_alt_path = Py_None; Py_INCREF(py_DFS_alt_path); } else { py_DFS_alt_path = PyString_FromStringOrNULL(object->DFS_alt_path); } return py_DFS_alt_path; } static int py_dfs_referral_v2_set_DFS_alt_path(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->DFS_alt_path"); return -1; } if (value == Py_None) { object->DFS_alt_path = NULL; } else { object->DFS_alt_path = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->DFS_alt_path = talloc_str; } } return 0; } static PyObject *py_dfs_referral_v2_get_netw_address(PyObject *obj, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(obj); PyObject *py_netw_address; if (object->netw_address == NULL) { Py_RETURN_NONE; } if (object->netw_address == NULL) { py_netw_address = Py_None; Py_INCREF(py_netw_address); } else { py_netw_address = PyString_FromStringOrNULL(object->netw_address); } return py_netw_address; } static int py_dfs_referral_v2_set_netw_address(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v2 *object = (struct dfs_referral_v2 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->netw_address"); return -1; } if (value == Py_None) { object->netw_address = NULL; } else { object->netw_address = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->netw_address = talloc_str; } } return 0; } static PyGetSetDef py_dfs_referral_v2_getsetters[] = { { .name = discard_const_p(char, "size"), .get = py_dfs_referral_v2_get_size, .set = py_dfs_referral_v2_set_size, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "server_type"), .get = py_dfs_referral_v2_get_server_type, .set = py_dfs_referral_v2_set_server_type, .doc = discard_const_p(char, "PIDL-generated element of base type DFS_SERVER_TYPE") }, { .name = discard_const_p(char, "entry_flags"), .get = py_dfs_referral_v2_get_entry_flags, .set = py_dfs_referral_v2_set_entry_flags, .doc = discard_const_p(char, "PIDL-generated element of base type DFS_FLAGS_REFERRAL") }, { .name = discard_const_p(char, "proximity"), .get = py_dfs_referral_v2_get_proximity, .set = py_dfs_referral_v2_set_proximity, .doc = discard_const_p(char, "PIDL-generated element of base type uint32") }, { .name = discard_const_p(char, "ttl"), .get = py_dfs_referral_v2_get_ttl, .set = py_dfs_referral_v2_set_ttl, .doc = discard_const_p(char, "PIDL-generated element of base type uint32") }, { .name = discard_const_p(char, "DFS_path"), .get = py_dfs_referral_v2_get_DFS_path, .set = py_dfs_referral_v2_set_DFS_path, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = discard_const_p(char, "DFS_alt_path"), .get = py_dfs_referral_v2_get_DFS_alt_path, .set = py_dfs_referral_v2_set_DFS_alt_path, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = discard_const_p(char, "netw_address"), .get = py_dfs_referral_v2_get_netw_address, .set = py_dfs_referral_v2_set_netw_address, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = NULL } }; static PyObject *py_dfs_referral_v2_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_referral_v2, type); } static PyTypeObject dfs_referral_v2_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral_v2", .tp_getset = py_dfs_referral_v2_getsetters, .tp_methods = NULL, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_v2_new, }; static PyObject *py_dfs_normal_referral_get_DFS_path(PyObject *obj, void *closure) { struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(obj); PyObject *py_DFS_path; if (object->DFS_path == NULL) { Py_RETURN_NONE; } if (object->DFS_path == NULL) { py_DFS_path = Py_None; Py_INCREF(py_DFS_path); } else { py_DFS_path = PyString_FromStringOrNULL(object->DFS_path); } return py_DFS_path; } static int py_dfs_normal_referral_set_DFS_path(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->DFS_path"); return -1; } if (value == Py_None) { object->DFS_path = NULL; } else { object->DFS_path = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->DFS_path = talloc_str; } } return 0; } static PyObject *py_dfs_normal_referral_get_DFS_alt_path(PyObject *obj, void *closure) { struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(obj); PyObject *py_DFS_alt_path; if (object->DFS_alt_path == NULL) { Py_RETURN_NONE; } if (object->DFS_alt_path == NULL) { py_DFS_alt_path = Py_None; Py_INCREF(py_DFS_alt_path); } else { py_DFS_alt_path = PyString_FromStringOrNULL(object->DFS_alt_path); } return py_DFS_alt_path; } static int py_dfs_normal_referral_set_DFS_alt_path(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->DFS_alt_path"); return -1; } if (value == Py_None) { object->DFS_alt_path = NULL; } else { object->DFS_alt_path = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->DFS_alt_path = talloc_str; } } return 0; } static PyObject *py_dfs_normal_referral_get_netw_address(PyObject *obj, void *closure) { struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(obj); PyObject *py_netw_address; if (object->netw_address == NULL) { Py_RETURN_NONE; } if (object->netw_address == NULL) { py_netw_address = Py_None; Py_INCREF(py_netw_address); } else { py_netw_address = PyString_FromStringOrNULL(object->netw_address); } return py_netw_address; } static int py_dfs_normal_referral_set_netw_address(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_normal_referral *object = (struct dfs_normal_referral *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->netw_address"); return -1; } if (value == Py_None) { object->netw_address = NULL; } else { object->netw_address = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->netw_address = talloc_str; } } return 0; } static PyGetSetDef py_dfs_normal_referral_getsetters[] = { { .name = discard_const_p(char, "DFS_path"), .get = py_dfs_normal_referral_get_DFS_path, .set = py_dfs_normal_referral_set_DFS_path, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = discard_const_p(char, "DFS_alt_path"), .get = py_dfs_normal_referral_get_DFS_alt_path, .set = py_dfs_normal_referral_set_DFS_alt_path, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = discard_const_p(char, "netw_address"), .get = py_dfs_normal_referral_get_netw_address, .set = py_dfs_normal_referral_set_netw_address, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = NULL } }; static PyObject *py_dfs_normal_referral_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_normal_referral, type); } static PyTypeObject dfs_normal_referral_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_normal_referral", .tp_getset = py_dfs_normal_referral_getsetters, .tp_methods = NULL, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_normal_referral_new, }; static PyObject *py_dfs_domain_referral_get_special_name(PyObject *obj, void *closure) { struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(obj); PyObject *py_special_name; if (object->special_name == NULL) { Py_RETURN_NONE; } if (object->special_name == NULL) { py_special_name = Py_None; Py_INCREF(py_special_name); } else { py_special_name = PyString_FromStringOrNULL(object->special_name); } return py_special_name; } static int py_dfs_domain_referral_set_special_name(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->special_name"); return -1; } if (value == Py_None) { object->special_name = NULL; } else { object->special_name = NULL; { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->special_name = talloc_str; } } return 0; } static PyObject *py_dfs_domain_referral_get_nb_expanded_names(PyObject *obj, void *closure) { struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(obj); PyObject *py_nb_expanded_names; py_nb_expanded_names = PyLong_FromLong((uint16_t)object->nb_expanded_names); return py_nb_expanded_names; } static int py_dfs_domain_referral_set_nb_expanded_names(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nb_expanded_names"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->nb_expanded_names)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->nb_expanded_names = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_domain_referral_get_expanded_names(PyObject *obj, void *closure) { struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(obj); PyObject *py_expanded_names; if (object->expanded_names == NULL) { Py_RETURN_NONE; } if (object->expanded_names == NULL) { py_expanded_names = Py_None; Py_INCREF(py_expanded_names); } else { py_expanded_names = pytalloc_GenericObject_reference_ex(object->expanded_names, object->expanded_names); } return py_expanded_names; } static int py_dfs_domain_referral_set_expanded_names(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_domain_referral *object = (struct dfs_domain_referral *)pytalloc_get_ptr(py_obj); talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->expanded_names)); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->expanded_names"); return -1; } if (value == Py_None) { object->expanded_names = NULL; } else { object->expanded_names = NULL; object->expanded_names = pytalloc_get_ptr(value); } return 0; } static PyGetSetDef py_dfs_domain_referral_getsetters[] = { { .name = discard_const_p(char, "special_name"), .get = py_dfs_domain_referral_get_special_name, .set = py_dfs_domain_referral_set_special_name, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = discard_const_p(char, "nb_expanded_names"), .get = py_dfs_domain_referral_get_nb_expanded_names, .set = py_dfs_domain_referral_set_nb_expanded_names, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "expanded_names"), .get = py_dfs_domain_referral_get_expanded_names, .set = py_dfs_domain_referral_set_expanded_names, .doc = discard_const_p(char, "PIDL-generated element of base type string_array") }, { .name = NULL } }; static PyObject *py_dfs_domain_referral_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_domain_referral, type); } static PyTypeObject dfs_domain_referral_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_domain_referral", .tp_getset = py_dfs_domain_referral_getsetters, .tp_methods = NULL, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_domain_referral_new, }; static PyObject *py_import_dfs_referral(TALLOC_CTX *mem_ctx, int level, union dfs_referral *in) { PyObject *ret; switch (level) { case 0: ret = pytalloc_reference_ex(&dfs_normal_referral_Type, mem_ctx, &in->r1); return ret; case 2: ret = pytalloc_reference_ex(&dfs_domain_referral_Type, mem_ctx, &in->r2); return ret; default: ret = Py_None; Py_INCREF(ret); return ret; } PyErr_SetString(PyExc_TypeError, "unknown union level"); return NULL; } static union dfs_referral *py_export_dfs_referral(TALLOC_CTX *mem_ctx, int level, PyObject *in) { union dfs_referral *ret = talloc_zero(mem_ctx, union dfs_referral); switch (level) { case 0: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->r1"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&dfs_normal_referral_Type, in, talloc_free(ret); return NULL;); if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) { PyErr_NoMemory(); talloc_free(ret); return NULL; } ret->r1 = *(struct dfs_normal_referral *)pytalloc_get_ptr(in); break; case 2: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->r2"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&dfs_domain_referral_Type, in, talloc_free(ret); return NULL;); if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) { PyErr_NoMemory(); talloc_free(ret); return NULL; } ret->r2 = *(struct dfs_domain_referral *)pytalloc_get_ptr(in); break; default: break; } return ret; } static PyObject *py_dfs_referral_import(PyTypeObject *type, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "mem_ctx", "level", "in", NULL }; PyObject *mem_ctx_obj = NULL; TALLOC_CTX *mem_ctx = NULL; int level = 0; PyObject *in_obj = NULL; union dfs_referral *in = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import", discard_const_p(char *, kwnames), &mem_ctx_obj, &level, &in_obj)) { return NULL; } mem_ctx = pytalloc_get_ptr(mem_ctx_obj); if (mem_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!"); return NULL; } in = (union dfs_referral *)pytalloc_get_ptr(in_obj); if (in == NULL) { PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union dfs_referral!"); return NULL; } return py_import_dfs_referral(mem_ctx, level, in); } static PyObject *py_dfs_referral_export(PyTypeObject *type, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "mem_ctx", "level", "in", NULL }; PyObject *mem_ctx_obj = NULL; TALLOC_CTX *mem_ctx = NULL; int level = 0; PyObject *in = NULL; union dfs_referral *out = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export", discard_const_p(char *, kwnames), &mem_ctx_obj, &level, &in)) { return NULL; } mem_ctx = pytalloc_get_ptr(mem_ctx_obj); if (mem_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!"); return NULL; } out = py_export_dfs_referral(mem_ctx, level, in); if (out == NULL) { return NULL; } return pytalloc_GenericObject_reference(out); } static PyMethodDef py_dfs_referral_methods[] = { { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_referral_import), METH_VARARGS|METH_KEYWORDS|METH_CLASS, "T.__import__(mem_ctx, level, in) => ret." }, { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_referral_export), METH_VARARGS|METH_KEYWORDS|METH_CLASS, "T.__export__(mem_ctx, level, in) => ret." }, { NULL, NULL, 0, NULL } }; static PyObject *py_dfs_referral_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name); return NULL; } static PyTypeObject dfs_referral_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral", .tp_getset = NULL, .tp_methods = py_dfs_referral_methods, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_new, }; static PyObject *py_import_dfs_padding(TALLOC_CTX *mem_ctx, int level, union dfs_padding *in) { PyObject *ret; switch (level) { case 16: ret = PyList_New(16); if (ret == NULL) { return NULL; } { int value_cntr_0; for (value_cntr_0 = 0; value_cntr_0 < (16); value_cntr_0++) { PyObject *py_value_0; py_value_0 = PyLong_FromLong((uint16_t)in->value[value_cntr_0]); PyList_SetItem(ret, value_cntr_0, py_value_0); } } return ret; default: ret = Py_None; Py_INCREF(ret); return ret; } PyErr_SetString(PyExc_TypeError, "unknown union level"); return NULL; } static union dfs_padding *py_export_dfs_padding(TALLOC_CTX *mem_ctx, int level, PyObject *in) { union dfs_padding *ret = talloc_zero(mem_ctx, union dfs_padding); switch (level) { case 16: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->value"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&PyList_Type, in, talloc_free(ret); return NULL;); { int value_cntr_0; if (ARRAY_SIZE(ret->value) != PyList_GET_SIZE(in)) { PyErr_Format(PyExc_TypeError, "Expected list of type %s, length %zu, got %zd", Py_TYPE(in)->tp_name, ARRAY_SIZE(ret->value), PyList_GET_SIZE(in)); talloc_free(ret); return NULL; } for (value_cntr_0 = 0; value_cntr_0 < PyList_GET_SIZE(in); value_cntr_0++) { if (PyList_GET_ITEM(in, value_cntr_0) == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->value[value_cntr_0]"); talloc_free(ret); return NULL; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(ret->value[value_cntr_0])); if (PyLong_Check(PyList_GET_ITEM(in, value_cntr_0))) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(PyList_GET_ITEM(in, value_cntr_0)); if (PyErr_Occurred() != NULL) { talloc_free(ret); return NULL; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); talloc_free(ret); return NULL; } ret->value[value_cntr_0] = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); talloc_free(ret); return NULL; } } } } break; default: break; } return ret; } static PyObject *py_dfs_padding_import(PyTypeObject *type, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "mem_ctx", "level", "in", NULL }; PyObject *mem_ctx_obj = NULL; TALLOC_CTX *mem_ctx = NULL; int level = 0; PyObject *in_obj = NULL; union dfs_padding *in = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import", discard_const_p(char *, kwnames), &mem_ctx_obj, &level, &in_obj)) { return NULL; } mem_ctx = pytalloc_get_ptr(mem_ctx_obj); if (mem_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!"); return NULL; } in = (union dfs_padding *)pytalloc_get_ptr(in_obj); if (in == NULL) { PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union dfs_padding!"); return NULL; } return py_import_dfs_padding(mem_ctx, level, in); } static PyObject *py_dfs_padding_export(PyTypeObject *type, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "mem_ctx", "level", "in", NULL }; PyObject *mem_ctx_obj = NULL; TALLOC_CTX *mem_ctx = NULL; int level = 0; PyObject *in = NULL; union dfs_padding *out = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export", discard_const_p(char *, kwnames), &mem_ctx_obj, &level, &in)) { return NULL; } mem_ctx = pytalloc_get_ptr(mem_ctx_obj); if (mem_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!"); return NULL; } out = py_export_dfs_padding(mem_ctx, level, in); if (out == NULL) { return NULL; } return pytalloc_GenericObject_reference(out); } static PyMethodDef py_dfs_padding_methods[] = { { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_padding_import), METH_VARARGS|METH_KEYWORDS|METH_CLASS, "T.__import__(mem_ctx, level, in) => ret." }, { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_padding_export), METH_VARARGS|METH_KEYWORDS|METH_CLASS, "T.__export__(mem_ctx, level, in) => ret." }, { NULL, NULL, 0, NULL } }; static PyObject *py_dfs_padding_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name); return NULL; } static PyTypeObject dfs_padding_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_padding", .tp_getset = NULL, .tp_methods = py_dfs_padding_methods, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_padding_new, }; static PyObject *py_dfs_referral_v3_get_size(PyObject *obj, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj); PyObject *py_size; py_size = PyLong_FromLong((uint16_t)object->size); return py_size; } static int py_dfs_referral_v3_set_size(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->size"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->size)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->size = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v3_get_server_type(PyObject *obj, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj); PyObject *py_server_type; py_server_type = PyLong_FromLong((uint16_t)object->server_type); return py_server_type; } static int py_dfs_referral_v3_set_server_type(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->server_type"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->server_type)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->server_type = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v3_get_entry_flags(PyObject *obj, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj); PyObject *py_entry_flags; py_entry_flags = PyLong_FromLong((uint16_t)object->entry_flags); return py_entry_flags; } static int py_dfs_referral_v3_set_entry_flags(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->entry_flags"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->entry_flags)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->entry_flags = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v3_get_ttl(PyObject *obj, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj); PyObject *py_ttl; py_ttl = PyLong_FromUnsignedLongLong((uint32_t)object->ttl); return py_ttl; } static int py_dfs_referral_v3_set_ttl(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->ttl"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->ttl)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->ttl = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_v3_get_referrals(PyObject *obj, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj); PyObject *py_referrals; py_referrals = pyrpc_import_union(&dfs_referral_Type, pytalloc_get_mem_ctx(obj), object->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP, &object->referrals, "union dfs_referral"); if (py_referrals == NULL) { return NULL; } return py_referrals; } static int py_dfs_referral_v3_set_referrals(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->referrals"); return -1; } { union dfs_referral *referrals_switch_0; referrals_switch_0 = (union dfs_referral *)pyrpc_export_union(&dfs_referral_Type, pytalloc_get_mem_ctx(py_obj), object->entry_flags & DFS_FLAG_REFERRAL_DOMAIN_RESP, value, "union dfs_referral"); if (referrals_switch_0 == NULL) { return -1; } object->referrals = *referrals_switch_0; } return 0; } static PyObject *py_dfs_referral_v3_get_service_site_guid(PyObject *obj, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(obj); PyObject *py_service_site_guid; py_service_site_guid = pyrpc_import_union(&dfs_padding_Type, pytalloc_get_mem_ctx(obj), object->size - 18, &object->service_site_guid, "union dfs_padding"); if (py_service_site_guid == NULL) { return NULL; } return py_service_site_guid; } static int py_dfs_referral_v3_set_service_site_guid(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_v3 *object = (struct dfs_referral_v3 *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->service_site_guid"); return -1; } { union dfs_padding *service_site_guid_switch_0; service_site_guid_switch_0 = (union dfs_padding *)pyrpc_export_union(&dfs_padding_Type, pytalloc_get_mem_ctx(py_obj), object->size - 18, value, "union dfs_padding"); if (service_site_guid_switch_0 == NULL) { return -1; } object->service_site_guid = *service_site_guid_switch_0; } return 0; } static PyGetSetDef py_dfs_referral_v3_getsetters[] = { { .name = discard_const_p(char, "size"), .get = py_dfs_referral_v3_get_size, .set = py_dfs_referral_v3_set_size, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "server_type"), .get = py_dfs_referral_v3_get_server_type, .set = py_dfs_referral_v3_set_server_type, .doc = discard_const_p(char, "PIDL-generated element of base type DFS_SERVER_TYPE") }, { .name = discard_const_p(char, "entry_flags"), .get = py_dfs_referral_v3_get_entry_flags, .set = py_dfs_referral_v3_set_entry_flags, .doc = discard_const_p(char, "PIDL-generated element of base type DFS_FLAGS_REFERRAL") }, { .name = discard_const_p(char, "ttl"), .get = py_dfs_referral_v3_get_ttl, .set = py_dfs_referral_v3_set_ttl, .doc = discard_const_p(char, "PIDL-generated element of base type uint32") }, { .name = discard_const_p(char, "referrals"), .get = py_dfs_referral_v3_get_referrals, .set = py_dfs_referral_v3_set_referrals, .doc = discard_const_p(char, "PIDL-generated element of base type dfs_referral") }, { .name = discard_const_p(char, "service_site_guid"), .get = py_dfs_referral_v3_get_service_site_guid, .set = py_dfs_referral_v3_set_service_site_guid, .doc = discard_const_p(char, "PIDL-generated element of base type dfs_padding") }, { .name = NULL } }; static PyObject *py_dfs_referral_v3_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_referral_v3, type); } static PyTypeObject dfs_referral_v3_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral_v3", .tp_getset = py_dfs_referral_v3_getsetters, .tp_methods = NULL, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_v3_new, }; static PyObject *py_import_dfs_referral_version(TALLOC_CTX *mem_ctx, int level, union dfs_referral_version *in) { PyObject *ret; switch (level) { case 1: ret = pytalloc_reference_ex(&dfs_referral_v1_Type, mem_ctx, &in->v1); return ret; case 2: ret = pytalloc_reference_ex(&dfs_referral_v2_Type, mem_ctx, &in->v2); return ret; case 3: ret = pytalloc_reference_ex(&dfs_referral_v3_Type, mem_ctx, &in->v3); return ret; case 4: ret = pytalloc_reference_ex(&dfs_referral_v3_Type, mem_ctx, &in->v4); return ret; default: ret = Py_None; Py_INCREF(ret); return ret; } PyErr_SetString(PyExc_TypeError, "unknown union level"); return NULL; } static union dfs_referral_version *py_export_dfs_referral_version(TALLOC_CTX *mem_ctx, int level, PyObject *in) { union dfs_referral_version *ret = talloc_zero(mem_ctx, union dfs_referral_version); switch (level) { case 1: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->v1"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&dfs_referral_v1_Type, in, talloc_free(ret); return NULL;); if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) { PyErr_NoMemory(); talloc_free(ret); return NULL; } ret->v1 = *(struct dfs_referral_v1 *)pytalloc_get_ptr(in); break; case 2: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->v2"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&dfs_referral_v2_Type, in, talloc_free(ret); return NULL;); if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) { PyErr_NoMemory(); talloc_free(ret); return NULL; } ret->v2 = *(struct dfs_referral_v2 *)pytalloc_get_ptr(in); break; case 3: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->v3"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&dfs_referral_v3_Type, in, talloc_free(ret); return NULL;); if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) { PyErr_NoMemory(); talloc_free(ret); return NULL; } ret->v3 = *(struct dfs_referral_v3 *)pytalloc_get_ptr(in); break; case 4: if (in == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct ret->v4"); talloc_free(ret); return NULL; } PY_CHECK_TYPE(&dfs_referral_v3_Type, in, talloc_free(ret); return NULL;); if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) { PyErr_NoMemory(); talloc_free(ret); return NULL; } ret->v4 = *(struct dfs_referral_v3 *)pytalloc_get_ptr(in); break; default: break; } return ret; } static PyObject *py_dfs_referral_version_import(PyTypeObject *type, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "mem_ctx", "level", "in", NULL }; PyObject *mem_ctx_obj = NULL; TALLOC_CTX *mem_ctx = NULL; int level = 0; PyObject *in_obj = NULL; union dfs_referral_version *in = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:import", discard_const_p(char *, kwnames), &mem_ctx_obj, &level, &in_obj)) { return NULL; } mem_ctx = pytalloc_get_ptr(mem_ctx_obj); if (mem_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!"); return NULL; } in = (union dfs_referral_version *)pytalloc_get_ptr(in_obj); if (in == NULL) { PyErr_Format(PyExc_TypeError, "in needs to be a pointer to union dfs_referral_version!"); return NULL; } return py_import_dfs_referral_version(mem_ctx, level, in); } static PyObject *py_dfs_referral_version_export(PyTypeObject *type, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "mem_ctx", "level", "in", NULL }; PyObject *mem_ctx_obj = NULL; TALLOC_CTX *mem_ctx = NULL; int level = 0; PyObject *in = NULL; union dfs_referral_version *out = NULL; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OiO:export", discard_const_p(char *, kwnames), &mem_ctx_obj, &level, &in)) { return NULL; } mem_ctx = pytalloc_get_ptr(mem_ctx_obj); if (mem_ctx == NULL) { PyErr_SetString(PyExc_TypeError, "mem_ctx is NULL)!"); return NULL; } out = py_export_dfs_referral_version(mem_ctx, level, in); if (out == NULL) { return NULL; } return pytalloc_GenericObject_reference(out); } static PyMethodDef py_dfs_referral_version_methods[] = { { "__import__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_referral_version_import), METH_VARARGS|METH_KEYWORDS|METH_CLASS, "T.__import__(mem_ctx, level, in) => ret." }, { "__export__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_referral_version_export), METH_VARARGS|METH_KEYWORDS|METH_CLASS, "T.__export__(mem_ctx, level, in) => ret." }, { NULL, NULL, 0, NULL } }; static PyObject *py_dfs_referral_version_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { PyErr_Format(PyExc_TypeError, "New %s Objects are not supported", type->tp_name); return NULL; } static PyTypeObject dfs_referral_version_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral_version", .tp_getset = NULL, .tp_methods = py_dfs_referral_version_methods, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_version_new, }; static PyObject *py_dfs_referral_type_get_version(PyObject *obj, void *closure) { struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(obj); PyObject *py_version; py_version = PyLong_FromLong((uint16_t)object->version); return py_version; } static int py_dfs_referral_type_set_version(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->version"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->version)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->version = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_type_get_referral(PyObject *obj, void *closure) { struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(obj); PyObject *py_referral; py_referral = pyrpc_import_union(&dfs_referral_version_Type, pytalloc_get_mem_ctx(obj), object->version, &object->referral, "union dfs_referral_version"); if (py_referral == NULL) { return NULL; } return py_referral; } static int py_dfs_referral_type_set_referral(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_type *object = (struct dfs_referral_type *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->referral"); return -1; } { union dfs_referral_version *referral_switch_0; referral_switch_0 = (union dfs_referral_version *)pyrpc_export_union(&dfs_referral_version_Type, pytalloc_get_mem_ctx(py_obj), object->version, value, "union dfs_referral_version"); if (referral_switch_0 == NULL) { return -1; } object->referral = *referral_switch_0; } return 0; } static PyGetSetDef py_dfs_referral_type_getsetters[] = { { .name = discard_const_p(char, "version"), .get = py_dfs_referral_type_get_version, .set = py_dfs_referral_type_set_version, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "referral"), .get = py_dfs_referral_type_get_referral, .set = py_dfs_referral_type_set_referral, .doc = discard_const_p(char, "PIDL-generated element of base type dfs_referral_version") }, { .name = NULL } }; static PyObject *py_dfs_referral_type_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_referral_type, type); } static PyTypeObject dfs_referral_type_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral_type", .tp_getset = py_dfs_referral_type_getsetters, .tp_methods = NULL, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_type_new, }; static PyObject *py_dfs_referral_resp_get_path_consumed(PyObject *obj, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj); PyObject *py_path_consumed; py_path_consumed = PyLong_FromLong((uint16_t)object->path_consumed); return py_path_consumed; } static int py_dfs_referral_resp_set_path_consumed(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->path_consumed"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->path_consumed)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->path_consumed = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_resp_get_nb_referrals(PyObject *obj, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj); PyObject *py_nb_referrals; py_nb_referrals = PyLong_FromLong((uint16_t)object->nb_referrals); return py_nb_referrals; } static int py_dfs_referral_resp_set_nb_referrals(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->nb_referrals"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->nb_referrals)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->nb_referrals = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_resp_get_header_flags(PyObject *obj, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj); PyObject *py_header_flags; py_header_flags = PyLong_FromUnsignedLongLong((uint32_t)object->header_flags); return py_header_flags; } static int py_dfs_referral_resp_set_header_flags(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->header_flags"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->header_flags)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->header_flags = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_referral_resp_get_referral_entries(PyObject *obj, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(obj); PyObject *py_referral_entries; py_referral_entries = PyList_New(object->nb_referrals); if (py_referral_entries == NULL) { return NULL; } { int referral_entries_cntr_0; for (referral_entries_cntr_0 = 0; referral_entries_cntr_0 < (object->nb_referrals); referral_entries_cntr_0++) { PyObject *py_referral_entries_0; py_referral_entries_0 = pytalloc_reference_ex(&dfs_referral_type_Type, object->referral_entries, &object->referral_entries[referral_entries_cntr_0]); PyList_SetItem(py_referral_entries, referral_entries_cntr_0, py_referral_entries_0); } } return py_referral_entries; } static int py_dfs_referral_resp_set_referral_entries(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->referral_entries"); return -1; } PY_CHECK_TYPE(&PyList_Type, value, return -1;); { int referral_entries_cntr_0; object->referral_entries = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->referral_entries, PyList_GET_SIZE(value)); if (!object->referral_entries) { return -1;; } talloc_set_name_const(object->referral_entries, "ARRAY: object->referral_entries"); for (referral_entries_cntr_0 = 0; referral_entries_cntr_0 < PyList_GET_SIZE(value); referral_entries_cntr_0++) { if (PyList_GET_ITEM(value, referral_entries_cntr_0) == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->referral_entries[referral_entries_cntr_0]"); return -1; } PY_CHECK_TYPE(&dfs_referral_type_Type, PyList_GET_ITEM(value, referral_entries_cntr_0), return -1;); if (talloc_reference(object->referral_entries, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, referral_entries_cntr_0))) == NULL) { PyErr_NoMemory(); return -1; } object->referral_entries[referral_entries_cntr_0] = *(struct dfs_referral_type *)pytalloc_get_ptr(PyList_GET_ITEM(value, referral_entries_cntr_0)); } } return 0; } static PyGetSetDef py_dfs_referral_resp_getsetters[] = { { .name = discard_const_p(char, "path_consumed"), .get = py_dfs_referral_resp_get_path_consumed, .set = py_dfs_referral_resp_set_path_consumed, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "nb_referrals"), .get = py_dfs_referral_resp_get_nb_referrals, .set = py_dfs_referral_resp_set_nb_referrals, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "header_flags"), .get = py_dfs_referral_resp_get_header_flags, .set = py_dfs_referral_resp_set_header_flags, .doc = discard_const_p(char, "PIDL-generated element of base type DFS_HEADER_FLAG") }, { .name = discard_const_p(char, "referral_entries"), .get = py_dfs_referral_resp_get_referral_entries, .set = py_dfs_referral_resp_set_referral_entries, .doc = discard_const_p(char, "PIDL-generated element of base type dfs_referral_type") }, { .name = NULL } }; static PyObject *py_dfs_referral_resp_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_referral_resp, type); } static PyObject *py_dfs_referral_resp_ndr_pack(PyObject *py_obj, PyObject *Py_UNUSED(ignored)) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); PyObject *ret = NULL; DATA_BLOB blob; enum ndr_err_code err; TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj)); if (tmp_ctx == NULL) { PyErr_SetNdrError(NDR_ERR_ALLOC); return NULL; } err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_dfs_referral_resp); if (!NDR_ERR_CODE_IS_SUCCESS(err)) { TALLOC_FREE(tmp_ctx); PyErr_SetNdrError(err); return NULL; } ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length); TALLOC_FREE(tmp_ctx); return ret; } static PyObject *py_dfs_referral_resp_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); DATA_BLOB blob = {.data = NULL, .length = 0}; Py_ssize_t blob_length = 0; enum ndr_err_code err; const char * const kwnames[] = { "data_blob", "allow_remaining", NULL }; PyObject *allow_remaining_obj = NULL; bool allow_remaining = false; if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__", discard_const_p(char *, kwnames), &blob.data, &blob_length, &allow_remaining_obj)) { return NULL; } blob.length = blob_length; if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) { allow_remaining = true; } if (allow_remaining) { err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_referral_resp); } else { err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_referral_resp); } if (!NDR_ERR_CODE_IS_SUCCESS(err)) { PyErr_SetNdrError(err); return NULL; } Py_RETURN_NONE; } static PyObject *py_dfs_referral_resp_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored)) { struct dfs_referral_resp *object = (struct dfs_referral_resp *)pytalloc_get_ptr(py_obj); PyObject *ret; char *retstr; retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_dfs_referral_resp, "dfs_referral_resp", object); ret = PyUnicode_FromString(retstr); talloc_free(retstr); return ret; } static PyMethodDef py_dfs_referral_resp_methods[] = { { "__ndr_pack__", (PyCFunction)py_dfs_referral_resp_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" }, { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_referral_resp_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" }, { "__ndr_print__", (PyCFunction)py_dfs_referral_resp_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" }, { NULL, NULL, 0, NULL } }; static PyTypeObject dfs_referral_resp_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_referral_resp", .tp_getset = py_dfs_referral_resp_getsetters, .tp_methods = py_dfs_referral_resp_methods, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_referral_resp_new, }; static PyObject *py_dfs_GetDFSReferral_in_get_max_referral_level(PyObject *obj, void *closure) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(obj); PyObject *py_max_referral_level; py_max_referral_level = PyLong_FromLong((uint16_t)object->max_referral_level); return py_max_referral_level; } static int py_dfs_GetDFSReferral_in_set_max_referral_level(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->max_referral_level"); return -1; } { const unsigned long long uint_max = ndr_sizeof2uintmax(sizeof(object->max_referral_level)); if (PyLong_Check(value)) { unsigned long long test_var; test_var = PyLong_AsUnsignedLongLong(value); if (PyErr_Occurred() != NULL) { return -1; } if (test_var > uint_max) { PyErr_Format(PyExc_OverflowError, "Expected type %s within range 0 - %llu, got %llu",\ PyLong_Type.tp_name, uint_max, test_var); return -1; } object->max_referral_level = test_var; } else { PyErr_Format(PyExc_TypeError, "Expected type %s",\ PyLong_Type.tp_name); return -1; } } return 0; } static PyObject *py_dfs_GetDFSReferral_in_get_servername(PyObject *obj, void *closure) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(obj); PyObject *py_servername; py_servername = PyString_FromStringOrNULL(object->servername); return py_servername; } static int py_dfs_GetDFSReferral_in_set_servername(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->servername"); return -1; } { const char *test_str; const char *talloc_str; PyObject *unicode = NULL; if (PyUnicode_Check(value)) { unicode = PyUnicode_AsEncodedString(value, "utf-8", "ignore"); if (unicode == NULL) { PyErr_NoMemory(); return -1; } test_str = PyBytes_AS_STRING(unicode); } else if (PyBytes_Check(value)) { test_str = PyBytes_AS_STRING(value); } else { PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name); return -1; } talloc_str = talloc_strdup(pytalloc_get_mem_ctx(py_obj), test_str); if (unicode != NULL) { Py_DECREF(unicode); } if (talloc_str == NULL) { PyErr_NoMemory(); return -1; } object->servername = talloc_str; } return 0; } static PyGetSetDef py_dfs_GetDFSReferral_in_getsetters[] = { { .name = discard_const_p(char, "max_referral_level"), .get = py_dfs_GetDFSReferral_in_get_max_referral_level, .set = py_dfs_GetDFSReferral_in_set_max_referral_level, .doc = discard_const_p(char, "PIDL-generated element of base type uint16") }, { .name = discard_const_p(char, "servername"), .get = py_dfs_GetDFSReferral_in_get_servername, .set = py_dfs_GetDFSReferral_in_set_servername, .doc = discard_const_p(char, "PIDL-generated element of base type string") }, { .name = NULL } }; static PyObject *py_dfs_GetDFSReferral_in_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return pytalloc_new(struct dfs_GetDFSReferral_in, type); } static PyObject *py_dfs_GetDFSReferral_in_ndr_pack(PyObject *py_obj, PyObject *Py_UNUSED(ignored)) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj); PyObject *ret = NULL; DATA_BLOB blob; enum ndr_err_code err; TALLOC_CTX *tmp_ctx = talloc_new(pytalloc_get_mem_ctx(py_obj)); if (tmp_ctx == NULL) { PyErr_SetNdrError(NDR_ERR_ALLOC); return NULL; } err = ndr_push_struct_blob(&blob, tmp_ctx, object, (ndr_push_flags_fn_t)ndr_push_dfs_GetDFSReferral_in); if (!NDR_ERR_CODE_IS_SUCCESS(err)) { TALLOC_FREE(tmp_ctx); PyErr_SetNdrError(err); return NULL; } ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length); TALLOC_FREE(tmp_ctx); return ret; } static PyObject *py_dfs_GetDFSReferral_in_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj); DATA_BLOB blob = {.data = NULL, .length = 0}; Py_ssize_t blob_length = 0; enum ndr_err_code err; const char * const kwnames[] = { "data_blob", "allow_remaining", NULL }; PyObject *allow_remaining_obj = NULL; bool allow_remaining = false; if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|O:__ndr_unpack__", discard_const_p(char *, kwnames), &blob.data, &blob_length, &allow_remaining_obj)) { return NULL; } blob.length = blob_length; if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) { allow_remaining = true; } if (allow_remaining) { err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetDFSReferral_in); } else { err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetDFSReferral_in); } if (!NDR_ERR_CODE_IS_SUCCESS(err)) { PyErr_SetNdrError(err); return NULL; } Py_RETURN_NONE; } static PyObject *py_dfs_GetDFSReferral_in_ndr_print(PyObject *py_obj, PyObject *Py_UNUSED(ignored)) { struct dfs_GetDFSReferral_in *object = (struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_obj); PyObject *ret; char *retstr; retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_dfs_GetDFSReferral_in, "dfs_GetDFSReferral_in", object); ret = PyUnicode_FromString(retstr); talloc_free(retstr); return ret; } static PyMethodDef py_dfs_GetDFSReferral_in_methods[] = { { "__ndr_pack__", (PyCFunction)py_dfs_GetDFSReferral_in_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" }, { "__ndr_unpack__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_GetDFSReferral_in_ndr_unpack), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" }, { "__ndr_print__", (PyCFunction)py_dfs_GetDFSReferral_in_ndr_print, METH_NOARGS, "S.ndr_print(object) -> None\nNDR print" }, { NULL, NULL, 0, NULL } }; static PyTypeObject dfs_GetDFSReferral_in_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_GetDFSReferral_in", .tp_getset = py_dfs_GetDFSReferral_in_getsetters, .tp_methods = py_dfs_GetDFSReferral_in_methods, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_GetDFSReferral_in_new, }; static PyObject *py_dfs_GetDFSReferral_in_get_req(PyObject *obj, void *closure) { struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(obj); PyObject *py_req; py_req = pytalloc_reference_ex(&dfs_GetDFSReferral_in_Type, pytalloc_get_mem_ctx(obj), &object->in.req); return py_req; } static int py_dfs_GetDFSReferral_in_set_req(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(py_obj); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->in.req"); return -1; } PY_CHECK_TYPE(&dfs_GetDFSReferral_in_Type, value, return -1;); if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) { PyErr_NoMemory(); return -1; } object->in.req = *(struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(value); return 0; } static PyObject *py_dfs_GetDFSReferral_out_get_resp(PyObject *obj, void *closure) { struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(obj); PyObject *py_resp; if (object->out.resp == NULL) { Py_RETURN_NONE; } py_resp = pytalloc_reference_ex(&dfs_referral_resp_Type, object->out.resp, object->out.resp); return py_resp; } static int py_dfs_GetDFSReferral_out_set_resp(PyObject *py_obj, PyObject *value, void *closure) { struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(py_obj); talloc_unlink(pytalloc_get_mem_ctx(py_obj), discard_const(object->out.resp)); if (value == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct object->out.resp"); return -1; } object->out.resp = talloc_ptrtype(pytalloc_get_mem_ctx(py_obj), object->out.resp); if (object->out.resp == NULL) { PyErr_NoMemory(); return -1; } PY_CHECK_TYPE(&dfs_referral_resp_Type, value, return -1;); if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) { PyErr_NoMemory(); return -1; } object->out.resp = (struct dfs_referral_resp *)pytalloc_get_ptr(value); return 0; } static PyGetSetDef py_dfs_GetDFSReferral_getsetters[] = { { .name = discard_const_p(char, "in_req"), .get = py_dfs_GetDFSReferral_in_get_req, .set = py_dfs_GetDFSReferral_in_set_req, .doc = discard_const_p(char, "PIDL-generated element of base type dfs_GetDFSReferral_in") }, { .name = discard_const_p(char, "out_resp"), .get = py_dfs_GetDFSReferral_out_get_resp, .set = py_dfs_GetDFSReferral_out_set_resp, .doc = discard_const_p(char, "PIDL-generated element of base type dfs_referral_resp") }, { .name = NULL } }; static PyObject *py_dfs_GetDFSReferral_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { PyObject *self = pytalloc_new(struct dfs_GetDFSReferral, type); struct dfs_GetDFSReferral *_self = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(self); TALLOC_CTX *mem_ctx = pytalloc_get_mem_ctx(self); _self->out.resp = talloc_zero(mem_ctx, struct dfs_referral_resp); return self; } static PyObject *py_dfs_GetDFSReferral_ndr_opnum(PyTypeObject *type, PyObject *Py_UNUSED(ignored)) { return PyLong_FromLong(0); } static PyObject *py_dfs_GetDFSReferral_ndr_pack(PyObject *py_obj, int ndr_inout_flags, uint32_t ndr_push_flags) { const struct ndr_interface_call *call = NULL; struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(py_obj); PyObject *ret = NULL; struct ndr_push *push = NULL; DATA_BLOB blob; enum ndr_err_code err; if (ndr_table_dfsblobs.num_calls < 1) { PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dfs_GetDFSReferral_ndr_pack"); return NULL; } call = &ndr_table_dfsblobs.calls[0]; push = ndr_push_init_ctx(pytalloc_get_mem_ctx(py_obj)); if (push == NULL) { PyErr_SetNdrError(NDR_ERR_ALLOC); return NULL; } push->flags |= ndr_push_flags; err = call->ndr_push(push, ndr_inout_flags, object); if (!NDR_ERR_CODE_IS_SUCCESS(err)) { TALLOC_FREE(push); PyErr_SetNdrError(err); return NULL; } blob = ndr_push_blob(push); ret = PyBytes_FromStringAndSize((char *)blob.data, blob.length); TALLOC_FREE(push); return ret; } static PyObject *py_dfs_GetDFSReferral_ndr_pack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "bigendian", "ndr64", NULL }; PyObject *bigendian_obj = NULL; PyObject *ndr64_obj = NULL; uint32_t ndr_push_flags = 0; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_in__", discard_const_p(char *, kwnames), &bigendian_obj, &ndr64_obj)) { return NULL; } if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) { ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN; } if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) { ndr_push_flags |= LIBNDR_FLAG_NDR64; } return py_dfs_GetDFSReferral_ndr_pack(py_obj, NDR_IN, ndr_push_flags); } static PyObject *py_dfs_GetDFSReferral_ndr_pack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs) { const char * const kwnames[] = { "bigendian", "ndr64", NULL }; PyObject *bigendian_obj = NULL; PyObject *ndr64_obj = NULL; uint32_t ndr_push_flags = 0; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO:__ndr_pack_out__", discard_const_p(char *, kwnames), &bigendian_obj, &ndr64_obj)) { return NULL; } if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) { ndr_push_flags |= LIBNDR_FLAG_BIGENDIAN; } if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) { ndr_push_flags |= LIBNDR_FLAG_NDR64; } return py_dfs_GetDFSReferral_ndr_pack(py_obj, NDR_OUT, ndr_push_flags); } static PyObject *py_dfs_GetDFSReferral_ndr_unpack(PyObject *py_obj, const DATA_BLOB *blob, int ndr_inout_flags, uint32_t ndr_pull_flags, bool allow_remaining) { const struct ndr_interface_call *call = NULL; struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(py_obj); struct ndr_pull *pull = NULL; enum ndr_err_code err; if (ndr_table_dfsblobs.num_calls < 1) { PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dfs_GetDFSReferral_ndr_unpack"); return NULL; } call = &ndr_table_dfsblobs.calls[0]; pull = ndr_pull_init_blob(blob, object); if (pull == NULL) { PyErr_SetNdrError(NDR_ERR_ALLOC); return NULL; } pull->flags |= ndr_pull_flags; err = call->ndr_pull(pull, ndr_inout_flags, object); if (!NDR_ERR_CODE_IS_SUCCESS(err)) { TALLOC_FREE(pull); PyErr_SetNdrError(err); return NULL; } if (!allow_remaining) { uint32_t highest_ofs; if (pull->offset > pull->relative_highest_offset) { highest_ofs = pull->offset; } else { highest_ofs = pull->relative_highest_offset; } if (highest_ofs < pull->data_size) { err = ndr_pull_error(pull, NDR_ERR_UNREAD_BYTES, "not all bytes consumed ofs[%u] size[%u]", highest_ofs, pull->data_size); TALLOC_FREE(pull); PyErr_SetNdrError(err); return NULL; } } TALLOC_FREE(pull); Py_RETURN_NONE; } static PyObject *py_dfs_GetDFSReferral_ndr_unpack_in(PyObject *py_obj, PyObject *args, PyObject *kwargs) { DATA_BLOB blob; Py_ssize_t blob_length = 0; const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL }; PyObject *bigendian_obj = NULL; PyObject *ndr64_obj = NULL; uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC; PyObject *allow_remaining_obj = NULL; bool allow_remaining = false; if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_in__", discard_const_p(char *, kwnames), &blob.data, &blob_length, &bigendian_obj, &ndr64_obj, &allow_remaining_obj)) { return NULL; } blob.length = blob_length; if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) { ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN; } if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) { ndr_pull_flags |= LIBNDR_FLAG_NDR64; } if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) { allow_remaining = true; } return py_dfs_GetDFSReferral_ndr_unpack(py_obj, &blob, NDR_IN, ndr_pull_flags, allow_remaining); } static PyObject *py_dfs_GetDFSReferral_ndr_unpack_out(PyObject *py_obj, PyObject *args, PyObject *kwargs) { DATA_BLOB blob; Py_ssize_t blob_length = 0; const char * const kwnames[] = { "data_blob", "bigendian", "ndr64", "allow_remaining", NULL }; PyObject *bigendian_obj = NULL; PyObject *ndr64_obj = NULL; uint32_t ndr_pull_flags = LIBNDR_FLAG_REF_ALLOC; PyObject *allow_remaining_obj = NULL; bool allow_remaining = false; if (!PyArg_ParseTupleAndKeywords(args, kwargs, PYARG_BYTES_LEN "|OOO:__ndr_unpack_out__", discard_const_p(char *, kwnames), &blob.data, &blob_length, &bigendian_obj, &ndr64_obj, &allow_remaining_obj)) { return NULL; } blob.length = blob_length; if (bigendian_obj && PyObject_IsTrue(bigendian_obj)) { ndr_pull_flags |= LIBNDR_FLAG_BIGENDIAN; } if (ndr64_obj && PyObject_IsTrue(ndr64_obj)) { ndr_pull_flags |= LIBNDR_FLAG_NDR64; } if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) { allow_remaining = true; } return py_dfs_GetDFSReferral_ndr_unpack(py_obj, &blob, NDR_OUT, ndr_pull_flags, allow_remaining); } static PyObject *py_dfs_GetDFSReferral_ndr_print(PyObject *py_obj, const char *name, int ndr_inout_flags) { const struct ndr_interface_call *call = NULL; struct dfs_GetDFSReferral *object = (struct dfs_GetDFSReferral *)pytalloc_get_ptr(py_obj); PyObject *ret; char *retstr; if (ndr_table_dfsblobs.num_calls < 1) { PyErr_SetString(PyExc_TypeError, "Internal Error, ndr_interface_call missing for py_dfs_GetDFSReferral_ndr_print"); return NULL; } call = &ndr_table_dfsblobs.calls[0]; retstr = ndr_print_function_string(pytalloc_get_mem_ctx(py_obj), call->ndr_print, name, ndr_inout_flags, object); ret = PyUnicode_FromString(retstr); TALLOC_FREE(retstr); return ret; } static PyObject *py_dfs_GetDFSReferral_ndr_print_in(PyObject *py_obj, PyObject *Py_UNUSED(ignored)) { return py_dfs_GetDFSReferral_ndr_print(py_obj, "dfs_GetDFSReferral_in", NDR_IN); } static PyObject *py_dfs_GetDFSReferral_ndr_print_out(PyObject *py_obj, PyObject *Py_UNUSED(ignored)) { return py_dfs_GetDFSReferral_ndr_print(py_obj, "dfs_GetDFSReferral_out", NDR_OUT); } static PyMethodDef py_dfs_GetDFSReferral_methods[] = { { "opnum", (PyCFunction)py_dfs_GetDFSReferral_ndr_opnum, METH_NOARGS|METH_CLASS, "dfsblobs.dfs_GetDFSReferral.opnum() -> 0 (0x00) " }, { "__ndr_pack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_GetDFSReferral_ndr_pack_in), METH_VARARGS|METH_KEYWORDS, "S.ndr_pack_in(object, bigendian=False, ndr64=False) -> blob\nNDR pack input" }, { "__ndr_pack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_GetDFSReferral_ndr_pack_out), METH_VARARGS|METH_KEYWORDS, "S.ndr_pack_out(object, bigendian=False, ndr64=False) -> blob\nNDR pack output" }, { "__ndr_unpack_in__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_GetDFSReferral_ndr_unpack_in), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack_in(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack input" }, { "__ndr_unpack_out__", PY_DISCARD_FUNC_SIG(PyCFunction,py_dfs_GetDFSReferral_ndr_unpack_out), METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack_out(class, blob, bigendian=False, ndr64=False, allow_remaining=False) -> None\nNDR unpack output" }, { "__ndr_print_in__", (PyCFunction)py_dfs_GetDFSReferral_ndr_print_in, METH_NOARGS, "S.ndr_print_in(object) -> None\nNDR print input" }, { "__ndr_print_out__", (PyCFunction)py_dfs_GetDFSReferral_ndr_print_out, METH_NOARGS, "S.ndr_print_out(object) -> None\nNDR print output" }, { NULL, NULL, 0, NULL } }; static PyTypeObject dfs_GetDFSReferral_Type = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfs_GetDFSReferral", .tp_getset = py_dfs_GetDFSReferral_getsetters, .tp_methods = py_dfs_GetDFSReferral_methods, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = py_dfs_GetDFSReferral_new, }; static bool pack_py_dfs_GetDFSReferral_args_in(PyObject *args, PyObject *kwargs, struct dfs_GetDFSReferral *r) { PyObject *py_req; const char *kwnames[] = { "req", NULL }; if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:dfs_GetDFSReferral", discard_const_p(char *, kwnames), &py_req)) { return false; } if (py_req == NULL) { PyErr_Format(PyExc_AttributeError, "Cannot delete NDR object: struct r->in.req"); return false; } PY_CHECK_TYPE(&dfs_GetDFSReferral_in_Type, py_req, return false;); if (talloc_reference(r, pytalloc_get_mem_ctx(py_req)) == NULL) { PyErr_NoMemory(); return false; } r->in.req = *(struct dfs_GetDFSReferral_in *)pytalloc_get_ptr(py_req); return true; } static PyObject *unpack_py_dfs_GetDFSReferral_args_out(struct dfs_GetDFSReferral *r) { PyObject *result; PyObject *py_resp; py_resp = pytalloc_reference_ex(&dfs_referral_resp_Type, r->out.resp, r->out.resp); result = py_resp; return result; } const struct PyNdrRpcMethodDef py_ndr_dfsblobs_methods[] = { { "dfs_GetDFSReferral", "S.dfs_GetDFSReferral(req) -> resp", (py_dcerpc_call_fn)dcerpc_dfs_GetDFSReferral_r, (py_data_pack_fn)pack_py_dfs_GetDFSReferral_args_in, (py_data_unpack_fn)unpack_py_dfs_GetDFSReferral_args_out, 0, &ndr_table_dfsblobs }, {0} }; static PyObject *interface_dfsblobs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_dfsblobs); } #define PY_DOC_DFSBLOBS "dfs referral blobs" static PyTypeObject dfsblobs_InterfaceType = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfsblobs", .tp_basicsize = sizeof(dcerpc_InterfaceObject), .tp_doc = "dfsblobs(binding, lp_ctx=None, credentials=None) -> connection\n" "\n" "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n" "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n" "credentials should be a credentials.Credentials object.\n\n"PY_DOC_DFSBLOBS, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = interface_dfsblobs_new, }; static PyObject *syntax_dfsblobs_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) { return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_dfsblobs.syntax_id); } #define PY_DOC_DFSBLOBS_SYNTAX "dfs referral blobs" static PyTypeObject dfsblobs_SyntaxType = { PyVarObject_HEAD_INIT(NULL, 0) .tp_name = "dfsblobs.dfsblobs_abstract_syntax", .tp_doc = "dfsblobs_abstract_syntax()\n"PY_DOC_DFSBLOBS_SYNTAX, .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, .tp_new = syntax_dfsblobs_new, }; static PyMethodDef dfsblobs_methods[] = { { NULL, NULL, 0, NULL } }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, .m_name = "dfsblobs", .m_doc = "dfsblobs DCE/RPC", .m_size = -1, .m_methods = dfsblobs_methods, }; MODULE_INIT_FUNC(dfsblobs) { PyObject *m = NULL; PyObject *dep_samba_dcerpc_misc = NULL; PyObject *dep_talloc = NULL; PyObject *dep_samba_dcerpc_base = NULL; dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc"); if (dep_samba_dcerpc_misc == NULL) goto out; dep_talloc = PyImport_ImportModule("talloc"); if (dep_talloc == NULL) goto out; dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base"); if (dep_samba_dcerpc_base == NULL) goto out; BaseObject_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "BaseObject"); if (BaseObject_Type == NULL) goto out; ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection"); if (ClientConnection_Type == NULL) goto out; ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id"); if (ndr_syntax_id_Type == NULL) goto out; dfs_referral_v1_Type.tp_base = BaseObject_Type; dfs_referral_v1_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_referral_v2_Type.tp_base = BaseObject_Type; dfs_referral_v2_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_normal_referral_Type.tp_base = BaseObject_Type; dfs_normal_referral_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_domain_referral_Type.tp_base = BaseObject_Type; dfs_domain_referral_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_referral_Type.tp_base = BaseObject_Type; dfs_referral_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_padding_Type.tp_base = BaseObject_Type; dfs_padding_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_referral_v3_Type.tp_base = BaseObject_Type; dfs_referral_v3_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_referral_version_Type.tp_base = BaseObject_Type; dfs_referral_version_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_referral_type_Type.tp_base = BaseObject_Type; dfs_referral_type_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_referral_resp_Type.tp_base = BaseObject_Type; dfs_referral_resp_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_GetDFSReferral_in_Type.tp_base = BaseObject_Type; dfs_GetDFSReferral_in_Type.tp_basicsize = pytalloc_BaseObject_size(); dfs_GetDFSReferral_Type.tp_base = BaseObject_Type; dfs_GetDFSReferral_Type.tp_basicsize = pytalloc_BaseObject_size(); dfsblobs_InterfaceType.tp_base = ClientConnection_Type; dfsblobs_SyntaxType.tp_base = ndr_syntax_id_Type; dfsblobs_SyntaxType.tp_basicsize = pytalloc_BaseObject_size(); if (PyType_Ready(&dfs_referral_v1_Type) < 0) goto out; if (PyType_Ready(&dfs_referral_v2_Type) < 0) goto out; if (PyType_Ready(&dfs_normal_referral_Type) < 0) goto out; if (PyType_Ready(&dfs_domain_referral_Type) < 0) goto out; if (PyType_Ready(&dfs_referral_Type) < 0) goto out; if (PyType_Ready(&dfs_padding_Type) < 0) goto out; if (PyType_Ready(&dfs_referral_v3_Type) < 0) goto out; if (PyType_Ready(&dfs_referral_version_Type) < 0) goto out; if (PyType_Ready(&dfs_referral_type_Type) < 0) goto out; if (PyType_Ready(&dfs_referral_resp_Type) < 0) goto out; if (PyType_Ready(&dfs_GetDFSReferral_in_Type) < 0) goto out; if (PyType_Ready(&dfs_GetDFSReferral_Type) < 0) goto out; if (PyType_Ready(&dfsblobs_InterfaceType) < 0) goto out; if (PyType_Ready(&dfsblobs_SyntaxType) < 0) goto out; if (!PyInterface_AddNdrRpcMethods(&dfsblobs_InterfaceType, py_ndr_dfsblobs_methods)) return NULL; #ifdef PY_DFS_REFERRAL_V1_PATCH PY_DFS_REFERRAL_V1_PATCH(&dfs_referral_v1_Type); #endif #ifdef PY_DFS_REFERRAL_V2_PATCH PY_DFS_REFERRAL_V2_PATCH(&dfs_referral_v2_Type); #endif #ifdef PY_DFS_NORMAL_REFERRAL_PATCH PY_DFS_NORMAL_REFERRAL_PATCH(&dfs_normal_referral_Type); #endif #ifdef PY_DFS_DOMAIN_REFERRAL_PATCH PY_DFS_DOMAIN_REFERRAL_PATCH(&dfs_domain_referral_Type); #endif #ifdef PY_DFS_REFERRAL_PATCH PY_DFS_REFERRAL_PATCH(&dfs_referral_Type); #endif #ifdef PY_DFS_PADDING_PATCH PY_DFS_PADDING_PATCH(&dfs_padding_Type); #endif #ifdef PY_DFS_REFERRAL_V3_PATCH PY_DFS_REFERRAL_V3_PATCH(&dfs_referral_v3_Type); #endif #ifdef PY_DFS_REFERRAL_VERSION_PATCH PY_DFS_REFERRAL_VERSION_PATCH(&dfs_referral_version_Type); #endif #ifdef PY_DFS_REFERRAL_TYPE_PATCH PY_DFS_REFERRAL_TYPE_PATCH(&dfs_referral_type_Type); #endif #ifdef PY_DFS_REFERRAL_RESP_PATCH PY_DFS_REFERRAL_RESP_PATCH(&dfs_referral_resp_Type); #endif #ifdef PY_DFS_GETDFSREFERRAL_IN_PATCH PY_DFS_GETDFSREFERRAL_IN_PATCH(&dfs_GetDFSReferral_in_Type); #endif #ifdef PY_DFS_GETDFSREFERRAL_PATCH PY_DFS_GETDFSREFERRAL_PATCH(&dfs_GetDFSReferral_Type); #endif #ifdef PY_DFSBLOBS_PATCH PY_DFSBLOBS_PATCH(&dfsblobs_InterfaceType); #endif #ifdef PY_DFSBLOBS_ABSTRACT_SYNTAX_PATCH PY_DFSBLOBS_ABSTRACT_SYNTAX_PATCH(&dfsblobs_SyntaxType); #endif #ifdef PY_ABSTRACT_SYNTAX_PATCH PY_ABSTRACT_SYNTAX_PATCH(&dfsblobs_SyntaxType); #endif m = PyModule_Create(&moduledef); if (m == NULL) goto out; PyModule_AddObject(m, "DFS_HEADER_FLAG_REFERAL_SVR", PyLong_FromUnsignedLongLong((uint32_t)DFS_HEADER_FLAG_REFERAL_SVR)); PyModule_AddObject(m, "DFS_HEADER_FLAG_STORAGE_SVR", PyLong_FromUnsignedLongLong((uint32_t)DFS_HEADER_FLAG_STORAGE_SVR)); PyModule_AddObject(m, "DFS_HEADER_FLAG_TARGET_BCK", PyLong_FromUnsignedLongLong((uint32_t)DFS_HEADER_FLAG_TARGET_BCK)); PyModule_AddObject(m, "DFS_SERVER_NON_ROOT", PyLong_FromLong((uint16_t)DFS_SERVER_NON_ROOT)); PyModule_AddObject(m, "DFS_SERVER_ROOT", PyLong_FromLong((uint16_t)DFS_SERVER_ROOT)); PyModule_AddObject(m, "DFS_FLAG_REFERRAL_DOMAIN_RESP", PyLong_FromLong((uint16_t)DFS_FLAG_REFERRAL_DOMAIN_RESP)); PyModule_AddObject(m, "DFS_FLAG_REFERRAL_FIRST_TARGET_SET", PyLong_FromLong((uint16_t)DFS_FLAG_REFERRAL_FIRST_TARGET_SET)); Py_INCREF((PyObject *)(void *)&dfs_referral_v1_Type); PyModule_AddObject(m, "dfs_referral_v1", (PyObject *)(void *)&dfs_referral_v1_Type); Py_INCREF((PyObject *)(void *)&dfs_referral_v2_Type); PyModule_AddObject(m, "dfs_referral_v2", (PyObject *)(void *)&dfs_referral_v2_Type); Py_INCREF((PyObject *)(void *)&dfs_normal_referral_Type); PyModule_AddObject(m, "dfs_normal_referral", (PyObject *)(void *)&dfs_normal_referral_Type); Py_INCREF((PyObject *)(void *)&dfs_domain_referral_Type); PyModule_AddObject(m, "dfs_domain_referral", (PyObject *)(void *)&dfs_domain_referral_Type); Py_INCREF((PyObject *)(void *)&dfs_referral_Type); PyModule_AddObject(m, "dfs_referral", (PyObject *)(void *)&dfs_referral_Type); Py_INCREF((PyObject *)(void *)&dfs_padding_Type); PyModule_AddObject(m, "dfs_padding", (PyObject *)(void *)&dfs_padding_Type); Py_INCREF((PyObject *)(void *)&dfs_referral_v3_Type); PyModule_AddObject(m, "dfs_referral_v3", (PyObject *)(void *)&dfs_referral_v3_Type); Py_INCREF((PyObject *)(void *)&dfs_referral_version_Type); PyModule_AddObject(m, "dfs_referral_version", (PyObject *)(void *)&dfs_referral_version_Type); Py_INCREF((PyObject *)(void *)&dfs_referral_type_Type); PyModule_AddObject(m, "dfs_referral_type", (PyObject *)(void *)&dfs_referral_type_Type); Py_INCREF((PyObject *)(void *)&dfs_referral_resp_Type); PyModule_AddObject(m, "dfs_referral_resp", (PyObject *)(void *)&dfs_referral_resp_Type); Py_INCREF((PyObject *)(void *)&dfs_GetDFSReferral_in_Type); PyModule_AddObject(m, "dfs_GetDFSReferral_in", (PyObject *)(void *)&dfs_GetDFSReferral_in_Type); Py_INCREF((PyObject *)(void *)&dfs_GetDFSReferral_Type); PyModule_AddObject(m, "dfs_GetDFSReferral", (PyObject *)(void *)&dfs_GetDFSReferral_Type); Py_INCREF((PyObject *)(void *)&dfsblobs_InterfaceType); PyModule_AddObject(m, "dfsblobs", (PyObject *)(void *)&dfsblobs_InterfaceType); Py_INCREF((PyObject *)(void *)&dfsblobs_SyntaxType); PyModule_AddObject(m, "dfsblobs_abstract_syntax", (PyObject *)(void *)&dfsblobs_SyntaxType); Py_INCREF((PyObject *)(void *)&dfsblobs_SyntaxType); PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&dfsblobs_SyntaxType); #ifdef PY_MOD_DFSBLOBS_PATCH PY_MOD_DFSBLOBS_PATCH(m); #endif out: Py_XDECREF(dep_samba_dcerpc_misc); Py_XDECREF(dep_talloc); Py_XDECREF(dep_samba_dcerpc_base); return m; }