bin.gen_ndr/default/librpc/gen_ndr/py_frsrpc.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/librpc/gen_ndr/ndr_frsrpc.h"
   9 #include "bin/default/librpc/gen_ndr/ndr_frsrpc_c.h"
  10
  11 #include "librpc/gen_ndr/misc.h"
  12 staticforward PyTypeObject frsrpc_CommPktChunkGuidName_Type;
  13 staticforward PyTypeObject frsrpc_CommPktGSVN_Type;
  14 staticforward PyTypeObject frsrpc_CommPktChangeOrderCommand_Type;
  15 staticforward PyTypeObject frsrpc_CommPktDataExtensionChecksum_Type;
  16 staticforward PyTypeObject frsrpc_CommPktDataExtensionRetryTimeout_Type;
  17 staticforward PyTypeObject frsrpc_CommPktCoRecordExtensionWin2k_Type;
  18 staticforward PyTypeObject frsrpc_CommPktChangeOrderRecordExtension_Type;
  19 staticforward PyTypeObject frsrpc_CommPktChunk_Type;
  20 staticforward PyTypeObject frsrpc_CommPktChunkCtr_Type;
  21 staticforward PyTypeObject frsrpc_FrsSendCommPktReq_Type;
  22 staticforward PyTypeObject frsrpc_InterfaceType;
  23
  24 void initfrsrpc(void);static PyTypeObject *Object_Type;
  25 static PyTypeObject *GUID_Type;
  26 static PyTypeObject *ClientConnection_Type;
  27
  28 static PyObject *py_frsrpc_CommPktChunkGuidName_get_guid(PyObject *obj, void *closure)
  29 {
  30         struct frsrpc_CommPktChunkGuidName *object = (struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(obj);
  31         PyObject *py_guid;
  32         py_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->guid);
  33         return py_guid;
  34 }
  35
  36 static int py_frsrpc_CommPktChunkGuidName_set_guid(PyObject *py_obj, PyObject *value, void *closure)
  37 {
  38         struct frsrpc_CommPktChunkGuidName *object = (struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(py_obj);
  39         PY_CHECK_TYPE(GUID_Type, value, return -1;);
  40         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
  41                 PyErr_NoMemory();
  42                 return -1;
  43         }
  44         object->guid = *(struct GUID *)pytalloc_get_ptr(value);
  45         return 0;
  46 }
  47
  48 static PyObject *py_frsrpc_CommPktChunkGuidName_get_name(PyObject *obj, void *closure)
  49 {
  50         struct frsrpc_CommPktChunkGuidName *object = (struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(obj);
  51         PyObject *py_name;
  52         py_name = PyString_FromStringOrNULL(object->name);
  53         return py_name;
  54 }
  55
  56 static int py_frsrpc_CommPktChunkGuidName_set_name(PyObject *py_obj, PyObject *value, void *closure)
  57 {
  58         struct frsrpc_CommPktChunkGuidName *object = (struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(py_obj);
  59         object->name = talloc_strdup(pytalloc_get_mem_ctx(py_obj), PyString_AS_STRING(value));
  60         return 0;
  61 }
  62
  63 static PyGetSetDef py_frsrpc_CommPktChunkGuidName_getsetters[] = {
  64         { discard_const_p(char, "guid"), py_frsrpc_CommPktChunkGuidName_get_guid, py_frsrpc_CommPktChunkGuidName_set_guid },
  65         { discard_const_p(char, "name"), py_frsrpc_CommPktChunkGuidName_get_name, py_frsrpc_CommPktChunkGuidName_set_name },
  66         { NULL }
  67 };
  68
  69 static PyObject *py_frsrpc_CommPktChunkGuidName_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
  70 {
  71         return pytalloc_new(struct frsrpc_CommPktChunkGuidName, type);
  72 }
  73
  74
  75 static PyTypeObject frsrpc_CommPktChunkGuidName_Type = {
  76         PyObject_HEAD_INIT(NULL) 0,
  77         .tp_name = "frsrpc.CommPktChunkGuidName",
  78         .tp_getset = py_frsrpc_CommPktChunkGuidName_getsetters,
  79         .tp_methods = NULL,
  80         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  81         .tp_basicsize = sizeof(pytalloc_Object),
  82         .tp_new = py_frsrpc_CommPktChunkGuidName_new,
  83 };
  84
  85
  86 static PyObject *py_frsrpc_CommPktGSVN_get_vsn(PyObject *obj, void *closure)
  87 {
  88         struct frsrpc_CommPktGSVN *object = (struct frsrpc_CommPktGSVN *)pytalloc_get_ptr(obj);
  89         PyObject *py_vsn;
  90         py_vsn = PyLong_FromLongLong(object->vsn);
  91         return py_vsn;
  92 }
  93
  94 static int py_frsrpc_CommPktGSVN_set_vsn(PyObject *py_obj, PyObject *value, void *closure)
  95 {
  96         struct frsrpc_CommPktGSVN *object = (struct frsrpc_CommPktGSVN *)pytalloc_get_ptr(py_obj);
  97         if (PyLong_Check(value)) {
  98                 object->vsn = PyLong_AsLongLong(value);
  99         } else if (PyInt_Check(value)) {
 100                 object->vsn = PyInt_AsLong(value);
 101         } else {
 102                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 103                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 104                 return -1;
 105         }
 106         return 0;
 107 }
 108
 109 static PyObject *py_frsrpc_CommPktGSVN_get_guid(PyObject *obj, void *closure)
 110 {
 111         struct frsrpc_CommPktGSVN *object = (struct frsrpc_CommPktGSVN *)pytalloc_get_ptr(obj);
 112         PyObject *py_guid;
 113         py_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->guid);
 114         return py_guid;
 115 }
 116
 117 static int py_frsrpc_CommPktGSVN_set_guid(PyObject *py_obj, PyObject *value, void *closure)
 118 {
 119         struct frsrpc_CommPktGSVN *object = (struct frsrpc_CommPktGSVN *)pytalloc_get_ptr(py_obj);
 120         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 121         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 122                 PyErr_NoMemory();
 123                 return -1;
 124         }
 125         object->guid = *(struct GUID *)pytalloc_get_ptr(value);
 126         return 0;
 127 }
 128
 129 static PyGetSetDef py_frsrpc_CommPktGSVN_getsetters[] = {
 130         { discard_const_p(char, "vsn"), py_frsrpc_CommPktGSVN_get_vsn, py_frsrpc_CommPktGSVN_set_vsn },
 131         { discard_const_p(char, "guid"), py_frsrpc_CommPktGSVN_get_guid, py_frsrpc_CommPktGSVN_set_guid },
 132         { NULL }
 133 };
 134
 135 static PyObject *py_frsrpc_CommPktGSVN_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 136 {
 137         return pytalloc_new(struct frsrpc_CommPktGSVN, type);
 138 }
 139
 140
 141 static PyTypeObject frsrpc_CommPktGSVN_Type = {
 142         PyObject_HEAD_INIT(NULL) 0,
 143         .tp_name = "frsrpc.CommPktGSVN",
 144         .tp_getset = py_frsrpc_CommPktGSVN_getsetters,
 145         .tp_methods = NULL,
 146         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 147         .tp_basicsize = sizeof(pytalloc_Object),
 148         .tp_new = py_frsrpc_CommPktGSVN_new,
 149 };
 150
 151
 152 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_sequence_number(PyObject *obj, void *closure)
 153 {
 154         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 155         PyObject *py_sequence_number;
 156         py_sequence_number = PyInt_FromLong(object->sequence_number);
 157         return py_sequence_number;
 158 }
 159
 160 static int py_frsrpc_CommPktChangeOrderCommand_set_sequence_number(PyObject *py_obj, PyObject *value, void *closure)
 161 {
 162         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 163         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 164         object->sequence_number = PyInt_AsLong(value);
 165         return 0;
 166 }
 167
 168 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_flags(PyObject *obj, void *closure)
 169 {
 170         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 171         PyObject *py_flags;
 172         py_flags = PyInt_FromLong(object->flags);
 173         return py_flags;
 174 }
 175
 176 static int py_frsrpc_CommPktChangeOrderCommand_set_flags(PyObject *py_obj, PyObject *value, void *closure)
 177 {
 178         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 179         if (PyLong_Check(value)) {
 180                 object->flags = PyLong_AsLongLong(value);
 181         } else if (PyInt_Check(value)) {
 182                 object->flags = PyInt_AsLong(value);
 183         } else {
 184                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 185                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 186                 return -1;
 187         }
 188         return 0;
 189 }
 190
 191 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_iflags(PyObject *obj, void *closure)
 192 {
 193         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 194         PyObject *py_iflags;
 195         py_iflags = PyInt_FromLong(object->iflags);
 196         return py_iflags;
 197 }
 198
 199 static int py_frsrpc_CommPktChangeOrderCommand_set_iflags(PyObject *py_obj, PyObject *value, void *closure)
 200 {
 201         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 202         if (PyLong_Check(value)) {
 203                 object->iflags = PyLong_AsLongLong(value);
 204         } else if (PyInt_Check(value)) {
 205                 object->iflags = PyInt_AsLong(value);
 206         } else {
 207                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 208                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 209                 return -1;
 210         }
 211         return 0;
 212 }
 213
 214 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_status(PyObject *obj, void *closure)
 215 {
 216         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 217         PyObject *py_status;
 218         py_status = PyInt_FromLong(object->status);
 219         return py_status;
 220 }
 221
 222 static int py_frsrpc_CommPktChangeOrderCommand_set_status(PyObject *py_obj, PyObject *value, void *closure)
 223 {
 224         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 225         if (PyLong_Check(value)) {
 226                 object->status = PyLong_AsLongLong(value);
 227         } else if (PyInt_Check(value)) {
 228                 object->status = PyInt_AsLong(value);
 229         } else {
 230                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 231                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 232                 return -1;
 233         }
 234         return 0;
 235 }
 236
 237 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_content_cmd(PyObject *obj, void *closure)
 238 {
 239         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 240         PyObject *py_content_cmd;
 241         py_content_cmd = PyInt_FromLong(object->content_cmd);
 242         return py_content_cmd;
 243 }
 244
 245 static int py_frsrpc_CommPktChangeOrderCommand_set_content_cmd(PyObject *py_obj, PyObject *value, void *closure)
 246 {
 247         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 248         if (PyLong_Check(value)) {
 249                 object->content_cmd = PyLong_AsLongLong(value);
 250         } else if (PyInt_Check(value)) {
 251                 object->content_cmd = PyInt_AsLong(value);
 252         } else {
 253                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 254                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 255                 return -1;
 256         }
 257         return 0;
 258 }
 259
 260 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_location_cmd(PyObject *obj, void *closure)
 261 {
 262         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 263         PyObject *py_location_cmd;
 264         py_location_cmd = PyInt_FromLong(object->location_cmd);
 265         return py_location_cmd;
 266 }
 267
 268 static int py_frsrpc_CommPktChangeOrderCommand_set_location_cmd(PyObject *py_obj, PyObject *value, void *closure)
 269 {
 270         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 271         if (PyLong_Check(value)) {
 272                 object->location_cmd = PyLong_AsLongLong(value);
 273         } else if (PyInt_Check(value)) {
 274                 object->location_cmd = PyInt_AsLong(value);
 275         } else {
 276                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 277                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 278                 return -1;
 279         }
 280         return 0;
 281 }
 282
 283 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_attributes(PyObject *obj, void *closure)
 284 {
 285         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 286         PyObject *py_file_attributes;
 287         py_file_attributes = PyInt_FromLong(object->file_attributes);
 288         return py_file_attributes;
 289 }
 290
 291 static int py_frsrpc_CommPktChangeOrderCommand_set_file_attributes(PyObject *py_obj, PyObject *value, void *closure)
 292 {
 293         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 294         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 295         object->file_attributes = PyInt_AsLong(value);
 296         return 0;
 297 }
 298
 299 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_version_number(PyObject *obj, void *closure)
 300 {
 301         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 302         PyObject *py_file_version_number;
 303         py_file_version_number = PyInt_FromLong(object->file_version_number);
 304         return py_file_version_number;
 305 }
 306
 307 static int py_frsrpc_CommPktChangeOrderCommand_set_file_version_number(PyObject *py_obj, PyObject *value, void *closure)
 308 {
 309         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 310         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 311         object->file_version_number = PyInt_AsLong(value);
 312         return 0;
 313 }
 314
 315 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_partern_ack_sequence_number(PyObject *obj, void *closure)
 316 {
 317         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 318         PyObject *py_partern_ack_sequence_number;
 319         py_partern_ack_sequence_number = PyInt_FromLong(object->partern_ack_sequence_number);
 320         return py_partern_ack_sequence_number;
 321 }
 322
 323 static int py_frsrpc_CommPktChangeOrderCommand_set_partern_ack_sequence_number(PyObject *py_obj, PyObject *value, void *closure)
 324 {
 325         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 326         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 327         object->partern_ack_sequence_number = PyInt_AsLong(value);
 328         return 0;
 329 }
 330
 331 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_not_used(PyObject *obj, void *closure)
 332 {
 333         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 334         PyObject *py_not_used;
 335         py_not_used = PyInt_FromLong(object->not_used);
 336         return py_not_used;
 337 }
 338
 339 static int py_frsrpc_CommPktChangeOrderCommand_set_not_used(PyObject *py_obj, PyObject *value, void *closure)
 340 {
 341         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 342         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 343         object->not_used = PyInt_AsLong(value);
 344         return 0;
 345 }
 346
 347 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_size(PyObject *obj, void *closure)
 348 {
 349         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 350         PyObject *py_file_size;
 351         py_file_size = PyLong_FromLongLong(object->file_size);
 352         return py_file_size;
 353 }
 354
 355 static int py_frsrpc_CommPktChangeOrderCommand_set_file_size(PyObject *py_obj, PyObject *value, void *closure)
 356 {
 357         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 358         if (PyLong_Check(value)) {
 359                 object->file_size = PyLong_AsLongLong(value);
 360         } else if (PyInt_Check(value)) {
 361                 object->file_size = PyInt_AsLong(value);
 362         } else {
 363                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 364                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 365                 return -1;
 366         }
 367         return 0;
 368 }
 369
 370 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_offset(PyObject *obj, void *closure)
 371 {
 372         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 373         PyObject *py_file_offset;
 374         py_file_offset = PyLong_FromLongLong(object->file_offset);
 375         return py_file_offset;
 376 }
 377
 378 static int py_frsrpc_CommPktChangeOrderCommand_set_file_offset(PyObject *py_obj, PyObject *value, void *closure)
 379 {
 380         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 381         if (PyLong_Check(value)) {
 382                 object->file_offset = PyLong_AsLongLong(value);
 383         } else if (PyInt_Check(value)) {
 384                 object->file_offset = PyInt_AsLong(value);
 385         } else {
 386                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 387                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 388                 return -1;
 389         }
 390         return 0;
 391 }
 392
 393 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_frs_vsn(PyObject *obj, void *closure)
 394 {
 395         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 396         PyObject *py_frs_vsn;
 397         py_frs_vsn = PyLong_FromLongLong(object->frs_vsn);
 398         return py_frs_vsn;
 399 }
 400
 401 static int py_frsrpc_CommPktChangeOrderCommand_set_frs_vsn(PyObject *py_obj, PyObject *value, void *closure)
 402 {
 403         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 404         if (PyLong_Check(value)) {
 405                 object->frs_vsn = PyLong_AsLongLong(value);
 406         } else if (PyInt_Check(value)) {
 407                 object->frs_vsn = PyInt_AsLong(value);
 408         } else {
 409                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 410                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 411                 return -1;
 412         }
 413         return 0;
 414 }
 415
 416 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_usn(PyObject *obj, void *closure)
 417 {
 418         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 419         PyObject *py_file_usn;
 420         py_file_usn = PyLong_FromLongLong(object->file_usn);
 421         return py_file_usn;
 422 }
 423
 424 static int py_frsrpc_CommPktChangeOrderCommand_set_file_usn(PyObject *py_obj, PyObject *value, void *closure)
 425 {
 426         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 427         if (PyLong_Check(value)) {
 428                 object->file_usn = PyLong_AsLongLong(value);
 429         } else if (PyInt_Check(value)) {
 430                 object->file_usn = PyInt_AsLong(value);
 431         } else {
 432                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 433                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 434                 return -1;
 435         }
 436         return 0;
 437 }
 438
 439 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_jrnl_usn(PyObject *obj, void *closure)
 440 {
 441         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 442         PyObject *py_jrnl_usn;
 443         py_jrnl_usn = PyLong_FromLongLong(object->jrnl_usn);
 444         return py_jrnl_usn;
 445 }
 446
 447 static int py_frsrpc_CommPktChangeOrderCommand_set_jrnl_usn(PyObject *py_obj, PyObject *value, void *closure)
 448 {
 449         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 450         if (PyLong_Check(value)) {
 451                 object->jrnl_usn = PyLong_AsLongLong(value);
 452         } else if (PyInt_Check(value)) {
 453                 object->jrnl_usn = PyInt_AsLong(value);
 454         } else {
 455                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 456                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 457                 return -1;
 458         }
 459         return 0;
 460 }
 461
 462 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_jrnl_first_usn(PyObject *obj, void *closure)
 463 {
 464         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 465         PyObject *py_jrnl_first_usn;
 466         py_jrnl_first_usn = PyLong_FromLongLong(object->jrnl_first_usn);
 467         return py_jrnl_first_usn;
 468 }
 469
 470 static int py_frsrpc_CommPktChangeOrderCommand_set_jrnl_first_usn(PyObject *py_obj, PyObject *value, void *closure)
 471 {
 472         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 473         if (PyLong_Check(value)) {
 474                 object->jrnl_first_usn = PyLong_AsLongLong(value);
 475         } else if (PyInt_Check(value)) {
 476                 object->jrnl_first_usn = PyInt_AsLong(value);
 477         } else {
 478                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 479                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 480                 return -1;
 481         }
 482         return 0;
 483 }
 484
 485 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_original_replica_num(PyObject *obj, void *closure)
 486 {
 487         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 488         PyObject *py_original_replica_num;
 489         py_original_replica_num = PyInt_FromLong(object->original_replica_num);
 490         return py_original_replica_num;
 491 }
 492
 493 static int py_frsrpc_CommPktChangeOrderCommand_set_original_replica_num(PyObject *py_obj, PyObject *value, void *closure)
 494 {
 495         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 496         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 497         object->original_replica_num = PyInt_AsLong(value);
 498         return 0;
 499 }
 500
 501 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_new_replica_num(PyObject *obj, void *closure)
 502 {
 503         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 504         PyObject *py_new_replica_num;
 505         py_new_replica_num = PyInt_FromLong(object->new_replica_num);
 506         return py_new_replica_num;
 507 }
 508
 509 static int py_frsrpc_CommPktChangeOrderCommand_set_new_replica_num(PyObject *py_obj, PyObject *value, void *closure)
 510 {
 511         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 512         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 513         object->new_replica_num = PyInt_AsLong(value);
 514         return 0;
 515 }
 516
 517 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_change_order_guid(PyObject *obj, void *closure)
 518 {
 519         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 520         PyObject *py_change_order_guid;
 521         py_change_order_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->change_order_guid);
 522         return py_change_order_guid;
 523 }
 524
 525 static int py_frsrpc_CommPktChangeOrderCommand_set_change_order_guid(PyObject *py_obj, PyObject *value, void *closure)
 526 {
 527         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 528         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 529         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 530                 PyErr_NoMemory();
 531                 return -1;
 532         }
 533         object->change_order_guid = *(struct GUID *)pytalloc_get_ptr(value);
 534         return 0;
 535 }
 536
 537 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_originator_guid(PyObject *obj, void *closure)
 538 {
 539         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 540         PyObject *py_originator_guid;
 541         py_originator_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->originator_guid);
 542         return py_originator_guid;
 543 }
 544
 545 static int py_frsrpc_CommPktChangeOrderCommand_set_originator_guid(PyObject *py_obj, PyObject *value, void *closure)
 546 {
 547         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 548         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 549         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 550                 PyErr_NoMemory();
 551                 return -1;
 552         }
 553         object->originator_guid = *(struct GUID *)pytalloc_get_ptr(value);
 554         return 0;
 555 }
 556
 557 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_guid(PyObject *obj, void *closure)
 558 {
 559         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 560         PyObject *py_file_guid;
 561         py_file_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->file_guid);
 562         return py_file_guid;
 563 }
 564
 565 static int py_frsrpc_CommPktChangeOrderCommand_set_file_guid(PyObject *py_obj, PyObject *value, void *closure)
 566 {
 567         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 568         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 569         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 570                 PyErr_NoMemory();
 571                 return -1;
 572         }
 573         object->file_guid = *(struct GUID *)pytalloc_get_ptr(value);
 574         return 0;
 575 }
 576
 577 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_old_parent_guid(PyObject *obj, void *closure)
 578 {
 579         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 580         PyObject *py_old_parent_guid;
 581         py_old_parent_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->old_parent_guid);
 582         return py_old_parent_guid;
 583 }
 584
 585 static int py_frsrpc_CommPktChangeOrderCommand_set_old_parent_guid(PyObject *py_obj, PyObject *value, void *closure)
 586 {
 587         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 588         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 589         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 590                 PyErr_NoMemory();
 591                 return -1;
 592         }
 593         object->old_parent_guid = *(struct GUID *)pytalloc_get_ptr(value);
 594         return 0;
 595 }
 596
 597 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_new_parent_guid(PyObject *obj, void *closure)
 598 {
 599         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 600         PyObject *py_new_parent_guid;
 601         py_new_parent_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->new_parent_guid);
 602         return py_new_parent_guid;
 603 }
 604
 605 static int py_frsrpc_CommPktChangeOrderCommand_set_new_parent_guid(PyObject *py_obj, PyObject *value, void *closure)
 606 {
 607         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 608         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 609         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 610                 PyErr_NoMemory();
 611                 return -1;
 612         }
 613         object->new_parent_guid = *(struct GUID *)pytalloc_get_ptr(value);
 614         return 0;
 615 }
 616
 617 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_connection_guid(PyObject *obj, void *closure)
 618 {
 619         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 620         PyObject *py_connection_guid;
 621         py_connection_guid = pytalloc_reference_ex(GUID_Type, pytalloc_get_mem_ctx(obj), &object->connection_guid);
 622         return py_connection_guid;
 623 }
 624
 625 static int py_frsrpc_CommPktChangeOrderCommand_set_connection_guid(PyObject *py_obj, PyObject *value, void *closure)
 626 {
 627         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 628         PY_CHECK_TYPE(GUID_Type, value, return -1;);
 629         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
 630                 PyErr_NoMemory();
 631                 return -1;
 632         }
 633         object->connection_guid = *(struct GUID *)pytalloc_get_ptr(value);
 634         return 0;
 635 }
 636
 637 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_ack_version(PyObject *obj, void *closure)
 638 {
 639         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 640         PyObject *py_ack_version;
 641         py_ack_version = PyLong_FromLongLong(object->ack_version);
 642         return py_ack_version;
 643 }
 644
 645 static int py_frsrpc_CommPktChangeOrderCommand_set_ack_version(PyObject *py_obj, PyObject *value, void *closure)
 646 {
 647         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 648         if (PyLong_Check(value)) {
 649                 object->ack_version = PyLong_AsLongLong(value);
 650         } else if (PyInt_Check(value)) {
 651                 object->ack_version = PyInt_AsLong(value);
 652         } else {
 653                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 654                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 655                 return -1;
 656         }
 657         return 0;
 658 }
 659
 660 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare2ul1(PyObject *obj, void *closure)
 661 {
 662         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 663         PyObject *py_spare2ul1;
 664         py_spare2ul1 = PyLong_FromLongLong(object->spare2ul1);
 665         return py_spare2ul1;
 666 }
 667
 668 static int py_frsrpc_CommPktChangeOrderCommand_set_spare2ul1(PyObject *py_obj, PyObject *value, void *closure)
 669 {
 670         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 671         if (PyLong_Check(value)) {
 672                 object->spare2ul1 = PyLong_AsLongLong(value);
 673         } else if (PyInt_Check(value)) {
 674                 object->spare2ul1 = PyInt_AsLong(value);
 675         } else {
 676                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 677                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 678                 return -1;
 679         }
 680         return 0;
 681 }
 682
 683 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare1guid_p1(PyObject *obj, void *closure)
 684 {
 685         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 686         PyObject *py_spare1guid_p1;
 687         py_spare1guid_p1 = PyLong_FromLongLong(object->spare1guid_p1);
 688         return py_spare1guid_p1;
 689 }
 690
 691 static int py_frsrpc_CommPktChangeOrderCommand_set_spare1guid_p1(PyObject *py_obj, PyObject *value, void *closure)
 692 {
 693         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 694         if (PyLong_Check(value)) {
 695                 object->spare1guid_p1 = PyLong_AsLongLong(value);
 696         } else if (PyInt_Check(value)) {
 697                 object->spare1guid_p1 = PyInt_AsLong(value);
 698         } else {
 699                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 700                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 701                 return -1;
 702         }
 703         return 0;
 704 }
 705
 706 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare1guid_p2(PyObject *obj, void *closure)
 707 {
 708         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 709         PyObject *py_spare1guid_p2;
 710         py_spare1guid_p2 = PyLong_FromLongLong(object->spare1guid_p2);
 711         return py_spare1guid_p2;
 712 }
 713
 714 static int py_frsrpc_CommPktChangeOrderCommand_set_spare1guid_p2(PyObject *py_obj, PyObject *value, void *closure)
 715 {
 716         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 717         if (PyLong_Check(value)) {
 718                 object->spare1guid_p2 = PyLong_AsLongLong(value);
 719         } else if (PyInt_Check(value)) {
 720                 object->spare1guid_p2 = PyInt_AsLong(value);
 721         } else {
 722                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 723                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 724                 return -1;
 725         }
 726         return 0;
 727 }
 728
 729 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare2guid_p1(PyObject *obj, void *closure)
 730 {
 731         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 732         PyObject *py_spare2guid_p1;
 733         py_spare2guid_p1 = PyLong_FromLongLong(object->spare2guid_p1);
 734         return py_spare2guid_p1;
 735 }
 736
 737 static int py_frsrpc_CommPktChangeOrderCommand_set_spare2guid_p1(PyObject *py_obj, PyObject *value, void *closure)
 738 {
 739         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 740         if (PyLong_Check(value)) {
 741                 object->spare2guid_p1 = PyLong_AsLongLong(value);
 742         } else if (PyInt_Check(value)) {
 743                 object->spare2guid_p1 = PyInt_AsLong(value);
 744         } else {
 745                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 746                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 747                 return -1;
 748         }
 749         return 0;
 750 }
 751
 752 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare3guid_p2(PyObject *obj, void *closure)
 753 {
 754         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 755         PyObject *py_spare3guid_p2;
 756         py_spare3guid_p2 = PyLong_FromLongLong(object->spare3guid_p2);
 757         return py_spare3guid_p2;
 758 }
 759
 760 static int py_frsrpc_CommPktChangeOrderCommand_set_spare3guid_p2(PyObject *py_obj, PyObject *value, void *closure)
 761 {
 762         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 763         if (PyLong_Check(value)) {
 764                 object->spare3guid_p2 = PyLong_AsLongLong(value);
 765         } else if (PyInt_Check(value)) {
 766                 object->spare3guid_p2 = PyInt_AsLong(value);
 767         } else {
 768                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 769                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 770                 return -1;
 771         }
 772         return 0;
 773 }
 774
 775 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare1wcs(PyObject *obj, void *closure)
 776 {
 777         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 778         PyObject *py_spare1wcs;
 779         py_spare1wcs = PyInt_FromLong(object->spare1wcs);
 780         return py_spare1wcs;
 781 }
 782
 783 static int py_frsrpc_CommPktChangeOrderCommand_set_spare1wcs(PyObject *py_obj, PyObject *value, void *closure)
 784 {
 785         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 786         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 787         object->spare1wcs = PyInt_AsLong(value);
 788         return 0;
 789 }
 790
 791 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare2wcs(PyObject *obj, void *closure)
 792 {
 793         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 794         PyObject *py_spare2wcs;
 795         py_spare2wcs = PyInt_FromLong(object->spare2wcs);
 796         return py_spare2wcs;
 797 }
 798
 799 static int py_frsrpc_CommPktChangeOrderCommand_set_spare2wcs(PyObject *py_obj, PyObject *value, void *closure)
 800 {
 801         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 802         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 803         object->spare2wcs = PyInt_AsLong(value);
 804         return 0;
 805 }
 806
 807 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_extension(PyObject *obj, void *closure)
 808 {
 809         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 810         PyObject *py_extension;
 811         py_extension = PyInt_FromLong(object->extension);
 812         return py_extension;
 813 }
 814
 815 static int py_frsrpc_CommPktChangeOrderCommand_set_extension(PyObject *py_obj, PyObject *value, void *closure)
 816 {
 817         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 818         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 819         object->extension = PyInt_AsLong(value);
 820         return 0;
 821 }
 822
 823 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_spare2bin(PyObject *obj, void *closure)
 824 {
 825         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 826         PyObject *py_spare2bin;
 827         py_spare2bin = PyInt_FromLong(object->spare2bin);
 828         return py_spare2bin;
 829 }
 830
 831 static int py_frsrpc_CommPktChangeOrderCommand_set_spare2bin(PyObject *py_obj, PyObject *value, void *closure)
 832 {
 833         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 834         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 835         object->spare2bin = PyInt_AsLong(value);
 836         return 0;
 837 }
 838
 839 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_event_time(PyObject *obj, void *closure)
 840 {
 841         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 842         PyObject *py_event_time;
 843         py_event_time = PyLong_FromLongLong(object->event_time);
 844         return py_event_time;
 845 }
 846
 847 static int py_frsrpc_CommPktChangeOrderCommand_set_event_time(PyObject *py_obj, PyObject *value, void *closure)
 848 {
 849         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 850         if (PyLong_Check(value)) {
 851                 object->event_time = PyLong_AsLongLong(value);
 852         } else if (PyInt_Check(value)) {
 853                 object->event_time = PyInt_AsLong(value);
 854         } else {
 855                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 856                   PyInt_Type.tp_name, PyLong_Type.tp_name);
 857                 return -1;
 858         }
 859         return 0;
 860 }
 861
 862 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_name_length(PyObject *obj, void *closure)
 863 {
 864         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 865         PyObject *py_file_name_length;
 866         py_file_name_length = PyInt_FromLong(object->file_name_length);
 867         return py_file_name_length;
 868 }
 869
 870 static int py_frsrpc_CommPktChangeOrderCommand_set_file_name_length(PyObject *py_obj, PyObject *value, void *closure)
 871 {
 872         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 873         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 874         object->file_name_length = PyInt_AsLong(value);
 875         return 0;
 876 }
 877
 878 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_file_name(PyObject *obj, void *closure)
 879 {
 880         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 881         PyObject *py_file_name;
 882         if (object->file_name == NULL) {
 883                 py_file_name = Py_None;
 884                 Py_INCREF(py_file_name);
 885         } else {
 886                 py_file_name = PyUnicode_Decode(object->file_name, strlen(object->file_name), "utf-8", "ignore");
 887         }
 888         return py_file_name;
 889 }
 890
 891 static int py_frsrpc_CommPktChangeOrderCommand_set_file_name(PyObject *py_obj, PyObject *value, void *closure)
 892 {
 893         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 894         if (PyUnicode_Check(value)) {
 895                 object->file_name = PyString_AS_STRING(PyUnicode_AsEncodedString(value, "utf-8", "ignore"));
 896         } else if (PyString_Check(value)) {
 897                 object->file_name = PyString_AS_STRING(value);
 898         } else {
 899                 PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(value)->tp_name);
 900                 return -1;
 901         }
 902         return 0;
 903 }
 904
 905 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_padding1(PyObject *obj, void *closure)
 906 {
 907         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 908         PyObject *py_padding1;
 909         py_padding1 = PyInt_FromLong(object->padding1);
 910         return py_padding1;
 911 }
 912
 913 static int py_frsrpc_CommPktChangeOrderCommand_set_padding1(PyObject *py_obj, PyObject *value, void *closure)
 914 {
 915         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 916         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 917         object->padding1 = PyInt_AsLong(value);
 918         return 0;
 919 }
 920
 921 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_padding2(PyObject *obj, void *closure)
 922 {
 923         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 924         PyObject *py_padding2;
 925         py_padding2 = PyInt_FromLong(object->padding2);
 926         return py_padding2;
 927 }
 928
 929 static int py_frsrpc_CommPktChangeOrderCommand_set_padding2(PyObject *py_obj, PyObject *value, void *closure)
 930 {
 931         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 932         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 933         object->padding2 = PyInt_AsLong(value);
 934         return 0;
 935 }
 936
 937 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_padding3(PyObject *obj, void *closure)
 938 {
 939         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 940         PyObject *py_padding3;
 941         py_padding3 = PyInt_FromLong(object->padding3);
 942         return py_padding3;
 943 }
 944
 945 static int py_frsrpc_CommPktChangeOrderCommand_set_padding3(PyObject *py_obj, PyObject *value, void *closure)
 946 {
 947         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 948         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 949         object->padding3 = PyInt_AsLong(value);
 950         return 0;
 951 }
 952
 953 static PyObject *py_frsrpc_CommPktChangeOrderCommand_get_padding4(PyObject *obj, void *closure)
 954 {
 955         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(obj);
 956         PyObject *py_padding4;
 957         py_padding4 = PyInt_FromLong(object->padding4);
 958         return py_padding4;
 959 }
 960
 961 static int py_frsrpc_CommPktChangeOrderCommand_set_padding4(PyObject *py_obj, PyObject *value, void *closure)
 962 {
 963         struct frsrpc_CommPktChangeOrderCommand *object = (struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(py_obj);
 964         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 965         object->padding4 = PyInt_AsLong(value);
 966         return 0;
 967 }
 968
 969 static PyGetSetDef py_frsrpc_CommPktChangeOrderCommand_getsetters[] = {
 970         { discard_const_p(char, "sequence_number"), py_frsrpc_CommPktChangeOrderCommand_get_sequence_number, py_frsrpc_CommPktChangeOrderCommand_set_sequence_number },
 971         { discard_const_p(char, "flags"), py_frsrpc_CommPktChangeOrderCommand_get_flags, py_frsrpc_CommPktChangeOrderCommand_set_flags },
 972         { discard_const_p(char, "iflags"), py_frsrpc_CommPktChangeOrderCommand_get_iflags, py_frsrpc_CommPktChangeOrderCommand_set_iflags },
 973         { discard_const_p(char, "status"), py_frsrpc_CommPktChangeOrderCommand_get_status, py_frsrpc_CommPktChangeOrderCommand_set_status },
 974         { discard_const_p(char, "content_cmd"), py_frsrpc_CommPktChangeOrderCommand_get_content_cmd, py_frsrpc_CommPktChangeOrderCommand_set_content_cmd },
 975         { discard_const_p(char, "location_cmd"), py_frsrpc_CommPktChangeOrderCommand_get_location_cmd, py_frsrpc_CommPktChangeOrderCommand_set_location_cmd },
 976         { discard_const_p(char, "file_attributes"), py_frsrpc_CommPktChangeOrderCommand_get_file_attributes, py_frsrpc_CommPktChangeOrderCommand_set_file_attributes },
 977         { discard_const_p(char, "file_version_number"), py_frsrpc_CommPktChangeOrderCommand_get_file_version_number, py_frsrpc_CommPktChangeOrderCommand_set_file_version_number },
 978         { discard_const_p(char, "partern_ack_sequence_number"), py_frsrpc_CommPktChangeOrderCommand_get_partern_ack_sequence_number, py_frsrpc_CommPktChangeOrderCommand_set_partern_ack_sequence_number },
 979         { discard_const_p(char, "not_used"), py_frsrpc_CommPktChangeOrderCommand_get_not_used, py_frsrpc_CommPktChangeOrderCommand_set_not_used },
 980         { discard_const_p(char, "file_size"), py_frsrpc_CommPktChangeOrderCommand_get_file_size, py_frsrpc_CommPktChangeOrderCommand_set_file_size },
 981         { discard_const_p(char, "file_offset"), py_frsrpc_CommPktChangeOrderCommand_get_file_offset, py_frsrpc_CommPktChangeOrderCommand_set_file_offset },
 982         { discard_const_p(char, "frs_vsn"), py_frsrpc_CommPktChangeOrderCommand_get_frs_vsn, py_frsrpc_CommPktChangeOrderCommand_set_frs_vsn },
 983         { discard_const_p(char, "file_usn"), py_frsrpc_CommPktChangeOrderCommand_get_file_usn, py_frsrpc_CommPktChangeOrderCommand_set_file_usn },
 984         { discard_const_p(char, "jrnl_usn"), py_frsrpc_CommPktChangeOrderCommand_get_jrnl_usn, py_frsrpc_CommPktChangeOrderCommand_set_jrnl_usn },
 985         { discard_const_p(char, "jrnl_first_usn"), py_frsrpc_CommPktChangeOrderCommand_get_jrnl_first_usn, py_frsrpc_CommPktChangeOrderCommand_set_jrnl_first_usn },
 986         { discard_const_p(char, "original_replica_num"), py_frsrpc_CommPktChangeOrderCommand_get_original_replica_num, py_frsrpc_CommPktChangeOrderCommand_set_original_replica_num },
 987         { discard_const_p(char, "new_replica_num"), py_frsrpc_CommPktChangeOrderCommand_get_new_replica_num, py_frsrpc_CommPktChangeOrderCommand_set_new_replica_num },
 988         { discard_const_p(char, "change_order_guid"), py_frsrpc_CommPktChangeOrderCommand_get_change_order_guid, py_frsrpc_CommPktChangeOrderCommand_set_change_order_guid },
 989         { discard_const_p(char, "originator_guid"), py_frsrpc_CommPktChangeOrderCommand_get_originator_guid, py_frsrpc_CommPktChangeOrderCommand_set_originator_guid },
 990         { discard_const_p(char, "file_guid"), py_frsrpc_CommPktChangeOrderCommand_get_file_guid, py_frsrpc_CommPktChangeOrderCommand_set_file_guid },
 991         { discard_const_p(char, "old_parent_guid"), py_frsrpc_CommPktChangeOrderCommand_get_old_parent_guid, py_frsrpc_CommPktChangeOrderCommand_set_old_parent_guid },
 992         { discard_const_p(char, "new_parent_guid"), py_frsrpc_CommPktChangeOrderCommand_get_new_parent_guid, py_frsrpc_CommPktChangeOrderCommand_set_new_parent_guid },
 993         { discard_const_p(char, "connection_guid"), py_frsrpc_CommPktChangeOrderCommand_get_connection_guid, py_frsrpc_CommPktChangeOrderCommand_set_connection_guid },
 994         { discard_const_p(char, "ack_version"), py_frsrpc_CommPktChangeOrderCommand_get_ack_version, py_frsrpc_CommPktChangeOrderCommand_set_ack_version },
 995         { discard_const_p(char, "spare2ul1"), py_frsrpc_CommPktChangeOrderCommand_get_spare2ul1, py_frsrpc_CommPktChangeOrderCommand_set_spare2ul1 },
 996         { discard_const_p(char, "spare1guid_p1"), py_frsrpc_CommPktChangeOrderCommand_get_spare1guid_p1, py_frsrpc_CommPktChangeOrderCommand_set_spare1guid_p1 },
 997         { discard_const_p(char, "spare1guid_p2"), py_frsrpc_CommPktChangeOrderCommand_get_spare1guid_p2, py_frsrpc_CommPktChangeOrderCommand_set_spare1guid_p2 },
 998         { discard_const_p(char, "spare2guid_p1"), py_frsrpc_CommPktChangeOrderCommand_get_spare2guid_p1, py_frsrpc_CommPktChangeOrderCommand_set_spare2guid_p1 },
 999         { discard_const_p(char, "spare3guid_p2"), py_frsrpc_CommPktChangeOrderCommand_get_spare3guid_p2, py_frsrpc_CommPktChangeOrderCommand_set_spare3guid_p2 },
1000         { discard_const_p(char, "spare1wcs"), py_frsrpc_CommPktChangeOrderCommand_get_spare1wcs, py_frsrpc_CommPktChangeOrderCommand_set_spare1wcs },
1001         { discard_const_p(char, "spare2wcs"), py_frsrpc_CommPktChangeOrderCommand_get_spare2wcs, py_frsrpc_CommPktChangeOrderCommand_set_spare2wcs },
1002         { discard_const_p(char, "extension"), py_frsrpc_CommPktChangeOrderCommand_get_extension, py_frsrpc_CommPktChangeOrderCommand_set_extension },
1003         { discard_const_p(char, "spare2bin"), py_frsrpc_CommPktChangeOrderCommand_get_spare2bin, py_frsrpc_CommPktChangeOrderCommand_set_spare2bin },
1004         { discard_const_p(char, "event_time"), py_frsrpc_CommPktChangeOrderCommand_get_event_time, py_frsrpc_CommPktChangeOrderCommand_set_event_time },
1005         { discard_const_p(char, "file_name_length"), py_frsrpc_CommPktChangeOrderCommand_get_file_name_length, py_frsrpc_CommPktChangeOrderCommand_set_file_name_length },
1006         { discard_const_p(char, "file_name"), py_frsrpc_CommPktChangeOrderCommand_get_file_name, py_frsrpc_CommPktChangeOrderCommand_set_file_name },
1007         { discard_const_p(char, "padding1"), py_frsrpc_CommPktChangeOrderCommand_get_padding1, py_frsrpc_CommPktChangeOrderCommand_set_padding1 },
1008         { discard_const_p(char, "padding2"), py_frsrpc_CommPktChangeOrderCommand_get_padding2, py_frsrpc_CommPktChangeOrderCommand_set_padding2 },
1009         { discard_const_p(char, "padding3"), py_frsrpc_CommPktChangeOrderCommand_get_padding3, py_frsrpc_CommPktChangeOrderCommand_set_padding3 },
1010         { discard_const_p(char, "padding4"), py_frsrpc_CommPktChangeOrderCommand_get_padding4, py_frsrpc_CommPktChangeOrderCommand_set_padding4 },
1011         { NULL }
1012 };
1013
1014 static PyObject *py_frsrpc_CommPktChangeOrderCommand_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1015 {
1016         return pytalloc_new(struct frsrpc_CommPktChangeOrderCommand, type);
1017 }
1018
1019
1020 static PyTypeObject frsrpc_CommPktChangeOrderCommand_Type = {
1021         PyObject_HEAD_INIT(NULL) 0,
1022         .tp_name = "frsrpc.CommPktChangeOrderCommand",
1023         .tp_getset = py_frsrpc_CommPktChangeOrderCommand_getsetters,
1024         .tp_methods = NULL,
1025         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1026         .tp_basicsize = sizeof(pytalloc_Object),
1027         .tp_new = py_frsrpc_CommPktChangeOrderCommand_new,
1028 };
1029
1030
1031 static PyObject *py_frsrpc_CommPktDataExtensionChecksum_get_prefix_size(PyObject *obj, void *closure)
1032 {
1033         struct frsrpc_CommPktDataExtensionChecksum *object = (struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(obj);
1034         PyObject *py_prefix_size;
1035         py_prefix_size = PyInt_FromLong(object->prefix_size);
1036         return py_prefix_size;
1037 }
1038
1039 static int py_frsrpc_CommPktDataExtensionChecksum_set_prefix_size(PyObject *py_obj, PyObject *value, void *closure)
1040 {
1041         struct frsrpc_CommPktDataExtensionChecksum *object = (struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(py_obj);
1042         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1043         object->prefix_size = PyInt_AsLong(value);
1044         return 0;
1045 }
1046
1047 static PyObject *py_frsrpc_CommPktDataExtensionChecksum_get_prefix_type(PyObject *obj, void *closure)
1048 {
1049         struct frsrpc_CommPktDataExtensionChecksum *object = (struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(obj);
1050         PyObject *py_prefix_type;
1051         py_prefix_type = PyInt_FromLong(object->prefix_type);
1052         return py_prefix_type;
1053 }
1054
1055 static int py_frsrpc_CommPktDataExtensionChecksum_set_prefix_type(PyObject *py_obj, PyObject *value, void *closure)
1056 {
1057         struct frsrpc_CommPktDataExtensionChecksum *object = (struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(py_obj);
1058         if (PyLong_Check(value)) {
1059                 object->prefix_type = PyLong_AsLongLong(value);
1060         } else if (PyInt_Check(value)) {
1061                 object->prefix_type = PyInt_AsLong(value);
1062         } else {
1063                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1064                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1065                 return -1;
1066         }
1067         return 0;
1068 }
1069
1070 static PyObject *py_frsrpc_CommPktDataExtensionChecksum_get_data(PyObject *obj, void *closure)
1071 {
1072         struct frsrpc_CommPktDataExtensionChecksum *object = (struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(obj);
1073         PyObject *py_data;
1074         py_data = PyList_New(16);
1075         if (py_data == NULL) {
1076                 return NULL;
1077         }
1078         {
1079                 int data_cntr_0;
1080                 for (data_cntr_0 = 0; data_cntr_0 < 16; data_cntr_0++) {
1081                         PyObject *py_data_0;
1082                         py_data_0 = PyInt_FromLong(object->data[data_cntr_0]);
1083                         PyList_SetItem(py_data, data_cntr_0, py_data_0);
1084                 }
1085         }
1086         return py_data;
1087 }
1088
1089 static int py_frsrpc_CommPktDataExtensionChecksum_set_data(PyObject *py_obj, PyObject *value, void *closure)
1090 {
1091         struct frsrpc_CommPktDataExtensionChecksum *object = (struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(py_obj);
1092         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
1093         {
1094                 int data_cntr_0;
1095                 for (data_cntr_0 = 0; data_cntr_0 < PyList_GET_SIZE(value); data_cntr_0++) {
1096                         PY_CHECK_TYPE(&PyInt_Type, PyList_GET_ITEM(value, data_cntr_0), return -1;);
1097                         object->data[data_cntr_0] = PyInt_AsLong(PyList_GET_ITEM(value, data_cntr_0));
1098                 }
1099         }
1100         return 0;
1101 }
1102
1103 static PyGetSetDef py_frsrpc_CommPktDataExtensionChecksum_getsetters[] = {
1104         { discard_const_p(char, "prefix_size"), py_frsrpc_CommPktDataExtensionChecksum_get_prefix_size, py_frsrpc_CommPktDataExtensionChecksum_set_prefix_size },
1105         { discard_const_p(char, "prefix_type"), py_frsrpc_CommPktDataExtensionChecksum_get_prefix_type, py_frsrpc_CommPktDataExtensionChecksum_set_prefix_type },
1106         { discard_const_p(char, "data"), py_frsrpc_CommPktDataExtensionChecksum_get_data, py_frsrpc_CommPktDataExtensionChecksum_set_data },
1107         { NULL }
1108 };
1109
1110 static PyObject *py_frsrpc_CommPktDataExtensionChecksum_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1111 {
1112         return pytalloc_new(struct frsrpc_CommPktDataExtensionChecksum, type);
1113 }
1114
1115
1116 static PyTypeObject frsrpc_CommPktDataExtensionChecksum_Type = {
1117         PyObject_HEAD_INIT(NULL) 0,
1118         .tp_name = "frsrpc.CommPktDataExtensionChecksum",
1119         .tp_getset = py_frsrpc_CommPktDataExtensionChecksum_getsetters,
1120         .tp_methods = NULL,
1121         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1122         .tp_basicsize = sizeof(pytalloc_Object),
1123         .tp_new = py_frsrpc_CommPktDataExtensionChecksum_new,
1124 };
1125
1126
1127 static PyObject *py_frsrpc_CommPktDataExtensionRetryTimeout_get_prefix_size(PyObject *obj, void *closure)
1128 {
1129         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(obj);
1130         PyObject *py_prefix_size;
1131         py_prefix_size = PyInt_FromLong(object->prefix_size);
1132         return py_prefix_size;
1133 }
1134
1135 static int py_frsrpc_CommPktDataExtensionRetryTimeout_set_prefix_size(PyObject *py_obj, PyObject *value, void *closure)
1136 {
1137         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(py_obj);
1138         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1139         object->prefix_size = PyInt_AsLong(value);
1140         return 0;
1141 }
1142
1143 static PyObject *py_frsrpc_CommPktDataExtensionRetryTimeout_get_prefix_type(PyObject *obj, void *closure)
1144 {
1145         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(obj);
1146         PyObject *py_prefix_type;
1147         py_prefix_type = PyInt_FromLong(object->prefix_type);
1148         return py_prefix_type;
1149 }
1150
1151 static int py_frsrpc_CommPktDataExtensionRetryTimeout_set_prefix_type(PyObject *py_obj, PyObject *value, void *closure)
1152 {
1153         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(py_obj);
1154         if (PyLong_Check(value)) {
1155                 object->prefix_type = PyLong_AsLongLong(value);
1156         } else if (PyInt_Check(value)) {
1157                 object->prefix_type = PyInt_AsLong(value);
1158         } else {
1159                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1160                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1161                 return -1;
1162         }
1163         return 0;
1164 }
1165
1166 static PyObject *py_frsrpc_CommPktDataExtensionRetryTimeout_get_count(PyObject *obj, void *closure)
1167 {
1168         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(obj);
1169         PyObject *py_count;
1170         py_count = PyInt_FromLong(object->count);
1171         return py_count;
1172 }
1173
1174 static int py_frsrpc_CommPktDataExtensionRetryTimeout_set_count(PyObject *py_obj, PyObject *value, void *closure)
1175 {
1176         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(py_obj);
1177         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1178         object->count = PyInt_AsLong(value);
1179         return 0;
1180 }
1181
1182 static PyObject *py_frsrpc_CommPktDataExtensionRetryTimeout_get_not_used(PyObject *obj, void *closure)
1183 {
1184         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(obj);
1185         PyObject *py_not_used;
1186         py_not_used = PyInt_FromLong(object->not_used);
1187         return py_not_used;
1188 }
1189
1190 static int py_frsrpc_CommPktDataExtensionRetryTimeout_set_not_used(PyObject *py_obj, PyObject *value, void *closure)
1191 {
1192         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(py_obj);
1193         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1194         object->not_used = PyInt_AsLong(value);
1195         return 0;
1196 }
1197
1198 static PyObject *py_frsrpc_CommPktDataExtensionRetryTimeout_get_first_try_time(PyObject *obj, void *closure)
1199 {
1200         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(obj);
1201         PyObject *py_first_try_time;
1202         py_first_try_time = PyLong_FromLongLong(object->first_try_time);
1203         return py_first_try_time;
1204 }
1205
1206 static int py_frsrpc_CommPktDataExtensionRetryTimeout_set_first_try_time(PyObject *py_obj, PyObject *value, void *closure)
1207 {
1208         struct frsrpc_CommPktDataExtensionRetryTimeout *object = (struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(py_obj);
1209         if (PyLong_Check(value)) {
1210                 object->first_try_time = PyLong_AsLongLong(value);
1211         } else if (PyInt_Check(value)) {
1212                 object->first_try_time = PyInt_AsLong(value);
1213         } else {
1214                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1215                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1216                 return -1;
1217         }
1218         return 0;
1219 }
1220
1221 static PyGetSetDef py_frsrpc_CommPktDataExtensionRetryTimeout_getsetters[] = {
1222         { discard_const_p(char, "prefix_size"), py_frsrpc_CommPktDataExtensionRetryTimeout_get_prefix_size, py_frsrpc_CommPktDataExtensionRetryTimeout_set_prefix_size },
1223         { discard_const_p(char, "prefix_type"), py_frsrpc_CommPktDataExtensionRetryTimeout_get_prefix_type, py_frsrpc_CommPktDataExtensionRetryTimeout_set_prefix_type },
1224         { discard_const_p(char, "count"), py_frsrpc_CommPktDataExtensionRetryTimeout_get_count, py_frsrpc_CommPktDataExtensionRetryTimeout_set_count },
1225         { discard_const_p(char, "not_used"), py_frsrpc_CommPktDataExtensionRetryTimeout_get_not_used, py_frsrpc_CommPktDataExtensionRetryTimeout_set_not_used },
1226         { discard_const_p(char, "first_try_time"), py_frsrpc_CommPktDataExtensionRetryTimeout_get_first_try_time, py_frsrpc_CommPktDataExtensionRetryTimeout_set_first_try_time },
1227         { NULL }
1228 };
1229
1230 static PyObject *py_frsrpc_CommPktDataExtensionRetryTimeout_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1231 {
1232         return pytalloc_new(struct frsrpc_CommPktDataExtensionRetryTimeout, type);
1233 }
1234
1235
1236 static PyTypeObject frsrpc_CommPktDataExtensionRetryTimeout_Type = {
1237         PyObject_HEAD_INIT(NULL) 0,
1238         .tp_name = "frsrpc.CommPktDataExtensionRetryTimeout",
1239         .tp_getset = py_frsrpc_CommPktDataExtensionRetryTimeout_getsetters,
1240         .tp_methods = NULL,
1241         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1242         .tp_basicsize = sizeof(pytalloc_Object),
1243         .tp_new = py_frsrpc_CommPktDataExtensionRetryTimeout_new,
1244 };
1245
1246
1247 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_get_field_size(PyObject *obj, void *closure)
1248 {
1249         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(obj);
1250         PyObject *py_field_size;
1251         py_field_size = PyInt_FromLong(object->field_size);
1252         return py_field_size;
1253 }
1254
1255 static int py_frsrpc_CommPktCoRecordExtensionWin2k_set_field_size(PyObject *py_obj, PyObject *value, void *closure)
1256 {
1257         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(py_obj);
1258         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1259         object->field_size = PyInt_AsLong(value);
1260         return 0;
1261 }
1262
1263 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_get_major(PyObject *obj, void *closure)
1264 {
1265         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(obj);
1266         PyObject *py_major;
1267         py_major = PyInt_FromLong(object->major);
1268         return py_major;
1269 }
1270
1271 static int py_frsrpc_CommPktCoRecordExtensionWin2k_set_major(PyObject *py_obj, PyObject *value, void *closure)
1272 {
1273         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(py_obj);
1274         if (PyLong_Check(value)) {
1275                 object->major = PyLong_AsLongLong(value);
1276         } else if (PyInt_Check(value)) {
1277                 object->major = PyInt_AsLong(value);
1278         } else {
1279                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1280                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1281                 return -1;
1282         }
1283         return 0;
1284 }
1285
1286 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_get_offset_count(PyObject *obj, void *closure)
1287 {
1288         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(obj);
1289         PyObject *py_offset_count;
1290         py_offset_count = PyInt_FromLong(object->offset_count);
1291         return py_offset_count;
1292 }
1293
1294 static int py_frsrpc_CommPktCoRecordExtensionWin2k_set_offset_count(PyObject *py_obj, PyObject *value, void *closure)
1295 {
1296         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(py_obj);
1297         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1298         object->offset_count = PyInt_AsLong(value);
1299         return 0;
1300 }
1301
1302 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_get_offset(PyObject *obj, void *closure)
1303 {
1304         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(obj);
1305         PyObject *py_offset;
1306         py_offset = PyInt_FromLong(object->offset);
1307         return py_offset;
1308 }
1309
1310 static int py_frsrpc_CommPktCoRecordExtensionWin2k_set_offset(PyObject *py_obj, PyObject *value, void *closure)
1311 {
1312         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(py_obj);
1313         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1314         object->offset = PyInt_AsLong(value);
1315         return 0;
1316 }
1317
1318 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_get_offset_last(PyObject *obj, void *closure)
1319 {
1320         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(obj);
1321         PyObject *py_offset_last;
1322         py_offset_last = PyInt_FromLong(object->offset_last);
1323         return py_offset_last;
1324 }
1325
1326 static int py_frsrpc_CommPktCoRecordExtensionWin2k_set_offset_last(PyObject *py_obj, PyObject *value, void *closure)
1327 {
1328         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(py_obj);
1329         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1330         object->offset_last = PyInt_AsLong(value);
1331         return 0;
1332 }
1333
1334 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_get_data_checksum(PyObject *obj, void *closure)
1335 {
1336         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(obj);
1337         PyObject *py_data_checksum;
1338         py_data_checksum = pytalloc_reference_ex(&frsrpc_CommPktDataExtensionChecksum_Type, pytalloc_get_mem_ctx(obj), &object->data_checksum);
1339         return py_data_checksum;
1340 }
1341
1342 static int py_frsrpc_CommPktCoRecordExtensionWin2k_set_data_checksum(PyObject *py_obj, PyObject *value, void *closure)
1343 {
1344         struct frsrpc_CommPktCoRecordExtensionWin2k *object = (struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(py_obj);
1345         PY_CHECK_TYPE(&frsrpc_CommPktDataExtensionChecksum_Type, value, return -1;);
1346         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
1347                 PyErr_NoMemory();
1348                 return -1;
1349         }
1350         object->data_checksum = *(struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(value);
1351         return 0;
1352 }
1353
1354 static PyGetSetDef py_frsrpc_CommPktCoRecordExtensionWin2k_getsetters[] = {
1355         { discard_const_p(char, "field_size"), py_frsrpc_CommPktCoRecordExtensionWin2k_get_field_size, py_frsrpc_CommPktCoRecordExtensionWin2k_set_field_size },
1356         { discard_const_p(char, "major"), py_frsrpc_CommPktCoRecordExtensionWin2k_get_major, py_frsrpc_CommPktCoRecordExtensionWin2k_set_major },
1357         { discard_const_p(char, "offset_count"), py_frsrpc_CommPktCoRecordExtensionWin2k_get_offset_count, py_frsrpc_CommPktCoRecordExtensionWin2k_set_offset_count },
1358         { discard_const_p(char, "offset"), py_frsrpc_CommPktCoRecordExtensionWin2k_get_offset, py_frsrpc_CommPktCoRecordExtensionWin2k_set_offset },
1359         { discard_const_p(char, "offset_last"), py_frsrpc_CommPktCoRecordExtensionWin2k_get_offset_last, py_frsrpc_CommPktCoRecordExtensionWin2k_set_offset_last },
1360         { discard_const_p(char, "data_checksum"), py_frsrpc_CommPktCoRecordExtensionWin2k_get_data_checksum, py_frsrpc_CommPktCoRecordExtensionWin2k_set_data_checksum },
1361         { NULL }
1362 };
1363
1364 static PyObject *py_frsrpc_CommPktCoRecordExtensionWin2k_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1365 {
1366         return pytalloc_new(struct frsrpc_CommPktCoRecordExtensionWin2k, type);
1367 }
1368
1369
1370 static PyTypeObject frsrpc_CommPktCoRecordExtensionWin2k_Type = {
1371         PyObject_HEAD_INIT(NULL) 0,
1372         .tp_name = "frsrpc.CommPktCoRecordExtensionWin2k",
1373         .tp_getset = py_frsrpc_CommPktCoRecordExtensionWin2k_getsetters,
1374         .tp_methods = NULL,
1375         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1376         .tp_basicsize = sizeof(pytalloc_Object),
1377         .tp_new = py_frsrpc_CommPktCoRecordExtensionWin2k_new,
1378 };
1379
1380
1381 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_field_size(PyObject *obj, void *closure)
1382 {
1383         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1384         PyObject *py_field_size;
1385         py_field_size = PyInt_FromLong(object->field_size);
1386         return py_field_size;
1387 }
1388
1389 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_field_size(PyObject *py_obj, PyObject *value, void *closure)
1390 {
1391         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1392         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1393         object->field_size = PyInt_AsLong(value);
1394         return 0;
1395 }
1396
1397 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_major(PyObject *obj, void *closure)
1398 {
1399         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1400         PyObject *py_major;
1401         py_major = PyInt_FromLong(object->major);
1402         return py_major;
1403 }
1404
1405 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_major(PyObject *py_obj, PyObject *value, void *closure)
1406 {
1407         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1408         if (PyLong_Check(value)) {
1409                 object->major = PyLong_AsLongLong(value);
1410         } else if (PyInt_Check(value)) {
1411                 object->major = PyInt_AsLong(value);
1412         } else {
1413                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1414                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1415                 return -1;
1416         }
1417         return 0;
1418 }
1419
1420 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_offset_count(PyObject *obj, void *closure)
1421 {
1422         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1423         PyObject *py_offset_count;
1424         py_offset_count = PyInt_FromLong(object->offset_count);
1425         return py_offset_count;
1426 }
1427
1428 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_offset_count(PyObject *py_obj, PyObject *value, void *closure)
1429 {
1430         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1431         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1432         object->offset_count = PyInt_AsLong(value);
1433         return 0;
1434 }
1435
1436 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_offset0(PyObject *obj, void *closure)
1437 {
1438         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1439         PyObject *py_offset0;
1440         py_offset0 = PyInt_FromLong(object->offset0);
1441         return py_offset0;
1442 }
1443
1444 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_offset0(PyObject *py_obj, PyObject *value, void *closure)
1445 {
1446         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1447         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1448         object->offset0 = PyInt_AsLong(value);
1449         return 0;
1450 }
1451
1452 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_offset1(PyObject *obj, void *closure)
1453 {
1454         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1455         PyObject *py_offset1;
1456         py_offset1 = PyInt_FromLong(object->offset1);
1457         return py_offset1;
1458 }
1459
1460 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_offset1(PyObject *py_obj, PyObject *value, void *closure)
1461 {
1462         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1463         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1464         object->offset1 = PyInt_AsLong(value);
1465         return 0;
1466 }
1467
1468 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_offset_last(PyObject *obj, void *closure)
1469 {
1470         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1471         PyObject *py_offset_last;
1472         py_offset_last = PyInt_FromLong(object->offset_last);
1473         return py_offset_last;
1474 }
1475
1476 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_offset_last(PyObject *py_obj, PyObject *value, void *closure)
1477 {
1478         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1479         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1480         object->offset_last = PyInt_AsLong(value);
1481         return 0;
1482 }
1483
1484 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_not_used(PyObject *obj, void *closure)
1485 {
1486         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1487         PyObject *py_not_used;
1488         py_not_used = PyInt_FromLong(object->not_used);
1489         return py_not_used;
1490 }
1491
1492 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_not_used(PyObject *py_obj, PyObject *value, void *closure)
1493 {
1494         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1495         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
1496         object->not_used = PyInt_AsLong(value);
1497         return 0;
1498 }
1499
1500 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_data_checksum(PyObject *obj, void *closure)
1501 {
1502         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1503         PyObject *py_data_checksum;
1504         py_data_checksum = pytalloc_reference_ex(&frsrpc_CommPktDataExtensionChecksum_Type, pytalloc_get_mem_ctx(obj), &object->data_checksum);
1505         return py_data_checksum;
1506 }
1507
1508 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_data_checksum(PyObject *py_obj, PyObject *value, void *closure)
1509 {
1510         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1511         PY_CHECK_TYPE(&frsrpc_CommPktDataExtensionChecksum_Type, value, return -1;);
1512         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
1513                 PyErr_NoMemory();
1514                 return -1;
1515         }
1516         object->data_checksum = *(struct frsrpc_CommPktDataExtensionChecksum *)pytalloc_get_ptr(value);
1517         return 0;
1518 }
1519
1520 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_get_data_retry_timeout(PyObject *obj, void *closure)
1521 {
1522         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(obj);
1523         PyObject *py_data_retry_timeout;
1524         py_data_retry_timeout = pytalloc_reference_ex(&frsrpc_CommPktDataExtensionRetryTimeout_Type, pytalloc_get_mem_ctx(obj), &object->data_retry_timeout);
1525         return py_data_retry_timeout;
1526 }
1527
1528 static int py_frsrpc_CommPktChangeOrderRecordExtension_set_data_retry_timeout(PyObject *py_obj, PyObject *value, void *closure)
1529 {
1530         struct frsrpc_CommPktChangeOrderRecordExtension *object = (struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(py_obj);
1531         PY_CHECK_TYPE(&frsrpc_CommPktDataExtensionRetryTimeout_Type, value, return -1;);
1532         if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
1533                 PyErr_NoMemory();
1534                 return -1;
1535         }
1536         object->data_retry_timeout = *(struct frsrpc_CommPktDataExtensionRetryTimeout *)pytalloc_get_ptr(value);
1537         return 0;
1538 }
1539
1540 static PyGetSetDef py_frsrpc_CommPktChangeOrderRecordExtension_getsetters[] = {
1541         { discard_const_p(char, "field_size"), py_frsrpc_CommPktChangeOrderRecordExtension_get_field_size, py_frsrpc_CommPktChangeOrderRecordExtension_set_field_size },
1542         { discard_const_p(char, "major"), py_frsrpc_CommPktChangeOrderRecordExtension_get_major, py_frsrpc_CommPktChangeOrderRecordExtension_set_major },
1543         { discard_const_p(char, "offset_count"), py_frsrpc_CommPktChangeOrderRecordExtension_get_offset_count, py_frsrpc_CommPktChangeOrderRecordExtension_set_offset_count },
1544         { discard_const_p(char, "offset0"), py_frsrpc_CommPktChangeOrderRecordExtension_get_offset0, py_frsrpc_CommPktChangeOrderRecordExtension_set_offset0 },
1545         { discard_const_p(char, "offset1"), py_frsrpc_CommPktChangeOrderRecordExtension_get_offset1, py_frsrpc_CommPktChangeOrderRecordExtension_set_offset1 },
1546         { discard_const_p(char, "offset_last"), py_frsrpc_CommPktChangeOrderRecordExtension_get_offset_last, py_frsrpc_CommPktChangeOrderRecordExtension_set_offset_last },
1547         { discard_const_p(char, "not_used"), py_frsrpc_CommPktChangeOrderRecordExtension_get_not_used, py_frsrpc_CommPktChangeOrderRecordExtension_set_not_used },
1548         { discard_const_p(char, "data_checksum"), py_frsrpc_CommPktChangeOrderRecordExtension_get_data_checksum, py_frsrpc_CommPktChangeOrderRecordExtension_set_data_checksum },
1549         { discard_const_p(char, "data_retry_timeout"), py_frsrpc_CommPktChangeOrderRecordExtension_get_data_retry_timeout, py_frsrpc_CommPktChangeOrderRecordExtension_set_data_retry_timeout },
1550         { NULL }
1551 };
1552
1553 static PyObject *py_frsrpc_CommPktChangeOrderRecordExtension_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1554 {
1555         return pytalloc_new(struct frsrpc_CommPktChangeOrderRecordExtension, type);
1556 }
1557
1558
1559 static PyTypeObject frsrpc_CommPktChangeOrderRecordExtension_Type = {
1560         PyObject_HEAD_INIT(NULL) 0,
1561         .tp_name = "frsrpc.CommPktChangeOrderRecordExtension",
1562         .tp_getset = py_frsrpc_CommPktChangeOrderRecordExtension_getsetters,
1563         .tp_methods = NULL,
1564         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
1565         .tp_basicsize = sizeof(pytalloc_Object),
1566         .tp_new = py_frsrpc_CommPktChangeOrderRecordExtension_new,
1567 };
1568
1569 PyObject *py_import_frsrpc_CommPktChunkData(TALLOC_CTX *mem_ctx, int level, union frsrpc_CommPktChunkData *in)
1570 {
1571         PyObject *ret;
1572
1573         switch (level) {
1574                 default:
1575                         ret = PyString_FromStringAndSize((char *)(in->blob).data, (in->blob).length);
1576                         return ret;
1577
1578                 case FRSRPC_COMM_PKT_CHUNK_BOP:
1579                         ret = PyInt_FromLong(in->bop);
1580                         return ret;
1581
1582                 case FRSRPC_COMM_PKT_CHUNK_COMMAND:
1583                         ret = PyInt_FromLong(in->command);
1584                         return ret;
1585
1586                 case FRSRPC_COMM_PKT_CHUNK_TO:
1587                         ret = pytalloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->to);
1588                         return ret;
1589
1590                 case FRSRPC_COMM_PKT_CHUNK_FROM:
1591                         ret = pytalloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->from);
1592                         return ret;
1593
1594                 case FRSRPC_COMM_PKT_CHUNK_REPLICA:
1595                         ret = pytalloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->replica);
1596                         return ret;
1597
1598                 case FRSRPC_COMM_PKT_CHUNK_CONNECTION:
1599                         ret = pytalloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->connection);
1600                         return ret;
1601
1602                 case FRSRPC_COMM_PKT_CHUNK_JOIN_GUID:
1603                         ret = pytalloc_reference_ex(GUID_Type, mem_ctx, &in->join_guid);
1604                         return ret;
1605
1606                 case FRSRPC_COMM_PKT_CHUNK_LAST_JOIN_TIME:
1607                         ret = PyLong_FromLongLong(in->last_join_time);
1608                         return ret;
1609
1610                 case FRSRPC_COMM_PKT_CHUNK_VVECTOR:
1611                         ret = pytalloc_reference_ex(&frsrpc_CommPktGSVN_Type, mem_ctx, &in->vvector);
1612                         return ret;
1613
1614                 case FRSRPC_COMM_PKT_CHUNK_JOIN_TIME:
1615                         ret = PyLong_FromLongLong(in->join_time);
1616                         return ret;
1617
1618                 case FRSRPC_COMM_PKT_CHUNK_REPLICA_VERSION_GUID:
1619                         ret = pytalloc_reference_ex(GUID_Type, mem_ctx, &in->replica_version_guid);
1620                         return ret;
1621
1622                 case FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID:
1623                         ret = pytalloc_reference_ex(GUID_Type, mem_ctx, &in->compression_guid);
1624                         return ret;
1625
1626                 case FRSRPC_COMM_PKT_CHUNK_BLOCK:
1627                         ret = PyString_FromStringAndSize((char *)(in->block).data, (in->block).length);
1628                         return ret;
1629
1630                 case FRSRPC_COMM_PKT_CHUNK_BLOCK_SIZE:
1631                         ret = PyLong_FromLongLong(in->block_size);
1632                         return ret;
1633
1634                 case FRSRPC_COMM_PKT_CHUNK_FILE_SIZE:
1635                         ret = PyLong_FromLongLong(in->file_size);
1636                         return ret;
1637
1638                 case FRSRPC_COMM_PKT_CHUNK_FILE_OFFSET:
1639                         ret = PyLong_FromLongLong(in->file_offset);
1640                         return ret;
1641
1642                 case FRSRPC_COMM_PKT_CHUNK_GVSN:
1643                         ret = pytalloc_reference_ex(&frsrpc_CommPktGSVN_Type, mem_ctx, &in->gvsn);
1644                         return ret;
1645
1646                 case FRSRPC_COMM_PKT_CHUNK_CO_GUID:
1647                         ret = pytalloc_reference_ex(GUID_Type, mem_ctx, &in->co_guid);
1648                         return ret;
1649
1650                 case FRSRPC_COMM_PKT_CHUNK_CO_SEQUENCE_NUMBER:
1651                         ret = PyInt_FromLong(in->co_sequnence_number);
1652                         return ret;
1653
1654                 case FRSRPC_COMM_PKT_CHUNK_REMOTE_CO:
1655                         ret = pytalloc_reference_ex(&frsrpc_CommPktChangeOrderCommand_Type, mem_ctx, &in->remote_co);
1656                         return ret;
1657
1658                 case FRSRPC_COMM_PKT_CHUNK_CO_EXT_WIN2K:
1659                         ret = pytalloc_reference_ex(&frsrpc_CommPktCoRecordExtensionWin2k_Type, mem_ctx, &in->co_ext_win2k);
1660                         return ret;
1661
1662                 case FRSRPC_COMM_PKT_CHUNK_CO_EXTENTION_2:
1663                         ret = pytalloc_reference_ex(&frsrpc_CommPktChangeOrderRecordExtension_Type, mem_ctx, &in->co_extension2);
1664                         return ret;
1665
1666                 case FRSRPC_COMM_PKT_CHUNK_EOP:
1667                         ret = PyInt_FromLong(in->bopend);
1668                         return ret;
1669
1670         }
1671         PyErr_SetString(PyExc_TypeError, "unknown union level");
1672         return NULL;
1673 }
1674
1675 union frsrpc_CommPktChunkData *py_export_frsrpc_CommPktChunkData(TALLOC_CTX *mem_ctx, int level, PyObject *in)
1676 {
1677         union frsrpc_CommPktChunkData *ret = talloc_zero(mem_ctx, union frsrpc_CommPktChunkData);
1678         switch (level) {
1679                 default:
1680                         ret->blob = data_blob_talloc(mem_ctx, PyString_AS_STRING(in), PyString_GET_SIZE(in));
1681                         break;
1682
1683                 case FRSRPC_COMM_PKT_CHUNK_BOP:
1684                         PY_CHECK_TYPE(&PyInt_Type, in, talloc_free(ret); return NULL;);
1685                         ret->bop = PyInt_AsLong(in);
1686                         break;
1687
1688                 case FRSRPC_COMM_PKT_CHUNK_COMMAND:
1689                         if (PyLong_Check(in)) {
1690                                 ret->command = PyLong_AsLongLong(in);
1691                         } else if (PyInt_Check(in)) {
1692                                 ret->command = PyInt_AsLong(in);
1693                         } else {
1694                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1695                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1696                                 talloc_free(ret); return NULL;
1697                         }
1698                         break;
1699
1700                 case FRSRPC_COMM_PKT_CHUNK_TO:
1701                         PY_CHECK_TYPE(&frsrpc_CommPktChunkGuidName_Type, in, talloc_free(ret); return NULL;);
1702                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1703                                 PyErr_NoMemory();
1704                                 talloc_free(ret); return NULL;
1705                         }
1706                         ret->to = *(struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(in);
1707                         break;
1708
1709                 case FRSRPC_COMM_PKT_CHUNK_FROM:
1710                         PY_CHECK_TYPE(&frsrpc_CommPktChunkGuidName_Type, in, talloc_free(ret); return NULL;);
1711                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1712                                 PyErr_NoMemory();
1713                                 talloc_free(ret); return NULL;
1714                         }
1715                         ret->from = *(struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(in);
1716                         break;
1717
1718                 case FRSRPC_COMM_PKT_CHUNK_REPLICA:
1719                         PY_CHECK_TYPE(&frsrpc_CommPktChunkGuidName_Type, in, talloc_free(ret); return NULL;);
1720                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1721                                 PyErr_NoMemory();
1722                                 talloc_free(ret); return NULL;
1723                         }
1724                         ret->replica = *(struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(in);
1725                         break;
1726
1727                 case FRSRPC_COMM_PKT_CHUNK_CONNECTION:
1728                         PY_CHECK_TYPE(&frsrpc_CommPktChunkGuidName_Type, in, talloc_free(ret); return NULL;);
1729                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1730                                 PyErr_NoMemory();
1731                                 talloc_free(ret); return NULL;
1732                         }
1733                         ret->connection = *(struct frsrpc_CommPktChunkGuidName *)pytalloc_get_ptr(in);
1734                         break;
1735
1736                 case FRSRPC_COMM_PKT_CHUNK_JOIN_GUID:
1737                         PY_CHECK_TYPE(GUID_Type, in, talloc_free(ret); return NULL;);
1738                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1739                                 PyErr_NoMemory();
1740                                 talloc_free(ret); return NULL;
1741                         }
1742                         ret->join_guid = *(struct GUID *)pytalloc_get_ptr(in);
1743                         break;
1744
1745                 case FRSRPC_COMM_PKT_CHUNK_LAST_JOIN_TIME:
1746                         if (PyLong_Check(in)) {
1747                                 ret->last_join_time = PyLong_AsLongLong(in);
1748                         } else if (PyInt_Check(in)) {
1749                                 ret->last_join_time = PyInt_AsLong(in);
1750                         } else {
1751                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1752                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1753                                 talloc_free(ret); return NULL;
1754                         }
1755                         break;
1756
1757                 case FRSRPC_COMM_PKT_CHUNK_VVECTOR:
1758                         PY_CHECK_TYPE(&frsrpc_CommPktGSVN_Type, in, talloc_free(ret); return NULL;);
1759                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1760                                 PyErr_NoMemory();
1761                                 talloc_free(ret); return NULL;
1762                         }
1763                         ret->vvector = *(struct frsrpc_CommPktGSVN *)pytalloc_get_ptr(in);
1764                         break;
1765
1766                 case FRSRPC_COMM_PKT_CHUNK_JOIN_TIME:
1767                         if (PyLong_Check(in)) {
1768                                 ret->join_time = PyLong_AsLongLong(in);
1769                         } else if (PyInt_Check(in)) {
1770                                 ret->join_time = PyInt_AsLong(in);
1771                         } else {
1772                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1773                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1774                                 talloc_free(ret); return NULL;
1775                         }
1776                         break;
1777
1778                 case FRSRPC_COMM_PKT_CHUNK_REPLICA_VERSION_GUID:
1779                         PY_CHECK_TYPE(GUID_Type, in, talloc_free(ret); return NULL;);
1780                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1781                                 PyErr_NoMemory();
1782                                 talloc_free(ret); return NULL;
1783                         }
1784                         ret->replica_version_guid = *(struct GUID *)pytalloc_get_ptr(in);
1785                         break;
1786
1787                 case FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID:
1788                         PY_CHECK_TYPE(GUID_Type, in, talloc_free(ret); return NULL;);
1789                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1790                                 PyErr_NoMemory();
1791                                 talloc_free(ret); return NULL;
1792                         }
1793                         ret->compression_guid = *(struct GUID *)pytalloc_get_ptr(in);
1794                         break;
1795
1796                 case FRSRPC_COMM_PKT_CHUNK_BLOCK:
1797                         ret->block = data_blob_talloc(mem_ctx, PyString_AS_STRING(in), PyString_GET_SIZE(in));
1798                         break;
1799
1800                 case FRSRPC_COMM_PKT_CHUNK_BLOCK_SIZE:
1801                         if (PyLong_Check(in)) {
1802                                 ret->block_size = PyLong_AsLongLong(in);
1803                         } else if (PyInt_Check(in)) {
1804                                 ret->block_size = PyInt_AsLong(in);
1805                         } else {
1806                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1807                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1808                                 talloc_free(ret); return NULL;
1809                         }
1810                         break;
1811
1812                 case FRSRPC_COMM_PKT_CHUNK_FILE_SIZE:
1813                         if (PyLong_Check(in)) {
1814                                 ret->file_size = PyLong_AsLongLong(in);
1815                         } else if (PyInt_Check(in)) {
1816                                 ret->file_size = PyInt_AsLong(in);
1817                         } else {
1818                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1819                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1820                                 talloc_free(ret); return NULL;
1821                         }
1822                         break;
1823
1824                 case FRSRPC_COMM_PKT_CHUNK_FILE_OFFSET:
1825                         if (PyLong_Check(in)) {
1826                                 ret->file_offset = PyLong_AsLongLong(in);
1827                         } else if (PyInt_Check(in)) {
1828                                 ret->file_offset = PyInt_AsLong(in);
1829                         } else {
1830                                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1831                                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1832                                 talloc_free(ret); return NULL;
1833                         }
1834                         break;
1835
1836                 case FRSRPC_COMM_PKT_CHUNK_GVSN:
1837                         PY_CHECK_TYPE(&frsrpc_CommPktGSVN_Type, in, talloc_free(ret); return NULL;);
1838                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1839                                 PyErr_NoMemory();
1840                                 talloc_free(ret); return NULL;
1841                         }
1842                         ret->gvsn = *(struct frsrpc_CommPktGSVN *)pytalloc_get_ptr(in);
1843                         break;
1844
1845                 case FRSRPC_COMM_PKT_CHUNK_CO_GUID:
1846                         PY_CHECK_TYPE(GUID_Type, in, talloc_free(ret); return NULL;);
1847                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1848                                 PyErr_NoMemory();
1849                                 talloc_free(ret); return NULL;
1850                         }
1851                         ret->co_guid = *(struct GUID *)pytalloc_get_ptr(in);
1852                         break;
1853
1854                 case FRSRPC_COMM_PKT_CHUNK_CO_SEQUENCE_NUMBER:
1855                         PY_CHECK_TYPE(&PyInt_Type, in, talloc_free(ret); return NULL;);
1856                         ret->co_sequnence_number = PyInt_AsLong(in);
1857                         break;
1858
1859                 case FRSRPC_COMM_PKT_CHUNK_REMOTE_CO:
1860                         PY_CHECK_TYPE(&frsrpc_CommPktChangeOrderCommand_Type, in, talloc_free(ret); return NULL;);
1861                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1862                                 PyErr_NoMemory();
1863                                 talloc_free(ret); return NULL;
1864                         }
1865                         ret->remote_co = *(struct frsrpc_CommPktChangeOrderCommand *)pytalloc_get_ptr(in);
1866                         break;
1867
1868                 case FRSRPC_COMM_PKT_CHUNK_CO_EXT_WIN2K:
1869                         PY_CHECK_TYPE(&frsrpc_CommPktCoRecordExtensionWin2k_Type, in, talloc_free(ret); return NULL;);
1870                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1871                                 PyErr_NoMemory();
1872                                 talloc_free(ret); return NULL;
1873                         }
1874                         ret->co_ext_win2k = *(struct frsrpc_CommPktCoRecordExtensionWin2k *)pytalloc_get_ptr(in);
1875                         break;
1876
1877                 case FRSRPC_COMM_PKT_CHUNK_CO_EXTENTION_2:
1878                         PY_CHECK_TYPE(&frsrpc_CommPktChangeOrderRecordExtension_Type, in, talloc_free(ret); return NULL;);
1879                         if (talloc_reference(mem_ctx, pytalloc_get_mem_ctx(in)) == NULL) {
1880                                 PyErr_NoMemory();
1881                                 talloc_free(ret); return NULL;
1882                         }
1883                         ret->co_extension2 = *(struct frsrpc_CommPktChangeOrderRecordExtension *)pytalloc_get_ptr(in);
1884                         break;
1885
1886                 case FRSRPC_COMM_PKT_CHUNK_EOP:
1887                         PY_CHECK_TYPE(&PyInt_Type, in, talloc_free(ret); return NULL;);
1888                         ret->bopend = PyInt_AsLong(in);
1889                         break;
1890
1891         }
1892
1893         return ret;
1894 }
1895
1896
1897 static PyObject *py_frsrpc_CommPktChunk_get_type(PyObject *obj, void *closure)
1898 {
1899         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(obj);
1900         PyObject *py_type;
1901         py_type = PyInt_FromLong(object->type);
1902         return py_type;
1903 }
1904
1905 static int py_frsrpc_CommPktChunk_set_type(PyObject *py_obj, PyObject *value, void *closure)
1906 {
1907         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(py_obj);
1908         if (PyLong_Check(value)) {
1909                 object->type = PyLong_AsLongLong(value);
1910         } else if (PyInt_Check(value)) {
1911                 object->type = PyInt_AsLong(value);
1912         } else {
1913                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
1914                   PyInt_Type.tp_name, PyLong_Type.tp_name);
1915                 return -1;
1916         }
1917         return 0;
1918 }
1919
1920 static PyObject *py_frsrpc_CommPktChunk_get_data(PyObject *obj, void *closure)
1921 {
1922         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(obj);
1923         PyObject *py_data;
1924         py_data = py_import_frsrpc_CommPktChunkData(pytalloc_get_mem_ctx(obj), object->type, &object->data);
1925         if (py_data == NULL) {
1926                 return NULL;
1927         }
1928         return py_data;
1929 }
1930
1931 static int py_frsrpc_CommPktChunk_set_data(PyObject *py_obj, PyObject *value, void *closure)
1932 {
1933         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(py_obj);
1934         {
1935                 union frsrpc_CommPktChunkData *data_switch_1;
1936                 data_switch_1 = py_export_frsrpc_CommPktChunkData(pytalloc_get_mem_ctx(py_obj), object->type, value);
1937                 if (data_switch_1 == NULL) {
1938                         return -1;
1939                 }
1940                 object->data = *data_switch_1;
1941         }
1942         return 0;
1943 }
1944
1945 static PyGetSetDef py_frsrpc_CommPktChunk_getsetters[] = {
1946         { discard_const_p(char, "type"), py_frsrpc_CommPktChunk_get_type, py_frsrpc_CommPktChunk_set_type },
1947         { discard_const_p(char, "data"), py_frsrpc_CommPktChunk_get_data, py_frsrpc_CommPktChunk_set_data },
1948         { NULL }
1949 };
1950
1951 static PyObject *py_frsrpc_CommPktChunk_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
1952 {
1953         return pytalloc_new(struct frsrpc_CommPktChunk, type);
1954 }
1955
1956 static PyObject *py_frsrpc_CommPktChunk_ndr_pack(PyObject *py_obj)
1957 {
1958         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(py_obj);
1959         DATA_BLOB blob;
1960         enum ndr_err_code err;
1961         err = ndr_push_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_push_flags_fn_t)ndr_push_frsrpc_CommPktChunk);
1962         if (err != NDR_ERR_SUCCESS) {
1963                 PyErr_SetNdrError(err);
1964                 return NULL;
1965         }
1966
1967         return PyString_FromStringAndSize((char *)blob.data, blob.length);
1968 }
1969
1970 static PyObject *py_frsrpc_CommPktChunk_ndr_unpack(PyObject *py_obj, PyObject *args, PyObject *kwargs)
1971 {
1972         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(py_obj);
1973         DATA_BLOB blob;
1974         int blob_length = 0;
1975         enum ndr_err_code err;
1976         const char * const kwnames[] = { "data_blob", "allow_remaining", NULL };
1977         PyObject *allow_remaining_obj = NULL;
1978         bool allow_remaining = false;
1979
1980         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s#|O:__ndr_unpack__",
1981                 discard_const_p(char *, kwnames),
1982                 &blob.data, &blob_length,
1983                 &allow_remaining_obj)) {
1984                 return NULL;
1985         }
1986         blob.length = blob_length;
1987
1988         if (allow_remaining_obj && PyObject_IsTrue(allow_remaining_obj)) {
1989                 allow_remaining = true;
1990         }
1991
1992         if (allow_remaining) {
1993                 err = ndr_pull_struct_blob(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_frsrpc_CommPktChunk);
1994         } else {
1995                 err = ndr_pull_struct_blob_all(&blob, pytalloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_frsrpc_CommPktChunk);
1996         }
1997         if (err != NDR_ERR_SUCCESS) {
1998                 PyErr_SetNdrError(err);
1999                 return NULL;
2000         }
2001
2002         Py_RETURN_NONE;
2003 }
2004
2005 static PyObject *py_frsrpc_CommPktChunk_ndr_print(PyObject *py_obj)
2006 {
2007         struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)pytalloc_get_ptr(py_obj);
2008         PyObject *ret;
2009         char *retstr;
2010
2011         retstr = ndr_print_struct_string(pytalloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_frsrpc_CommPktChunk, "frsrpc_CommPktChunk", object);
2012         ret = PyString_FromString(retstr);
2013         talloc_free(retstr);
2014
2015         return ret;
2016 }
2017
2018 static PyMethodDef py_frsrpc_CommPktChunk_methods[] = {
2019         { "__ndr_pack__", (PyCFunction)py_frsrpc_CommPktChunk_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
2020         { "__ndr_unpack__", (PyCFunction)py_frsrpc_CommPktChunk_ndr_unpack, METH_VARARGS|METH_KEYWORDS, "S.ndr_unpack(class, blob, allow_remaining=False) -> None\nNDR unpack" },
2021         { "__ndr_print__", (PyCFunction)py_frsrpc_CommPktChunk_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
2022         { NULL, NULL, 0, NULL }
2023 };
2024
2025
2026 static PyTypeObject frsrpc_CommPktChunk_Type = {
2027         PyObject_HEAD_INIT(NULL) 0,
2028         .tp_name = "frsrpc.CommPktChunk",
2029         .tp_getset = py_frsrpc_CommPktChunk_getsetters,
2030         .tp_methods = py_frsrpc_CommPktChunk_methods,
2031         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2032         .tp_basicsize = sizeof(pytalloc_Object),
2033         .tp_new = py_frsrpc_CommPktChunk_new,
2034 };
2035
2036
2037 static PyObject *py_frsrpc_CommPktChunkCtr_get_num_chunks(PyObject *obj, void *closure)
2038 {
2039         struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)pytalloc_get_ptr(obj);
2040         PyObject *py_num_chunks;
2041         py_num_chunks = PyInt_FromLong(object->num_chunks);
2042         return py_num_chunks;
2043 }
2044
2045 static int py_frsrpc_CommPktChunkCtr_set_num_chunks(PyObject *py_obj, PyObject *value, void *closure)
2046 {
2047         struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)pytalloc_get_ptr(py_obj);
2048         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2049         object->num_chunks = PyInt_AsLong(value);
2050         return 0;
2051 }
2052
2053 static PyObject *py_frsrpc_CommPktChunkCtr_get_chunks(PyObject *obj, void *closure)
2054 {
2055         struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)pytalloc_get_ptr(obj);
2056         PyObject *py_chunks;
2057         py_chunks = PyList_New(object->num_chunks);
2058         if (py_chunks == NULL) {
2059                 return NULL;
2060         }
2061         {
2062                 int chunks_cntr_0;
2063                 for (chunks_cntr_0 = 0; chunks_cntr_0 < object->num_chunks; chunks_cntr_0++) {
2064                         PyObject *py_chunks_0;
2065                         py_chunks_0 = pytalloc_reference_ex(&frsrpc_CommPktChunk_Type, object->chunks, &object->chunks[chunks_cntr_0]);
2066                         PyList_SetItem(py_chunks, chunks_cntr_0, py_chunks_0);
2067                 }
2068         }
2069         return py_chunks;
2070 }
2071
2072 static int py_frsrpc_CommPktChunkCtr_set_chunks(PyObject *py_obj, PyObject *value, void *closure)
2073 {
2074         struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)pytalloc_get_ptr(py_obj);
2075         PY_CHECK_TYPE(&PyList_Type, value, return -1;);
2076         {
2077                 int chunks_cntr_0;
2078                 object->chunks = talloc_array_ptrtype(pytalloc_get_mem_ctx(py_obj), object->chunks, PyList_GET_SIZE(value));
2079                 if (!object->chunks) { return -1;; }
2080                 talloc_set_name_const(object->chunks, "ARRAY: object->chunks");
2081                 for (chunks_cntr_0 = 0; chunks_cntr_0 < PyList_GET_SIZE(value); chunks_cntr_0++) {
2082                         PY_CHECK_TYPE(&frsrpc_CommPktChunk_Type, PyList_GET_ITEM(value, chunks_cntr_0), return -1;);
2083                         if (talloc_reference(object->chunks, pytalloc_get_mem_ctx(PyList_GET_ITEM(value, chunks_cntr_0))) == NULL) {
2084                                 PyErr_NoMemory();
2085                                 return -1;
2086                         }
2087                         object->chunks[chunks_cntr_0] = *(struct frsrpc_CommPktChunk *)pytalloc_get_ptr(PyList_GET_ITEM(value, chunks_cntr_0));
2088                 }
2089         }
2090         return 0;
2091 }
2092
2093 static PyGetSetDef py_frsrpc_CommPktChunkCtr_getsetters[] = {
2094         { discard_const_p(char, "num_chunks"), py_frsrpc_CommPktChunkCtr_get_num_chunks, py_frsrpc_CommPktChunkCtr_set_num_chunks },
2095         { discard_const_p(char, "chunks"), py_frsrpc_CommPktChunkCtr_get_chunks, py_frsrpc_CommPktChunkCtr_set_chunks },
2096         { NULL }
2097 };
2098
2099 static PyObject *py_frsrpc_CommPktChunkCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2100 {
2101         return pytalloc_new(struct frsrpc_CommPktChunkCtr, type);
2102 }
2103
2104
2105 static PyTypeObject frsrpc_CommPktChunkCtr_Type = {
2106         PyObject_HEAD_INIT(NULL) 0,
2107         .tp_name = "frsrpc.CommPktChunkCtr",
2108         .tp_getset = py_frsrpc_CommPktChunkCtr_getsetters,
2109         .tp_methods = NULL,
2110         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2111         .tp_basicsize = sizeof(pytalloc_Object),
2112         .tp_new = py_frsrpc_CommPktChunkCtr_new,
2113 };
2114
2115
2116 static PyObject *py_frsrpc_FrsSendCommPktReq_get_major(PyObject *obj, void *closure)
2117 {
2118         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2119         PyObject *py_major;
2120         py_major = PyInt_FromLong(object->major);
2121         return py_major;
2122 }
2123
2124 static int py_frsrpc_FrsSendCommPktReq_set_major(PyObject *py_obj, PyObject *value, void *closure)
2125 {
2126         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2127         if (PyLong_Check(value)) {
2128                 object->major = PyLong_AsLongLong(value);
2129         } else if (PyInt_Check(value)) {
2130                 object->major = PyInt_AsLong(value);
2131         } else {
2132                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2133                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2134                 return -1;
2135         }
2136         return 0;
2137 }
2138
2139 static PyObject *py_frsrpc_FrsSendCommPktReq_get_minor(PyObject *obj, void *closure)
2140 {
2141         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2142         PyObject *py_minor;
2143         py_minor = PyInt_FromLong(object->minor);
2144         return py_minor;
2145 }
2146
2147 static int py_frsrpc_FrsSendCommPktReq_set_minor(PyObject *py_obj, PyObject *value, void *closure)
2148 {
2149         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2150         if (PyLong_Check(value)) {
2151                 object->minor = PyLong_AsLongLong(value);
2152         } else if (PyInt_Check(value)) {
2153                 object->minor = PyInt_AsLong(value);
2154         } else {
2155                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2156                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2157                 return -1;
2158         }
2159         return 0;
2160 }
2161
2162 static PyObject *py_frsrpc_FrsSendCommPktReq_get_cs_id(PyObject *obj, void *closure)
2163 {
2164         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2165         PyObject *py_cs_id;
2166         py_cs_id = PyInt_FromLong(object->cs_id);
2167         return py_cs_id;
2168 }
2169
2170 static int py_frsrpc_FrsSendCommPktReq_set_cs_id(PyObject *py_obj, PyObject *value, void *closure)
2171 {
2172         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2173         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2174         object->cs_id = PyInt_AsLong(value);
2175         return 0;
2176 }
2177
2178 static PyObject *py_frsrpc_FrsSendCommPktReq_get_memory_len(PyObject *obj, void *closure)
2179 {
2180         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2181         PyObject *py_memory_len;
2182         py_memory_len = PyInt_FromLong(object->memory_len);
2183         return py_memory_len;
2184 }
2185
2186 static int py_frsrpc_FrsSendCommPktReq_set_memory_len(PyObject *py_obj, PyObject *value, void *closure)
2187 {
2188         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2189         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2190         object->memory_len = PyInt_AsLong(value);
2191         return 0;
2192 }
2193
2194 static PyObject *py_frsrpc_FrsSendCommPktReq_get_pkt_len(PyObject *obj, void *closure)
2195 {
2196         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2197         PyObject *py_pkt_len;
2198         py_pkt_len = PyInt_FromLong(object->pkt_len);
2199         return py_pkt_len;
2200 }
2201
2202 static int py_frsrpc_FrsSendCommPktReq_set_pkt_len(PyObject *py_obj, PyObject *value, void *closure)
2203 {
2204         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2205         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2206         object->pkt_len = PyInt_AsLong(value);
2207         return 0;
2208 }
2209
2210 static PyObject *py_frsrpc_FrsSendCommPktReq_get_upk_len(PyObject *obj, void *closure)
2211 {
2212         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2213         PyObject *py_upk_len;
2214         py_upk_len = PyInt_FromLong(object->upk_len);
2215         return py_upk_len;
2216 }
2217
2218 static int py_frsrpc_FrsSendCommPktReq_set_upk_len(PyObject *py_obj, PyObject *value, void *closure)
2219 {
2220         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2221         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2222         object->upk_len = PyInt_AsLong(value);
2223         return 0;
2224 }
2225
2226 static PyObject *py_frsrpc_FrsSendCommPktReq_get_ctr(PyObject *obj, void *closure)
2227 {
2228         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2229         PyObject *py_ctr;
2230         if (object->ctr == NULL) {
2231                 py_ctr = Py_None;
2232                 Py_INCREF(py_ctr);
2233         } else {
2234                 py_ctr = pytalloc_reference_ex(&frsrpc_CommPktChunkCtr_Type, object->ctr, object->ctr);
2235         }
2236         return py_ctr;
2237 }
2238
2239 static int py_frsrpc_FrsSendCommPktReq_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
2240 {
2241         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2242         talloc_unlink(pytalloc_get_mem_ctx(py_obj), object->ctr);
2243         if (value == Py_None) {
2244                 object->ctr = NULL;
2245         } else {
2246                 object->ctr = NULL;
2247                 PY_CHECK_TYPE(&frsrpc_CommPktChunkCtr_Type, value, return -1;);
2248                 if (talloc_reference(pytalloc_get_mem_ctx(py_obj), pytalloc_get_mem_ctx(value)) == NULL) {
2249                         PyErr_NoMemory();
2250                         return -1;
2251                 }
2252                 object->ctr = (struct frsrpc_CommPktChunkCtr *)pytalloc_get_ptr(value);
2253         }
2254         return 0;
2255 }
2256
2257 static PyObject *py_frsrpc_FrsSendCommPktReq_get_data_name(PyObject *obj, void *closure)
2258 {
2259         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2260         PyObject *py_data_name;
2261         py_data_name = PyInt_FromLong(object->data_name);
2262         return py_data_name;
2263 }
2264
2265 static int py_frsrpc_FrsSendCommPktReq_set_data_name(PyObject *py_obj, PyObject *value, void *closure)
2266 {
2267         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2268         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2269         object->data_name = PyInt_AsLong(value);
2270         return 0;
2271 }
2272
2273 static PyObject *py_frsrpc_FrsSendCommPktReq_get_data_handle(PyObject *obj, void *closure)
2274 {
2275         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(obj);
2276         PyObject *py_data_handle;
2277         py_data_handle = PyInt_FromLong(object->data_handle);
2278         return py_data_handle;
2279 }
2280
2281 static int py_frsrpc_FrsSendCommPktReq_set_data_handle(PyObject *py_obj, PyObject *value, void *closure)
2282 {
2283         struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_obj);
2284         PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
2285         object->data_handle = PyInt_AsLong(value);
2286         return 0;
2287 }
2288
2289 static PyGetSetDef py_frsrpc_FrsSendCommPktReq_getsetters[] = {
2290         { discard_const_p(char, "major"), py_frsrpc_FrsSendCommPktReq_get_major, py_frsrpc_FrsSendCommPktReq_set_major },
2291         { discard_const_p(char, "minor"), py_frsrpc_FrsSendCommPktReq_get_minor, py_frsrpc_FrsSendCommPktReq_set_minor },
2292         { discard_const_p(char, "cs_id"), py_frsrpc_FrsSendCommPktReq_get_cs_id, py_frsrpc_FrsSendCommPktReq_set_cs_id },
2293         { discard_const_p(char, "memory_len"), py_frsrpc_FrsSendCommPktReq_get_memory_len, py_frsrpc_FrsSendCommPktReq_set_memory_len },
2294         { discard_const_p(char, "pkt_len"), py_frsrpc_FrsSendCommPktReq_get_pkt_len, py_frsrpc_FrsSendCommPktReq_set_pkt_len },
2295         { discard_const_p(char, "upk_len"), py_frsrpc_FrsSendCommPktReq_get_upk_len, py_frsrpc_FrsSendCommPktReq_set_upk_len },
2296         { discard_const_p(char, "ctr"), py_frsrpc_FrsSendCommPktReq_get_ctr, py_frsrpc_FrsSendCommPktReq_set_ctr },
2297         { discard_const_p(char, "data_name"), py_frsrpc_FrsSendCommPktReq_get_data_name, py_frsrpc_FrsSendCommPktReq_set_data_name },
2298         { discard_const_p(char, "data_handle"), py_frsrpc_FrsSendCommPktReq_get_data_handle, py_frsrpc_FrsSendCommPktReq_set_data_handle },
2299         { NULL }
2300 };
2301
2302 static PyObject *py_frsrpc_FrsSendCommPktReq_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2303 {
2304         return pytalloc_new(struct frsrpc_FrsSendCommPktReq, type);
2305 }
2306
2307
2308 static PyTypeObject frsrpc_FrsSendCommPktReq_Type = {
2309         PyObject_HEAD_INIT(NULL) 0,
2310         .tp_name = "frsrpc.FrsSendCommPktReq",
2311         .tp_getset = py_frsrpc_FrsSendCommPktReq_getsetters,
2312         .tp_methods = NULL,
2313         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2314         .tp_basicsize = sizeof(pytalloc_Object),
2315         .tp_new = py_frsrpc_FrsSendCommPktReq_new,
2316 };
2317
2318
2319 static bool pack_py_frsrpc_FrsSendCommPkt_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsSendCommPkt *r)
2320 {
2321         PyObject *py_req;
2322         const char *kwnames[] = {
2323                 "req", NULL
2324         };
2325
2326         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:frsrpc_FrsSendCommPkt", discard_const_p(char *, kwnames), &py_req)) {
2327                 return false;
2328         }
2329
2330         PY_CHECK_TYPE(&frsrpc_FrsSendCommPktReq_Type, py_req, return false;);
2331         if (talloc_reference(r, pytalloc_get_mem_ctx(py_req)) == NULL) {
2332                 PyErr_NoMemory();
2333                 return false;
2334         }
2335         r->in.req = *(struct frsrpc_FrsSendCommPktReq *)pytalloc_get_ptr(py_req);
2336         return true;
2337 }
2338
2339 static PyObject *unpack_py_frsrpc_FrsSendCommPkt_args_out(struct frsrpc_FrsSendCommPkt *r)
2340 {
2341         PyObject *result;
2342         result = Py_None;
2343         Py_INCREF(result);
2344         if (!W_ERROR_IS_OK(r->out.result)) {
2345                 PyErr_SetWERROR(r->out.result);
2346                 return NULL;
2347         }
2348
2349         return result;
2350 }
2351
2352 static bool pack_py_frsrpc_FrsVerifyPromotionParent_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsVerifyPromotionParent *r)
2353 {
2354         PyObject *py_parent_account;
2355         PyObject *py_parent_password;
2356         PyObject *py_replica_set_name;
2357         PyObject *py_replica_set_type;
2358         PyObject *py_partner_auth_level;
2359         PyObject *py___ndr_guid_size;
2360         const char *kwnames[] = {
2361                 "parent_account", "parent_password", "replica_set_name", "replica_set_type", "partner_auth_level", "__ndr_guid_size", NULL
2362         };
2363
2364         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOO:frsrpc_FrsVerifyPromotionParent", discard_const_p(char *, kwnames), &py_parent_account, &py_parent_password, &py_replica_set_name, &py_replica_set_type, &py_partner_auth_level, &py___ndr_guid_size)) {
2365                 return false;
2366         }
2367
2368         if (py_parent_account == Py_None) {
2369                 r->in.parent_account = NULL;
2370         } else {
2371                 r->in.parent_account = NULL;
2372                 if (PyUnicode_Check(py_parent_account)) {
2373                         r->in.parent_account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_account, "utf-8", "ignore"));
2374                 } else if (PyString_Check(py_parent_account)) {
2375                         r->in.parent_account = PyString_AS_STRING(py_parent_account);
2376                 } else {
2377                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_account)->tp_name);
2378                         return false;
2379                 }
2380         }
2381         if (py_parent_password == Py_None) {
2382                 r->in.parent_password = NULL;
2383         } else {
2384                 r->in.parent_password = NULL;
2385                 if (PyUnicode_Check(py_parent_password)) {
2386                         r->in.parent_password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_password, "utf-8", "ignore"));
2387                 } else if (PyString_Check(py_parent_password)) {
2388                         r->in.parent_password = PyString_AS_STRING(py_parent_password);
2389                 } else {
2390                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_password)->tp_name);
2391                         return false;
2392                 }
2393         }
2394         if (py_replica_set_name == Py_None) {
2395                 r->in.replica_set_name = NULL;
2396         } else {
2397                 r->in.replica_set_name = NULL;
2398                 if (PyUnicode_Check(py_replica_set_name)) {
2399                         r->in.replica_set_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_name, "utf-8", "ignore"));
2400                 } else if (PyString_Check(py_replica_set_name)) {
2401                         r->in.replica_set_name = PyString_AS_STRING(py_replica_set_name);
2402                 } else {
2403                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_name)->tp_name);
2404                         return false;
2405                 }
2406         }
2407         if (py_replica_set_type == Py_None) {
2408                 r->in.replica_set_type = NULL;
2409         } else {
2410                 r->in.replica_set_type = NULL;
2411                 if (PyUnicode_Check(py_replica_set_type)) {
2412                         r->in.replica_set_type = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_type, "utf-8", "ignore"));
2413                 } else if (PyString_Check(py_replica_set_type)) {
2414                         r->in.replica_set_type = PyString_AS_STRING(py_replica_set_type);
2415                 } else {
2416                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_type)->tp_name);
2417                         return false;
2418                 }
2419         }
2420         if (PyLong_Check(py_partner_auth_level)) {
2421                 r->in.partner_auth_level = PyLong_AsLongLong(py_partner_auth_level);
2422         } else if (PyInt_Check(py_partner_auth_level)) {
2423                 r->in.partner_auth_level = PyInt_AsLong(py_partner_auth_level);
2424         } else {
2425                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2426                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2427                 return false;
2428         }
2429         PY_CHECK_TYPE(&PyInt_Type, py___ndr_guid_size, return false;);
2430         r->in.__ndr_guid_size = PyInt_AsLong(py___ndr_guid_size);
2431         return true;
2432 }
2433
2434 static PyObject *unpack_py_frsrpc_FrsVerifyPromotionParent_args_out(struct frsrpc_FrsVerifyPromotionParent *r)
2435 {
2436         PyObject *result;
2437         result = Py_None;
2438         Py_INCREF(result);
2439         if (!W_ERROR_IS_OK(r->out.result)) {
2440                 PyErr_SetWERROR(r->out.result);
2441                 return NULL;
2442         }
2443
2444         return result;
2445 }
2446
2447 static bool pack_py_frsrpc_FrsStartPromotionParent_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsStartPromotionParent *r)
2448 {
2449         PyObject *py_parent_account;
2450         PyObject *py_parent_password;
2451         PyObject *py_replica_set_name;
2452         PyObject *py_replica_set_type;
2453         PyObject *py_connection_name;
2454         PyObject *py_partner_name;
2455         PyObject *py_partner_princ_name;
2456         PyObject *py_partner_auth_level;
2457         PyObject *py___ndr_guid_size;
2458         PyObject *py_connection_guid;
2459         PyObject *py_partner_guid;
2460         PyObject *py_parent_guid;
2461         const char *kwnames[] = {
2462                 "parent_account", "parent_password", "replica_set_name", "replica_set_type", "connection_name", "partner_name", "partner_princ_name", "partner_auth_level", "__ndr_guid_size", "connection_guid", "partner_guid", "parent_guid", NULL
2463         };
2464
2465         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOOOOOOOOOO:frsrpc_FrsStartPromotionParent", discard_const_p(char *, kwnames), &py_parent_account, &py_parent_password, &py_replica_set_name, &py_replica_set_type, &py_connection_name, &py_partner_name, &py_partner_princ_name, &py_partner_auth_level, &py___ndr_guid_size, &py_connection_guid, &py_partner_guid, &py_parent_guid)) {
2466                 return false;
2467         }
2468
2469         if (py_parent_account == Py_None) {
2470                 r->in.parent_account = NULL;
2471         } else {
2472                 r->in.parent_account = NULL;
2473                 if (PyUnicode_Check(py_parent_account)) {
2474                         r->in.parent_account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_account, "utf-8", "ignore"));
2475                 } else if (PyString_Check(py_parent_account)) {
2476                         r->in.parent_account = PyString_AS_STRING(py_parent_account);
2477                 } else {
2478                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_account)->tp_name);
2479                         return false;
2480                 }
2481         }
2482         if (py_parent_password == Py_None) {
2483                 r->in.parent_password = NULL;
2484         } else {
2485                 r->in.parent_password = NULL;
2486                 if (PyUnicode_Check(py_parent_password)) {
2487                         r->in.parent_password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_password, "utf-8", "ignore"));
2488                 } else if (PyString_Check(py_parent_password)) {
2489                         r->in.parent_password = PyString_AS_STRING(py_parent_password);
2490                 } else {
2491                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_password)->tp_name);
2492                         return false;
2493                 }
2494         }
2495         if (py_replica_set_name == Py_None) {
2496                 r->in.replica_set_name = NULL;
2497         } else {
2498                 r->in.replica_set_name = NULL;
2499                 if (PyUnicode_Check(py_replica_set_name)) {
2500                         r->in.replica_set_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_name, "utf-8", "ignore"));
2501                 } else if (PyString_Check(py_replica_set_name)) {
2502                         r->in.replica_set_name = PyString_AS_STRING(py_replica_set_name);
2503                 } else {
2504                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_name)->tp_name);
2505                         return false;
2506                 }
2507         }
2508         if (py_replica_set_type == Py_None) {
2509                 r->in.replica_set_type = NULL;
2510         } else {
2511                 r->in.replica_set_type = NULL;
2512                 if (PyUnicode_Check(py_replica_set_type)) {
2513                         r->in.replica_set_type = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_type, "utf-8", "ignore"));
2514                 } else if (PyString_Check(py_replica_set_type)) {
2515                         r->in.replica_set_type = PyString_AS_STRING(py_replica_set_type);
2516                 } else {
2517                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_type)->tp_name);
2518                         return false;
2519                 }
2520         }
2521         if (py_connection_name == Py_None) {
2522                 r->in.connection_name = NULL;
2523         } else {
2524                 r->in.connection_name = NULL;
2525                 if (PyUnicode_Check(py_connection_name)) {
2526                         r->in.connection_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_connection_name, "utf-8", "ignore"));
2527                 } else if (PyString_Check(py_connection_name)) {
2528                         r->in.connection_name = PyString_AS_STRING(py_connection_name);
2529                 } else {
2530                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_connection_name)->tp_name);
2531                         return false;
2532                 }
2533         }
2534         if (py_partner_name == Py_None) {
2535                 r->in.partner_name = NULL;
2536         } else {
2537                 r->in.partner_name = NULL;
2538                 if (PyUnicode_Check(py_partner_name)) {
2539                         r->in.partner_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_partner_name, "utf-8", "ignore"));
2540                 } else if (PyString_Check(py_partner_name)) {
2541                         r->in.partner_name = PyString_AS_STRING(py_partner_name);
2542                 } else {
2543                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_partner_name)->tp_name);
2544                         return false;
2545                 }
2546         }
2547         if (py_partner_princ_name == Py_None) {
2548                 r->in.partner_princ_name = NULL;
2549         } else {
2550                 r->in.partner_princ_name = NULL;
2551                 if (PyUnicode_Check(py_partner_princ_name)) {
2552                         r->in.partner_princ_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_partner_princ_name, "utf-8", "ignore"));
2553                 } else if (PyString_Check(py_partner_princ_name)) {
2554                         r->in.partner_princ_name = PyString_AS_STRING(py_partner_princ_name);
2555                 } else {
2556                         PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_partner_princ_name)->tp_name);
2557                         return false;
2558                 }
2559         }
2560         if (PyLong_Check(py_partner_auth_level)) {
2561                 r->in.partner_auth_level = PyLong_AsLongLong(py_partner_auth_level);
2562         } else if (PyInt_Check(py_partner_auth_level)) {
2563                 r->in.partner_auth_level = PyInt_AsLong(py_partner_auth_level);
2564         } else {
2565                 PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
2566                   PyInt_Type.tp_name, PyLong_Type.tp_name);
2567                 return false;
2568         }
2569         PY_CHECK_TYPE(&PyInt_Type, py___ndr_guid_size, return false;);
2570         r->in.__ndr_guid_size = PyInt_AsLong(py___ndr_guid_size);
2571         if (py_connection_guid == Py_None) {
2572                 r->in.connection_guid = NULL;
2573         } else {
2574                 r->in.connection_guid = NULL;
2575                 PY_CHECK_TYPE(GUID_Type, py_connection_guid, return false;);
2576                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_connection_guid)) == NULL) {
2577                         PyErr_NoMemory();
2578                         return false;
2579                 }
2580                 r->in.connection_guid = (struct GUID *)pytalloc_get_ptr(py_connection_guid);
2581         }
2582         if (py_partner_guid == Py_None) {
2583                 r->in.partner_guid = NULL;
2584         } else {
2585                 r->in.partner_guid = NULL;
2586                 PY_CHECK_TYPE(GUID_Type, py_partner_guid, return false;);
2587                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_partner_guid)) == NULL) {
2588                         PyErr_NoMemory();
2589                         return false;
2590                 }
2591                 r->in.partner_guid = (struct GUID *)pytalloc_get_ptr(py_partner_guid);
2592         }
2593         if (py_parent_guid == Py_None) {
2594                 r->in.parent_guid = NULL;
2595         } else {
2596                 r->in.parent_guid = NULL;
2597                 PY_CHECK_TYPE(GUID_Type, py_parent_guid, return false;);
2598                 if (talloc_reference(r, pytalloc_get_mem_ctx(py_parent_guid)) == NULL) {
2599                         PyErr_NoMemory();
2600                         return false;
2601                 }
2602                 r->in.parent_guid = (struct GUID *)pytalloc_get_ptr(py_parent_guid);
2603         }
2604         return true;
2605 }
2606
2607 static PyObject *unpack_py_frsrpc_FrsStartPromotionParent_args_out(struct frsrpc_FrsStartPromotionParent *r)
2608 {
2609         PyObject *result;
2610         PyObject *py_parent_guid;
2611         if (r->out.parent_guid == NULL) {
2612                 py_parent_guid = Py_None;
2613                 Py_INCREF(py_parent_guid);
2614         } else {
2615                 py_parent_guid = pytalloc_reference_ex(GUID_Type, r->out.parent_guid, r->out.parent_guid);
2616         }
2617         result = py_parent_guid;
2618         if (!W_ERROR_IS_OK(r->out.result)) {
2619                 PyErr_SetWERROR(r->out.result);
2620                 return NULL;
2621         }
2622
2623         return result;
2624 }
2625
2626 static bool pack_py_frsrpc_FrsNOP_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsNOP *r)
2627 {
2628         const char *kwnames[] = {
2629                 NULL
2630         };
2631
2632         if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":frsrpc_FrsNOP", discard_const_p(char *, kwnames))) {
2633                 return false;
2634         }
2635
2636         return true;
2637 }
2638
2639 static PyObject *unpack_py_frsrpc_FrsNOP_args_out(struct frsrpc_FrsNOP *r)
2640 {
2641         PyObject *result;
2642         result = Py_None;
2643         Py_INCREF(result);
2644         if (!W_ERROR_IS_OK(r->out.result)) {
2645                 PyErr_SetWERROR(r->out.result);
2646                 return NULL;
2647         }
2648
2649         return result;
2650 }
2651
2652 const struct PyNdrRpcMethodDef py_ndr_frsrpc_methods[] = {
2653         { "FrsSendCommPkt", "S.FrsSendCommPkt(req) -> None", (py_dcerpc_call_fn)dcerpc_frsrpc_FrsSendCommPkt_r, (py_data_pack_fn)pack_py_frsrpc_FrsSendCommPkt_args_in, (py_data_unpack_fn)unpack_py_frsrpc_FrsSendCommPkt_args_out, 0, &ndr_table_frsrpc },
2654         { "FrsVerifyPromotionParent", "S.FrsVerifyPromotionParent(parent_account, parent_password, replica_set_name, replica_set_type, partner_auth_level, __ndr_guid_size) -> None", (py_dcerpc_call_fn)dcerpc_frsrpc_FrsVerifyPromotionParent_r, (py_data_pack_fn)pack_py_frsrpc_FrsVerifyPromotionParent_args_in, (py_data_unpack_fn)unpack_py_frsrpc_FrsVerifyPromotionParent_args_out, 1, &ndr_table_frsrpc },
2655         { "FrsStartPromotionParent", "S.FrsStartPromotionParent(parent_account, parent_password, replica_set_name, replica_set_type, connection_name, partner_name, partner_princ_name, partner_auth_level, __ndr_guid_size, connection_guid, partner_guid, parent_guid) -> parent_guid", (py_dcerpc_call_fn)dcerpc_frsrpc_FrsStartPromotionParent_r, (py_data_pack_fn)pack_py_frsrpc_FrsStartPromotionParent_args_in, (py_data_unpack_fn)unpack_py_frsrpc_FrsStartPromotionParent_args_out, 2, &ndr_table_frsrpc },
2656         { "FrsNOP", "S.FrsNOP() -> None", (py_dcerpc_call_fn)dcerpc_frsrpc_FrsNOP_r, (py_data_pack_fn)pack_py_frsrpc_FrsNOP_args_in, (py_data_unpack_fn)unpack_py_frsrpc_FrsNOP_args_out, 3, &ndr_table_frsrpc },
2657         { NULL }
2658 };
2659
2660 static PyObject *interface_frsrpc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
2661 {
2662         return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_frsrpc);
2663 }
2664
2665 #define PY_DOC_FRSRPC "File Replication Service"
2666 static PyTypeObject frsrpc_InterfaceType = {
2667         PyObject_HEAD_INIT(NULL) 0,
2668         .tp_name = "frsrpc.frsrpc",
2669         .tp_basicsize = sizeof(dcerpc_InterfaceObject),
2670         .tp_doc = "frsrpc(binding, lp_ctx=None, credentials=None) -> connection\n"
2671 "\n"
2672 "binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
2673 "lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
2674 "credentials should be a credentials.Credentials object.\n\n"PY_DOC_FRSRPC,
2675         .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
2676         .tp_new = interface_frsrpc_new,
2677 };
2678
2679 static PyMethodDef frsrpc_methods[] = {
2680         { NULL, NULL, 0, NULL }
2681 };
2682
2683 void initfrsrpc(void)
2684 {
2685         PyObject *m;
2686         PyObject *dep_talloc;
2687         PyObject *dep_samba_dcerpc_misc;
2688         PyObject *dep_samba_dcerpc_base;
2689
2690         dep_talloc = PyImport_ImportModule("talloc");
2691         if (dep_talloc == NULL)
2692                 return;
2693
2694         dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
2695         if (dep_samba_dcerpc_misc == NULL)
2696                 return;
2697
2698         dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
2699         if (dep_samba_dcerpc_base == NULL)
2700                 return;
2701
2702         Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
2703         if (Object_Type == NULL)
2704                 return;
2705
2706         GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
2707         if (GUID_Type == NULL)
2708                 return;
2709
2710         ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
2711         if (ClientConnection_Type == NULL)
2712                 return;
2713
2714         frsrpc_CommPktChunkGuidName_Type.tp_base = Object_Type;
2715
2716         frsrpc_CommPktGSVN_Type.tp_base = Object_Type;
2717
2718         frsrpc_CommPktChangeOrderCommand_Type.tp_base = Object_Type;
2719
2720         frsrpc_CommPktDataExtensionChecksum_Type.tp_base = Object_Type;
2721
2722         frsrpc_CommPktDataExtensionRetryTimeout_Type.tp_base = Object_Type;
2723
2724         frsrpc_CommPktCoRecordExtensionWin2k_Type.tp_base = Object_Type;
2725
2726         frsrpc_CommPktChangeOrderRecordExtension_Type.tp_base = Object_Type;
2727
2728         frsrpc_CommPktChunk_Type.tp_base = Object_Type;
2729
2730         frsrpc_CommPktChunkCtr_Type.tp_base = Object_Type;
2731
2732         frsrpc_FrsSendCommPktReq_Type.tp_base = Object_Type;
2733
2734         frsrpc_InterfaceType.tp_base = ClientConnection_Type;
2735
2736         if (PyType_Ready(&frsrpc_CommPktChunkGuidName_Type) < 0)
2737                 return;
2738         if (PyType_Ready(&frsrpc_CommPktGSVN_Type) < 0)
2739                 return;
2740         if (PyType_Ready(&frsrpc_CommPktChangeOrderCommand_Type) < 0)
2741                 return;
2742         if (PyType_Ready(&frsrpc_CommPktDataExtensionChecksum_Type) < 0)
2743                 return;
2744         if (PyType_Ready(&frsrpc_CommPktDataExtensionRetryTimeout_Type) < 0)
2745                 return;
2746         if (PyType_Ready(&frsrpc_CommPktCoRecordExtensionWin2k_Type) < 0)
2747                 return;
2748         if (PyType_Ready(&frsrpc_CommPktChangeOrderRecordExtension_Type) < 0)
2749                 return;
2750         if (PyType_Ready(&frsrpc_CommPktChunk_Type) < 0)
2751                 return;
2752         if (PyType_Ready(&frsrpc_CommPktChunkCtr_Type) < 0)
2753                 return;
2754         if (PyType_Ready(&frsrpc_FrsSendCommPktReq_Type) < 0)
2755                 return;
2756         if (PyType_Ready(&frsrpc_InterfaceType) < 0)
2757                 return;
2758         if (!PyInterface_AddNdrRpcMethods(&frsrpc_InterfaceType, py_ndr_frsrpc_methods))
2759                 return;
2760
2761 #ifdef PY_COMMPKTCHUNKGUIDNAME_PATCH
2762         PY_COMMPKTCHUNKGUIDNAME_PATCH(&frsrpc_CommPktChunkGuidName_Type);
2763 #endif
2764 #ifdef PY_COMMPKTGSVN_PATCH
2765         PY_COMMPKTGSVN_PATCH(&frsrpc_CommPktGSVN_Type);
2766 #endif
2767 #ifdef PY_COMMPKTCHANGEORDERCOMMAND_PATCH
2768         PY_COMMPKTCHANGEORDERCOMMAND_PATCH(&frsrpc_CommPktChangeOrderCommand_Type);
2769 #endif
2770 #ifdef PY_COMMPKTDATAEXTENSIONCHECKSUM_PATCH
2771         PY_COMMPKTDATAEXTENSIONCHECKSUM_PATCH(&frsrpc_CommPktDataExtensionChecksum_Type);
2772 #endif
2773 #ifdef PY_COMMPKTDATAEXTENSIONRETRYTIMEOUT_PATCH
2774         PY_COMMPKTDATAEXTENSIONRETRYTIMEOUT_PATCH(&frsrpc_CommPktDataExtensionRetryTimeout_Type);
2775 #endif
2776 #ifdef PY_COMMPKTCORECORDEXTENSIONWIN2K_PATCH
2777         PY_COMMPKTCORECORDEXTENSIONWIN2K_PATCH(&frsrpc_CommPktCoRecordExtensionWin2k_Type);
2778 #endif
2779 #ifdef PY_COMMPKTCHANGEORDERRECORDEXTENSION_PATCH
2780         PY_COMMPKTCHANGEORDERRECORDEXTENSION_PATCH(&frsrpc_CommPktChangeOrderRecordExtension_Type);
2781 #endif
2782 #ifdef PY_COMMPKTCHUNK_PATCH
2783         PY_COMMPKTCHUNK_PATCH(&frsrpc_CommPktChunk_Type);
2784 #endif
2785 #ifdef PY_COMMPKTCHUNKCTR_PATCH
2786         PY_COMMPKTCHUNKCTR_PATCH(&frsrpc_CommPktChunkCtr_Type);
2787 #endif
2788 #ifdef PY_FRSSENDCOMMPKTREQ_PATCH
2789         PY_FRSSENDCOMMPKTREQ_PATCH(&frsrpc_FrsSendCommPktReq_Type);
2790 #endif
2791 #ifdef PY_FRSRPC_PATCH
2792         PY_FRSRPC_PATCH(&frsrpc_InterfaceType);
2793 #endif
2794
2795         m = Py_InitModule3("frsrpc", frsrpc_methods, "frsrpc DCE/RPC");
2796         if (m == NULL)
2797                 return;
2798
2799         PyModule_AddObject(m, "FRSRPC_CO_IFLAG_CO_ABORT", PyInt_FromLong(FRSRPC_CO_IFLAG_CO_ABORT));
2800         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEOUT", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEOUT));
2801         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_FILE_CREATE", PyInt_FromLong(FRSRPC_CONTENT_REASON_FILE_CREATE));
2802         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NAMED_DATA_EXTEND", PyInt_FromLong(FRSRPC_CONTENT_REASON_NAMED_DATA_EXTEND));
2803         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_COMMAND", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_COMMAND));
2804         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEIN2", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEIN2));
2805         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_JOIN_TIME", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_JOIN_TIME));
2806         PyModule_AddObject(m, "FRSRPC_CO_FLAG_JUST_OID_RESET", PyInt_FromLong(FRSRPC_CO_FLAG_JUST_OID_RESET));
2807         PyModule_AddObject(m, "FRSRPC_COMMAND_WJOIN_DONE", PyInt_FromLong(FRSRPC_COMMAND_WJOIN_DONE));
2808         PyModule_AddObject(m, "FRSRPC_CO_STATUS_ALLOC_STAGING_LOCAL_CO", PyInt_FromLong(FRSRPC_CO_STATUS_ALLOC_STAGING_LOCAL_CO));
2809         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEIN", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEIN));
2810         PyModule_AddObject(m, "FRSRPC_CO_STATUS_ALLOC_STAGING_REMOTE_CO", PyInt_FromLong(FRSRPC_CO_STATUS_ALLOC_STAGING_REMOTE_CO));
2811         PyModule_AddObject(m, "FRSRPC_CO_STATUS_DB_STATE_UPDATE_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_DB_STATE_UPDATE_COMPLETED));
2812         PyModule_AddObject(m, "FRSRPC_CO_FLAG_CONTENT_CMD", PyInt_FromLong(FRSRPC_CO_FLAG_CONTENT_CMD));
2813         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_LAST_JOIN_TIME", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_LAST_JOIN_TIME));
2814         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_RETRYING", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_RETRYING));
2815         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_FILE_DELETE", PyInt_FromLong(FRSRPC_CONTENT_REASON_FILE_DELETE));
2816         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_FROM", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_FROM));
2817         PyModule_AddObject(m, "FRSRPC_COMMAND_JOINED", PyInt_FromLong(FRSRPC_COMMAND_JOINED));
2818         PyModule_AddObject(m, "FRSRPC_CO_FLAG_MOVEIN_GEN", PyInt_FromLong(FRSRPC_CO_FLAG_MOVEIN_GEN));
2819         PyModule_AddObject(m, "FRSRPC_COMMAND_START_JOIN", PyInt_FromLong(FRSRPC_COMMAND_START_JOIN));
2820         PyModule_AddObject(m, "FRSRPC_DATA_EXTENSION_TERMINATOR", PyInt_FromLong(FRSRPC_DATA_EXTENSION_TERMINATOR));
2821         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_EA_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_EA_CHANGE));
2822         PyModule_AddObject(m, "FRSRPC_CO_FLAG_CONTROL", PyInt_FromLong(FRSRPC_CO_FLAG_CONTROL));
2823         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVERS", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVERS));
2824         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_WAIT_RETRY", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_WAIT_RETRY));
2825         PyModule_AddObject(m, "FRSRPC_CO_FLAG_COMPRESSED_STAGE", PyInt_FromLong(FRSRPC_CO_FLAG_COMPRESSED_STAGE));
2826         PyModule_AddObject(m, "FRSRPC_CO_FLAG_VVJOIN_TO_ORIG", PyInt_FromLong(FRSRPC_CO_FLAG_VVJOIN_TO_ORIG));
2827         PyModule_AddObject(m, "FRSRPC_COMMAND_REMOTE_CO", PyInt_FromLong(FRSRPC_COMMAND_REMOTE_CO));
2828         PyModule_AddObject(m, "FRSRPC_DATA_EXTENSION_RETRY_TIMEOUT", PyInt_FromLong(FRSRPC_DATA_EXTENSION_RETRY_TIMEOUT));
2829         PyModule_AddObject(m, "FRSRPC_CO_STATUS_DB_STATE_UPDATE_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_DB_STATE_UPDATE_STARTED));
2830         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_GUID));
2831         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MAJOR_0", PyInt_FromLong(FRSRPC_COMM_PKT_MAJOR_0));
2832         PyModule_AddObject(m, "FRSRPC_CO_IFLAG_DIR_ENUM_PENDING", PyInt_FromLong(FRSRPC_CO_IFLAG_DIR_ENUM_PENDING));
2833         PyModule_AddObject(m, "FRSRPC_CO_FLAG_SKIP_ORIG_REC_C", PyInt_FromLong(FRSRPC_CO_FLAG_SKIP_ORIG_REC_C));
2834         PyModule_AddObject(m, "FRSRPC_CO_STATUS_LOCAL_CO_STAGING_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_LOCAL_CO_STAGING_STARTED));
2835         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_COMPRESSION_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_COMPRESSION_CHANGE));
2836         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_0", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_0));
2837         PyModule_AddObject(m, "FRSRPC_CO_FLAG_OUT_OF_ORDER", PyInt_FromLong(FRSRPC_CO_FLAG_OUT_OF_ORDER));
2838         PyModule_AddObject(m, "FRSRPC_PARENT_AUTH_LEVEL_NO_AUTHENTICATION", PyInt_FromLong(FRSRPC_PARENT_AUTH_LEVEL_NO_AUTHENTICATION));
2839         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_DATA_OVERWRITE", PyInt_FromLong(FRSRPC_CONTENT_REASON_DATA_OVERWRITE));
2840         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_1", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_1));
2841         PyModule_AddObject(m, "FRSRPC_COMMAND_RECEIVING_STATE", PyInt_FromLong(FRSRPC_COMMAND_RECEIVING_STATE));
2842         PyModule_AddObject(m, "FRSRPC_CO_STATUS_CO_RECYCLED_FOR_ENUM", PyInt_FromLong(FRSRPC_CO_STATUS_CO_RECYCLED_FOR_ENUM));
2843         PyModule_AddObject(m, "FRSRPC_COMMAND_REMOTE_CO_DONE", PyInt_FromLong(FRSRPC_COMMAND_REMOTE_CO_DONE));
2844         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_7", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_7));
2845         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEOUT", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEOUT));
2846         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_4", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_4));
2847         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_GVSN", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_GVSN));
2848         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_STARTED));
2849         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_SEQUENCE_NUMBER", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_SEQUENCE_NUMBER));
2850         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NEW_NAME", PyInt_FromLong(FRSRPC_CONTENT_REASON_NEW_NAME));
2851         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_NO_CMD", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_NO_CMD));
2852         PyModule_AddObject(m, "FRSRPC_CO_STATUS_WAIT_RETRY_REMOTE_CO_STAGING", PyInt_FromLong(FRSRPC_CO_STATUS_WAIT_RETRY_REMOTE_CO_STAGING));
2853         PyModule_AddObject(m, "FRSRPC_COMMAND_ABORT_FETCH", PyInt_FromLong(FRSRPC_COMMAND_ABORT_FETCH));
2854         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NAMED_DATA_OVERWRITE", PyInt_FromLong(FRSRPC_CONTENT_REASON_NAMED_DATA_OVERWRITE));
2855         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_5", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_5));
2856         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_EXTENTION_2", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_EXTENTION_2));
2857         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_CREATE", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_CREATE));
2858         PyModule_AddObject(m, "FRSRPC_CO_STATUS_LOCAL_CO_STAGING_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_LOCAL_CO_STAGING_COMPLETED));
2859         PyModule_AddObject(m, "FRSRPC_CO_FLAG_NEW_FILE", PyInt_FromLong(FRSRPC_CO_FLAG_NEW_FILE));
2860         PyModule_AddObject(m, "FRSRPC_CO_FLAG_LOCALCO", PyInt_FromLong(FRSRPC_CO_FLAG_LOCALCO));
2861         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEIN", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEIN));
2862         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_FILE_SIZE", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_FILE_SIZE));
2863         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_EXT_WIN2K", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_EXT_WIN2K));
2864         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_8", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_8));
2865         PyModule_AddObject(m, "FRSRPC_CO_FLAG_VV_ACTIVATED", PyInt_FromLong(FRSRPC_CO_FLAG_VV_ACTIVATED));
2866         PyModule_AddObject(m, "FRSRPC_CO_STATUS_REMOTE_CO_STAGING_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_REMOTE_CO_STAGING_STARTED));
2867         PyModule_AddObject(m, "FRSRPC_CO_STATUS_CO_ABORTED", PyInt_FromLong(FRSRPC_CO_STATUS_CO_ABORTED));
2868         PyModule_AddObject(m, "FRSRPC_CO_IFLAG_VVRETIRE_EXEC", PyInt_FromLong(FRSRPC_CO_IFLAG_VVRETIRE_EXEC));
2869         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_DELETE", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_DELETE));
2870         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_VVECTOR", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_VVECTOR));
2871         PyModule_AddObject(m, "FRSRPC_CO_RECORD_EXTENSION_VERSION_1", PyInt_FromLong(FRSRPC_CO_RECORD_EXTENSION_VERSION_1));
2872         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_REMOTE_CO", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_REMOTE_CO));
2873         PyModule_AddObject(m, "FRSRPC_CO_IFLAG_NONE", PyInt_FromLong(0x0000000));
2874         PyModule_AddObject(m, "FRSRPC_CO_FLAG_DIRECTED_CO", PyInt_FromLong(FRSRPC_CO_FLAG_DIRECTED_CO));
2875         PyModule_AddObject(m, "FRSRPC_COMMAND_NEED_JOIN", PyInt_FromLong(FRSRPC_COMMAND_NEED_JOIN));
2876         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_DATA_TRUNCATION", PyInt_FromLong(FRSRPC_CONTENT_REASON_DATA_TRUNCATION));
2877         PyModule_AddObject(m, "FRSRPC_CO_STATUS_REMOTE_CO_STAGING_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_REMOTE_CO_STAGING_COMPLETED));
2878         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_RENAME_RETRYING", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_RENAME_RETRYING));
2879         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_9", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_9));
2880         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVERS", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVERS));
2881         PyModule_AddObject(m, "FRSRPC_CO_FLAG_MORPH_GEN_HEAD", PyInt_FromLong(FRSRPC_CO_FLAG_MORPH_GEN_HEAD));
2882         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_JOIN_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_JOIN_GUID));
2883         PyModule_AddObject(m, "FRSRPC_CO_STATUS_WAIT_RETRY_LOCAL_CO_STAGING", PyInt_FromLong(FRSRPC_CO_STATUS_WAIT_RETRY_LOCAL_CO_STAGING));
2884         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_DELETE", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_DELETE));
2885         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEDIR", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEDIR));
2886         PyModule_AddObject(m, "FRSRPC_CO_FLAG_SKIP_VV_UPDATE", PyInt_FromLong(FRSRPC_CO_FLAG_SKIP_VV_UPDATE));
2887         PyModule_AddObject(m, "FRSRPC_COMMAND_RETRY_FETCH", PyInt_FromLong(FRSRPC_COMMAND_RETRY_FETCH));
2888         PyModule_AddObject(m, "FRSRPC_CO_STATUS_REQUEST_OUTBOUND_PROPAGATION", PyInt_FromLong(FRSRPC_CO_STATUS_REQUEST_OUTBOUND_PROPAGATION));
2889         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NAMED_DATA_TRUNCATION", PyInt_FromLong(FRSRPC_CONTENT_REASON_NAMED_DATA_TRUNCATION));
2890         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CONNECTION", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CONNECTION));
2891         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_NO_CMD", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_NO_CMD));
2892         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID));
2893         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_DATA_EXTEND", PyInt_FromLong(FRSRPC_CONTENT_REASON_DATA_EXTEND));
2894         PyModule_AddObject(m, "FRSRPC_COMMAND_SEND_STAGE", PyInt_FromLong(FRSRPC_COMMAND_SEND_STAGE));
2895         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEIN2", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEIN2));
2896         PyModule_AddObject(m, "FRSRPC_CO_STATUS_CO_ENTERED_LOG", PyInt_FromLong(FRSRPC_CO_STATUS_CO_ENTERED_LOG));
2897         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_BASIC_INFO_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_BASIC_INFO_CHANGE));
2898         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_6", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_6));
2899         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_BLOCK_SIZE", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_BLOCK_SIZE));
2900         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_REPLICA_VERSION_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_REPLICA_VERSION_GUID));
2901         PyModule_AddObject(m, "FRSRPC_CO_FLAG_LOCATION_CMD", PyInt_FromLong(FRSRPC_CO_FLAG_LOCATION_CMD));
2902         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_EOP", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_EOP));
2903         PyModule_AddObject(m, "FRSRPC_COMMAND_UNJOIN_REMOTE", PyInt_FromLong(FRSRPC_COMMAND_UNJOIN_REMOTE));
2904         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_COMPLETED));
2905         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_FILE_OFFSET", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_FILE_OFFSET));
2906         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_REPLICA", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_REPLICA));
2907         PyModule_AddObject(m, "FRSRPC_DATA_EXTENSION_MD5_CHECKSUM", PyInt_FromLong(FRSRPC_DATA_EXTENSION_MD5_CHECKSUM));
2908         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_BOP", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_BOP));
2909         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEDIR", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEDIR));
2910         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_REQUESTED", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_REQUESTED));
2911         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_3", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_3));
2912         PyModule_AddObject(m, "FRSRPC_CO_RECORD_EXTENSION_VERSION_WIN2K", PyInt_FromLong(FRSRPC_CO_RECORD_EXTENSION_VERSION_WIN2K));
2913         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_SECURITY_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_SECURITY_CHANGE));
2914         PyModule_AddObject(m, "FRSRPC_CO_FLAG_RETRY", PyInt_FromLong(FRSRPC_CO_FLAG_RETRY));
2915         PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_CREATE", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_CREATE));
2916         PyModule_AddObject(m, "FRSRPC_COMMAND_JOINING", PyInt_FromLong(FRSRPC_COMMAND_JOINING));
2917         PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_DELETE_RETRYING", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_DELETE_RETRYING));
2918         PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_OLD_NAME", PyInt_FromLong(FRSRPC_CONTENT_REASON_OLD_NAME));
2919         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_BLOCK", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_BLOCK));
2920         PyModule_AddObject(m, "FRSRPC_CO_FLAG_ONLIST", PyInt_FromLong(FRSRPC_CO_FLAG_ONLIST));
2921         PyModule_AddObject(m, "FRSRPC_CO_STATUS_REQUEST_ACCEPTED_OUTBOUND_LOG", PyInt_FromLong(FRSRPC_CO_STATUS_REQUEST_ACCEPTED_OUTBOUND_LOG));
2922         PyModule_AddObject(m, "FRSRPC_CO_FLAG_ABORT_CO", PyInt_FromLong(FRSRPC_CO_FLAG_ABORT_CO));
2923         PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_2", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_2));
2924         PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_TO", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_TO));
2925         PyModule_AddObject(m, "FRSRPC_PARENT_AUTH_LEVEL_ENCRYPTED_KERBEROS", PyInt_FromLong(FRSRPC_PARENT_AUTH_LEVEL_ENCRYPTED_KERBEROS));
2926         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChunkGuidName_Type);
2927         PyModule_AddObject(m, "CommPktChunkGuidName", (PyObject *)(void *)&frsrpc_CommPktChunkGuidName_Type);
2928         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktGSVN_Type);
2929         PyModule_AddObject(m, "CommPktGSVN", (PyObject *)(void *)&frsrpc_CommPktGSVN_Type);
2930         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChangeOrderCommand_Type);
2931         PyModule_AddObject(m, "CommPktChangeOrderCommand", (PyObject *)(void *)&frsrpc_CommPktChangeOrderCommand_Type);
2932         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktDataExtensionChecksum_Type);
2933         PyModule_AddObject(m, "CommPktDataExtensionChecksum", (PyObject *)(void *)&frsrpc_CommPktDataExtensionChecksum_Type);
2934         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktDataExtensionRetryTimeout_Type);
2935         PyModule_AddObject(m, "CommPktDataExtensionRetryTimeout", (PyObject *)(void *)&frsrpc_CommPktDataExtensionRetryTimeout_Type);
2936         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktCoRecordExtensionWin2k_Type);
2937         PyModule_AddObject(m, "CommPktCoRecordExtensionWin2k", (PyObject *)(void *)&frsrpc_CommPktCoRecordExtensionWin2k_Type);
2938         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChangeOrderRecordExtension_Type);
2939         PyModule_AddObject(m, "CommPktChangeOrderRecordExtension", (PyObject *)(void *)&frsrpc_CommPktChangeOrderRecordExtension_Type);
2940         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChunk_Type);
2941         PyModule_AddObject(m, "CommPktChunk", (PyObject *)(void *)&frsrpc_CommPktChunk_Type);
2942         Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChunkCtr_Type);
2943         PyModule_AddObject(m, "CommPktChunkCtr", (PyObject *)(void *)&frsrpc_CommPktChunkCtr_Type);
2944         Py_INCREF((PyObject *)(void *)&frsrpc_FrsSendCommPktReq_Type);
2945         PyModule_AddObject(m, "FrsSendCommPktReq", (PyObject *)(void *)&frsrpc_FrsSendCommPktReq_Type);
2946         Py_INCREF((PyObject *)(void *)&frsrpc_InterfaceType);
2947         PyModule_AddObject(m, "frsrpc", (PyObject *)(void *)&frsrpc_InterfaceType);
2948 #ifdef PY_MOD_FRSRPC_PATCH
2949         PY_MOD_FRSRPC_PATCH(m);
2950 #endif
2951
2952 }