← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/py_frsrpc.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/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 "librpc/gen_ndr/ndr_frsrpc.h"
 
9
#include "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 *)py_talloc_get_ptr(obj);
 
31
        PyObject *py_guid;
 
32
        py_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
39
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
40
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
41
                PyErr_NoMemory();
 
42
                return -1;
 
43
        }
 
44
        object->guid = *(struct GUID *)py_talloc_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 *)py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
59
        object->name = talloc_strdup(py_talloc_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 py_talloc_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(py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
112
        PyObject *py_guid;
 
113
        py_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
120
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
121
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
122
                PyErr_NoMemory();
 
123
                return -1;
 
124
        }
 
125
        object->guid = *(struct GUID *)py_talloc_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 py_talloc_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(py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
520
        PyObject *py_change_order_guid;
 
521
        py_change_order_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
528
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
529
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
530
                PyErr_NoMemory();
 
531
                return -1;
 
532
        }
 
533
        object->change_order_guid = *(struct GUID *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
540
        PyObject *py_originator_guid;
 
541
        py_originator_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
548
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
549
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
550
                PyErr_NoMemory();
 
551
                return -1;
 
552
        }
 
553
        object->originator_guid = *(struct GUID *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
560
        PyObject *py_file_guid;
 
561
        py_file_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
568
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
569
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
570
                PyErr_NoMemory();
 
571
                return -1;
 
572
        }
 
573
        object->file_guid = *(struct GUID *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
580
        PyObject *py_old_parent_guid;
 
581
        py_old_parent_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
588
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
589
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
590
                PyErr_NoMemory();
 
591
                return -1;
 
592
        }
 
593
        object->old_parent_guid = *(struct GUID *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
600
        PyObject *py_new_parent_guid;
 
601
        py_new_parent_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
608
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
609
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
610
                PyErr_NoMemory();
 
611
                return -1;
 
612
        }
 
613
        object->new_parent_guid = *(struct GUID *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
620
        PyObject *py_connection_guid;
 
621
        py_connection_guid = py_talloc_reference_ex(GUID_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
628
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
629
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
630
                PyErr_NoMemory();
 
631
                return -1;
 
632
        }
 
633
        object->connection_guid = *(struct GUID *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 py_talloc_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(py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 py_talloc_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(py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 py_talloc_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(py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
1337
        PyObject *py_data_checksum;
 
1338
        py_data_checksum = py_talloc_reference_ex(&frsrpc_CommPktDataExtensionChecksum_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
1345
        PY_CHECK_TYPE(&frsrpc_CommPktDataExtensionChecksum_Type, value, return -1;);
 
1346
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
1347
                PyErr_NoMemory();
 
1348
                return -1;
 
1349
        }
 
1350
        object->data_checksum = *(struct frsrpc_CommPktDataExtensionChecksum *)py_talloc_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 py_talloc_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(py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
1503
        PyObject *py_data_checksum;
 
1504
        py_data_checksum = py_talloc_reference_ex(&frsrpc_CommPktDataExtensionChecksum_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
1511
        PY_CHECK_TYPE(&frsrpc_CommPktDataExtensionChecksum_Type, value, return -1;);
 
1512
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
1513
                PyErr_NoMemory();
 
1514
                return -1;
 
1515
        }
 
1516
        object->data_checksum = *(struct frsrpc_CommPktDataExtensionChecksum *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
1523
        PyObject *py_data_retry_timeout;
 
1524
        py_data_retry_timeout = py_talloc_reference_ex(&frsrpc_CommPktDataExtensionRetryTimeout_Type, py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
1531
        PY_CHECK_TYPE(&frsrpc_CommPktDataExtensionRetryTimeout_Type, value, return -1;);
 
1532
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
1533
                PyErr_NoMemory();
 
1534
                return -1;
 
1535
        }
 
1536
        object->data_retry_timeout = *(struct frsrpc_CommPktDataExtensionRetryTimeout *)py_talloc_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 py_talloc_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(py_talloc_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 = py_talloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->to);
 
1588
                        return ret;
 
1589
 
 
1590
                case FRSRPC_COMM_PKT_CHUNK_FROM:
 
1591
                        ret = py_talloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->from);
 
1592
                        return ret;
 
1593
 
 
1594
                case FRSRPC_COMM_PKT_CHUNK_REPLICA:
 
1595
                        ret = py_talloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->replica);
 
1596
                        return ret;
 
1597
 
 
1598
                case FRSRPC_COMM_PKT_CHUNK_CONNECTION:
 
1599
                        ret = py_talloc_reference_ex(&frsrpc_CommPktChunkGuidName_Type, mem_ctx, &in->connection);
 
1600
                        return ret;
 
1601
 
 
1602
                case FRSRPC_COMM_PKT_CHUNK_JOIN_GUID:
 
1603
                        ret = py_talloc_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 = py_talloc_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 = py_talloc_reference_ex(GUID_Type, mem_ctx, &in->replica_version_guid);
 
1620
                        return ret;
 
1621
 
 
1622
                case FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID:
 
1623
                        ret = py_talloc_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 = py_talloc_reference_ex(&frsrpc_CommPktGSVN_Type, mem_ctx, &in->gvsn);
 
1644
                        return ret;
 
1645
 
 
1646
                case FRSRPC_COMM_PKT_CHUNK_CO_GUID:
 
1647
                        ret = py_talloc_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 = py_talloc_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 = py_talloc_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 = py_talloc_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->bop);
 
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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1703
                                PyErr_NoMemory();
 
1704
                                talloc_free(ret); return NULL;
 
1705
                        }
 
1706
                        ret->to = *(struct frsrpc_CommPktChunkGuidName *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1712
                                PyErr_NoMemory();
 
1713
                                talloc_free(ret); return NULL;
 
1714
                        }
 
1715
                        ret->from = *(struct frsrpc_CommPktChunkGuidName *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1721
                                PyErr_NoMemory();
 
1722
                                talloc_free(ret); return NULL;
 
1723
                        }
 
1724
                        ret->replica = *(struct frsrpc_CommPktChunkGuidName *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1730
                                PyErr_NoMemory();
 
1731
                                talloc_free(ret); return NULL;
 
1732
                        }
 
1733
                        ret->connection = *(struct frsrpc_CommPktChunkGuidName *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1739
                                PyErr_NoMemory();
 
1740
                                talloc_free(ret); return NULL;
 
1741
                        }
 
1742
                        ret->join_guid = *(struct GUID *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1760
                                PyErr_NoMemory();
 
1761
                                talloc_free(ret); return NULL;
 
1762
                        }
 
1763
                        ret->vvector = *(struct frsrpc_CommPktGSVN *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1781
                                PyErr_NoMemory();
 
1782
                                talloc_free(ret); return NULL;
 
1783
                        }
 
1784
                        ret->replica_version_guid = *(struct GUID *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1790
                                PyErr_NoMemory();
 
1791
                                talloc_free(ret); return NULL;
 
1792
                        }
 
1793
                        ret->compression_guid = *(struct GUID *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1839
                                PyErr_NoMemory();
 
1840
                                talloc_free(ret); return NULL;
 
1841
                        }
 
1842
                        ret->gvsn = *(struct frsrpc_CommPktGSVN *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1848
                                PyErr_NoMemory();
 
1849
                                talloc_free(ret); return NULL;
 
1850
                        }
 
1851
                        ret->co_guid = *(struct GUID *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1862
                                PyErr_NoMemory();
 
1863
                                talloc_free(ret); return NULL;
 
1864
                        }
 
1865
                        ret->remote_co = *(struct frsrpc_CommPktChangeOrderCommand *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1871
                                PyErr_NoMemory();
 
1872
                                talloc_free(ret); return NULL;
 
1873
                        }
 
1874
                        ret->co_ext_win2k = *(struct frsrpc_CommPktCoRecordExtensionWin2k *)py_talloc_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, py_talloc_get_mem_ctx(in)) == NULL) {
 
1880
                                PyErr_NoMemory();
 
1881
                                talloc_free(ret); return NULL;
 
1882
                        }
 
1883
                        ret->co_extension2 = *(struct frsrpc_CommPktChangeOrderRecordExtension *)py_talloc_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->bop = 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 *)py_talloc_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 *)py_talloc_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 *)py_talloc_get_ptr(obj);
 
1923
        PyObject *py_data;
 
1924
        py_data = py_import_frsrpc_CommPktChunkData(py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
1934
        {
 
1935
                union frsrpc_CommPktChunkData *data_switch_1;
 
1936
                data_switch_1 = py_export_frsrpc_CommPktChunkData(py_talloc_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 py_talloc_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 *)py_talloc_get_ptr(py_obj);
 
1959
        DATA_BLOB blob;
 
1960
        enum ndr_err_code err;
 
1961
        err = ndr_push_struct_blob(&blob, py_talloc_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)
 
1971
{
 
1972
        struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)py_talloc_get_ptr(py_obj);
 
1973
        DATA_BLOB blob;
 
1974
        enum ndr_err_code err;
 
1975
        if (!PyArg_ParseTuple(args, "s#:__ndr_unpack__", &blob.data, &blob.length))
 
1976
                return NULL;
 
1977
 
 
1978
        err = ndr_pull_struct_blob_all(&blob, py_talloc_get_mem_ctx(py_obj), object, (ndr_pull_flags_fn_t)ndr_pull_frsrpc_CommPktChunk);
 
1979
        if (err != NDR_ERR_SUCCESS) {
 
1980
                PyErr_SetNdrError(err);
 
1981
                return NULL;
 
1982
        }
 
1983
 
 
1984
        Py_RETURN_NONE;
 
1985
}
 
1986
 
 
1987
static PyObject *py_frsrpc_CommPktChunk_ndr_print(PyObject *py_obj)
 
1988
{
 
1989
        struct frsrpc_CommPktChunk *object = (struct frsrpc_CommPktChunk *)py_talloc_get_ptr(py_obj);
 
1990
        PyObject *ret;
 
1991
        char *retstr;
 
1992
 
 
1993
        retstr = ndr_print_struct_string(py_talloc_get_mem_ctx(py_obj), (ndr_print_fn_t)ndr_print_frsrpc_CommPktChunk, "frsrpc_CommPktChunk", object);
 
1994
        ret = PyString_FromString(retstr);
 
1995
        talloc_free(retstr);
 
1996
 
 
1997
        return ret;
 
1998
}
 
1999
 
 
2000
static PyMethodDef py_frsrpc_CommPktChunk_methods[] = {
 
2001
        { "__ndr_pack__", (PyCFunction)py_frsrpc_CommPktChunk_ndr_pack, METH_NOARGS, "S.ndr_pack(object) -> blob\nNDR pack" },
 
2002
        { "__ndr_unpack__", (PyCFunction)py_frsrpc_CommPktChunk_ndr_unpack, METH_VARARGS, "S.ndr_unpack(class, blob) -> None\nNDR unpack" },
 
2003
        { "__ndr_print__", (PyCFunction)py_frsrpc_CommPktChunk_ndr_print, METH_VARARGS, "S.ndr_print(object) -> None\nNDR print" },
 
2004
        { NULL, NULL, 0, NULL }
 
2005
};
 
2006
 
 
2007
 
 
2008
static PyTypeObject frsrpc_CommPktChunk_Type = {
 
2009
        PyObject_HEAD_INIT(NULL) 0,
 
2010
        .tp_name = "frsrpc.CommPktChunk",
 
2011
        .tp_getset = py_frsrpc_CommPktChunk_getsetters,
 
2012
        .tp_methods = py_frsrpc_CommPktChunk_methods,
 
2013
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 
2014
        .tp_basicsize = sizeof(py_talloc_Object),
 
2015
        .tp_new = py_frsrpc_CommPktChunk_new,
 
2016
};
 
2017
 
 
2018
 
 
2019
static PyObject *py_frsrpc_CommPktChunkCtr_get_num_chunks(PyObject *obj, void *closure)
 
2020
{
 
2021
        struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)py_talloc_get_ptr(obj);
 
2022
        PyObject *py_num_chunks;
 
2023
        py_num_chunks = PyInt_FromLong(object->num_chunks);
 
2024
        return py_num_chunks;
 
2025
}
 
2026
 
 
2027
static int py_frsrpc_CommPktChunkCtr_set_num_chunks(PyObject *py_obj, PyObject *value, void *closure)
 
2028
{
 
2029
        struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)py_talloc_get_ptr(py_obj);
 
2030
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2031
        object->num_chunks = PyInt_AsLong(value);
 
2032
        return 0;
 
2033
}
 
2034
 
 
2035
static PyObject *py_frsrpc_CommPktChunkCtr_get_chunks(PyObject *obj, void *closure)
 
2036
{
 
2037
        struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)py_talloc_get_ptr(obj);
 
2038
        PyObject *py_chunks;
 
2039
        py_chunks = PyList_New(object->num_chunks);
 
2040
        if (py_chunks == NULL) {
 
2041
                return NULL;
 
2042
        }
 
2043
        {
 
2044
                int chunks_cntr_0;
 
2045
                for (chunks_cntr_0 = 0; chunks_cntr_0 < object->num_chunks; chunks_cntr_0++) {
 
2046
                        PyObject *py_chunks_0;
 
2047
                        py_chunks_0 = py_talloc_reference_ex(&frsrpc_CommPktChunk_Type, object->chunks, &object->chunks[chunks_cntr_0]);
 
2048
                        PyList_SetItem(py_chunks, chunks_cntr_0, py_chunks_0);
 
2049
                }
 
2050
        }
 
2051
        return py_chunks;
 
2052
}
 
2053
 
 
2054
static int py_frsrpc_CommPktChunkCtr_set_chunks(PyObject *py_obj, PyObject *value, void *closure)
 
2055
{
 
2056
        struct frsrpc_CommPktChunkCtr *object = (struct frsrpc_CommPktChunkCtr *)py_talloc_get_ptr(py_obj);
 
2057
        PY_CHECK_TYPE(&PyList_Type, value, return -1;);
 
2058
        {
 
2059
                int chunks_cntr_0;
 
2060
                object->chunks = talloc_array_ptrtype(py_talloc_get_mem_ctx(py_obj), object->chunks, PyList_GET_SIZE(value));
 
2061
                if (!object->chunks) { return -1;; }
 
2062
                talloc_set_name_const(object->chunks, "ARRAY: object->chunks");
 
2063
                for (chunks_cntr_0 = 0; chunks_cntr_0 < PyList_GET_SIZE(value); chunks_cntr_0++) {
 
2064
                        PY_CHECK_TYPE(&frsrpc_CommPktChunk_Type, PyList_GET_ITEM(value, chunks_cntr_0), return -1;);
 
2065
                        if (talloc_reference(object->chunks, py_talloc_get_mem_ctx(PyList_GET_ITEM(value, chunks_cntr_0))) == NULL) {
 
2066
                                PyErr_NoMemory();
 
2067
                                return -1;
 
2068
                        }
 
2069
                        object->chunks[chunks_cntr_0] = *(struct frsrpc_CommPktChunk *)py_talloc_get_ptr(PyList_GET_ITEM(value, chunks_cntr_0));
 
2070
                }
 
2071
        }
 
2072
        return 0;
 
2073
}
 
2074
 
 
2075
static PyGetSetDef py_frsrpc_CommPktChunkCtr_getsetters[] = {
 
2076
        { discard_const_p(char, "num_chunks"), py_frsrpc_CommPktChunkCtr_get_num_chunks, py_frsrpc_CommPktChunkCtr_set_num_chunks },
 
2077
        { discard_const_p(char, "chunks"), py_frsrpc_CommPktChunkCtr_get_chunks, py_frsrpc_CommPktChunkCtr_set_chunks },
 
2078
        { NULL }
 
2079
};
 
2080
 
 
2081
static PyObject *py_frsrpc_CommPktChunkCtr_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 
2082
{
 
2083
        return py_talloc_new(struct frsrpc_CommPktChunkCtr, type);
 
2084
}
 
2085
 
 
2086
 
 
2087
static PyTypeObject frsrpc_CommPktChunkCtr_Type = {
 
2088
        PyObject_HEAD_INIT(NULL) 0,
 
2089
        .tp_name = "frsrpc.CommPktChunkCtr",
 
2090
        .tp_getset = py_frsrpc_CommPktChunkCtr_getsetters,
 
2091
        .tp_methods = NULL,
 
2092
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 
2093
        .tp_basicsize = sizeof(py_talloc_Object),
 
2094
        .tp_new = py_frsrpc_CommPktChunkCtr_new,
 
2095
};
 
2096
 
 
2097
 
 
2098
static PyObject *py_frsrpc_FrsSendCommPktReq_get_major(PyObject *obj, void *closure)
 
2099
{
 
2100
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2101
        PyObject *py_major;
 
2102
        py_major = PyInt_FromLong(object->major);
 
2103
        return py_major;
 
2104
}
 
2105
 
 
2106
static int py_frsrpc_FrsSendCommPktReq_set_major(PyObject *py_obj, PyObject *value, void *closure)
 
2107
{
 
2108
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2109
        if (PyLong_Check(value)) {
 
2110
                object->major = PyLong_AsLongLong(value);
 
2111
        } else if (PyInt_Check(value)) {
 
2112
                object->major = PyInt_AsLong(value);
 
2113
        } else {
 
2114
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
2115
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
2116
                return -1;
 
2117
        }
 
2118
        return 0;
 
2119
}
 
2120
 
 
2121
static PyObject *py_frsrpc_FrsSendCommPktReq_get_minor(PyObject *obj, void *closure)
 
2122
{
 
2123
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2124
        PyObject *py_minor;
 
2125
        py_minor = PyInt_FromLong(object->minor);
 
2126
        return py_minor;
 
2127
}
 
2128
 
 
2129
static int py_frsrpc_FrsSendCommPktReq_set_minor(PyObject *py_obj, PyObject *value, void *closure)
 
2130
{
 
2131
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2132
        if (PyLong_Check(value)) {
 
2133
                object->minor = PyLong_AsLongLong(value);
 
2134
        } else if (PyInt_Check(value)) {
 
2135
                object->minor = PyInt_AsLong(value);
 
2136
        } else {
 
2137
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
2138
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
2139
                return -1;
 
2140
        }
 
2141
        return 0;
 
2142
}
 
2143
 
 
2144
static PyObject *py_frsrpc_FrsSendCommPktReq_get_cs_id(PyObject *obj, void *closure)
 
2145
{
 
2146
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2147
        PyObject *py_cs_id;
 
2148
        py_cs_id = PyInt_FromLong(object->cs_id);
 
2149
        return py_cs_id;
 
2150
}
 
2151
 
 
2152
static int py_frsrpc_FrsSendCommPktReq_set_cs_id(PyObject *py_obj, PyObject *value, void *closure)
 
2153
{
 
2154
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2155
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2156
        object->cs_id = PyInt_AsLong(value);
 
2157
        return 0;
 
2158
}
 
2159
 
 
2160
static PyObject *py_frsrpc_FrsSendCommPktReq_get_memory_len(PyObject *obj, void *closure)
 
2161
{
 
2162
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2163
        PyObject *py_memory_len;
 
2164
        py_memory_len = PyInt_FromLong(object->memory_len);
 
2165
        return py_memory_len;
 
2166
}
 
2167
 
 
2168
static int py_frsrpc_FrsSendCommPktReq_set_memory_len(PyObject *py_obj, PyObject *value, void *closure)
 
2169
{
 
2170
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2171
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2172
        object->memory_len = PyInt_AsLong(value);
 
2173
        return 0;
 
2174
}
 
2175
 
 
2176
static PyObject *py_frsrpc_FrsSendCommPktReq_get_pkt_len(PyObject *obj, void *closure)
 
2177
{
 
2178
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2179
        PyObject *py_pkt_len;
 
2180
        py_pkt_len = PyInt_FromLong(object->pkt_len);
 
2181
        return py_pkt_len;
 
2182
}
 
2183
 
 
2184
static int py_frsrpc_FrsSendCommPktReq_set_pkt_len(PyObject *py_obj, PyObject *value, void *closure)
 
2185
{
 
2186
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2187
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2188
        object->pkt_len = PyInt_AsLong(value);
 
2189
        return 0;
 
2190
}
 
2191
 
 
2192
static PyObject *py_frsrpc_FrsSendCommPktReq_get_upk_len(PyObject *obj, void *closure)
 
2193
{
 
2194
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2195
        PyObject *py_upk_len;
 
2196
        py_upk_len = PyInt_FromLong(object->upk_len);
 
2197
        return py_upk_len;
 
2198
}
 
2199
 
 
2200
static int py_frsrpc_FrsSendCommPktReq_set_upk_len(PyObject *py_obj, PyObject *value, void *closure)
 
2201
{
 
2202
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2203
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2204
        object->upk_len = PyInt_AsLong(value);
 
2205
        return 0;
 
2206
}
 
2207
 
 
2208
static PyObject *py_frsrpc_FrsSendCommPktReq_get_ctr(PyObject *obj, void *closure)
 
2209
{
 
2210
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2211
        PyObject *py_ctr;
 
2212
        if (object->ctr == NULL) {
 
2213
                py_ctr = Py_None;
 
2214
                Py_INCREF(py_ctr);
 
2215
        } else {
 
2216
                py_ctr = py_talloc_reference_ex(&frsrpc_CommPktChunkCtr_Type, object->ctr, object->ctr);
 
2217
        }
 
2218
        return py_ctr;
 
2219
}
 
2220
 
 
2221
static int py_frsrpc_FrsSendCommPktReq_set_ctr(PyObject *py_obj, PyObject *value, void *closure)
 
2222
{
 
2223
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2224
        talloc_unlink(py_talloc_get_mem_ctx(py_obj), object->ctr);
 
2225
        if (value == Py_None) {
 
2226
                object->ctr = NULL;
 
2227
        } else {
 
2228
                object->ctr = NULL;
 
2229
                PY_CHECK_TYPE(&frsrpc_CommPktChunkCtr_Type, value, return -1;);
 
2230
                if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
2231
                        PyErr_NoMemory();
 
2232
                        return -1;
 
2233
                }
 
2234
                object->ctr = (struct frsrpc_CommPktChunkCtr *)py_talloc_get_ptr(value);
 
2235
        }
 
2236
        return 0;
 
2237
}
 
2238
 
 
2239
static PyObject *py_frsrpc_FrsSendCommPktReq_get_data_name(PyObject *obj, void *closure)
 
2240
{
 
2241
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2242
        PyObject *py_data_name;
 
2243
        py_data_name = PyInt_FromLong(object->data_name);
 
2244
        return py_data_name;
 
2245
}
 
2246
 
 
2247
static int py_frsrpc_FrsSendCommPktReq_set_data_name(PyObject *py_obj, PyObject *value, void *closure)
 
2248
{
 
2249
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2250
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2251
        object->data_name = PyInt_AsLong(value);
 
2252
        return 0;
 
2253
}
 
2254
 
 
2255
static PyObject *py_frsrpc_FrsSendCommPktReq_get_data_handle(PyObject *obj, void *closure)
 
2256
{
 
2257
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(obj);
 
2258
        PyObject *py_data_handle;
 
2259
        py_data_handle = PyInt_FromLong(object->data_handle);
 
2260
        return py_data_handle;
 
2261
}
 
2262
 
 
2263
static int py_frsrpc_FrsSendCommPktReq_set_data_handle(PyObject *py_obj, PyObject *value, void *closure)
 
2264
{
 
2265
        struct frsrpc_FrsSendCommPktReq *object = (struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_obj);
 
2266
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
2267
        object->data_handle = PyInt_AsLong(value);
 
2268
        return 0;
 
2269
}
 
2270
 
 
2271
static PyGetSetDef py_frsrpc_FrsSendCommPktReq_getsetters[] = {
 
2272
        { discard_const_p(char, "major"), py_frsrpc_FrsSendCommPktReq_get_major, py_frsrpc_FrsSendCommPktReq_set_major },
 
2273
        { discard_const_p(char, "minor"), py_frsrpc_FrsSendCommPktReq_get_minor, py_frsrpc_FrsSendCommPktReq_set_minor },
 
2274
        { discard_const_p(char, "cs_id"), py_frsrpc_FrsSendCommPktReq_get_cs_id, py_frsrpc_FrsSendCommPktReq_set_cs_id },
 
2275
        { discard_const_p(char, "memory_len"), py_frsrpc_FrsSendCommPktReq_get_memory_len, py_frsrpc_FrsSendCommPktReq_set_memory_len },
 
2276
        { discard_const_p(char, "pkt_len"), py_frsrpc_FrsSendCommPktReq_get_pkt_len, py_frsrpc_FrsSendCommPktReq_set_pkt_len },
 
2277
        { discard_const_p(char, "upk_len"), py_frsrpc_FrsSendCommPktReq_get_upk_len, py_frsrpc_FrsSendCommPktReq_set_upk_len },
 
2278
        { discard_const_p(char, "ctr"), py_frsrpc_FrsSendCommPktReq_get_ctr, py_frsrpc_FrsSendCommPktReq_set_ctr },
 
2279
        { discard_const_p(char, "data_name"), py_frsrpc_FrsSendCommPktReq_get_data_name, py_frsrpc_FrsSendCommPktReq_set_data_name },
 
2280
        { discard_const_p(char, "data_handle"), py_frsrpc_FrsSendCommPktReq_get_data_handle, py_frsrpc_FrsSendCommPktReq_set_data_handle },
 
2281
        { NULL }
 
2282
};
 
2283
 
 
2284
static PyObject *py_frsrpc_FrsSendCommPktReq_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 
2285
{
 
2286
        return py_talloc_new(struct frsrpc_FrsSendCommPktReq, type);
 
2287
}
 
2288
 
 
2289
 
 
2290
static PyTypeObject frsrpc_FrsSendCommPktReq_Type = {
 
2291
        PyObject_HEAD_INIT(NULL) 0,
 
2292
        .tp_name = "frsrpc.FrsSendCommPktReq",
 
2293
        .tp_getset = py_frsrpc_FrsSendCommPktReq_getsetters,
 
2294
        .tp_methods = NULL,
 
2295
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 
2296
        .tp_basicsize = sizeof(py_talloc_Object),
 
2297
        .tp_new = py_frsrpc_FrsSendCommPktReq_new,
 
2298
};
 
2299
 
 
2300
 
 
2301
static bool pack_py_frsrpc_FrsSendCommPkt_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsSendCommPkt *r)
 
2302
{
 
2303
        PyObject *py_req;
 
2304
        const char *kwnames[] = {
 
2305
                "req", NULL
 
2306
        };
 
2307
 
 
2308
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:frsrpc_FrsSendCommPkt", discard_const_p(char *, kwnames), &py_req)) {
 
2309
                return false;
 
2310
        }
 
2311
 
 
2312
        PY_CHECK_TYPE(&frsrpc_FrsSendCommPktReq_Type, py_req, return false;);
 
2313
        if (talloc_reference(r, py_talloc_get_mem_ctx(py_req)) == NULL) {
 
2314
                PyErr_NoMemory();
 
2315
                return false;
 
2316
        }
 
2317
        r->in.req = *(struct frsrpc_FrsSendCommPktReq *)py_talloc_get_ptr(py_req);
 
2318
        return true;
 
2319
}
 
2320
 
 
2321
static PyObject *unpack_py_frsrpc_FrsSendCommPkt_args_out(struct frsrpc_FrsSendCommPkt *r)
 
2322
{
 
2323
        PyObject *result;
 
2324
        result = Py_None;
 
2325
        Py_INCREF(result);
 
2326
        if (!W_ERROR_IS_OK(r->out.result)) {
 
2327
                PyErr_SetWERROR(r->out.result);
 
2328
                return NULL;
 
2329
        }
 
2330
 
 
2331
        return result;
 
2332
}
 
2333
 
 
2334
static bool pack_py_frsrpc_FrsVerifyPromotionParent_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsVerifyPromotionParent *r)
 
2335
{
 
2336
        PyObject *py_parent_account;
 
2337
        PyObject *py_parent_password;
 
2338
        PyObject *py_replica_set_name;
 
2339
        PyObject *py_replica_set_type;
 
2340
        PyObject *py_partner_auth_level;
 
2341
        PyObject *py___ndr_guid_size;
 
2342
        const char *kwnames[] = {
 
2343
                "parent_account", "parent_password", "replica_set_name", "replica_set_type", "partner_auth_level", "__ndr_guid_size", NULL
 
2344
        };
 
2345
 
 
2346
        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)) {
 
2347
                return false;
 
2348
        }
 
2349
 
 
2350
        if (py_parent_account == Py_None) {
 
2351
                r->in.parent_account = NULL;
 
2352
        } else {
 
2353
                r->in.parent_account = NULL;
 
2354
                if (PyUnicode_Check(py_parent_account)) {
 
2355
                        r->in.parent_account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_account, "utf-8", "ignore"));
 
2356
                } else if (PyString_Check(py_parent_account)) {
 
2357
                        r->in.parent_account = PyString_AS_STRING(py_parent_account);
 
2358
                } else {
 
2359
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_account)->tp_name);
 
2360
                        return false;
 
2361
                }
 
2362
        }
 
2363
        if (py_parent_password == Py_None) {
 
2364
                r->in.parent_password = NULL;
 
2365
        } else {
 
2366
                r->in.parent_password = NULL;
 
2367
                if (PyUnicode_Check(py_parent_password)) {
 
2368
                        r->in.parent_password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_password, "utf-8", "ignore"));
 
2369
                } else if (PyString_Check(py_parent_password)) {
 
2370
                        r->in.parent_password = PyString_AS_STRING(py_parent_password);
 
2371
                } else {
 
2372
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_password)->tp_name);
 
2373
                        return false;
 
2374
                }
 
2375
        }
 
2376
        if (py_replica_set_name == Py_None) {
 
2377
                r->in.replica_set_name = NULL;
 
2378
        } else {
 
2379
                r->in.replica_set_name = NULL;
 
2380
                if (PyUnicode_Check(py_replica_set_name)) {
 
2381
                        r->in.replica_set_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_name, "utf-8", "ignore"));
 
2382
                } else if (PyString_Check(py_replica_set_name)) {
 
2383
                        r->in.replica_set_name = PyString_AS_STRING(py_replica_set_name);
 
2384
                } else {
 
2385
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_name)->tp_name);
 
2386
                        return false;
 
2387
                }
 
2388
        }
 
2389
        if (py_replica_set_type == Py_None) {
 
2390
                r->in.replica_set_type = NULL;
 
2391
        } else {
 
2392
                r->in.replica_set_type = NULL;
 
2393
                if (PyUnicode_Check(py_replica_set_type)) {
 
2394
                        r->in.replica_set_type = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_type, "utf-8", "ignore"));
 
2395
                } else if (PyString_Check(py_replica_set_type)) {
 
2396
                        r->in.replica_set_type = PyString_AS_STRING(py_replica_set_type);
 
2397
                } else {
 
2398
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_type)->tp_name);
 
2399
                        return false;
 
2400
                }
 
2401
        }
 
2402
        if (PyLong_Check(py_partner_auth_level)) {
 
2403
                r->in.partner_auth_level = PyLong_AsLongLong(py_partner_auth_level);
 
2404
        } else if (PyInt_Check(py_partner_auth_level)) {
 
2405
                r->in.partner_auth_level = PyInt_AsLong(py_partner_auth_level);
 
2406
        } else {
 
2407
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
2408
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
2409
                return false;
 
2410
        }
 
2411
        PY_CHECK_TYPE(&PyInt_Type, py___ndr_guid_size, return false;);
 
2412
        r->in.__ndr_guid_size = PyInt_AsLong(py___ndr_guid_size);
 
2413
        return true;
 
2414
}
 
2415
 
 
2416
static PyObject *unpack_py_frsrpc_FrsVerifyPromotionParent_args_out(struct frsrpc_FrsVerifyPromotionParent *r)
 
2417
{
 
2418
        PyObject *result;
 
2419
        result = Py_None;
 
2420
        Py_INCREF(result);
 
2421
        if (!W_ERROR_IS_OK(r->out.result)) {
 
2422
                PyErr_SetWERROR(r->out.result);
 
2423
                return NULL;
 
2424
        }
 
2425
 
 
2426
        return result;
 
2427
}
 
2428
 
 
2429
static bool pack_py_frsrpc_FrsStartPromotionParent_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsStartPromotionParent *r)
 
2430
{
 
2431
        PyObject *py_parent_account;
 
2432
        PyObject *py_parent_password;
 
2433
        PyObject *py_replica_set_name;
 
2434
        PyObject *py_replica_set_type;
 
2435
        PyObject *py_connection_name;
 
2436
        PyObject *py_partner_name;
 
2437
        PyObject *py_partner_princ_name;
 
2438
        PyObject *py_partner_auth_level;
 
2439
        PyObject *py___ndr_guid_size;
 
2440
        PyObject *py_connection_guid;
 
2441
        PyObject *py_partner_guid;
 
2442
        PyObject *py_parent_guid;
 
2443
        const char *kwnames[] = {
 
2444
                "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
 
2445
        };
 
2446
 
 
2447
        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)) {
 
2448
                return false;
 
2449
        }
 
2450
 
 
2451
        if (py_parent_account == Py_None) {
 
2452
                r->in.parent_account = NULL;
 
2453
        } else {
 
2454
                r->in.parent_account = NULL;
 
2455
                if (PyUnicode_Check(py_parent_account)) {
 
2456
                        r->in.parent_account = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_account, "utf-8", "ignore"));
 
2457
                } else if (PyString_Check(py_parent_account)) {
 
2458
                        r->in.parent_account = PyString_AS_STRING(py_parent_account);
 
2459
                } else {
 
2460
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_account)->tp_name);
 
2461
                        return false;
 
2462
                }
 
2463
        }
 
2464
        if (py_parent_password == Py_None) {
 
2465
                r->in.parent_password = NULL;
 
2466
        } else {
 
2467
                r->in.parent_password = NULL;
 
2468
                if (PyUnicode_Check(py_parent_password)) {
 
2469
                        r->in.parent_password = PyString_AS_STRING(PyUnicode_AsEncodedString(py_parent_password, "utf-8", "ignore"));
 
2470
                } else if (PyString_Check(py_parent_password)) {
 
2471
                        r->in.parent_password = PyString_AS_STRING(py_parent_password);
 
2472
                } else {
 
2473
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_parent_password)->tp_name);
 
2474
                        return false;
 
2475
                }
 
2476
        }
 
2477
        if (py_replica_set_name == Py_None) {
 
2478
                r->in.replica_set_name = NULL;
 
2479
        } else {
 
2480
                r->in.replica_set_name = NULL;
 
2481
                if (PyUnicode_Check(py_replica_set_name)) {
 
2482
                        r->in.replica_set_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_name, "utf-8", "ignore"));
 
2483
                } else if (PyString_Check(py_replica_set_name)) {
 
2484
                        r->in.replica_set_name = PyString_AS_STRING(py_replica_set_name);
 
2485
                } else {
 
2486
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_name)->tp_name);
 
2487
                        return false;
 
2488
                }
 
2489
        }
 
2490
        if (py_replica_set_type == Py_None) {
 
2491
                r->in.replica_set_type = NULL;
 
2492
        } else {
 
2493
                r->in.replica_set_type = NULL;
 
2494
                if (PyUnicode_Check(py_replica_set_type)) {
 
2495
                        r->in.replica_set_type = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_type, "utf-8", "ignore"));
 
2496
                } else if (PyString_Check(py_replica_set_type)) {
 
2497
                        r->in.replica_set_type = PyString_AS_STRING(py_replica_set_type);
 
2498
                } else {
 
2499
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_type)->tp_name);
 
2500
                        return false;
 
2501
                }
 
2502
        }
 
2503
        if (py_connection_name == Py_None) {
 
2504
                r->in.connection_name = NULL;
 
2505
        } else {
 
2506
                r->in.connection_name = NULL;
 
2507
                if (PyUnicode_Check(py_connection_name)) {
 
2508
                        r->in.connection_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_connection_name, "utf-8", "ignore"));
 
2509
                } else if (PyString_Check(py_connection_name)) {
 
2510
                        r->in.connection_name = PyString_AS_STRING(py_connection_name);
 
2511
                } else {
 
2512
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_connection_name)->tp_name);
 
2513
                        return false;
 
2514
                }
 
2515
        }
 
2516
        if (py_partner_name == Py_None) {
 
2517
                r->in.partner_name = NULL;
 
2518
        } else {
 
2519
                r->in.partner_name = NULL;
 
2520
                if (PyUnicode_Check(py_partner_name)) {
 
2521
                        r->in.partner_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_partner_name, "utf-8", "ignore"));
 
2522
                } else if (PyString_Check(py_partner_name)) {
 
2523
                        r->in.partner_name = PyString_AS_STRING(py_partner_name);
 
2524
                } else {
 
2525
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_partner_name)->tp_name);
 
2526
                        return false;
 
2527
                }
 
2528
        }
 
2529
        if (py_partner_princ_name == Py_None) {
 
2530
                r->in.partner_princ_name = NULL;
 
2531
        } else {
 
2532
                r->in.partner_princ_name = NULL;
 
2533
                if (PyUnicode_Check(py_partner_princ_name)) {
 
2534
                        r->in.partner_princ_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_partner_princ_name, "utf-8", "ignore"));
 
2535
                } else if (PyString_Check(py_partner_princ_name)) {
 
2536
                        r->in.partner_princ_name = PyString_AS_STRING(py_partner_princ_name);
 
2537
                } else {
 
2538
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_partner_princ_name)->tp_name);
 
2539
                        return false;
 
2540
                }
 
2541
        }
 
2542
        if (PyLong_Check(py_partner_auth_level)) {
 
2543
                r->in.partner_auth_level = PyLong_AsLongLong(py_partner_auth_level);
 
2544
        } else if (PyInt_Check(py_partner_auth_level)) {
 
2545
                r->in.partner_auth_level = PyInt_AsLong(py_partner_auth_level);
 
2546
        } else {
 
2547
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
2548
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
2549
                return false;
 
2550
        }
 
2551
        PY_CHECK_TYPE(&PyInt_Type, py___ndr_guid_size, return false;);
 
2552
        r->in.__ndr_guid_size = PyInt_AsLong(py___ndr_guid_size);
 
2553
        if (py_connection_guid == Py_None) {
 
2554
                r->in.connection_guid = NULL;
 
2555
        } else {
 
2556
                r->in.connection_guid = NULL;
 
2557
                PY_CHECK_TYPE(GUID_Type, py_connection_guid, return false;);
 
2558
                if (talloc_reference(r, py_talloc_get_mem_ctx(py_connection_guid)) == NULL) {
 
2559
                        PyErr_NoMemory();
 
2560
                        return false;
 
2561
                }
 
2562
                r->in.connection_guid = (struct GUID *)py_talloc_get_ptr(py_connection_guid);
 
2563
        }
 
2564
        if (py_partner_guid == Py_None) {
 
2565
                r->in.partner_guid = NULL;
 
2566
        } else {
 
2567
                r->in.partner_guid = NULL;
 
2568
                PY_CHECK_TYPE(GUID_Type, py_partner_guid, return false;);
 
2569
                if (talloc_reference(r, py_talloc_get_mem_ctx(py_partner_guid)) == NULL) {
 
2570
                        PyErr_NoMemory();
 
2571
                        return false;
 
2572
                }
 
2573
                r->in.partner_guid = (struct GUID *)py_talloc_get_ptr(py_partner_guid);
 
2574
        }
 
2575
        if (py_parent_guid == Py_None) {
 
2576
                r->in.parent_guid = NULL;
 
2577
        } else {
 
2578
                r->in.parent_guid = NULL;
 
2579
                PY_CHECK_TYPE(GUID_Type, py_parent_guid, return false;);
 
2580
                if (talloc_reference(r, py_talloc_get_mem_ctx(py_parent_guid)) == NULL) {
 
2581
                        PyErr_NoMemory();
 
2582
                        return false;
 
2583
                }
 
2584
                r->in.parent_guid = (struct GUID *)py_talloc_get_ptr(py_parent_guid);
 
2585
        }
 
2586
        return true;
 
2587
}
 
2588
 
 
2589
static PyObject *unpack_py_frsrpc_FrsStartPromotionParent_args_out(struct frsrpc_FrsStartPromotionParent *r)
 
2590
{
 
2591
        PyObject *result;
 
2592
        PyObject *py_parent_guid;
 
2593
        if (r->out.parent_guid == NULL) {
 
2594
                py_parent_guid = Py_None;
 
2595
                Py_INCREF(py_parent_guid);
 
2596
        } else {
 
2597
                py_parent_guid = py_talloc_reference_ex(GUID_Type, r->out.parent_guid, r->out.parent_guid);
 
2598
        }
 
2599
        result = py_parent_guid;
 
2600
        if (!W_ERROR_IS_OK(r->out.result)) {
 
2601
                PyErr_SetWERROR(r->out.result);
 
2602
                return NULL;
 
2603
        }
 
2604
 
 
2605
        return result;
 
2606
}
 
2607
 
 
2608
static bool pack_py_frsrpc_FrsNOP_args_in(PyObject *args, PyObject *kwargs, struct frsrpc_FrsNOP *r)
 
2609
{
 
2610
        const char *kwnames[] = {
 
2611
                NULL
 
2612
        };
 
2613
 
 
2614
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":frsrpc_FrsNOP", discard_const_p(char *, kwnames))) {
 
2615
                return false;
 
2616
        }
 
2617
 
 
2618
        return true;
 
2619
}
 
2620
 
 
2621
static PyObject *unpack_py_frsrpc_FrsNOP_args_out(struct frsrpc_FrsNOP *r)
 
2622
{
 
2623
        PyObject *result;
 
2624
        result = Py_None;
 
2625
        Py_INCREF(result);
 
2626
        if (!W_ERROR_IS_OK(r->out.result)) {
 
2627
                PyErr_SetWERROR(r->out.result);
 
2628
                return NULL;
 
2629
        }
 
2630
 
 
2631
        return result;
 
2632
}
 
2633
 
 
2634
const struct PyNdrRpcMethodDef py_ndr_frsrpc_methods[] = {
 
2635
        { "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 },
 
2636
        { "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 },
 
2637
        { "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 },
 
2638
        { "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 },
 
2639
        { NULL }
 
2640
};
 
2641
 
 
2642
static PyObject *interface_frsrpc_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 
2643
{
 
2644
        return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_frsrpc);
 
2645
}
 
2646
 
 
2647
#define PY_DOC_FRSRPC "File Replication Service"
 
2648
static PyTypeObject frsrpc_InterfaceType = {
 
2649
        PyObject_HEAD_INIT(NULL) 0,
 
2650
        .tp_name = "frsrpc.frsrpc",
 
2651
        .tp_basicsize = sizeof(dcerpc_InterfaceObject),
 
2652
        .tp_doc = "frsrpc(binding, lp_ctx=None, credentials=None) -> connection\n"
 
2653
"\n"
 
2654
"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
 
2655
"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
 
2656
"credentials should be a credentials.Credentials object.\n\n"PY_DOC_FRSRPC,
 
2657
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 
2658
        .tp_new = interface_frsrpc_new,
 
2659
};
 
2660
 
 
2661
static PyMethodDef frsrpc_methods[] = {
 
2662
        { NULL, NULL, 0, NULL }
 
2663
};
 
2664
 
 
2665
void initfrsrpc(void)
 
2666
{
 
2667
        PyObject *m;
 
2668
        PyObject *dep_talloc;
 
2669
        PyObject *dep_samba_dcerpc_misc;
 
2670
        PyObject *dep_samba_dcerpc_base;
 
2671
 
 
2672
        dep_talloc = PyImport_ImportModule("talloc");
 
2673
        if (dep_talloc == NULL)
 
2674
                return;
 
2675
 
 
2676
        dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
 
2677
        if (dep_samba_dcerpc_misc == NULL)
 
2678
                return;
 
2679
 
 
2680
        dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
 
2681
        if (dep_samba_dcerpc_base == NULL)
 
2682
                return;
 
2683
 
 
2684
        Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
 
2685
        if (Object_Type == NULL)
 
2686
                return;
 
2687
 
 
2688
        GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
 
2689
        if (GUID_Type == NULL)
 
2690
                return;
 
2691
 
 
2692
        ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
 
2693
        if (ClientConnection_Type == NULL)
 
2694
                return;
 
2695
 
 
2696
        frsrpc_CommPktChunkGuidName_Type.tp_base = Object_Type;
 
2697
 
 
2698
        frsrpc_CommPktGSVN_Type.tp_base = Object_Type;
 
2699
 
 
2700
        frsrpc_CommPktChangeOrderCommand_Type.tp_base = Object_Type;
 
2701
 
 
2702
        frsrpc_CommPktDataExtensionChecksum_Type.tp_base = Object_Type;
 
2703
 
 
2704
        frsrpc_CommPktDataExtensionRetryTimeout_Type.tp_base = Object_Type;
 
2705
 
 
2706
        frsrpc_CommPktCoRecordExtensionWin2k_Type.tp_base = Object_Type;
 
2707
 
 
2708
        frsrpc_CommPktChangeOrderRecordExtension_Type.tp_base = Object_Type;
 
2709
 
 
2710
        frsrpc_CommPktChunk_Type.tp_base = Object_Type;
 
2711
 
 
2712
        frsrpc_CommPktChunkCtr_Type.tp_base = Object_Type;
 
2713
 
 
2714
        frsrpc_FrsSendCommPktReq_Type.tp_base = Object_Type;
 
2715
 
 
2716
        frsrpc_InterfaceType.tp_base = ClientConnection_Type;
 
2717
 
 
2718
        if (PyType_Ready(&frsrpc_CommPktChunkGuidName_Type) < 0)
 
2719
                return;
 
2720
        if (PyType_Ready(&frsrpc_CommPktGSVN_Type) < 0)
 
2721
                return;
 
2722
        if (PyType_Ready(&frsrpc_CommPktChangeOrderCommand_Type) < 0)
 
2723
                return;
 
2724
        if (PyType_Ready(&frsrpc_CommPktDataExtensionChecksum_Type) < 0)
 
2725
                return;
 
2726
        if (PyType_Ready(&frsrpc_CommPktDataExtensionRetryTimeout_Type) < 0)
 
2727
                return;
 
2728
        if (PyType_Ready(&frsrpc_CommPktCoRecordExtensionWin2k_Type) < 0)
 
2729
                return;
 
2730
        if (PyType_Ready(&frsrpc_CommPktChangeOrderRecordExtension_Type) < 0)
 
2731
                return;
 
2732
        if (PyType_Ready(&frsrpc_CommPktChunk_Type) < 0)
 
2733
                return;
 
2734
        if (PyType_Ready(&frsrpc_CommPktChunkCtr_Type) < 0)
 
2735
                return;
 
2736
        if (PyType_Ready(&frsrpc_FrsSendCommPktReq_Type) < 0)
 
2737
                return;
 
2738
        if (PyType_Ready(&frsrpc_InterfaceType) < 0)
 
2739
                return;
 
2740
        if (!PyInterface_AddNdrRpcMethods(&frsrpc_InterfaceType, py_ndr_frsrpc_methods))
 
2741
                return;
 
2742
 
 
2743
#ifdef PY_COMMPKTCHUNKGUIDNAME_PATCH
 
2744
        PY_COMMPKTCHUNKGUIDNAME_PATCH(&frsrpc_CommPktChunkGuidName_Type);
 
2745
#endif
 
2746
#ifdef PY_COMMPKTGSVN_PATCH
 
2747
        PY_COMMPKTGSVN_PATCH(&frsrpc_CommPktGSVN_Type);
 
2748
#endif
 
2749
#ifdef PY_COMMPKTCHANGEORDERCOMMAND_PATCH
 
2750
        PY_COMMPKTCHANGEORDERCOMMAND_PATCH(&frsrpc_CommPktChangeOrderCommand_Type);
 
2751
#endif
 
2752
#ifdef PY_COMMPKTDATAEXTENSIONCHECKSUM_PATCH
 
2753
        PY_COMMPKTDATAEXTENSIONCHECKSUM_PATCH(&frsrpc_CommPktDataExtensionChecksum_Type);
 
2754
#endif
 
2755
#ifdef PY_COMMPKTDATAEXTENSIONRETRYTIMEOUT_PATCH
 
2756
        PY_COMMPKTDATAEXTENSIONRETRYTIMEOUT_PATCH(&frsrpc_CommPktDataExtensionRetryTimeout_Type);
 
2757
#endif
 
2758
#ifdef PY_COMMPKTCORECORDEXTENSIONWIN2K_PATCH
 
2759
        PY_COMMPKTCORECORDEXTENSIONWIN2K_PATCH(&frsrpc_CommPktCoRecordExtensionWin2k_Type);
 
2760
#endif
 
2761
#ifdef PY_COMMPKTCHANGEORDERRECORDEXTENSION_PATCH
 
2762
        PY_COMMPKTCHANGEORDERRECORDEXTENSION_PATCH(&frsrpc_CommPktChangeOrderRecordExtension_Type);
 
2763
#endif
 
2764
#ifdef PY_COMMPKTCHUNK_PATCH
 
2765
        PY_COMMPKTCHUNK_PATCH(&frsrpc_CommPktChunk_Type);
 
2766
#endif
 
2767
#ifdef PY_COMMPKTCHUNKCTR_PATCH
 
2768
        PY_COMMPKTCHUNKCTR_PATCH(&frsrpc_CommPktChunkCtr_Type);
 
2769
#endif
 
2770
#ifdef PY_FRSSENDCOMMPKTREQ_PATCH
 
2771
        PY_FRSSENDCOMMPKTREQ_PATCH(&frsrpc_FrsSendCommPktReq_Type);
 
2772
#endif
 
2773
#ifdef PY_FRSRPC_PATCH
 
2774
        PY_FRSRPC_PATCH(&frsrpc_InterfaceType);
 
2775
#endif
 
2776
 
 
2777
        m = Py_InitModule3("frsrpc", frsrpc_methods, "frsrpc DCE/RPC");
 
2778
        if (m == NULL)
 
2779
                return;
 
2780
 
 
2781
        PyModule_AddObject(m, "FRSRPC_CO_IFLAG_CO_ABORT", PyInt_FromLong(FRSRPC_CO_IFLAG_CO_ABORT));
 
2782
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEOUT", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEOUT));
 
2783
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_FILE_CREATE", PyInt_FromLong(FRSRPC_CONTENT_REASON_FILE_CREATE));
 
2784
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NAMED_DATA_EXTEND", PyInt_FromLong(FRSRPC_CONTENT_REASON_NAMED_DATA_EXTEND));
 
2785
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_COMMAND", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_COMMAND));
 
2786
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEIN2", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEIN2));
 
2787
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_JOIN_TIME", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_JOIN_TIME));
 
2788
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_JUST_OID_RESET", PyInt_FromLong(FRSRPC_CO_FLAG_JUST_OID_RESET));
 
2789
        PyModule_AddObject(m, "FRSRPC_COMMAND_WJOIN_DONE", PyInt_FromLong(FRSRPC_COMMAND_WJOIN_DONE));
 
2790
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_ALLOC_STAGING_LOCAL_CO", PyInt_FromLong(FRSRPC_CO_STATUS_ALLOC_STAGING_LOCAL_CO));
 
2791
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEIN", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEIN));
 
2792
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_ALLOC_STAGING_REMOTE_CO", PyInt_FromLong(FRSRPC_CO_STATUS_ALLOC_STAGING_REMOTE_CO));
 
2793
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_DB_STATE_UPDATE_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_DB_STATE_UPDATE_COMPLETED));
 
2794
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_CONTENT_CMD", PyInt_FromLong(FRSRPC_CO_FLAG_CONTENT_CMD));
 
2795
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_LAST_JOIN_TIME", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_LAST_JOIN_TIME));
 
2796
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_RETRYING", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_RETRYING));
 
2797
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_FILE_DELETE", PyInt_FromLong(FRSRPC_CONTENT_REASON_FILE_DELETE));
 
2798
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_FROM", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_FROM));
 
2799
        PyModule_AddObject(m, "FRSRPC_COMMAND_JOINED", PyInt_FromLong(FRSRPC_COMMAND_JOINED));
 
2800
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_MOVEIN_GEN", PyInt_FromLong(FRSRPC_CO_FLAG_MOVEIN_GEN));
 
2801
        PyModule_AddObject(m, "FRSRPC_COMMAND_START_JOIN", PyInt_FromLong(FRSRPC_COMMAND_START_JOIN));
 
2802
        PyModule_AddObject(m, "FRSRPC_DATA_EXTENSION_TERMINATOR", PyInt_FromLong(FRSRPC_DATA_EXTENSION_TERMINATOR));
 
2803
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_EA_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_EA_CHANGE));
 
2804
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_CONTROL", PyInt_FromLong(FRSRPC_CO_FLAG_CONTROL));
 
2805
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVERS", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVERS));
 
2806
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_WAIT_RETRY", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_WAIT_RETRY));
 
2807
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_COMPRESSED_STAGE", PyInt_FromLong(FRSRPC_CO_FLAG_COMPRESSED_STAGE));
 
2808
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_VVJOIN_TO_ORIG", PyInt_FromLong(FRSRPC_CO_FLAG_VVJOIN_TO_ORIG));
 
2809
        PyModule_AddObject(m, "FRSRPC_COMMAND_REMOTE_CO", PyInt_FromLong(FRSRPC_COMMAND_REMOTE_CO));
 
2810
        PyModule_AddObject(m, "FRSRPC_DATA_EXTENSION_RETRY_TIMEOUT", PyInt_FromLong(FRSRPC_DATA_EXTENSION_RETRY_TIMEOUT));
 
2811
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_DB_STATE_UPDATE_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_DB_STATE_UPDATE_STARTED));
 
2812
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_GUID));
 
2813
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MAJOR_0", PyInt_FromLong(FRSRPC_COMM_PKT_MAJOR_0));
 
2814
        PyModule_AddObject(m, "FRSRPC_CO_IFLAG_DIR_ENUM_PENDING", PyInt_FromLong(FRSRPC_CO_IFLAG_DIR_ENUM_PENDING));
 
2815
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_SKIP_ORIG_REC_C", PyInt_FromLong(FRSRPC_CO_FLAG_SKIP_ORIG_REC_C));
 
2816
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_LOCAL_CO_STAGING_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_LOCAL_CO_STAGING_STARTED));
 
2817
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_COMPRESSION_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_COMPRESSION_CHANGE));
 
2818
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_0", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_0));
 
2819
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_OUT_OF_ORDER", PyInt_FromLong(FRSRPC_CO_FLAG_OUT_OF_ORDER));
 
2820
        PyModule_AddObject(m, "FRSRPC_PARENT_AUTH_LEVEL_NO_AUTHENTICATION", PyInt_FromLong(FRSRPC_PARENT_AUTH_LEVEL_NO_AUTHENTICATION));
 
2821
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_DATA_OVERWRITE", PyInt_FromLong(FRSRPC_CONTENT_REASON_DATA_OVERWRITE));
 
2822
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_1", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_1));
 
2823
        PyModule_AddObject(m, "FRSRPC_COMMAND_RECEIVING_STATE", PyInt_FromLong(FRSRPC_COMMAND_RECEIVING_STATE));
 
2824
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_CO_RECYCLED_FOR_ENUM", PyInt_FromLong(FRSRPC_CO_STATUS_CO_RECYCLED_FOR_ENUM));
 
2825
        PyModule_AddObject(m, "FRSRPC_COMMAND_REMOTE_CO_DONE", PyInt_FromLong(FRSRPC_COMMAND_REMOTE_CO_DONE));
 
2826
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_7", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_7));
 
2827
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEOUT", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEOUT));
 
2828
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_4", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_4));
 
2829
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_GVSN", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_GVSN));
 
2830
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_STARTED));
 
2831
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_SEQUENCE_NUMBER", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_SEQUENCE_NUMBER));
 
2832
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NEW_NAME", PyInt_FromLong(FRSRPC_CONTENT_REASON_NEW_NAME));
 
2833
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_NO_CMD", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_NO_CMD));
 
2834
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_WAIT_RETRY_REMOTE_CO_STAGING", PyInt_FromLong(FRSRPC_CO_STATUS_WAIT_RETRY_REMOTE_CO_STAGING));
 
2835
        PyModule_AddObject(m, "FRSRPC_COMMAND_ABORT_FETCH", PyInt_FromLong(FRSRPC_COMMAND_ABORT_FETCH));
 
2836
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NAMED_DATA_OVERWRITE", PyInt_FromLong(FRSRPC_CONTENT_REASON_NAMED_DATA_OVERWRITE));
 
2837
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_5", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_5));
 
2838
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_EXTENTION_2", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_EXTENTION_2));
 
2839
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_CREATE", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_CREATE));
 
2840
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_LOCAL_CO_STAGING_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_LOCAL_CO_STAGING_COMPLETED));
 
2841
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_NEW_FILE", PyInt_FromLong(FRSRPC_CO_FLAG_NEW_FILE));
 
2842
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_LOCALCO", PyInt_FromLong(FRSRPC_CO_FLAG_LOCALCO));
 
2843
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEIN", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEIN));
 
2844
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_FILE_SIZE", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_FILE_SIZE));
 
2845
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CO_EXT_WIN2K", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CO_EXT_WIN2K));
 
2846
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_8", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_8));
 
2847
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_VV_ACTIVATED", PyInt_FromLong(FRSRPC_CO_FLAG_VV_ACTIVATED));
 
2848
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_REMOTE_CO_STAGING_STARTED", PyInt_FromLong(FRSRPC_CO_STATUS_REMOTE_CO_STAGING_STARTED));
 
2849
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_CO_ABORTED", PyInt_FromLong(FRSRPC_CO_STATUS_CO_ABORTED));
 
2850
        PyModule_AddObject(m, "FRSRPC_CO_IFLAG_VVRETIRE_EXEC", PyInt_FromLong(FRSRPC_CO_IFLAG_VVRETIRE_EXEC));
 
2851
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_DELETE", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_DELETE));
 
2852
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_VVECTOR", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_VVECTOR));
 
2853
        PyModule_AddObject(m, "FRSRPC_CO_RECORD_EXTENSION_VERSION_1", PyInt_FromLong(FRSRPC_CO_RECORD_EXTENSION_VERSION_1));
 
2854
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_REMOTE_CO", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_REMOTE_CO));
 
2855
        PyModule_AddObject(m, "FRSRPC_CO_IFLAG_NONE", PyInt_FromLong(0x0000000));
 
2856
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_DIRECTED_CO", PyInt_FromLong(FRSRPC_CO_FLAG_DIRECTED_CO));
 
2857
        PyModule_AddObject(m, "FRSRPC_COMMAND_NEED_JOIN", PyInt_FromLong(FRSRPC_COMMAND_NEED_JOIN));
 
2858
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_DATA_TRUNCATION", PyInt_FromLong(FRSRPC_CONTENT_REASON_DATA_TRUNCATION));
 
2859
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_REMOTE_CO_STAGING_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_REMOTE_CO_STAGING_COMPLETED));
 
2860
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_RENAME_RETRYING", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_RENAME_RETRYING));
 
2861
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_9", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_9));
 
2862
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVERS", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVERS));
 
2863
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_MORPH_GEN_HEAD", PyInt_FromLong(FRSRPC_CO_FLAG_MORPH_GEN_HEAD));
 
2864
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_JOIN_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_JOIN_GUID));
 
2865
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_WAIT_RETRY_LOCAL_CO_STAGING", PyInt_FromLong(FRSRPC_CO_STATUS_WAIT_RETRY_LOCAL_CO_STAGING));
 
2866
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_DELETE", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_DELETE));
 
2867
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEDIR", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEDIR));
 
2868
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_SKIP_VV_UPDATE", PyInt_FromLong(FRSRPC_CO_FLAG_SKIP_VV_UPDATE));
 
2869
        PyModule_AddObject(m, "FRSRPC_COMMAND_RETRY_FETCH", PyInt_FromLong(FRSRPC_COMMAND_RETRY_FETCH));
 
2870
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_REQUEST_OUTBOUND_PROPAGATION", PyInt_FromLong(FRSRPC_CO_STATUS_REQUEST_OUTBOUND_PROPAGATION));
 
2871
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_NAMED_DATA_TRUNCATION", PyInt_FromLong(FRSRPC_CONTENT_REASON_NAMED_DATA_TRUNCATION));
 
2872
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_CONNECTION", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_CONNECTION));
 
2873
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_NO_CMD", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_NO_CMD));
 
2874
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_COMPRESSION_GUID));
 
2875
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_DATA_EXTEND", PyInt_FromLong(FRSRPC_CONTENT_REASON_DATA_EXTEND));
 
2876
        PyModule_AddObject(m, "FRSRPC_COMMAND_SEND_STAGE", PyInt_FromLong(FRSRPC_COMMAND_SEND_STAGE));
 
2877
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_MOVEIN2", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_MOVEIN2));
 
2878
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_CO_ENTERED_LOG", PyInt_FromLong(FRSRPC_CO_STATUS_CO_ENTERED_LOG));
 
2879
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_BASIC_INFO_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_BASIC_INFO_CHANGE));
 
2880
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_6", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_6));
 
2881
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_BLOCK_SIZE", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_BLOCK_SIZE));
 
2882
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_REPLICA_VERSION_GUID", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_REPLICA_VERSION_GUID));
 
2883
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_LOCATION_CMD", PyInt_FromLong(FRSRPC_CO_FLAG_LOCATION_CMD));
 
2884
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_EOP", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_EOP));
 
2885
        PyModule_AddObject(m, "FRSRPC_COMMAND_UNJOIN_REMOTE", PyInt_FromLong(FRSRPC_COMMAND_UNJOIN_REMOTE));
 
2886
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_COMPLETED", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_COMPLETED));
 
2887
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_FILE_OFFSET", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_FILE_OFFSET));
 
2888
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_REPLICA", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_REPLICA));
 
2889
        PyModule_AddObject(m, "FRSRPC_DATA_EXTENSION_MD5_CHECKSUM", PyInt_FromLong(FRSRPC_DATA_EXTENSION_MD5_CHECKSUM));
 
2890
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_BOP", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_BOP));
 
2891
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_DIR_MOVEDIR", PyInt_FromLong(FRSRPC_CO_LOCATION_DIR_MOVEDIR));
 
2892
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_REQUESTED", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_REQUESTED));
 
2893
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_3", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_3));
 
2894
        PyModule_AddObject(m, "FRSRPC_CO_RECORD_EXTENSION_VERSION_WIN2K", PyInt_FromLong(FRSRPC_CO_RECORD_EXTENSION_VERSION_WIN2K));
 
2895
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_SECURITY_CHANGE", PyInt_FromLong(FRSRPC_CONTENT_REASON_SECURITY_CHANGE));
 
2896
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_RETRY", PyInt_FromLong(FRSRPC_CO_FLAG_RETRY));
 
2897
        PyModule_AddObject(m, "FRSRPC_CO_LOCATION_FILE_CREATE", PyInt_FromLong(FRSRPC_CO_LOCATION_FILE_CREATE));
 
2898
        PyModule_AddObject(m, "FRSRPC_COMMAND_JOINING", PyInt_FromLong(FRSRPC_COMMAND_JOINING));
 
2899
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_FILE_INSTALL_DELETE_RETRYING", PyInt_FromLong(FRSRPC_CO_STATUS_FILE_INSTALL_DELETE_RETRYING));
 
2900
        PyModule_AddObject(m, "FRSRPC_CONTENT_REASON_OLD_NAME", PyInt_FromLong(FRSRPC_CONTENT_REASON_OLD_NAME));
 
2901
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_BLOCK", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_BLOCK));
 
2902
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_ONLIST", PyInt_FromLong(FRSRPC_CO_FLAG_ONLIST));
 
2903
        PyModule_AddObject(m, "FRSRPC_CO_STATUS_REQUEST_ACCEPTED_OUTBOUND_LOG", PyInt_FromLong(FRSRPC_CO_STATUS_REQUEST_ACCEPTED_OUTBOUND_LOG));
 
2904
        PyModule_AddObject(m, "FRSRPC_CO_FLAG_ABORT_CO", PyInt_FromLong(FRSRPC_CO_FLAG_ABORT_CO));
 
2905
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_MINOR_2", PyInt_FromLong(FRSRPC_COMM_PKT_MINOR_2));
 
2906
        PyModule_AddObject(m, "FRSRPC_COMM_PKT_CHUNK_TO", PyInt_FromLong(FRSRPC_COMM_PKT_CHUNK_TO));
 
2907
        PyModule_AddObject(m, "FRSRPC_PARENT_AUTH_LEVEL_ENCRYPTED_KERBEROS", PyInt_FromLong(FRSRPC_PARENT_AUTH_LEVEL_ENCRYPTED_KERBEROS));
 
2908
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChunkGuidName_Type);
 
2909
        PyModule_AddObject(m, "CommPktChunkGuidName", (PyObject *)(void *)&frsrpc_CommPktChunkGuidName_Type);
 
2910
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktGSVN_Type);
 
2911
        PyModule_AddObject(m, "CommPktGSVN", (PyObject *)(void *)&frsrpc_CommPktGSVN_Type);
 
2912
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChangeOrderCommand_Type);
 
2913
        PyModule_AddObject(m, "CommPktChangeOrderCommand", (PyObject *)(void *)&frsrpc_CommPktChangeOrderCommand_Type);
 
2914
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktDataExtensionChecksum_Type);
 
2915
        PyModule_AddObject(m, "CommPktDataExtensionChecksum", (PyObject *)(void *)&frsrpc_CommPktDataExtensionChecksum_Type);
 
2916
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktDataExtensionRetryTimeout_Type);
 
2917
        PyModule_AddObject(m, "CommPktDataExtensionRetryTimeout", (PyObject *)(void *)&frsrpc_CommPktDataExtensionRetryTimeout_Type);
 
2918
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktCoRecordExtensionWin2k_Type);
 
2919
        PyModule_AddObject(m, "CommPktCoRecordExtensionWin2k", (PyObject *)(void *)&frsrpc_CommPktCoRecordExtensionWin2k_Type);
 
2920
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChangeOrderRecordExtension_Type);
 
2921
        PyModule_AddObject(m, "CommPktChangeOrderRecordExtension", (PyObject *)(void *)&frsrpc_CommPktChangeOrderRecordExtension_Type);
 
2922
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChunk_Type);
 
2923
        PyModule_AddObject(m, "CommPktChunk", (PyObject *)(void *)&frsrpc_CommPktChunk_Type);
 
2924
        Py_INCREF((PyObject *)(void *)&frsrpc_CommPktChunkCtr_Type);
 
2925
        PyModule_AddObject(m, "CommPktChunkCtr", (PyObject *)(void *)&frsrpc_CommPktChunkCtr_Type);
 
2926
        Py_INCREF((PyObject *)(void *)&frsrpc_FrsSendCommPktReq_Type);
 
2927
        PyModule_AddObject(m, "FrsSendCommPktReq", (PyObject *)(void *)&frsrpc_FrsSendCommPktReq_Type);
 
2928
        Py_INCREF((PyObject *)(void *)&frsrpc_InterfaceType);
 
2929
        PyModule_AddObject(m, "frsrpc", (PyObject *)(void *)&frsrpc_InterfaceType);
 
2930
#ifdef PY_MOD_FRSRPC_PATCH
 
2931
        PY_MOD_FRSRPC_PATCH(m);
 
2932
#endif
 
2933
 
 
2934
}