#include <pytalloc.h>
#include "librpc/rpc/pyrpc.h"
#include "librpc/rpc/pyrpc_util.h"
-#include "librpc/gen_ndr/ndr_svcctl.h"
-#include "librpc/gen_ndr/ndr_svcctl_c.h"
+#include "autoconf/librpc/gen_ndr/ndr_svcctl.h"
+#include "autoconf/librpc/gen_ndr/ndr_svcctl_c.h"
#include "librpc/gen_ndr/misc.h"
#include "librpc/gen_ndr/security.h"
static PyObject *py_SERVICE_LOCK_STATUS_get_is_locked(PyObject *obj, void *closure)
{
- struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_is_locked;
py_is_locked = PyInt_FromLong(object->is_locked);
return py_is_locked;
static int py_SERVICE_LOCK_STATUS_set_is_locked(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->is_locked = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_LOCK_STATUS_get_lock_owner(PyObject *obj, void *closure)
{
- struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_lock_owner;
if (object->lock_owner == NULL) {
py_lock_owner = Py_None;
static int py_SERVICE_LOCK_STATUS_set_lock_owner(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->lock_owner = NULL;
} else {
static PyObject *py_SERVICE_LOCK_STATUS_get_lock_duration(PyObject *obj, void *closure)
{
- struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_lock_duration;
py_lock_duration = PyInt_FromLong(object->lock_duration);
return py_lock_duration;
static int py_SERVICE_LOCK_STATUS_set_lock_duration(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_LOCK_STATUS *object = (struct SERVICE_LOCK_STATUS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->lock_duration = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_LOCK_STATUS_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct SERVICE_LOCK_STATUS, type);
+ return pytalloc_new(struct SERVICE_LOCK_STATUS, type);
}
.tp_getset = py_SERVICE_LOCK_STATUS_getsetters,
.tp_methods = NULL,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_SERVICE_LOCK_STATUS_new,
};
static PyObject *py_SERVICE_STATUS_get_type(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_type;
py_type = PyInt_FromLong(object->type);
return py_type;
static int py_SERVICE_STATUS_set_type(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->type = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_STATUS_get_state(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_state;
py_state = PyInt_FromLong(object->state);
return py_state;
static int py_SERVICE_STATUS_set_state(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
if (PyLong_Check(value)) {
object->state = PyLong_AsLongLong(value);
} else if (PyInt_Check(value)) {
static PyObject *py_SERVICE_STATUS_get_controls_accepted(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_controls_accepted;
py_controls_accepted = PyInt_FromLong(object->controls_accepted);
return py_controls_accepted;
static int py_SERVICE_STATUS_set_controls_accepted(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
if (PyLong_Check(value)) {
object->controls_accepted = PyLong_AsLongLong(value);
} else if (PyInt_Check(value)) {
static PyObject *py_SERVICE_STATUS_get_win32_exit_code(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_win32_exit_code;
py_win32_exit_code = PyErr_FromWERROR(object->win32_exit_code);
return py_win32_exit_code;
static int py_SERVICE_STATUS_set_win32_exit_code(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
object->win32_exit_code = W_ERROR(PyInt_AsLong(value));
return 0;
}
static PyObject *py_SERVICE_STATUS_get_service_exit_code(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_service_exit_code;
py_service_exit_code = PyInt_FromLong(object->service_exit_code);
return py_service_exit_code;
static int py_SERVICE_STATUS_set_service_exit_code(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->service_exit_code = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_STATUS_get_check_point(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_check_point;
py_check_point = PyInt_FromLong(object->check_point);
return py_check_point;
static int py_SERVICE_STATUS_set_check_point(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->check_point = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_STATUS_get_wait_hint(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(obj);
PyObject *py_wait_hint;
py_wait_hint = PyInt_FromLong(object->wait_hint);
return py_wait_hint;
static int py_SERVICE_STATUS_set_wait_hint(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS *object = (struct SERVICE_STATUS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->wait_hint = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_STATUS_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct SERVICE_STATUS, type);
+ return pytalloc_new(struct SERVICE_STATUS, type);
}
.tp_getset = py_SERVICE_STATUS_getsetters,
.tp_methods = NULL,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_SERVICE_STATUS_new,
};
static PyObject *py_SERVICE_STATUS_PROCESS_get_status(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(obj);
PyObject *py_status;
- py_status = py_talloc_reference_ex(&SERVICE_STATUS_Type, py_talloc_get_mem_ctx(obj), &object->status);
+ py_status = pytalloc_reference_ex(&SERVICE_STATUS_Type, pytalloc_get_mem_ctx(obj), &object->status);
return py_status;
}
static int py_SERVICE_STATUS_PROCESS_set_status(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&SERVICE_STATUS_Type, value, return -1;);
- if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
+ if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
PyErr_NoMemory();
return -1;
}
- object->status = *(struct SERVICE_STATUS *)py_talloc_get_ptr(value);
+ object->status = *(struct SERVICE_STATUS *)pytalloc_get_ptr(value);
return 0;
}
static PyObject *py_SERVICE_STATUS_PROCESS_get_process_id(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(obj);
PyObject *py_process_id;
py_process_id = PyInt_FromLong(object->process_id);
return py_process_id;
static int py_SERVICE_STATUS_PROCESS_set_process_id(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->process_id = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_STATUS_PROCESS_get_service_flags(PyObject *obj, void *closure)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(obj);
PyObject *py_service_flags;
py_service_flags = PyInt_FromLong(object->service_flags);
return py_service_flags;
static int py_SERVICE_STATUS_PROCESS_set_service_flags(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->service_flags = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_STATUS_PROCESS_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct SERVICE_STATUS_PROCESS, type);
+ return pytalloc_new(struct SERVICE_STATUS_PROCESS, type);
}
static PyObject *py_SERVICE_STATUS_PROCESS_ndr_pack(PyObject *py_obj)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
enum ndr_err_code err;
- err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_SERVICE_STATUS_PROCESS);
+ err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_SERVICE_STATUS_PROCESS);
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
return PyString_FromStringAndSize((char *)blob.data, blob.length);
}
-static PyObject *py_SERVICE_STATUS_PROCESS_ndr_unpack(PyObject *py_obj, PyObject *args)
+static PyObject *py_SERVICE_STATUS_PROCESS_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
+ int blob_length = 0;
enum ndr_err_code err;
- if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
+ const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
+ PyObject *allow_remaining_obj = NULL;
+ bool allow_remaining = false;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|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;
+ }
- err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_STATUS_PROCESS);
+ if (allow_remaining) {
+ err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_STATUS_PROCESS);
+ } else {
+ err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_STATUS_PROCESS);
+ }
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
static PyObject *py_SERVICE_STATUS_PROCESS_ndr_print(PyObject *py_obj)
{
- struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_STATUS_PROCESS *object = (struct SERVICE_STATUS_PROCESS *)pytalloc_get_ptr(py_obj);
PyObject *ret;
char *retstr;
- retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_SERVICE_STATUS_PROCESS, "SERVICE_STATUS_PROCESS", object);
+ retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_SERVICE_STATUS_PROCESS, "SERVICE_STATUS_PROCESS", object);
ret = PyString_FromString(retstr);
talloc_free(retstr);
static PyMethodDef py_SERVICE_STATUS_PROCESS_methods[] = {
{ "__ndr_pack__", (PyCFunction)py_SERVICE_STATUS_PROCESS_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
- { "__ndr_unpack__", (PyCFunction)py_SERVICE_STATUS_PROCESS_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
+ { "__ndr_unpack__", (PyCFunction)py_SERVICE_STATUS_PROCESS_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
{ "__ndr_print__", (PyCFunction)py_SERVICE_STATUS_PROCESS_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
{ NULL, NULL, 0, NULL }
};
.tp_getset = py_SERVICE_STATUS_PROCESS_getsetters,
.tp_methods = py_SERVICE_STATUS_PROCESS_methods,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_SERVICE_STATUS_PROCESS_new,
};
static PyObject *py_ENUM_SERVICE_STATUSW_get_service_name(PyObject *obj, void *closure)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(obj);
PyObject *py_service_name;
if (object->service_name == NULL) {
py_service_name = Py_None;
static int py_ENUM_SERVICE_STATUSW_set_service_name(PyObject *py_obj, PyObject *value, void *closure)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->service_name = NULL;
} else {
object->service_name = NULL;
- object->service_name = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->service_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_ENUM_SERVICE_STATUSW_get_display_name(PyObject *obj, void *closure)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(obj);
PyObject *py_display_name;
if (object->display_name == NULL) {
py_display_name = Py_None;
static int py_ENUM_SERVICE_STATUSW_set_display_name(PyObject *py_obj, PyObject *value, void *closure)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->display_name = NULL;
} else {
object->display_name = NULL;
- object->display_name = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->display_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_ENUM_SERVICE_STATUSW_get_status(PyObject *obj, void *closure)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(obj);
PyObject *py_status;
- py_status = py_talloc_reference_ex(&SERVICE_STATUS_Type, py_talloc_get_mem_ctx(obj), &object->status);
+ py_status = pytalloc_reference_ex(&SERVICE_STATUS_Type, pytalloc_get_mem_ctx(obj), &object->status);
return py_status;
}
static int py_ENUM_SERVICE_STATUSW_set_status(PyObject *py_obj, PyObject *value, void *closure)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&SERVICE_STATUS_Type, value, return -1;);
- if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
+ if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
PyErr_NoMemory();
return -1;
}
- object->status = *(struct SERVICE_STATUS *)py_talloc_get_ptr(value);
+ object->status = *(struct SERVICE_STATUS *)pytalloc_get_ptr(value);
return 0;
}
static PyObject *py_ENUM_SERVICE_STATUSW_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct ENUM_SERVICE_STATUSW, type);
+ return pytalloc_new(struct ENUM_SERVICE_STATUSW, type);
}
static PyObject *py_ENUM_SERVICE_STATUSW_ndr_pack(PyObject *py_obj)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
enum ndr_err_code err;
- err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSW);
+ err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSW);
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
return PyString_FromStringAndSize((char *)blob.data, blob.length);
}
-static PyObject *py_ENUM_SERVICE_STATUSW_ndr_unpack(PyObject *py_obj, PyObject *args)
+static PyObject *py_ENUM_SERVICE_STATUSW_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
+ int blob_length = 0;
enum ndr_err_code err;
- if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
+ const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
+ PyObject *allow_remaining_obj = NULL;
+ bool allow_remaining = false;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
+ discard_const_p(char *, kwnames),
+ &blob.data, &blob_length,
+ &allow_remaining_obj)) {
return NULL;
+ }
+ blob.length = blob_length;
- err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ENUM_SERVICE_STATUSW);
+ 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_ENUM_SERVICE_STATUSW);
+ } else {
+ err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ENUM_SERVICE_STATUSW);
+ }
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
static PyObject *py_ENUM_SERVICE_STATUSW_ndr_print(PyObject *py_obj)
{
- struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSW *object = (struct ENUM_SERVICE_STATUSW *)pytalloc_get_ptr(py_obj);
PyObject *ret;
char *retstr;
- retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ENUM_SERVICE_STATUSW, "ENUM_SERVICE_STATUSW", object);
+ retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ENUM_SERVICE_STATUSW, "ENUM_SERVICE_STATUSW", object);
ret = PyString_FromString(retstr);
talloc_free(retstr);
static PyMethodDef py_ENUM_SERVICE_STATUSW_methods[] = {
{ "__ndr_pack__", (PyCFunction)py_ENUM_SERVICE_STATUSW_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
- { "__ndr_unpack__", (PyCFunction)py_ENUM_SERVICE_STATUSW_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
+ { "__ndr_unpack__", (PyCFunction)py_ENUM_SERVICE_STATUSW_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
{ "__ndr_print__", (PyCFunction)py_ENUM_SERVICE_STATUSW_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
{ NULL, NULL, 0, NULL }
};
.tp_getset = py_ENUM_SERVICE_STATUSW_getsetters,
.tp_methods = py_ENUM_SERVICE_STATUSW_methods,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_ENUM_SERVICE_STATUSW_new,
};
static PyObject *py_ENUM_SERVICE_STATUSA_get_service_name(PyObject *obj, void *closure)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(obj);
PyObject *py_service_name;
if (object->service_name == NULL) {
py_service_name = Py_None;
static int py_ENUM_SERVICE_STATUSA_set_service_name(PyObject *py_obj, PyObject *value, void *closure)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->service_name = NULL;
} else {
object->service_name = NULL;
- object->service_name = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->service_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_ENUM_SERVICE_STATUSA_get_display_name(PyObject *obj, void *closure)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(obj);
PyObject *py_display_name;
if (object->display_name == NULL) {
py_display_name = Py_None;
static int py_ENUM_SERVICE_STATUSA_set_display_name(PyObject *py_obj, PyObject *value, void *closure)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->display_name = NULL;
} else {
object->display_name = NULL;
- object->display_name = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->display_name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_ENUM_SERVICE_STATUSA_get_status(PyObject *obj, void *closure)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(obj);
PyObject *py_status;
- py_status = py_talloc_reference_ex(&SERVICE_STATUS_Type, py_talloc_get_mem_ctx(obj), &object->status);
+ py_status = pytalloc_reference_ex(&SERVICE_STATUS_Type, pytalloc_get_mem_ctx(obj), &object->status);
return py_status;
}
static int py_ENUM_SERVICE_STATUSA_set_status(PyObject *py_obj, PyObject *value, void *closure)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&SERVICE_STATUS_Type, value, return -1;);
- if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
+ if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
PyErr_NoMemory();
return -1;
}
- object->status = *(struct SERVICE_STATUS *)py_talloc_get_ptr(value);
+ object->status = *(struct SERVICE_STATUS *)pytalloc_get_ptr(value);
return 0;
}
static PyObject *py_ENUM_SERVICE_STATUSA_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct ENUM_SERVICE_STATUSA, type);
+ return pytalloc_new(struct ENUM_SERVICE_STATUSA, type);
}
static PyObject *py_ENUM_SERVICE_STATUSA_ndr_pack(PyObject *py_obj)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
enum ndr_err_code err;
- err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSA);
+ err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_ENUM_SERVICE_STATUSA);
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
return PyString_FromStringAndSize((char *)blob.data, blob.length);
}
-static PyObject *py_ENUM_SERVICE_STATUSA_ndr_unpack(PyObject *py_obj, PyObject *args)
+static PyObject *py_ENUM_SERVICE_STATUSA_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
+ int blob_length = 0;
enum ndr_err_code err;
- if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
+ const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
+ PyObject *allow_remaining_obj = NULL;
+ bool allow_remaining = false;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
+ discard_const_p(char *, kwnames),
+ &blob.data, &blob_length,
+ &allow_remaining_obj)) {
return NULL;
+ }
+ blob.length = blob_length;
- err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ENUM_SERVICE_STATUSA);
+ 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_ENUM_SERVICE_STATUSA);
+ } else {
+ err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_ENUM_SERVICE_STATUSA);
+ }
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
static PyObject *py_ENUM_SERVICE_STATUSA_ndr_print(PyObject *py_obj)
{
- struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)py_talloc_get_ptr(py_obj);
+ struct ENUM_SERVICE_STATUSA *object = (struct ENUM_SERVICE_STATUSA *)pytalloc_get_ptr(py_obj);
PyObject *ret;
char *retstr;
- retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ENUM_SERVICE_STATUSA, "ENUM_SERVICE_STATUSA", object);
+ retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_ENUM_SERVICE_STATUSA, "ENUM_SERVICE_STATUSA", object);
ret = PyString_FromString(retstr);
talloc_free(retstr);
static PyMethodDef py_ENUM_SERVICE_STATUSA_methods[] = {
{ "__ndr_pack__", (PyCFunction)py_ENUM_SERVICE_STATUSA_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
- { "__ndr_unpack__", (PyCFunction)py_ENUM_SERVICE_STATUSA_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
+ { "__ndr_unpack__", (PyCFunction)py_ENUM_SERVICE_STATUSA_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
{ "__ndr_print__", (PyCFunction)py_ENUM_SERVICE_STATUSA_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
{ NULL, NULL, 0, NULL }
};
.tp_getset = py_ENUM_SERVICE_STATUSA_getsetters,
.tp_methods = py_ENUM_SERVICE_STATUSA_methods,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_ENUM_SERVICE_STATUSA_new,
};
static PyObject *py_QUERY_SERVICE_CONFIG_get_service_type(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_service_type;
py_service_type = PyInt_FromLong(object->service_type);
return py_service_type;
static int py_QUERY_SERVICE_CONFIG_set_service_type(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->service_type = PyInt_AsLong(value);
return 0;
static PyObject *py_QUERY_SERVICE_CONFIG_get_start_type(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_start_type;
py_start_type = PyInt_FromLong(object->start_type);
return py_start_type;
static int py_QUERY_SERVICE_CONFIG_set_start_type(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (PyLong_Check(value)) {
object->start_type = PyLong_AsLongLong(value);
} else if (PyInt_Check(value)) {
static PyObject *py_QUERY_SERVICE_CONFIG_get_error_control(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_error_control;
py_error_control = PyInt_FromLong(object->error_control);
return py_error_control;
static int py_QUERY_SERVICE_CONFIG_set_error_control(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (PyLong_Check(value)) {
object->error_control = PyLong_AsLongLong(value);
} else if (PyInt_Check(value)) {
static PyObject *py_QUERY_SERVICE_CONFIG_get_executablepath(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_executablepath;
if (object->executablepath == NULL) {
py_executablepath = Py_None;
static int py_QUERY_SERVICE_CONFIG_set_executablepath(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->executablepath = NULL;
} else {
static PyObject *py_QUERY_SERVICE_CONFIG_get_loadordergroup(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_loadordergroup;
if (object->loadordergroup == NULL) {
py_loadordergroup = Py_None;
static int py_QUERY_SERVICE_CONFIG_set_loadordergroup(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->loadordergroup = NULL;
} else {
static PyObject *py_QUERY_SERVICE_CONFIG_get_tag_id(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_tag_id;
py_tag_id = PyInt_FromLong(object->tag_id);
return py_tag_id;
static int py_QUERY_SERVICE_CONFIG_set_tag_id(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->tag_id = PyInt_AsLong(value);
return 0;
static PyObject *py_QUERY_SERVICE_CONFIG_get_dependencies(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_dependencies;
if (object->dependencies == NULL) {
py_dependencies = Py_None;
static int py_QUERY_SERVICE_CONFIG_set_dependencies(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->dependencies = NULL;
} else {
static PyObject *py_QUERY_SERVICE_CONFIG_get_startname(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_startname;
if (object->startname == NULL) {
py_startname = Py_None;
static int py_QUERY_SERVICE_CONFIG_set_startname(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->startname = NULL;
} else {
static PyObject *py_QUERY_SERVICE_CONFIG_get_displayname(PyObject *obj, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(obj);
PyObject *py_displayname;
if (object->displayname == NULL) {
py_displayname = Py_None;
static int py_QUERY_SERVICE_CONFIG_set_displayname(PyObject *py_obj, PyObject *value, void *closure)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->displayname = NULL;
} else {
static PyObject *py_QUERY_SERVICE_CONFIG_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct QUERY_SERVICE_CONFIG, type);
+ return pytalloc_new(struct QUERY_SERVICE_CONFIG, type);
}
static PyObject *py_QUERY_SERVICE_CONFIG_ndr_pack(PyObject *py_obj)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
enum ndr_err_code err;
- err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG);
+ err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_QUERY_SERVICE_CONFIG);
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
return PyString_FromStringAndSize((char *)blob.data, blob.length);
}
-static PyObject *py_QUERY_SERVICE_CONFIG_ndr_unpack(PyObject *py_obj, PyObject *args)
+static PyObject *py_QUERY_SERVICE_CONFIG_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
+ int blob_length = 0;
enum ndr_err_code err;
- if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
+ const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
+ PyObject *allow_remaining_obj = NULL;
+ bool allow_remaining = false;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
+ discard_const_p(char *, kwnames),
+ &blob.data, &blob_length,
+ &allow_remaining_obj)) {
return NULL;
+ }
+ blob.length = blob_length;
- err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_QUERY_SERVICE_CONFIG);
+ 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_QUERY_SERVICE_CONFIG);
+ } else {
+ err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_QUERY_SERVICE_CONFIG);
+ }
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
static PyObject *py_QUERY_SERVICE_CONFIG_ndr_print(PyObject *py_obj)
{
- struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)py_talloc_get_ptr(py_obj);
+ struct QUERY_SERVICE_CONFIG *object = (struct QUERY_SERVICE_CONFIG *)pytalloc_get_ptr(py_obj);
PyObject *ret;
char *retstr;
- retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_QUERY_SERVICE_CONFIG, "QUERY_SERVICE_CONFIG", object);
+ retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_QUERY_SERVICE_CONFIG, "QUERY_SERVICE_CONFIG", object);
ret = PyString_FromString(retstr);
talloc_free(retstr);
static PyMethodDef py_QUERY_SERVICE_CONFIG_methods[] = {
{ "__ndr_pack__", (PyCFunction)py_QUERY_SERVICE_CONFIG_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
- { "__ndr_unpack__", (PyCFunction)py_QUERY_SERVICE_CONFIG_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
+ { "__ndr_unpack__", (PyCFunction)py_QUERY_SERVICE_CONFIG_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
{ "__ndr_print__", (PyCFunction)py_QUERY_SERVICE_CONFIG_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
{ NULL, NULL, 0, NULL }
};
.tp_getset = py_QUERY_SERVICE_CONFIG_getsetters,
.tp_methods = py_QUERY_SERVICE_CONFIG_methods,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_QUERY_SERVICE_CONFIG_new,
};
static PyObject *py_svcctl_ArgumentString_get_string(PyObject *obj, void *closure)
{
- struct svcctl_ArgumentString *object = (struct svcctl_ArgumentString *)py_talloc_get_ptr(obj);
+ struct svcctl_ArgumentString *object = (struct svcctl_ArgumentString *)pytalloc_get_ptr(obj);
PyObject *py_string;
if (object->string == NULL) {
py_string = Py_None;
static int py_svcctl_ArgumentString_set_string(PyObject *py_obj, PyObject *value, void *closure)
{
- struct svcctl_ArgumentString *object = (struct svcctl_ArgumentString *)py_talloc_get_ptr(py_obj);
+ struct svcctl_ArgumentString *object = (struct svcctl_ArgumentString *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->string = NULL;
} else {
static PyObject *py_svcctl_ArgumentString_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct svcctl_ArgumentString, type);
+ return pytalloc_new(struct svcctl_ArgumentString, type);
}
.tp_getset = py_svcctl_ArgumentString_getsetters,
.tp_methods = NULL,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_svcctl_ArgumentString_new,
};
static PyObject *py_SERVICE_DESCRIPTION_get_description(PyObject *obj, void *closure)
{
- struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)py_talloc_get_ptr(obj);
+ struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)pytalloc_get_ptr(obj);
PyObject *py_description;
if (object->description == NULL) {
py_description = Py_None;
static int py_SERVICE_DESCRIPTION_set_description(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->description = NULL;
} else {
object->description = NULL;
- object->description = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->description = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_SERVICE_DESCRIPTION_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct SERVICE_DESCRIPTION, type);
+ return pytalloc_new(struct SERVICE_DESCRIPTION, type);
}
static PyObject *py_SERVICE_DESCRIPTION_ndr_pack(PyObject *py_obj)
{
- struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
enum ndr_err_code err;
- err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_SERVICE_DESCRIPTION);
+ err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_SERVICE_DESCRIPTION);
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
return PyString_FromStringAndSize((char *)blob.data, blob.length);
}
-static PyObject *py_SERVICE_DESCRIPTION_ndr_unpack(PyObject *py_obj, PyObject *args)
+static PyObject *py_SERVICE_DESCRIPTION_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
- struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
+ int blob_length = 0;
enum ndr_err_code err;
- if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
+ const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
+ PyObject *allow_remaining_obj = NULL;
+ bool allow_remaining = false;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
+ discard_const_p(char *, kwnames),
+ &blob.data, &blob_length,
+ &allow_remaining_obj)) {
return NULL;
+ }
+ blob.length = blob_length;
- err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_DESCRIPTION);
+ 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_SERVICE_DESCRIPTION);
+ } else {
+ err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_DESCRIPTION);
+ }
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
static PyObject *py_SERVICE_DESCRIPTION_ndr_print(PyObject *py_obj)
{
- struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_DESCRIPTION *object = (struct SERVICE_DESCRIPTION *)pytalloc_get_ptr(py_obj);
PyObject *ret;
char *retstr;
- retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_SERVICE_DESCRIPTION, "SERVICE_DESCRIPTION", object);
+ retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_SERVICE_DESCRIPTION, "SERVICE_DESCRIPTION", object);
ret = PyString_FromString(retstr);
talloc_free(retstr);
static PyMethodDef py_SERVICE_DESCRIPTION_methods[] = {
{ "__ndr_pack__", (PyCFunction)py_SERVICE_DESCRIPTION_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
- { "__ndr_unpack__", (PyCFunction)py_SERVICE_DESCRIPTION_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
+ { "__ndr_unpack__", (PyCFunction)py_SERVICE_DESCRIPTION_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
{ "__ndr_print__", (PyCFunction)py_SERVICE_DESCRIPTION_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
{ NULL, NULL, 0, NULL }
};
.tp_getset = py_SERVICE_DESCRIPTION_getsetters,
.tp_methods = py_SERVICE_DESCRIPTION_methods,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_SERVICE_DESCRIPTION_new,
};
static PyObject *py_SC_ACTION_get_type(PyObject *obj, void *closure)
{
- struct SC_ACTION *object = (struct SC_ACTION *)py_talloc_get_ptr(obj);
+ struct SC_ACTION *object = (struct SC_ACTION *)pytalloc_get_ptr(obj);
PyObject *py_type;
py_type = PyInt_FromLong(object->type);
return py_type;
static int py_SC_ACTION_set_type(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SC_ACTION *object = (struct SC_ACTION *)py_talloc_get_ptr(py_obj);
+ struct SC_ACTION *object = (struct SC_ACTION *)pytalloc_get_ptr(py_obj);
if (PyLong_Check(value)) {
object->type = PyLong_AsLongLong(value);
} else if (PyInt_Check(value)) {
static PyObject *py_SC_ACTION_get_delay(PyObject *obj, void *closure)
{
- struct SC_ACTION *object = (struct SC_ACTION *)py_talloc_get_ptr(obj);
+ struct SC_ACTION *object = (struct SC_ACTION *)pytalloc_get_ptr(obj);
PyObject *py_delay;
py_delay = PyInt_FromLong(object->delay);
return py_delay;
static int py_SC_ACTION_set_delay(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SC_ACTION *object = (struct SC_ACTION *)py_talloc_get_ptr(py_obj);
+ struct SC_ACTION *object = (struct SC_ACTION *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->delay = PyInt_AsLong(value);
return 0;
static PyObject *py_SC_ACTION_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct SC_ACTION, type);
+ return pytalloc_new(struct SC_ACTION, type);
}
.tp_getset = py_SC_ACTION_getsetters,
.tp_methods = NULL,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_SC_ACTION_new,
};
static PyObject *py_SERVICE_FAILURE_ACTIONS_get_reset_period(PyObject *obj, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(obj);
PyObject *py_reset_period;
py_reset_period = PyInt_FromLong(object->reset_period);
return py_reset_period;
static int py_SERVICE_FAILURE_ACTIONS_set_reset_period(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->reset_period = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_FAILURE_ACTIONS_get_rebootmsg(PyObject *obj, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(obj);
PyObject *py_rebootmsg;
if (object->rebootmsg == NULL) {
py_rebootmsg = Py_None;
static int py_SERVICE_FAILURE_ACTIONS_set_rebootmsg(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->rebootmsg = NULL;
} else {
object->rebootmsg = NULL;
- object->rebootmsg = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->rebootmsg = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_SERVICE_FAILURE_ACTIONS_get_command(PyObject *obj, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(obj);
PyObject *py_command;
if (object->command == NULL) {
py_command = Py_None;
static int py_SERVICE_FAILURE_ACTIONS_set_command(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
if (value == Py_None) {
object->command = NULL;
} else {
object->command = NULL;
- object->command = talloc_strdup(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
+ object->command = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
}
return 0;
}
static PyObject *py_SERVICE_FAILURE_ACTIONS_get_num_actions(PyObject *obj, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(obj);
PyObject *py_num_actions;
py_num_actions = PyInt_FromLong(object->num_actions);
return py_num_actions;
static int py_SERVICE_FAILURE_ACTIONS_set_num_actions(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
object->num_actions = PyInt_AsLong(value);
return 0;
static PyObject *py_SERVICE_FAILURE_ACTIONS_get_actions(PyObject *obj, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(obj);
PyObject *py_actions;
if (object->actions == NULL) {
py_actions = Py_None;
int actions_cntr_1;
for (actions_cntr_1 = 0; actions_cntr_1 < object->num_actions; actions_cntr_1++) {
PyObject *py_actions_1;
- py_actions_1 = py_talloc_reference_ex(&SC_ACTION_Type, object->actions, &object->actions[actions_cntr_1]);
+ py_actions_1 = pytalloc_reference_ex(&SC_ACTION_Type, object->actions, &object->actions[actions_cntr_1]);
PyList_SetItem(py_actions, actions_cntr_1, py_actions_1);
}
}
static int py_SERVICE_FAILURE_ACTIONS_set_actions(PyObject *py_obj, PyObject *value, void *closure)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
- talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->actions);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
+ talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->actions);
if (value == Py_None) {
object->actions = NULL;
} else {
PY_CHECK_TYPE(&PyList_Type, value, return -1;);
{
int actions_cntr_1;
- object->actions = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->actions, PyList_GET_SIZE(value));
+ object->actions = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->actions, PyList_GET_SIZE(value));
if (!object->actions) { return -1;; }
talloc_set_name_const(object->actions, "ARRAY: object->actions");
for (actions_cntr_1 = 0; actions_cntr_1 < PyList_GET_SIZE(value); actions_cntr_1++) {
PY_CHECK_TYPE(&SC_ACTION_Type, PyList_GET_ITEM(value, actions_cntr_1), return -1;);
- if (talloc_reference(object->actions, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, actions_cntr_1))) == NULL) {
+ if (talloc_reference(object->actions, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, actions_cntr_1))) == NULL) {
PyErr_NoMemory();
return -1;
}
- object->actions[actions_cntr_1] = *(struct SC_ACTION *)py_talloc_get_ptr(PyList_GET_ITEM(value, actions_cntr_1));
+ object->actions[actions_cntr_1] = *(struct SC_ACTION *)pytalloc_get_ptr(PyList_GET_ITEM(value, actions_cntr_1));
}
}
}
static PyObject *py_SERVICE_FAILURE_ACTIONS_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
{
- return py_talloc_new(struct SERVICE_FAILURE_ACTIONS, type);
+ return pytalloc_new(struct SERVICE_FAILURE_ACTIONS, type);
}
static PyObject *py_SERVICE_FAILURE_ACTIONS_ndr_pack(PyObject *py_obj)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
enum ndr_err_code err;
- err = ndr_push_struct_blob(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_SERVICE_FAILURE_ACTIONS);
+ err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_SERVICE_FAILURE_ACTIONS);
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
return PyString_FromStringAndSize((char *)blob.data, blob.length);
}
-static PyObject *py_SERVICE_FAILURE_ACTIONS_ndr_unpack(PyObject *py_obj, PyObject *args)
+static PyObject *py_SERVICE_FAILURE_ACTIONS_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
DATA_BLOB blob;
+ int blob_length = 0;
enum ndr_err_code err;
- if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
+ const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
+ PyObject *allow_remaining_obj = NULL;
+ bool allow_remaining = false;
+
+ if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
+ discard_const_p(char *, kwnames),
+ &blob.data, &blob_length,
+ &allow_remaining_obj)) {
return NULL;
+ }
+ blob.length = blob_length;
- err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_FAILURE_ACTIONS);
+ 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_SERVICE_FAILURE_ACTIONS);
+ } else {
+ err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_SERVICE_FAILURE_ACTIONS);
+ }
if (err != NDR_ERR_SUCCESS) {
PyErr_SetNdrError(err);
return NULL;
static PyObject *py_SERVICE_FAILURE_ACTIONS_ndr_print(PyObject *py_obj)
{
- struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)py_talloc_get_ptr(py_obj);
+ struct SERVICE_FAILURE_ACTIONS *object = (struct SERVICE_FAILURE_ACTIONS *)pytalloc_get_ptr(py_obj);
PyObject *ret;
char *retstr;
- retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_SERVICE_FAILURE_ACTIONS, "SERVICE_FAILURE_ACTIONS", object);
+ retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_SERVICE_FAILURE_ACTIONS, "SERVICE_FAILURE_ACTIONS", object);
ret = PyString_FromString(retstr);
talloc_free(retstr);
static PyMethodDef py_SERVICE_FAILURE_ACTIONS_methods[] = {
{ "__ndr_pack__", (PyCFunction)py_SERVICE_FAILURE_ACTIONS_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
- { "__ndr_unpack__", (PyCFunction)py_SERVICE_FAILURE_ACTIONS_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
+ { "__ndr_unpack__", (PyCFunction)py_SERVICE_FAILURE_ACTIONS_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
{ "__ndr_print__", (PyCFunction)py_SERVICE_FAILURE_ACTIONS_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
{ NULL, NULL, 0, NULL }
};
.tp_getset = py_SERVICE_FAILURE_ACTIONS_getsetters,
.tp_methods = py_SERVICE_FAILURE_ACTIONS_methods,
.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
- .tp_basicsize = sizeof(py_talloc_Object),
+ .tp_basicsize = sizeof(pytalloc_Object),
.tp_new = py_SERVICE_FAILURE_ACTIONS_new,
};
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
return true;
}
{
PyObject *result;
PyObject *py_handle;
- py_handle = py_talloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
+ py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
result = py_handle;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (PyLong_Check(py_control)) {
r->in.control = PyLong_AsLongLong(py_control);
} else if (PyInt_Check(py_control)) {
{
PyObject *result;
PyObject *py_service_status;
- py_service_status = py_talloc_reference_ex(&SERVICE_STATUS_Type, r->out.service_status, r->out.service_status);
+ py_service_status = pytalloc_reference_ex(&SERVICE_STATUS_Type, r->out.service_status, r->out.service_status);
result = py_service_status;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
return true;
}
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
return true;
}
{
PyObject *result;
PyObject *py_lock;
- py_lock = py_talloc_reference_ex(policy_handle_Type, r->out.lock, r->out.lock);
+ py_lock = pytalloc_reference_ex(policy_handle_Type, r->out.lock, r->out.lock);
result = py_lock;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (PyLong_Check(py_security_flags)) {
r->in.security_flags = PyLong_AsLongLong(py_security_flags);
} else if (PyInt_Check(py_security_flags)) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (PyLong_Check(py_security_flags)) {
r->in.security_flags = PyLong_AsLongLong(py_security_flags);
} else if (PyInt_Check(py_security_flags)) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
return true;
}
{
PyObject *result;
PyObject *py_service_status;
- py_service_status = py_talloc_reference_ex(&SERVICE_STATUS_Type, r->out.service_status, r->out.service_status);
+ py_service_status = pytalloc_reference_ex(&SERVICE_STATUS_Type, r->out.service_status, r->out.service_status);
result = py_service_status;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.lock = talloc_ptrtype(r, r->in.lock);
PY_CHECK_TYPE(policy_handle_Type, py_lock, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_lock)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_lock)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.lock = (struct policy_handle *)py_talloc_get_ptr(py_lock);
+ r->in.lock = (struct policy_handle *)pytalloc_get_ptr(py_lock);
return true;
}
{
PyObject *result;
PyObject *py_lock;
- py_lock = py_talloc_reference_ex(policy_handle_Type, r->out.lock, r->out.lock);
+ py_lock = pytalloc_reference_ex(policy_handle_Type, r->out.lock, r->out.lock);
result = py_lock;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_bits, return false;);
r->in.bits = PyInt_AsLong(py_bits);
PY_CHECK_TYPE(&PyInt_Type, py_bitson, return false;);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_type, return false;);
r->in.type = PyInt_AsLong(py_type);
if (PyLong_Check(py_start_type)) {
r->in.scmanager_handle = talloc_ptrtype(r, r->in.scmanager_handle);
PY_CHECK_TYPE(policy_handle_Type, py_scmanager_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_scmanager_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_scmanager_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.scmanager_handle = (struct policy_handle *)py_talloc_get_ptr(py_scmanager_handle);
+ r->in.scmanager_handle = (struct policy_handle *)pytalloc_get_ptr(py_scmanager_handle);
if (PyUnicode_Check(py_ServiceName)) {
r->in.ServiceName = PyString_AS_STRING(PyUnicode_AsEncodedString(py_ServiceName, "utf-8", "ignore"));
} else if (PyString_Check(py_ServiceName)) {
py_TagId = PyInt_FromLong(*r->out.TagId);
}
PyTuple_SetItem(result, 0, py_TagId);
- py_handle = py_talloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
+ py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
PyTuple_SetItem(result, 1, py_handle);
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.service = talloc_ptrtype(r, r->in.service);
PY_CHECK_TYPE(policy_handle_Type, py_service, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_service)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_service)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.service = (struct policy_handle *)py_talloc_get_ptr(py_service);
+ r->in.service = (struct policy_handle *)pytalloc_get_ptr(py_service);
if (PyLong_Check(py_state)) {
r->in.state = PyLong_AsLongLong(py_state);
} else if (PyInt_Check(py_state)) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_type, return false;);
r->in.type = PyInt_AsLong(py_type);
if (PyLong_Check(py_state)) {
{
PyObject *result;
PyObject *py_handle;
- py_handle = py_talloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
+ py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
result = py_handle;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.scmanager_handle = talloc_ptrtype(r, r->in.scmanager_handle);
PY_CHECK_TYPE(policy_handle_Type, py_scmanager_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_scmanager_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_scmanager_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.scmanager_handle = (struct policy_handle *)py_talloc_get_ptr(py_scmanager_handle);
+ r->in.scmanager_handle = (struct policy_handle *)pytalloc_get_ptr(py_scmanager_handle);
if (PyUnicode_Check(py_ServiceName)) {
r->in.ServiceName = PyString_AS_STRING(PyUnicode_AsEncodedString(py_ServiceName, "utf-8", "ignore"));
} else if (PyString_Check(py_ServiceName)) {
{
PyObject *result;
PyObject *py_handle;
- py_handle = py_talloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
+ py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
result = py_handle;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_offered, return false;);
r->in.offered = PyInt_AsLong(py_offered);
return true;
PyObject *py_query;
PyObject *py_needed;
result = PyTuple_New(2);
- py_query = py_talloc_reference_ex(&QUERY_SERVICE_CONFIG_Type, r->out.query, r->out.query);
+ py_query = pytalloc_reference_ex(&QUERY_SERVICE_CONFIG_Type, r->out.query, r->out.query);
PyTuple_SetItem(result, 0, py_query);
py_needed = PyInt_FromLong(*r->out.needed);
PyTuple_SetItem(result, 1, py_needed);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_offered, return false;);
r->in.offered = PyInt_AsLong(py_offered);
return true;
PyObject *py_lock_status;
PyObject *py_needed;
result = PyTuple_New(2);
- py_lock_status = py_talloc_reference_ex(&SERVICE_LOCK_STATUS_Type, r->out.lock_status, r->out.lock_status);
+ py_lock_status = pytalloc_reference_ex(&SERVICE_LOCK_STATUS_Type, r->out.lock_status, r->out.lock_status);
PyTuple_SetItem(result, 0, py_lock_status);
py_needed = PyInt_FromLong(*r->out.needed);
PyTuple_SetItem(result, 1, py_needed);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyList_Type, py_Arguments, return false;);
r->in.NumArgs = PyList_GET_SIZE(py_Arguments);
if (py_Arguments == Py_None) {
talloc_set_name_const(r->in.Arguments, "ARRAY: r->in.Arguments");
for (Arguments_cntr_1 = 0; Arguments_cntr_1 < PyList_GET_SIZE(py_Arguments); Arguments_cntr_1++) {
PY_CHECK_TYPE(&svcctl_ArgumentString_Type, PyList_GET_ITEM(py_Arguments, Arguments_cntr_1), return false;);
- if (talloc_reference(r->in.Arguments, py_talloc_get_mem_ctx(PyList_GET_ITEM(py_Arguments, Arguments_cntr_1))) == NULL) {
+ if (talloc_reference(r->in.Arguments, pytalloc_get_mem_ctx(PyList_GET_ITEM(py_Arguments, Arguments_cntr_1))) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.Arguments[Arguments_cntr_1] = *(struct svcctl_ArgumentString *)py_talloc_get_ptr(PyList_GET_ITEM(py_Arguments, Arguments_cntr_1));
+ r->in.Arguments[Arguments_cntr_1] = *(struct svcctl_ArgumentString *)pytalloc_get_ptr(PyList_GET_ITEM(py_Arguments, Arguments_cntr_1));
}
}
}
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (py_service_name == Py_None) {
r->in.service_name = NULL;
} else {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (py_service_name == Py_None) {
r->in.service_name = NULL;
} else {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_bits, return false;);
r->in.bits = PyInt_AsLong(py_bits);
PY_CHECK_TYPE(&PyInt_Type, py_bitson, return false;);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_type, return false;);
r->in.type = PyInt_AsLong(py_type);
if (PyLong_Check(py_start_type)) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (py_ServiceName == Py_None) {
r->in.ServiceName = NULL;
} else {
r->in.service = talloc_ptrtype(r, r->in.service);
PY_CHECK_TYPE(policy_handle_Type, py_service, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_service)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_service)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.service = (struct policy_handle *)py_talloc_get_ptr(py_service);
+ r->in.service = (struct policy_handle *)pytalloc_get_ptr(py_service);
if (PyLong_Check(py_state)) {
r->in.state = PyLong_AsLongLong(py_state);
} else if (PyInt_Check(py_state)) {
py_service_status = Py_None;
Py_INCREF(py_service_status);
} else {
- py_service_status = py_talloc_reference_ex(&ENUM_SERVICE_STATUSA_Type, r->out.service_status, r->out.service_status);
+ py_service_status = pytalloc_reference_ex(&ENUM_SERVICE_STATUSA_Type, r->out.service_status, r->out.service_status);
}
PyTuple_SetItem(result, 0, py_service_status);
py_needed = PyInt_FromLong(*r->out.needed);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_type, return false;);
r->in.type = PyInt_AsLong(py_type);
if (PyLong_Check(py_state)) {
{
PyObject *result;
PyObject *py_handle;
- py_handle = py_talloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
+ py_handle = pytalloc_reference_ex(policy_handle_Type, r->out.handle, r->out.handle);
result = py_handle;
if (!W_ERROR_IS_OK(r->out.result)) {
PyErr_SetWERROR(r->out.result);
r->in.scmanager_handle = talloc_ptrtype(r, r->in.scmanager_handle);
PY_CHECK_TYPE(policy_handle_Type, py_scmanager_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_scmanager_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_scmanager_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.scmanager_handle = (struct policy_handle *)py_talloc_get_ptr(py_scmanager_handle);
+ r->in.scmanager_handle = (struct policy_handle *)pytalloc_get_ptr(py_scmanager_handle);
if (py_ServiceName == Py_None) {
r->in.ServiceName = NULL;
} else {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_offered, return false;);
r->in.offered = PyInt_AsLong(py_offered);
return true;
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_offered, return false;);
r->in.offered = PyInt_AsLong(py_offered);
return true;
PyObject *py_lock_status;
PyObject *py_needed;
result = PyTuple_New(2);
- py_lock_status = py_talloc_reference_ex(&SERVICE_LOCK_STATUS_Type, r->out.lock_status, r->out.lock_status);
+ py_lock_status = pytalloc_reference_ex(&SERVICE_LOCK_STATUS_Type, r->out.lock_status, r->out.lock_status);
PyTuple_SetItem(result, 0, py_lock_status);
py_needed = PyInt_FromLong(*r->out.needed);
PyTuple_SetItem(result, 1, py_needed);
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_NumArgs, return false;);
r->in.NumArgs = PyInt_AsLong(py_NumArgs);
if (py_Arguments == Py_None) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (py_service_name == Py_None) {
r->in.service_name = NULL;
} else {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (py_service_name == Py_None) {
r->in.service_name = NULL;
} else {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_info_level, return false;);
r->in.info_level = PyInt_AsLong(py_info_level);
if (py_info == Py_None) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
PY_CHECK_TYPE(&PyInt_Type, py_info_level, return false;);
r->in.info_level = PyInt_AsLong(py_info_level);
if (py_info == Py_None) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (PyLong_Check(py_info_level)) {
r->in.info_level = PyLong_AsLongLong(py_info_level);
} else if (PyInt_Check(py_info_level)) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (PyLong_Check(py_info_level)) {
r->in.info_level = PyLong_AsLongLong(py_info_level);
} else if (PyInt_Check(py_info_level)) {
r->in.handle = talloc_ptrtype(r, r->in.handle);
PY_CHECK_TYPE(policy_handle_Type, py_handle, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_handle)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_handle)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.handle = (struct policy_handle *)py_talloc_get_ptr(py_handle);
+ r->in.handle = (struct policy_handle *)pytalloc_get_ptr(py_handle);
if (PyLong_Check(py_info_level)) {
r->in.info_level = PyLong_AsLongLong(py_info_level);
} else if (PyInt_Check(py_info_level)) {
r->in.scmanager = talloc_ptrtype(r, r->in.scmanager);
PY_CHECK_TYPE(policy_handle_Type, py_scmanager, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_scmanager)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_scmanager)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.scmanager = (struct policy_handle *)py_talloc_get_ptr(py_scmanager);
+ r->in.scmanager = (struct policy_handle *)pytalloc_get_ptr(py_scmanager);
PY_CHECK_TYPE(&PyInt_Type, py_info_level, return false;);
r->in.info_level = PyInt_AsLong(py_info_level);
PY_CHECK_TYPE(&PyInt_Type, py_type, return false;);
r->in.scmanager = talloc_ptrtype(r, r->in.scmanager);
PY_CHECK_TYPE(policy_handle_Type, py_scmanager, return false;);
- if (talloc_reference(r, py_talloc_get_mem_ctx(py_scmanager)) == NULL) {
+ if (talloc_reference(r, pytalloc_get_mem_ctx(py_scmanager)) == NULL) {
PyErr_NoMemory();
return false;
}
- r->in.scmanager = (struct policy_handle *)py_talloc_get_ptr(py_scmanager);
+ r->in.scmanager = (struct policy_handle *)pytalloc_get_ptr(py_scmanager);
PY_CHECK_TYPE(&PyInt_Type, py_info_level, return false;);
r->in.info_level = PyInt_AsLong(py_info_level);
PY_CHECK_TYPE(&PyInt_Type, py_type, return false;);
PyModule_AddObject(m, "SC_RIGHT_SVC_QUERY_CONFIG", PyInt_FromLong(SC_RIGHT_SVC_QUERY_CONFIG));
PyModule_AddObject(m, "SERVICE_WRITE_ACCESS", PyInt_FromLong((SEC_STD_REQUIRED|SERVICE_READ_ACCESS|SERVICE_EXECUTE_ACCESS|SC_RIGHT_SVC_CHANGE_CONFIG)));
- PyModule_AddObject(m, "SV_TYPE_DOMAIN_CTRL", PyInt_FromLong(SV_TYPE_DOMAIN_CTRL));
PyModule_AddObject(m, "SVCCTL_ACCEPT_SHUTDOWN", PyInt_FromLong(SVCCTL_ACCEPT_SHUTDOWN));
PyModule_AddObject(m, "SVCCTL_DISABLED", PyInt_FromLong(SVCCTL_DISABLED));
- PyModule_AddObject(m, "SV_TYPE_SERVER_NT", PyInt_FromLong(SV_TYPE_SERVER_NT));
- PyModule_AddObject(m, "SV_TYPE_AFP", PyInt_FromLong(SV_TYPE_AFP));
- PyModule_AddObject(m, "SV_TYPE_SERVER_UNIX", PyInt_FromLong(SV_TYPE_SERVER_UNIX));
PyModule_AddObject(m, "SERVICE_READ_ACCESS", PyInt_FromLong((SEC_STD_READ_CONTROL|SC_RIGHT_SVC_ENUMERATE_DEPENDENTS|SC_RIGHT_SVC_INTERROGATE|SC_RIGHT_SVC_QUERY_CONFIG|SC_RIGHT_SVC_QUERY_STATUS|SC_RIGHT_SVC_USER_DEFINED_CONTROL)));
- PyModule_AddObject(m, "SV_TYPE_DOMAIN_MASTER", PyInt_FromLong(SV_TYPE_DOMAIN_MASTER));
PyModule_AddObject(m, "SERVICE_STATE_ACTIVE", PyInt_FromLong(SERVICE_STATE_ACTIVE));
PyModule_AddObject(m, "SVCCTL_CONTINUE_PENDING", PyInt_FromLong(SVCCTL_CONTINUE_PENDING));
PyModule_AddObject(m, "SVCCTL_STOPPED", PyInt_FromLong(SVCCTL_STOPPED));
PyModule_AddObject(m, "SERVICE_TYPE_FS_DRIVER", PyInt_FromLong(0x02));
PyModule_AddObject(m, "SC_ACTION_RUN_COMMAND", PyInt_FromLong(SC_ACTION_RUN_COMMAND));
PyModule_AddObject(m, "SVCCTL_SYSTEM_START", PyInt_FromLong(SVCCTL_SYSTEM_START));
- PyModule_AddObject(m, "SV_TYPE_BACKUP_BROWSER", PyInt_FromLong(SV_TYPE_BACKUP_BROWSER));
- PyModule_AddObject(m, "SV_TYPE_DIALIN_SERVER", PyInt_FromLong(SV_TYPE_DIALIN_SERVER));
PyModule_AddObject(m, "SC_RIGHT_SVC_CHANGE_CONFIG", PyInt_FromLong(SC_RIGHT_SVC_CHANGE_CONFIG));
- PyModule_AddObject(m, "SV_TYPE_WFW", PyInt_FromLong(SV_TYPE_WFW));
PyModule_AddObject(m, "SVCCTL_ACCEPT_NETBINDCHANGE", PyInt_FromLong(SVCCTL_ACCEPT_NETBINDCHANGE));
PyModule_AddObject(m, "SERVICE_TYPE_INTERACTIVE_PROCESS", PyInt_FromLong(0x100));
PyModule_AddObject(m, "SC_ACTION_NONE", PyInt_FromLong(SC_ACTION_NONE));
PyModule_AddObject(m, "SERVICE_TYPE_WIN32_OWN_PROCESS", PyInt_FromLong(0x10));
PyModule_AddObject(m, "SC_RIGHT_MGR_CONNECT", PyInt_FromLong(SC_RIGHT_MGR_CONNECT));
PyModule_AddObject(m, "SVCCTL_CONTROL_PAUSE", PyInt_FromLong(SVCCTL_CONTROL_PAUSE));
- PyModule_AddObject(m, "SV_TYPE_POTENTIAL_BROWSER", PyInt_FromLong(SV_TYPE_POTENTIAL_BROWSER));
PyModule_AddObject(m, "SVCCTL_SVC_ERROR_IGNORE", PyInt_FromLong(SVCCTL_SVC_ERROR_IGNORE));
PyModule_AddObject(m, "SC_ACTION_REBOOT", PyInt_FromLong(SC_ACTION_REBOOT));
- PyModule_AddObject(m, "SV_TYPE_SERVER", PyInt_FromLong(SV_TYPE_SERVER));
PyModule_AddObject(m, "SERVICE_TYPE_DRIVER", PyInt_FromLong(SERVICE_TYPE_KERNEL_DRIVER|SERVICE_TYPE_FS_DRIVER|SERVICE_TYPE_RECOGNIZER_DRIVER));
- PyModule_AddObject(m, "SV_TYPE_SQLSERVER", PyInt_FromLong(SV_TYPE_SQLSERVER));
PyModule_AddObject(m, "SC_RIGHT_MGR_MODIFY_BOOT_CONFIG", PyInt_FromLong(SC_RIGHT_MGR_MODIFY_BOOT_CONFIG));
PyModule_AddObject(m, "SVCCTL_SVC_ERROR_NORMAL", PyInt_FromLong(SVCCTL_SVC_ERROR_NORMAL));
PyModule_AddObject(m, "SVCCTL_ACCEPT_PAUSE_CONTINUE", PyInt_FromLong(SVCCTL_ACCEPT_PAUSE_CONTINUE));
PyModule_AddObject(m, "SERVICE_TYPE_ADAPTER", PyInt_FromLong(0x04));
PyModule_AddObject(m, "SVCCTL_CONTROL_CONTINUE", PyInt_FromLong(SVCCTL_CONTROL_CONTINUE));
- PyModule_AddObject(m, "SV_TYPE_ALL", PyInt_FromLong(0xFFFFFFFF));
- PyModule_AddObject(m, "SV_TYPE_DOMAIN_BAKCTRL", PyInt_FromLong(SV_TYPE_DOMAIN_BAKCTRL));
- PyModule_AddObject(m, "SV_TYPE_DOMAIN_ENUM", PyInt_FromLong(SV_TYPE_DOMAIN_ENUM));
PyModule_AddObject(m, "SERVICE_TYPE_RECOGNIZER_DRIVER", PyInt_FromLong(0x08));
- PyModule_AddObject(m, "SV_TYPE_DOMAIN_MEMBER", PyInt_FromLong(SV_TYPE_DOMAIN_MEMBER));
PyModule_AddObject(m, "SVCCTL_PAUSED", PyInt_FromLong(SVCCTL_PAUSED));
PyModule_AddObject(m, "SERVICE_EXECUTE_ACCESS", PyInt_FromLong((SERVICE_READ_ACCESS|SC_RIGHT_SVC_START|SC_RIGHT_SVC_STOP|SC_RIGHT_SVC_PAUSE_CONTINUE)));
PyModule_AddObject(m, "SVCCTL_CONTROL_SHUTDOWN", PyInt_FromLong(SVCCTL_CONTROL_SHUTDOWN));
- PyModule_AddObject(m, "SV_TYPE_PRINTQ_SERVER", PyInt_FromLong(SV_TYPE_PRINTQ_SERVER));
PyModule_AddObject(m, "SERVICE_TYPE_WIN32", PyInt_FromLong(SERVICE_TYPE_WIN32_OWN_PROCESS|SERVICE_TYPE_WIN32_SHARE_PROCESS));
PyModule_AddObject(m, "SVCCTL_ACCEPT_HARDWAREPROFILECHANGE", PyInt_FromLong(SVCCTL_ACCEPT_HARDWAREPROFILECHANGE));
- PyModule_AddObject(m, "SV_TYPE_WORKSTATION", PyInt_FromLong(SV_TYPE_WORKSTATION));
PyModule_AddObject(m, "SVCCTL_ACCEPT_PARAMCHANGE", PyInt_FromLong(SVCCTL_ACCEPT_PARAMCHANGE));
PyModule_AddObject(m, "SVCCTL_SVC_ERROR_SEVERE", PyInt_FromLong(SVCCTL_SVC_ERROR_SEVERE));
PyModule_AddObject(m, "SVCCTL_ACCEPT_NONE", PyInt_FromLong(0x00000000));
- PyModule_AddObject(m, "SV_TYPE_SERVER_VMS", PyInt_FromLong(SV_TYPE_SERVER_VMS));
- PyModule_AddObject(m, "SV_TYPE_SERVER_MFPN", PyInt_FromLong(SV_TYPE_SERVER_MFPN));
PyModule_AddObject(m, "SERVICE_CONFIG_DESCRIPTION", PyInt_FromLong(SERVICE_CONFIG_DESCRIPTION));
PyModule_AddObject(m, "SVCCTL_START_PENDING", PyInt_FromLong(SVCCTL_START_PENDING));
PyModule_AddObject(m, "SC_RIGHT_SVC_USER_DEFINED_CONTROL", PyInt_FromLong(SC_RIGHT_SVC_USER_DEFINED_CONTROL));
- PyModule_AddObject(m, "SV_TYPE_ALTERNATE_XPORT", PyInt_FromLong(SV_TYPE_ALTERNATE_XPORT));
- PyModule_AddObject(m, "SV_TYPE_DFS_SERVER", PyInt_FromLong(SV_TYPE_DFS_SERVER));
PyModule_AddObject(m, "SC_ACTION_RESTART", PyInt_FromLong(SC_ACTION_RESTART));
PyModule_AddObject(m, "SVCCTL_ACCEPT_STOP", PyInt_FromLong(SVCCTL_ACCEPT_STOP));
- PyModule_AddObject(m, "SC_RIGHT_SVC_ENUMERATE_DEPENDENTS", PyInt_FromLong(SC_RIGHT_SVC_ENUMERATE_DEPENDENTS));
PyModule_AddObject(m, "SC_RIGHT_MGR_CREATE_SERVICE", PyInt_FromLong(SC_RIGHT_MGR_CREATE_SERVICE));
+ PyModule_AddObject(m, "SC_RIGHT_SVC_ENUMERATE_DEPENDENTS", PyInt_FromLong(SC_RIGHT_SVC_ENUMERATE_DEPENDENTS));
PyModule_AddObject(m, "SC_MAX_ARGUMENTS", PyInt_FromLong(1024));
PyModule_AddObject(m, "SVCCTL_ACCEPT_POWEREVENT", PyInt_FromLong(SVCCTL_ACCEPT_POWEREVENT));
PyModule_AddObject(m, "SVCCTL_CONTROL_INTERROGATE", PyInt_FromLong(SVCCTL_CONTROL_INTERROGATE));
PyModule_AddObject(m, "SVCCTL_STATE_UNKNOWN", PyInt_FromLong(SVCCTL_STATE_UNKNOWN));
- PyModule_AddObject(m, "SV_TYPE_MASTER_BROWSER", PyInt_FromLong(SV_TYPE_MASTER_BROWSER));
- PyModule_AddObject(m, "SV_TYPE_SERVER_OSF", PyInt_FromLong(SV_TYPE_SERVER_OSF));
- PyModule_AddObject(m, "SV_TYPE_LOCAL_LIST_ONLY", PyInt_FromLong(SV_TYPE_LOCAL_LIST_ONLY));
- PyModule_AddObject(m, "SC_RIGHT_MGR_LOCK", PyInt_FromLong(SC_RIGHT_MGR_LOCK));
PyModule_AddObject(m, "SVCCTL_SVC_ERROR_CRITICAL", PyInt_FromLong(SVCCTL_SVC_ERROR_CRITICAL));
- PyModule_AddObject(m, "SC_RIGHT_MGR_ENUMERATE_SERVICE", PyInt_FromLong(SC_RIGHT_MGR_ENUMERATE_SERVICE));
+ PyModule_AddObject(m, "SC_RIGHT_MGR_LOCK", PyInt_FromLong(SC_RIGHT_MGR_LOCK));
PyModule_AddObject(m, "SVCCTL_PAUSE_PENDING", PyInt_FromLong(SVCCTL_PAUSE_PENDING));
+ PyModule_AddObject(m, "SC_RIGHT_MGR_ENUMERATE_SERVICE", PyInt_FromLong(SC_RIGHT_MGR_ENUMERATE_SERVICE));
PyModule_AddObject(m, "SVCCTL_RUNNING", PyInt_FromLong(SVCCTL_RUNNING));
PyModule_AddObject(m, "SVCCTL_CONTROL_STOP", PyInt_FromLong(SVCCTL_CONTROL_STOP));
PyModule_AddObject(m, "SC_MANAGER_EXECUTE_ACCESS", PyInt_FromLong(SC_MANAGER_READ_ACCESS));
PyModule_AddObject(m, "SERVICE_TYPE_WIN32_SHARE_PROCESS", PyInt_FromLong(0x20));
PyModule_AddObject(m, "SVCCTL_AUTO_START", PyInt_FromLong(SVCCTL_AUTO_START));
- PyModule_AddObject(m, "SV_TYPE_NOVELL", PyInt_FromLong(SV_TYPE_NOVELL));
PyModule_AddObject(m, "SVC_STATUS_PROCESS_INFO", PyInt_FromLong(SVC_STATUS_PROCESS_INFO));
- PyModule_AddObject(m, "SV_TYPE_WIN95_PLUS", PyInt_FromLong(SV_TYPE_WIN95_PLUS));
PyModule_AddObject(m, "SC_MANAGER_WRITE_ACCESS", PyInt_FromLong((SEC_STD_REQUIRED|SC_MANAGER_READ_ACCESS|SC_RIGHT_MGR_CREATE_SERVICE|SC_RIGHT_MGR_LOCK|SC_RIGHT_MGR_MODIFY_BOOT_CONFIG)));
PyModule_AddObject(m, "SC_RIGHT_SVC_START", PyInt_FromLong(SC_RIGHT_SVC_START));
- PyModule_AddObject(m, "SC_RIGHT_MGR_QUERY_LOCK_STATUS", PyInt_FromLong(SC_RIGHT_MGR_QUERY_LOCK_STATUS));
- PyModule_AddObject(m, "SERVICE_STATE_ALL", PyInt_FromLong(SERVICE_STATE_ALL));
PyModule_AddObject(m, "SC_MANAGER_READ_ACCESS", PyInt_FromLong((SEC_STD_READ_CONTROL|SC_RIGHT_MGR_CONNECT|SC_RIGHT_MGR_ENUMERATE_SERVICE|SC_RIGHT_MGR_QUERY_LOCK_STATUS)));
+ PyModule_AddObject(m, "SERVICE_STATE_ALL", PyInt_FromLong(SERVICE_STATE_ALL));
+ PyModule_AddObject(m, "SC_RIGHT_MGR_QUERY_LOCK_STATUS", PyInt_FromLong(SC_RIGHT_MGR_QUERY_LOCK_STATUS));
PyModule_AddObject(m, "SC_RIGHT_SVC_INTERROGATE", PyInt_FromLong(SC_RIGHT_SVC_INTERROGATE));
PyModule_AddObject(m, "SC_RIGHT_SVC_PAUSE_CONTINUE", PyInt_FromLong(SC_RIGHT_SVC_PAUSE_CONTINUE));
PyModule_AddObject(m, "SVCCTL_BOOT_START", PyInt_FromLong(SVCCTL_BOOT_START));
- PyModule_AddObject(m, "SV_TYPE_NT", PyInt_FromLong(SV_TYPE_NT));
PyModule_AddObject(m, "SC_MAX_ARGUMENT_LENGTH", PyInt_FromLong(1024));
PyModule_AddObject(m, "SC_MANAGER_ALL_ACCESS", PyInt_FromLong(SC_MANAGER_WRITE_ACCESS));
PyModule_AddObject(m, "SERVICE_STATE_INACTIVE", PyInt_FromLong(SERVICE_STATE_INACTIVE));
- PyModule_AddObject(m, "SV_TYPE_TIME_SOURCE", PyInt_FromLong(SV_TYPE_TIME_SOURCE));
PyModule_AddObject(m, "SVCCTL_DEMAND_START", PyInt_FromLong(SVCCTL_DEMAND_START));
PyModule_AddObject(m, "SERVICE_CONFIG_FAILURE_ACTIONS", PyInt_FromLong(SERVICE_CONFIG_FAILURE_ACTIONS));
- PyModule_AddObject(m, "SC_RIGHT_SVC_STOP", PyInt_FromLong(SC_RIGHT_SVC_STOP));
PyModule_AddObject(m, "SERVICE_TYPE_KERNEL_DRIVER", PyInt_FromLong(0x01));
+ PyModule_AddObject(m, "SC_RIGHT_SVC_STOP", PyInt_FromLong(SC_RIGHT_SVC_STOP));
PyModule_AddObject(m, "SVCCTL_STOP_PENDING", PyInt_FromLong(SVCCTL_STOP_PENDING));
Py_INCREF((PyObject *)(void *)&SERVICE_LOCK_STATUS_Type);
PyModule_AddObject(m, "SERVICE_LOCK_STATUS", (PyObject *)(void *)&SERVICE_LOCK_STATUS_Type);
git.samba.org / abartlet / samba-debian.git / blobdiff