bin/default/librpc/gen_ndr/py_dsbackup.c

   1
   2 /* Python wrapper functions auto-generated by pidl */
   3 #define PY_SSIZE_T_CLEAN 1 /* We use Py_ssize_t for PyArg_ParseTupleAndKeywords */
   4 #include <Python.h>
   5 #include "includes.h"
   6 #include <pytalloc.h>
   7 #include "librpc/rpc/pyrpc.h"
   8 #include "librpc/rpc/pyrpc_util.h"
   9 #include "bin/default/librpc/gen_ndr/ndr_dsbackup.h"
  10 #include "bin/default/librpc/gen_ndr/ndr_dsbackup_c.h"
  11
  12 /*
  13  * These functions are here to ensure they can be optimized out by
  14  * the compiler based on the constant input values
  15  */
  16
  17 static inline unsigned long long ndr_sizeof2uintmax(size_t var_size)
  18 {
  19         switch (var_size) {
  20         case 8:
  21                 return UINT64_MAX;
  22         case 4:
  23                 return UINT32_MAX;
  24         case 2:
  25                 return UINT16_MAX;
  26         case 1:
  27                 return UINT8_MAX;
  28         }
  29
  30         return 0;
  31 }
  32
  33 static inline long long ndr_sizeof2intmax(size_t var_size)
  34 {
  35         switch (var_size) {
  36         case 8:
  37                 return INT64_MAX;
  38         case 4:
  39                 return INT32_MAX;
  40         case 2:
  41                 return INT16_MAX;
  42         case 1:
  43                 return INT8_MAX;
  44         }
  45
  46         return 0;
  47 }
  48
  49 static inline PyObject *ndr_PyLong_FromLongLong(long long v)
  50 {
  51         if (v > LONG_MAX || v < LONG_MIN) {
  52                 return PyLong_FromLongLong(v);
  53         } else {
  54                 return PyInt_FromLong(v);
  55         }
  56 }
  57
  58 static inline PyObject *ndr_PyLong_FromUnsignedLongLong(unsigned long long v)
  59 {
  60         if (v > LONG_MAX) {
  61                 return PyLong_FromUnsignedLongLong(v);
  62         } else {
  63                 return PyInt_FromLong(v);
  64         }
  65 }
  66
  67 static PyTypeObject ad_backup_InterfaceType;
  68
  69 static PyTypeObject ad_restore_InterfaceType;
  70
  71 void initdsbackup(void);static PyTypeObject *ClientConnection_Type;
  72 static PyTypeObject *ndr_syntax_id_Type;
  73
  74 const struct PyNdrRpcMethodDef py_ndr_ad_backup_methods[] = {
  75         { NULL }
  76 };
  77
  78 static PyObject *interface_ad_backup_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
  79 {
  80         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_ad_backup);
  81 }
  82
  83 #define PY_DOC_AD_BACKUP "Backup support for Active Directory"
  84 static PyTypeObject ad_backup_InterfaceType = {
  85         PyObject_HEAD_INIT(NULL) 0,
  86         .tp_name = "dsbackup.ad_backup",
  87         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
  88         .tp_doc = "ad_backup(binding, lp_ctx=None, credentials=None) -> connection\n"
  89 "\n"
  90 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
  91 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
  92 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_AD_BACKUP,
  93         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  94         .tp_new = interface_ad_backup_new,
  95 };
  96
  97 static PyObject *syntax_ad_backup_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
  98 {
  99         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_ad_backup.syntax_id);
 100 }
 101
 102 #define PY_DOC_AD_BACKUP_SYNTAX "Backup support for Active Directory"
 103 static PyTypeObject ad_backup_SyntaxType = {
 104         PyObject_HEAD_INIT(NULL) 0,
 105         .tp_name = "dsbackup.ad_backup",
 106         .tp_doc = "abstract_syntax()\n"PY_DOC_AD_BACKUP_SYNTAX,
 107         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 108         .tp_new = syntax_ad_backup_new,
 109 };
 110
 111
 112 const struct PyNdrRpcMethodDef py_ndr_ad_restore_methods[] = {
 113         { NULL }
 114 };
 115
 116 static PyObject *interface_ad_restore_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 117 {
 118         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_ad_restore);
 119 }
 120
 121 #define PY_DOC_AD_RESTORE "Restoring Active Directory backups"
 122 static PyTypeObject ad_restore_InterfaceType = {
 123         PyObject_HEAD_INIT(NULL) 0,
 124         .tp_name = "dsbackup.ad_restore",
 125         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
 126         .tp_doc = "ad_restore(binding, lp_ctx=None, credentials=None) -> connection\n"
 127 "\n"
 128 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
 129 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
 130 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_AD_RESTORE,
 131         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 132         .tp_new = interface_ad_restore_new,
 133 };
 134
 135 static PyObject *syntax_ad_restore_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 136 {
 137         return py_dcerpc_syntax_init_helper(type, args, kwargs, &ndr_table_ad_restore.syntax_id);
 138 }
 139
 140 #define PY_DOC_AD_RESTORE_SYNTAX "Restoring Active Directory backups"
 141 static PyTypeObject ad_restore_SyntaxType = {
 142         PyObject_HEAD_INIT(NULL) 0,
 143         .tp_name = "dsbackup.ad_restore",
 144         .tp_doc = "abstract_syntax()\n"PY_DOC_AD_RESTORE_SYNTAX,
 145         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 146         .tp_new = syntax_ad_restore_new,
 147 };
 148
 149 static PyMethodDef dsbackup_methods[] = {
 150         { NULL, NULL, 0, NULL }
 151 };
 152
 153 void initdsbackup(void)
 154 {
 155         PyObject *m;
 156         PyObject *dep_samba_dcerpc_base;
 157         PyObject *dep_samba_dcerpc_misc;
 158
 159         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
 160         if (dep_samba_dcerpc_base == NULL)
 161                 return;
 162
 163         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
 164         if (dep_samba_dcerpc_misc == NULL)
 165                 return;
 166
 167         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
 168         if (ClientConnection_Type == NULL)
 169                 return;
 170
 171         ndr_syntax_id_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "ndr_syntax_id");
 172         if (ndr_syntax_id_Type == NULL)
 173                 return;
 174
 175         ad_backup_InterfaceType.tp_base = ClientConnection_Type;
 176
 177         ad_backup_SyntaxType.tp_base = ndr_syntax_id_Type;
 178         ad_backup_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();
 179
 180         ad_restore_InterfaceType.tp_base = ClientConnection_Type;
 181
 182         ad_restore_SyntaxType.tp_base = ndr_syntax_id_Type;
 183         ad_restore_SyntaxType.tp_basicsize = pytalloc_BaseObject_size();
 184
 185         if (PyType_Ready(&ad_backup_InterfaceType) < 0)
 186                 return;
 187         if (PyType_Ready(&ad_backup_SyntaxType) < 0)
 188                 return;
 189         if (PyType_Ready(&ad_restore_InterfaceType) < 0)
 190                 return;
 191         if (PyType_Ready(&ad_restore_SyntaxType) < 0)
 192                 return;
 193         if (!PyInterface_AddNdrRpcMethods(&ad_backup_InterfaceType, py_ndr_ad_backup_methods))
 194                 return;
 195
 196         if (!PyInterface_AddNdrRpcMethods(&ad_restore_InterfaceType, py_ndr_ad_restore_methods))
 197                 return;
 198
 199 #ifdef PY_AD_BACKUP_PATCH
 200         PY_AD_BACKUP_PATCH(&ad_backup_InterfaceType);
 201 #endif
 202 #ifdef PY_ABSTRACT_SYNTAX_PATCH
 203         PY_ABSTRACT_SYNTAX_PATCH(&ad_backup_SyntaxType);
 204 #endif
 205 #ifdef PY_AD_RESTORE_PATCH
 206         PY_AD_RESTORE_PATCH(&ad_restore_InterfaceType);
 207 #endif
 208 #ifdef PY_ABSTRACT_SYNTAX_PATCH
 209         PY_ABSTRACT_SYNTAX_PATCH(&ad_restore_SyntaxType);
 210 #endif
 211
 212         m = Py_InitModule3("dsbackup", dsbackup_methods, "dsbackup DCE/RPC");
 213         if (m == NULL)
 214                 return;
 215
 216         Py_INCREF((PyObject *)(void *)&ad_backup_InterfaceType);
 217         PyModule_AddObject(m, "ad_backup", (PyObject *)(void *)&ad_backup_InterfaceType);
 218         Py_INCREF((PyObject *)(void *)&ad_backup_SyntaxType);
 219         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&ad_backup_SyntaxType);
 220         Py_INCREF((PyObject *)(void *)&ad_restore_InterfaceType);
 221         PyModule_AddObject(m, "ad_restore", (PyObject *)(void *)&ad_restore_InterfaceType);
 222         Py_INCREF((PyObject *)(void *)&ad_restore_SyntaxType);
 223         PyModule_AddObject(m, "abstract_syntax", (PyObject *)(void *)&ad_restore_SyntaxType);
 224 #ifdef PY_MOD_DSBACKUP_PATCH
 225         PY_MOD_DSBACKUP_PATCH(m);
 226 #endif
 227
 228 }