bin.gen_ndr/default/source4/librpc/gen_ndr/py_ntp_signd.c

   1
   2 /* Python wrapper functions auto-generated by pidl */
   3 #include <Python.h>
   4 #include "includes.h"
   5 #include <pytalloc.h>
   6 #include "librpc/rpc/pyrpc.h"
   7 #include "librpc/rpc/pyrpc_util.h"
   8 #include "bin/default/source4/librpc/gen_ndr/ndr_ntp_signd.h"
   9 #include "bin/default/source4/librpc/gen_ndr/ndr_ntp_signd_c.h"
  10
  11 staticforward PyTypeObject sign_request_Type;
  12 staticforward PyTypeObject signed_reply_Type;
  13 staticforward PyTypeObject ntp_signd_InterfaceType;
  14
  15 void initntp_signd(void);static PyTypeObject *Object_Type;
  16 static PyTypeObject *ClientConnection_Type;
  17
  18 static PyObject *py_sign_request_get_version(PyObject *obj, void *closure)
  19 {
  20         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(obj);
  21         PyObject *py_version;
  22         py_version = PyInt_FromLong(object->version);
  23         return py_version;
  24 }
  25
  26 static int py_sign_request_set_version(PyObject *py_obj, PyObject *value, void *closure)
  27 {
  28         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
  29         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  30         object->version = PyInt_AsLong(value);
  31         return 0;
  32 }
  33
  34 static PyObject *py_sign_request_get_op(PyObject *obj, void *closure)
  35 {
  36         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(obj);
  37         PyObject *py_op;
  38         py_op = PyInt_FromLong(object->op);
  39         return py_op;
  40 }
  41
  42 static int py_sign_request_set_op(PyObject *py_obj, PyObject *value, void *closure)
  43 {
  44         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
  45         if (PyLong_Check(value)) {
  46                 object->op = PyLong_AsLongLong(value);
  47         } else if (PyInt_Check(value)) {
  48                 object->op = PyInt_AsLong(value);
  49         } else {
  50                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
  51                   PyInt_Type.tp_name, PyLong_Type.tp_name);
  52                 return -1;
  53         }
  54         return 0;
  55 }
  56
  57 static PyObject *py_sign_request_get_packet_id(PyObject *obj, void *closure)
  58 {
  59         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(obj);
  60         PyObject *py_packet_id;
  61         py_packet_id = PyInt_FromLong(object->packet_id);
  62         return py_packet_id;
  63 }
  64
  65 static int py_sign_request_set_packet_id(PyObject *py_obj, PyObject *value, void *closure)
  66 {
  67         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
  68         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  69         object->packet_id = PyInt_AsLong(value);
  70         return 0;
  71 }
  72
  73 static PyObject *py_sign_request_get_key_id(PyObject *obj, void *closure)
  74 {
  75         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(obj);
  76         PyObject *py_key_id;
  77         py_key_id = PyInt_FromLong(object->key_id);
  78         return py_key_id;
  79 }
  80
  81 static int py_sign_request_set_key_id(PyObject *py_obj, PyObject *value, void *closure)
  82 {
  83         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
  84         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
  85         object->key_id = PyInt_AsLong(value);
  86         return 0;
  87 }
  88
  89 static PyObject *py_sign_request_get_packet_to_sign(PyObject *obj, void *closure)
  90 {
  91         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(obj);
  92         PyObject *py_packet_to_sign;
  93         py_packet_to_sign = PyString_FromStringAndSize((char *)(object->packet_to_sign).data, (object->packet_to_sign).length);
  94         return py_packet_to_sign;
  95 }
  96
  97 static int py_sign_request_set_packet_to_sign(PyObject *py_obj, PyObject *value, void *closure)
  98 {
  99         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
 100         object->packet_to_sign = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
 101         return 0;
 102 }
 103
 104 static PyGetSetDef py_sign_request_getsetters[] = {
 105         { discard_const_p(char, "version"), py_sign_request_get_version, py_sign_request_set_version },
 106         { discard_const_p(char, "op"), py_sign_request_get_op, py_sign_request_set_op },
 107         { discard_const_p(char, "packet_id"), py_sign_request_get_packet_id, py_sign_request_set_packet_id },
 108         { discard_const_p(char, "key_id"), py_sign_request_get_key_id, py_sign_request_set_key_id },
 109         { discard_const_p(char, "packet_to_sign"), py_sign_request_get_packet_to_sign, py_sign_request_set_packet_to_sign },
 110         { NULL }
 111 };
 112
 113 static PyObject *py_sign_request_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 114 {
 115         return pytalloc_new(struct sign_request, type);
 116 }
 117
 118 static PyObject *py_sign_request_ndr_pack(PyObject *py_obj)
 119 {
 120         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
 121         DATA_BLOB blob;
 122         enum ndr_err_code err;
 123         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_sign_request);
 124         if (err != NDR_ERR_SUCCESS) {
 125                 PyErr_SetNdrError(err);
 126                 return NULL;
 127         }
 128
 129         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 130 }
 131
 132 static PyObject *py_sign_request_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
 133 {
 134         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
 135         DATA_BLOB blob;
 136         int blob_length = 0;
 137         enum ndr_err_code err;
 138         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
 139         PyObject *allow_remaining_obj = NULL;
 140         bool allow_remaining = false;
 141
 142         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
 143                 discard_const_p(char *, kwnames),
 144                 &blob.data, &blob_length,
 145                 &allow_remaining_obj)) {
 146                 return NULL;
 147         }
 148         blob.length = blob_length;
 149
 150         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
 151                 allow_remaining = true;
 152         }
 153
 154         if (allow_remaining) {
 155                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_sign_request);
 156         } else {
 157                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_sign_request);
 158         }
 159         if (err != NDR_ERR_SUCCESS) {
 160                 PyErr_SetNdrError(err);
 161                 return NULL;
 162         }
 163
 164         Py_RETURN_NONE;
 165 }
 166
 167 static PyObject *py_sign_request_ndr_print(PyObject *py_obj)
 168 {
 169         struct sign_request *object = (struct sign_request *)pytalloc_get_ptr(py_obj);
 170         PyObject *ret;
 171         char *retstr;
 172
 173         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_sign_request, "sign_request", object);
 174         ret = PyString_FromString(retstr);
 175         talloc_free(retstr);
 176
 177         return ret;
 178 }
 179
 180 static PyMethodDef py_sign_request_methods[] = {
 181         { "__ndr_pack__", (PyCFunction)py_sign_request_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 182         { "__ndr_unpack__", (PyCFunction)py_sign_request_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
 183         { "__ndr_print__", (PyCFunction)py_sign_request_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 184         { NULL, NULL, 0, NULL }
 185 };
 186
 187
 188 static PyTypeObject sign_request_Type = {
 189         PyObject_HEAD_INIT(NULL) 0,
 190         .tp_name = "ntp_signd.sign_request",
 191         .tp_getset = py_sign_request_getsetters,
 192         .tp_methods = py_sign_request_methods,
 193         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 194         .tp_basicsize = sizeof(pytalloc_Object),
 195         .tp_new = py_sign_request_new,
 196 };
 197
 198
 199 static PyObject *py_signed_reply_get_version(PyObject *obj, void *closure)
 200 {
 201         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(obj);
 202         PyObject *py_version;
 203         py_version = PyInt_FromLong(object->version);
 204         return py_version;
 205 }
 206
 207 static int py_signed_reply_set_version(PyObject *py_obj, PyObject *value, void *closure)
 208 {
 209         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 210         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 211         object->version = PyInt_AsLong(value);
 212         return 0;
 213 }
 214
 215 static PyObject *py_signed_reply_get_op(PyObject *obj, void *closure)
 216 {
 217         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(obj);
 218         PyObject *py_op;
 219         py_op = PyInt_FromLong(object->op);
 220         return py_op;
 221 }
 222
 223 static int py_signed_reply_set_op(PyObject *py_obj, PyObject *value, void *closure)
 224 {
 225         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 226         if (PyLong_Check(value)) {
 227                 object->op = PyLong_AsLongLong(value);
 228         } else if (PyInt_Check(value)) {
 229                 object->op = PyInt_AsLong(value);
 230         } else {
 231                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 232                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 233                 return -1;
 234         }
 235         return 0;
 236 }
 237
 238 static PyObject *py_signed_reply_get_packet_id(PyObject *obj, void *closure)
 239 {
 240         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(obj);
 241         PyObject *py_packet_id;
 242         py_packet_id = PyInt_FromLong(object->packet_id);
 243         return py_packet_id;
 244 }
 245
 246 static int py_signed_reply_set_packet_id(PyObject *py_obj, PyObject *value, void *closure)
 247 {
 248         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 249         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 250         object->packet_id = PyInt_AsLong(value);
 251         return 0;
 252 }
 253
 254 static PyObject *py_signed_reply_get_signed_packet(PyObject *obj, void *closure)
 255 {
 256         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(obj);
 257         PyObject *py_signed_packet;
 258         py_signed_packet = PyString_FromStringAndSize((char *)(object->signed_packet).data, (object->signed_packet).length);
 259         return py_signed_packet;
 260 }
 261
 262 static int py_signed_reply_set_signed_packet(PyObject *py_obj, PyObject *value, void *closure)
 263 {
 264         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 265         object->signed_packet = data_blob_talloc(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
 266         return 0;
 267 }
 268
 269 static PyGetSetDef py_signed_reply_getsetters[] = {
 270         { discard_const_p(char, "version"), py_signed_reply_get_version, py_signed_reply_set_version },
 271         { discard_const_p(char, "op"), py_signed_reply_get_op, py_signed_reply_set_op },
 272         { discard_const_p(char, "packet_id"), py_signed_reply_get_packet_id, py_signed_reply_set_packet_id },
 273         { discard_const_p(char, "signed_packet"), py_signed_reply_get_signed_packet, py_signed_reply_set_signed_packet },
 274         { NULL }
 275 };
 276
 277 static PyObject *py_signed_reply_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 278 {
 279         return pytalloc_new(struct signed_reply, type);
 280 }
 281
 282 static PyObject *py_signed_reply_ndr_pack(PyObject *py_obj)
 283 {
 284         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 285         DATA_BLOB blob;
 286         enum ndr_err_code err;
 287         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_signed_reply);
 288         if (err != NDR_ERR_SUCCESS) {
 289                 PyErr_SetNdrError(err);
 290                 return NULL;
 291         }
 292
 293         return PyString_FromStringAndSize((char *)blob.data, blob.length);
 294 }
 295
 296 static PyObject *py_signed_reply_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
 297 {
 298         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 299         DATA_BLOB blob;
 300         int blob_length = 0;
 301         enum ndr_err_code err;
 302         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
 303         PyObject *allow_remaining_obj = NULL;
 304         bool allow_remaining = false;
 305
 306         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
 307                 discard_const_p(char *, kwnames),
 308                 &blob.data, &blob_length,
 309                 &allow_remaining_obj)) {
 310                 return NULL;
 311         }
 312         blob.length = blob_length;
 313
 314         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
 315                 allow_remaining = true;
 316         }
 317
 318         if (allow_remaining) {
 319                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_signed_reply);
 320         } else {
 321                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_signed_reply);
 322         }
 323         if (err != NDR_ERR_SUCCESS) {
 324                 PyErr_SetNdrError(err);
 325                 return NULL;
 326         }
 327
 328         Py_RETURN_NONE;
 329 }
 330
 331 static PyObject *py_signed_reply_ndr_print(PyObject *py_obj)
 332 {
 333         struct signed_reply *object = (struct signed_reply *)pytalloc_get_ptr(py_obj);
 334         PyObject *ret;
 335         char *retstr;
 336
 337         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_signed_reply, "signed_reply", object);
 338         ret = PyString_FromString(retstr);
 339         talloc_free(retstr);
 340
 341         return ret;
 342 }
 343
 344 static PyMethodDef py_signed_reply_methods[] = {
 345         { "__ndr_pack__", (PyCFunction)py_signed_reply_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 346         { "__ndr_unpack__", (PyCFunction)py_signed_reply_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
 347         { "__ndr_print__", (PyCFunction)py_signed_reply_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 348         { NULL, NULL, 0, NULL }
 349 };
 350
 351
 352 static PyTypeObject signed_reply_Type = {
 353         PyObject_HEAD_INIT(NULL) 0,
 354         .tp_name = "ntp_signd.signed_reply",
 355         .tp_getset = py_signed_reply_getsetters,
 356         .tp_methods = py_signed_reply_methods,
 357         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 358         .tp_basicsize = sizeof(pytalloc_Object),
 359         .tp_new = py_signed_reply_new,
 360 };
 361
 362
 363 static bool pack_py_decode_sign_requst_args_in(PyObject *args, PyObject *kwargs, struct decode_sign_requst *r)
 364 {
 365         PyObject *py_request;
 366         const char *kwnames[] = {
 367                 "request", NULL
 368         };
 369
 370         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:decode_sign_requst", discard_const_p(char *, kwnames), &py_request)) {
 371                 return false;
 372         }
 373
 374         PY_CHECK_TYPE(&sign_request_Type, py_request, return false;);
 375         if (talloc_reference(r, pytalloc_get_mem_ctx(py_request)) == NULL) {
 376                 PyErr_NoMemory();
 377                 return false;
 378         }
 379         r->in.request = *(struct sign_request *)pytalloc_get_ptr(py_request);
 380         return true;
 381 }
 382
 383 static PyObject *unpack_py_decode_sign_requst_args_out(struct decode_sign_requst *r)
 384 {
 385         PyObject *result;
 386         result = Py_None;
 387         Py_INCREF(result);
 388         return result;
 389 }
 390
 391 const struct PyNdrRpcMethodDef py_ndr_ntp_signd_methods[] = {
 392         { "decode_sign_requst", "S.decode_sign_requst(request) -> None", (py_dcerpc_call_fn)dcerpc_decode_sign_requst_r, (py_data_pack_fn)pack_py_decode_sign_requst_args_in, (py_data_unpack_fn)unpack_py_decode_sign_requst_args_out, 0, &ndr_table_ntp_signd },
 393         { NULL }
 394 };
 395
 396 static PyObject *interface_ntp_signd_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 397 {
 398         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_ntp_signd);
 399 }
 400
 401 static PyTypeObject ntp_signd_InterfaceType = {
 402         PyObject_HEAD_INIT(NULL) 0,
 403         .tp_name = "ntp_signd.ntp_signd",
 404         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
 405         .tp_doc = "ntp_signd(binding, lp_ctx=None, credentials=None) -> connection\n"
 406 "\n"
 407 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
 408 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
 409 "credentials should be a credentials.Credentials object.\n\n",
 410         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 411         .tp_new = interface_ntp_signd_new,
 412 };
 413
 414 static PyMethodDef ntp_signd_methods[] = {
 415         { NULL, NULL, 0, NULL }
 416 };
 417
 418 void initntp_signd(void)
 419 {
 420         PyObject *m;
 421         PyObject *dep_talloc;
 422         PyObject *dep_samba_dcerpc_base;
 423
 424         dep_talloc = PyImport_ImportModule("talloc");
 425         if (dep_talloc == NULL)
 426                 return;
 427
 428         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
 429         if (dep_samba_dcerpc_base == NULL)
 430                 return;
 431
 432         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
 433         if (Object_Type == NULL)
 434                 return;
 435
 436         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
 437         if (ClientConnection_Type == NULL)
 438                 return;
 439
 440         sign_request_Type.tp_base = Object_Type;
 441
 442         signed_reply_Type.tp_base = Object_Type;
 443
 444         ntp_signd_InterfaceType.tp_base = ClientConnection_Type;
 445
 446         if (PyType_Ready(&sign_request_Type) < 0)
 447                 return;
 448         if (PyType_Ready(&signed_reply_Type) < 0)
 449                 return;
 450         if (PyType_Ready(&ntp_signd_InterfaceType) < 0)
 451                 return;
 452         if (!PyInterface_AddNdrRpcMethods(&ntp_signd_InterfaceType, py_ndr_ntp_signd_methods))
 453                 return;
 454
 455 #ifdef PY_SIGN_REQUEST_PATCH
 456         PY_SIGN_REQUEST_PATCH(&sign_request_Type);
 457 #endif
 458 #ifdef PY_SIGNED_REPLY_PATCH
 459         PY_SIGNED_REPLY_PATCH(&signed_reply_Type);
 460 #endif
 461 #ifdef PY_NTP_SIGND_PATCH
 462         PY_NTP_SIGND_PATCH(&ntp_signd_InterfaceType);
 463 #endif
 464
 465         m = Py_InitModule3("ntp_signd", ntp_signd_methods, "ntp_signd DCE/RPC");
 466         if (m == NULL)
 467                 return;
 468
 469         PyModule_AddObject(m, "SIGNING_SUCCESS", PyInt_FromLong(SIGNING_SUCCESS));
 470         PyModule_AddObject(m, "SIGN_TO_CLIENT", PyInt_FromLong(SIGN_TO_CLIENT));
 471         PyModule_AddObject(m, "NTP_SIGND_PROTOCOL_VERSION_0", PyInt_FromLong(0));
 472         PyModule_AddObject(m, "SIGNING_FAILURE", PyInt_FromLong(SIGNING_FAILURE));
 473         PyModule_AddObject(m, "CHECK_SERVER_SIGNATURE", PyInt_FromLong(CHECK_SERVER_SIGNATURE));
 474         PyModule_AddObject(m, "ASK_SERVER_TO_SIGN", PyInt_FromLong(ASK_SERVER_TO_SIGN));
 475         Py_INCREF((PyObject *)(void *)&sign_request_Type);
 476         PyModule_AddObject(m, "sign_request", (PyObject *)(void *)&sign_request_Type);
 477         Py_INCREF((PyObject *)(void *)&signed_reply_Type);
 478         PyModule_AddObject(m, "signed_reply", (PyObject *)(void *)&signed_reply_Type);
 479         Py_INCREF((PyObject *)(void *)&ntp_signd_InterfaceType);
 480         PyModule_AddObject(m, "ntp_signd", (PyObject *)(void *)&ntp_signd_InterfaceType);
 481 #ifdef PY_MOD_NTP_SIGND_PATCH
 482         PY_MOD_NTP_SIGND_PATCH(m);
 483 #endif
 484
 485 }