← Back to branch summary

~lefteris-nikoltsios/+junk/samba-lp1016895

« back to all changes in this revision

Viewing changes to source3/librpc/gen_ndr/py_frsapi.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_frsapi.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_frsapi.h"
 
9
#include "librpc/gen_ndr/ndr_frsapi_c.h"
 
10
 
 
11
#include "librpc/gen_ndr/misc.h"
 
12
staticforward PyTypeObject frsapi_Info_Type;
 
13
staticforward PyTypeObject frsapi_InterfaceType;
 
14
 
 
15
void initfrsapi(void);static PyTypeObject *Object_Type;
 
16
static PyTypeObject *GUID_Type;
 
17
static PyTypeObject *ClientConnection_Type;
 
18
 
 
19
static PyObject *py_frsapi_Info_get_length(PyObject *obj, void *closure)
 
20
{
 
21
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
22
        PyObject *py_length;
 
23
        py_length = PyInt_FromLong(object->length);
 
24
        return py_length;
 
25
}
 
26
 
 
27
static int py_frsapi_Info_set_length(PyObject *py_obj, PyObject *value, void *closure)
 
28
{
 
29
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
30
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
31
        object->length = PyInt_AsLong(value);
 
32
        return 0;
 
33
}
 
34
 
 
35
static PyObject *py_frsapi_Info_get_guid(PyObject *obj, void *closure)
 
36
{
 
37
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
38
        PyObject *py_guid;
 
39
        py_guid = py_talloc_reference_ex(GUID_Type, py_talloc_get_mem_ctx(obj), &object->guid);
 
40
        return py_guid;
 
41
}
 
42
 
 
43
static int py_frsapi_Info_set_guid(PyObject *py_obj, PyObject *value, void *closure)
 
44
{
 
45
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
46
        PY_CHECK_TYPE(GUID_Type, value, return -1;);
 
47
        if (talloc_reference(py_talloc_get_mem_ctx(py_obj), py_talloc_get_mem_ctx(value)) == NULL) {
 
48
                PyErr_NoMemory();
 
49
                return -1;
 
50
        }
 
51
        object->guid = *(struct GUID *)py_talloc_get_ptr(value);
 
52
        return 0;
 
53
}
 
54
 
 
55
static PyObject *py_frsapi_Info_get_length2(PyObject *obj, void *closure)
 
56
{
 
57
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
58
        PyObject *py_length2;
 
59
        py_length2 = PyInt_FromLong(object->length2);
 
60
        return py_length2;
 
61
}
 
62
 
 
63
static int py_frsapi_Info_set_length2(PyObject *py_obj, PyObject *value, void *closure)
 
64
{
 
65
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
66
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
67
        object->length2 = PyInt_AsLong(value);
 
68
        return 0;
 
69
}
 
70
 
 
71
static PyObject *py_frsapi_Info_get_unknown1(PyObject *obj, void *closure)
 
72
{
 
73
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
74
        PyObject *py_unknown1;
 
75
        py_unknown1 = PyInt_FromLong(object->unknown1);
 
76
        return py_unknown1;
 
77
}
 
78
 
 
79
static int py_frsapi_Info_set_unknown1(PyObject *py_obj, PyObject *value, void *closure)
 
80
{
 
81
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
82
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
83
        object->unknown1 = PyInt_AsLong(value);
 
84
        return 0;
 
85
}
 
86
 
 
87
static PyObject *py_frsapi_Info_get_level(PyObject *obj, void *closure)
 
88
{
 
89
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
90
        PyObject *py_level;
 
91
        py_level = PyInt_FromLong(object->level);
 
92
        return py_level;
 
93
}
 
94
 
 
95
static int py_frsapi_Info_set_level(PyObject *py_obj, PyObject *value, void *closure)
 
96
{
 
97
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
98
        if (PyLong_Check(value)) {
 
99
                object->level = PyLong_AsLongLong(value);
 
100
        } else if (PyInt_Check(value)) {
 
101
                object->level = PyInt_AsLong(value);
 
102
        } else {
 
103
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
104
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
105
                return -1;
 
106
        }
 
107
        return 0;
 
108
}
 
109
 
 
110
static PyObject *py_frsapi_Info_get_query_counter(PyObject *obj, void *closure)
 
111
{
 
112
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
113
        PyObject *py_query_counter;
 
114
        py_query_counter = PyInt_FromLong(object->query_counter);
 
115
        return py_query_counter;
 
116
}
 
117
 
 
118
static int py_frsapi_Info_set_query_counter(PyObject *py_obj, PyObject *value, void *closure)
 
119
{
 
120
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
121
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
122
        object->query_counter = PyInt_AsLong(value);
 
123
        return 0;
 
124
}
 
125
 
 
126
static PyObject *py_frsapi_Info_get_unknown2(PyObject *obj, void *closure)
 
127
{
 
128
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
129
        PyObject *py_unknown2;
 
130
        py_unknown2 = PyInt_FromLong(object->unknown2);
 
131
        return py_unknown2;
 
132
}
 
133
 
 
134
static int py_frsapi_Info_set_unknown2(PyObject *py_obj, PyObject *value, void *closure)
 
135
{
 
136
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
137
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
138
        object->unknown2 = PyInt_AsLong(value);
 
139
        return 0;
 
140
}
 
141
 
 
142
static PyObject *py_frsapi_Info_get_offset(PyObject *obj, void *closure)
 
143
{
 
144
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
145
        PyObject *py_offset;
 
146
        py_offset = PyInt_FromLong(object->offset);
 
147
        return py_offset;
 
148
}
 
149
 
 
150
static int py_frsapi_Info_set_offset(PyObject *py_obj, PyObject *value, void *closure)
 
151
{
 
152
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
153
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
154
        object->offset = PyInt_AsLong(value);
 
155
        return 0;
 
156
}
 
157
 
 
158
static PyObject *py_frsapi_Info_get_blob_len(PyObject *obj, void *closure)
 
159
{
 
160
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
161
        PyObject *py_blob_len;
 
162
        py_blob_len = PyInt_FromLong(object->blob_len);
 
163
        return py_blob_len;
 
164
}
 
165
 
 
166
static int py_frsapi_Info_set_blob_len(PyObject *py_obj, PyObject *value, void *closure)
 
167
{
 
168
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
169
        PY_CHECK_TYPE(&PyInt_Type, value, return -1;);
 
170
        object->blob_len = PyInt_AsLong(value);
 
171
        return 0;
 
172
}
 
173
 
 
174
static PyObject *py_frsapi_Info_get_blob(PyObject *obj, void *closure)
 
175
{
 
176
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(obj);
 
177
        PyObject *py_blob;
 
178
        py_blob = PyString_FromStringAndSize((char *)(object->blob).data, (object->blob).length);
 
179
        return py_blob;
 
180
}
 
181
 
 
182
static int py_frsapi_Info_set_blob(PyObject *py_obj, PyObject *value, void *closure)
 
183
{
 
184
        struct frsapi_Info *object = (struct frsapi_Info *)py_talloc_get_ptr(py_obj);
 
185
        object->blob = data_blob_talloc(py_talloc_get_mem_ctx(py_obj), PyString_AS_STRING(value), PyString_GET_SIZE(value));
 
186
        return 0;
 
187
}
 
188
 
 
189
static PyGetSetDef py_frsapi_Info_getsetters[] = {
 
190
        { discard_const_p(char, "length"), py_frsapi_Info_get_length, py_frsapi_Info_set_length },
 
191
        { discard_const_p(char, "guid"), py_frsapi_Info_get_guid, py_frsapi_Info_set_guid },
 
192
        { discard_const_p(char, "length2"), py_frsapi_Info_get_length2, py_frsapi_Info_set_length2 },
 
193
        { discard_const_p(char, "unknown1"), py_frsapi_Info_get_unknown1, py_frsapi_Info_set_unknown1 },
 
194
        { discard_const_p(char, "level"), py_frsapi_Info_get_level, py_frsapi_Info_set_level },
 
195
        { discard_const_p(char, "query_counter"), py_frsapi_Info_get_query_counter, py_frsapi_Info_set_query_counter },
 
196
        { discard_const_p(char, "unknown2"), py_frsapi_Info_get_unknown2, py_frsapi_Info_set_unknown2 },
 
197
        { discard_const_p(char, "offset"), py_frsapi_Info_get_offset, py_frsapi_Info_set_offset },
 
198
        { discard_const_p(char, "blob_len"), py_frsapi_Info_get_blob_len, py_frsapi_Info_set_blob_len },
 
199
        { discard_const_p(char, "blob"), py_frsapi_Info_get_blob, py_frsapi_Info_set_blob },
 
200
        { NULL }
 
201
};
 
202
 
 
203
static PyObject *py_frsapi_Info_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 
204
{
 
205
        return py_talloc_new(struct frsapi_Info, type);
 
206
}
 
207
 
 
208
 
 
209
static PyTypeObject frsapi_Info_Type = {
 
210
        PyObject_HEAD_INIT(NULL) 0,
 
211
        .tp_name = "frsapi.Info",
 
212
        .tp_getset = py_frsapi_Info_getsetters,
 
213
        .tp_methods = NULL,
 
214
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 
215
        .tp_basicsize = sizeof(py_talloc_Object),
 
216
        .tp_new = py_frsapi_Info_new,
 
217
};
 
218
 
 
219
 
 
220
static bool pack_py_frsapi_SetDsPollingIntervalW_args_in(PyObject *args, PyObject *kwargs, struct frsapi_SetDsPollingIntervalW *r)
 
221
{
 
222
        PyObject *py_CurrentInterval;
 
223
        PyObject *py_DsPollingLongInterval;
 
224
        PyObject *py_DsPollingShortInterval;
 
225
        const char *kwnames[] = {
 
226
                "CurrentInterval", "DsPollingLongInterval", "DsPollingShortInterval", NULL
 
227
        };
 
228
 
 
229
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:frsapi_SetDsPollingIntervalW", discard_const_p(char *, kwnames), &py_CurrentInterval, &py_DsPollingLongInterval, &py_DsPollingShortInterval)) {
 
230
                return false;
 
231
        }
 
232
 
 
233
        PY_CHECK_TYPE(&PyInt_Type, py_CurrentInterval, return false;);
 
234
        r->in.CurrentInterval = PyInt_AsLong(py_CurrentInterval);
 
235
        PY_CHECK_TYPE(&PyInt_Type, py_DsPollingLongInterval, return false;);
 
236
        r->in.DsPollingLongInterval = PyInt_AsLong(py_DsPollingLongInterval);
 
237
        PY_CHECK_TYPE(&PyInt_Type, py_DsPollingShortInterval, return false;);
 
238
        r->in.DsPollingShortInterval = PyInt_AsLong(py_DsPollingShortInterval);
 
239
        return true;
 
240
}
 
241
 
 
242
static PyObject *unpack_py_frsapi_SetDsPollingIntervalW_args_out(struct frsapi_SetDsPollingIntervalW *r)
 
243
{
 
244
        PyObject *result;
 
245
        result = Py_None;
 
246
        Py_INCREF(result);
 
247
        if (!W_ERROR_IS_OK(r->out.result)) {
 
248
                PyErr_SetWERROR(r->out.result);
 
249
                return NULL;
 
250
        }
 
251
 
 
252
        return result;
 
253
}
 
254
 
 
255
static bool pack_py_frsapi_GetDsPollingIntervalW_args_in(PyObject *args, PyObject *kwargs, struct frsapi_GetDsPollingIntervalW *r)
 
256
{
 
257
        const char *kwnames[] = {
 
258
                NULL
 
259
        };
 
260
 
 
261
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, ":frsapi_GetDsPollingIntervalW", discard_const_p(char *, kwnames))) {
 
262
                return false;
 
263
        }
 
264
 
 
265
        return true;
 
266
}
 
267
 
 
268
static PyObject *unpack_py_frsapi_GetDsPollingIntervalW_args_out(struct frsapi_GetDsPollingIntervalW *r)
 
269
{
 
270
        PyObject *result;
 
271
        PyObject *py_CurrentInterval;
 
272
        PyObject *py_DsPollingLongInterval;
 
273
        PyObject *py_DsPollingShortInterval;
 
274
        result = PyTuple_New(3);
 
275
        py_CurrentInterval = PyInt_FromLong(*r->out.CurrentInterval);
 
276
        PyTuple_SetItem(result, 0, py_CurrentInterval);
 
277
        py_DsPollingLongInterval = PyInt_FromLong(*r->out.DsPollingLongInterval);
 
278
        PyTuple_SetItem(result, 1, py_DsPollingLongInterval);
 
279
        py_DsPollingShortInterval = PyInt_FromLong(*r->out.DsPollingShortInterval);
 
280
        PyTuple_SetItem(result, 2, py_DsPollingShortInterval);
 
281
        if (!W_ERROR_IS_OK(r->out.result)) {
 
282
                PyErr_SetWERROR(r->out.result);
 
283
                return NULL;
 
284
        }
 
285
 
 
286
        return result;
 
287
}
 
288
 
 
289
static bool pack_py_frsapi_InfoW_args_in(PyObject *args, PyObject *kwargs, struct frsapi_InfoW *r)
 
290
{
 
291
        PyObject *py_length;
 
292
        PyObject *py_info;
 
293
        const char *kwnames[] = {
 
294
                "length", "info", NULL
 
295
        };
 
296
 
 
297
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:frsapi_InfoW", discard_const_p(char *, kwnames), &py_length, &py_info)) {
 
298
                return false;
 
299
        }
 
300
 
 
301
        PY_CHECK_TYPE(&PyInt_Type, py_length, return false;);
 
302
        r->in.length = PyInt_AsLong(py_length);
 
303
        if (py_info == Py_None) {
 
304
                r->in.info = NULL;
 
305
        } else {
 
306
                r->in.info = NULL;
 
307
                PY_CHECK_TYPE(&frsapi_Info_Type, py_info, return false;);
 
308
                if (talloc_reference(r, py_talloc_get_mem_ctx(py_info)) == NULL) {
 
309
                        PyErr_NoMemory();
 
310
                        return false;
 
311
                }
 
312
                r->in.info = (struct frsapi_Info *)py_talloc_get_ptr(py_info);
 
313
        }
 
314
        return true;
 
315
}
 
316
 
 
317
static PyObject *unpack_py_frsapi_InfoW_args_out(struct frsapi_InfoW *r)
 
318
{
 
319
        PyObject *result;
 
320
        PyObject *py_info;
 
321
        if (r->out.info == NULL) {
 
322
                py_info = Py_None;
 
323
                Py_INCREF(py_info);
 
324
        } else {
 
325
                py_info = py_talloc_reference_ex(&frsapi_Info_Type, r->out.info, r->out.info);
 
326
        }
 
327
        result = py_info;
 
328
        if (!W_ERROR_IS_OK(r->out.result)) {
 
329
                PyErr_SetWERROR(r->out.result);
 
330
                return NULL;
 
331
        }
 
332
 
 
333
        return result;
 
334
}
 
335
 
 
336
static bool pack_py_frsapi_IsPathReplicated_args_in(PyObject *args, PyObject *kwargs, struct frsapi_IsPathReplicated *r)
 
337
{
 
338
        PyObject *py_path;
 
339
        PyObject *py_replica_set_type;
 
340
        const char *kwnames[] = {
 
341
                "path", "replica_set_type", NULL
 
342
        };
 
343
 
 
344
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:frsapi_IsPathReplicated", discard_const_p(char *, kwnames), &py_path, &py_replica_set_type)) {
 
345
                return false;
 
346
        }
 
347
 
 
348
        if (py_path == Py_None) {
 
349
                r->in.path = NULL;
 
350
        } else {
 
351
                r->in.path = NULL;
 
352
                if (PyUnicode_Check(py_path)) {
 
353
                        r->in.path = PyString_AS_STRING(PyUnicode_AsEncodedString(py_path, "utf-8", "ignore"));
 
354
                } else if (PyString_Check(py_path)) {
 
355
                        r->in.path = PyString_AS_STRING(py_path);
 
356
                } else {
 
357
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_path)->tp_name);
 
358
                        return false;
 
359
                }
 
360
        }
 
361
        if (PyLong_Check(py_replica_set_type)) {
 
362
                r->in.replica_set_type = PyLong_AsLongLong(py_replica_set_type);
 
363
        } else if (PyInt_Check(py_replica_set_type)) {
 
364
                r->in.replica_set_type = PyInt_AsLong(py_replica_set_type);
 
365
        } else {
 
366
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
367
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
368
                return false;
 
369
        }
 
370
        return true;
 
371
}
 
372
 
 
373
static PyObject *unpack_py_frsapi_IsPathReplicated_args_out(struct frsapi_IsPathReplicated *r)
 
374
{
 
375
        PyObject *result;
 
376
        PyObject *py_replicated;
 
377
        PyObject *py_primary;
 
378
        PyObject *py_root;
 
379
        PyObject *py_replica_set_guid;
 
380
        result = PyTuple_New(4);
 
381
        py_replicated = PyInt_FromLong(*r->out.replicated);
 
382
        PyTuple_SetItem(result, 0, py_replicated);
 
383
        py_primary = PyInt_FromLong(*r->out.primary);
 
384
        PyTuple_SetItem(result, 1, py_primary);
 
385
        py_root = PyInt_FromLong(*r->out.root);
 
386
        PyTuple_SetItem(result, 2, py_root);
 
387
        py_replica_set_guid = py_talloc_reference_ex(GUID_Type, r->out.replica_set_guid, r->out.replica_set_guid);
 
388
        PyTuple_SetItem(result, 3, py_replica_set_guid);
 
389
        if (!W_ERROR_IS_OK(r->out.result)) {
 
390
                PyErr_SetWERROR(r->out.result);
 
391
                return NULL;
 
392
        }
 
393
 
 
394
        return result;
 
395
}
 
396
 
 
397
static bool pack_py_frsapi_WriterCommand_args_in(PyObject *args, PyObject *kwargs, struct frsapi_WriterCommand *r)
 
398
{
 
399
        PyObject *py_command;
 
400
        const char *kwnames[] = {
 
401
                "command", NULL
 
402
        };
 
403
 
 
404
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:frsapi_WriterCommand", discard_const_p(char *, kwnames), &py_command)) {
 
405
                return false;
 
406
        }
 
407
 
 
408
        if (PyLong_Check(py_command)) {
 
409
                r->in.command = PyLong_AsLongLong(py_command);
 
410
        } else if (PyInt_Check(py_command)) {
 
411
                r->in.command = PyInt_AsLong(py_command);
 
412
        } else {
 
413
                PyErr_Format(PyExc_TypeError, "Expected type %s or %s",\
 
414
                  PyInt_Type.tp_name, PyLong_Type.tp_name);
 
415
                return false;
 
416
        }
 
417
        return true;
 
418
}
 
419
 
 
420
static PyObject *unpack_py_frsapi_WriterCommand_args_out(struct frsapi_WriterCommand *r)
 
421
{
 
422
        PyObject *result;
 
423
        result = Py_None;
 
424
        Py_INCREF(result);
 
425
        if (!W_ERROR_IS_OK(r->out.result)) {
 
426
                PyErr_SetWERROR(r->out.result);
 
427
                return NULL;
 
428
        }
 
429
 
 
430
        return result;
 
431
}
 
432
 
 
433
static bool pack_py_frsapi_ForceReplication_args_in(PyObject *args, PyObject *kwargs, struct frsapi_ForceReplication *r)
 
434
{
 
435
        PyObject *py_replica_set_guid;
 
436
        PyObject *py_connection_guid;
 
437
        PyObject *py_replica_set_name;
 
438
        PyObject *py_partner_dns_name;
 
439
        const char *kwnames[] = {
 
440
                "replica_set_guid", "connection_guid", "replica_set_name", "partner_dns_name", NULL
 
441
        };
 
442
 
 
443
        if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:frsapi_ForceReplication", discard_const_p(char *, kwnames), &py_replica_set_guid, &py_connection_guid, &py_replica_set_name, &py_partner_dns_name)) {
 
444
                return false;
 
445
        }
 
446
 
 
447
        if (py_replica_set_guid == Py_None) {
 
448
                r->in.replica_set_guid = NULL;
 
449
        } else {
 
450
                r->in.replica_set_guid = NULL;
 
451
                PY_CHECK_TYPE(GUID_Type, py_replica_set_guid, return false;);
 
452
                if (talloc_reference(r, py_talloc_get_mem_ctx(py_replica_set_guid)) == NULL) {
 
453
                        PyErr_NoMemory();
 
454
                        return false;
 
455
                }
 
456
                r->in.replica_set_guid = (struct GUID *)py_talloc_get_ptr(py_replica_set_guid);
 
457
        }
 
458
        if (py_connection_guid == Py_None) {
 
459
                r->in.connection_guid = NULL;
 
460
        } else {
 
461
                r->in.connection_guid = NULL;
 
462
                PY_CHECK_TYPE(GUID_Type, py_connection_guid, return false;);
 
463
                if (talloc_reference(r, py_talloc_get_mem_ctx(py_connection_guid)) == NULL) {
 
464
                        PyErr_NoMemory();
 
465
                        return false;
 
466
                }
 
467
                r->in.connection_guid = (struct GUID *)py_talloc_get_ptr(py_connection_guid);
 
468
        }
 
469
        if (py_replica_set_name == Py_None) {
 
470
                r->in.replica_set_name = NULL;
 
471
        } else {
 
472
                r->in.replica_set_name = NULL;
 
473
                if (PyUnicode_Check(py_replica_set_name)) {
 
474
                        r->in.replica_set_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_replica_set_name, "utf-8", "ignore"));
 
475
                } else if (PyString_Check(py_replica_set_name)) {
 
476
                        r->in.replica_set_name = PyString_AS_STRING(py_replica_set_name);
 
477
                } else {
 
478
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_replica_set_name)->tp_name);
 
479
                        return false;
 
480
                }
 
481
        }
 
482
        if (py_partner_dns_name == Py_None) {
 
483
                r->in.partner_dns_name = NULL;
 
484
        } else {
 
485
                r->in.partner_dns_name = NULL;
 
486
                if (PyUnicode_Check(py_partner_dns_name)) {
 
487
                        r->in.partner_dns_name = PyString_AS_STRING(PyUnicode_AsEncodedString(py_partner_dns_name, "utf-8", "ignore"));
 
488
                } else if (PyString_Check(py_partner_dns_name)) {
 
489
                        r->in.partner_dns_name = PyString_AS_STRING(py_partner_dns_name);
 
490
                } else {
 
491
                        PyErr_Format(PyExc_TypeError, "Expected string or unicode object, got %s", Py_TYPE(py_partner_dns_name)->tp_name);
 
492
                        return false;
 
493
                }
 
494
        }
 
495
        return true;
 
496
}
 
497
 
 
498
static PyObject *unpack_py_frsapi_ForceReplication_args_out(struct frsapi_ForceReplication *r)
 
499
{
 
500
        PyObject *result;
 
501
        result = Py_None;
 
502
        Py_INCREF(result);
 
503
        if (!W_ERROR_IS_OK(r->out.result)) {
 
504
                PyErr_SetWERROR(r->out.result);
 
505
                return NULL;
 
506
        }
 
507
 
 
508
        return result;
 
509
}
 
510
 
 
511
const struct PyNdrRpcMethodDef py_ndr_frsapi_methods[] = {
 
512
        { "SetDsPollingIntervalW", "S.SetDsPollingIntervalW(CurrentInterval, DsPollingLongInterval, DsPollingShortInterval) -> None", (py_dcerpc_call_fn)dcerpc_frsapi_SetDsPollingIntervalW_r, (py_data_pack_fn)pack_py_frsapi_SetDsPollingIntervalW_args_in, (py_data_unpack_fn)unpack_py_frsapi_SetDsPollingIntervalW_args_out, 4, &ndr_table_frsapi },
 
513
        { "GetDsPollingIntervalW", "S.GetDsPollingIntervalW() -> (CurrentInterval, DsPollingLongInterval, DsPollingShortInterval)", (py_dcerpc_call_fn)dcerpc_frsapi_GetDsPollingIntervalW_r, (py_data_pack_fn)pack_py_frsapi_GetDsPollingIntervalW_args_in, (py_data_unpack_fn)unpack_py_frsapi_GetDsPollingIntervalW_args_out, 5, &ndr_table_frsapi },
 
514
        { "InfoW", "S.InfoW(length, info) -> info", (py_dcerpc_call_fn)dcerpc_frsapi_InfoW_r, (py_data_pack_fn)pack_py_frsapi_InfoW_args_in, (py_data_unpack_fn)unpack_py_frsapi_InfoW_args_out, 7, &ndr_table_frsapi },
 
515
        { "IsPathReplicated", "S.IsPathReplicated(path, replica_set_type) -> (replicated, primary, root, replica_set_guid)", (py_dcerpc_call_fn)dcerpc_frsapi_IsPathReplicated_r, (py_data_pack_fn)pack_py_frsapi_IsPathReplicated_args_in, (py_data_unpack_fn)unpack_py_frsapi_IsPathReplicated_args_out, 8, &ndr_table_frsapi },
 
516
        { "WriterCommand", "S.WriterCommand(command) -> None", (py_dcerpc_call_fn)dcerpc_frsapi_WriterCommand_r, (py_data_pack_fn)pack_py_frsapi_WriterCommand_args_in, (py_data_unpack_fn)unpack_py_frsapi_WriterCommand_args_out, 9, &ndr_table_frsapi },
 
517
        { "ForceReplication", "S.ForceReplication(replica_set_guid, connection_guid, replica_set_name, partner_dns_name) -> None", (py_dcerpc_call_fn)dcerpc_frsapi_ForceReplication_r, (py_data_pack_fn)pack_py_frsapi_ForceReplication_args_in, (py_data_unpack_fn)unpack_py_frsapi_ForceReplication_args_out, 10, &ndr_table_frsapi },
 
518
        { NULL }
 
519
};
 
520
 
 
521
static PyObject *interface_frsapi_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 
522
{
 
523
        return py_dcerpc_interface_init_helper(type, args, kwargs, &ndr_table_frsapi);
 
524
}
 
525
 
 
526
#define PY_DOC_FRSAPI "File Replication API"
 
527
static PyTypeObject frsapi_InterfaceType = {
 
528
        PyObject_HEAD_INIT(NULL) 0,
 
529
        .tp_name = "frsapi.frsapi",
 
530
        .tp_basicsize = sizeof(dcerpc_InterfaceObject),
 
531
        .tp_doc = "frsapi(binding, lp_ctx=None, credentials=None) -> connection\n"
 
532
"\n"
 
533
"binding should be a DCE/RPC binding string (for example: ncacn_ip_tcp:127.0.0.1)\n"
 
534
"lp_ctx should be a path to a smb.conf file or a param.LoadParm object\n"
 
535
"credentials should be a credentials.Credentials object.\n\n"PY_DOC_FRSAPI,
 
536
        .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
 
537
        .tp_new = interface_frsapi_new,
 
538
};
 
539
 
 
540
static PyMethodDef frsapi_methods[] = {
 
541
        { NULL, NULL, 0, NULL }
 
542
};
 
543
 
 
544
void initfrsapi(void)
 
545
{
 
546
        PyObject *m;
 
547
        PyObject *dep_talloc;
 
548
        PyObject *dep_samba_dcerpc_misc;
 
549
        PyObject *dep_samba_dcerpc_base;
 
550
 
 
551
        dep_talloc = PyImport_ImportModule("talloc");
 
552
        if (dep_talloc == NULL)
 
553
                return;
 
554
 
 
555
        dep_samba_dcerpc_misc = PyImport_ImportModule("samba.dcerpc.misc");
 
556
        if (dep_samba_dcerpc_misc == NULL)
 
557
                return;
 
558
 
 
559
        dep_samba_dcerpc_base = PyImport_ImportModule("samba.dcerpc.base");
 
560
        if (dep_samba_dcerpc_base == NULL)
 
561
                return;
 
562
 
 
563
        Object_Type = (PyTypeObject *)PyObject_GetAttrString(dep_talloc, "Object");
 
564
        if (Object_Type == NULL)
 
565
                return;
 
566
 
 
567
        GUID_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_misc, "GUID");
 
568
        if (GUID_Type == NULL)
 
569
                return;
 
570
 
 
571
        ClientConnection_Type = (PyTypeObject *)PyObject_GetAttrString(dep_samba_dcerpc_base, "ClientConnection");
 
572
        if (ClientConnection_Type == NULL)
 
573
                return;
 
574
 
 
575
        frsapi_Info_Type.tp_base = Object_Type;
 
576
 
 
577
        frsapi_InterfaceType.tp_base = ClientConnection_Type;
 
578
 
 
579
        if (PyType_Ready(&frsapi_Info_Type) < 0)
 
580
                return;
 
581
        if (PyType_Ready(&frsapi_InterfaceType) < 0)
 
582
                return;
 
583
        if (!PyInterface_AddNdrRpcMethods(&frsapi_InterfaceType, py_ndr_frsapi_methods))
 
584
                return;
 
585
 
 
586
#ifdef PY_INFO_PATCH
 
587
        PY_INFO_PATCH(&frsapi_Info_Type);
 
588
#endif
 
589
#ifdef PY_FRSAPI_PATCH
 
590
        PY_FRSAPI_PATCH(&frsapi_InterfaceType);
 
591
#endif
 
592
 
 
593
        m = Py_InitModule3("frsapi", frsapi_methods, "frsapi DCE/RPC");
 
594
        if (m == NULL)
 
595
                return;
 
596
 
 
597
        PyModule_AddObject(m, "FRSAPI_INFO_CONFIGTABLE", PyInt_FromLong(FRSAPI_INFO_CONFIGTABLE));
 
598
        PyModule_AddObject(m, "FRSAPI_INFO_SETS", PyInt_FromLong(FRSAPI_INFO_SETS));
 
599
        PyModule_AddObject(m, "FRSAPI_INFO_VERSION", PyInt_FromLong(FRSAPI_INFO_VERSION));
 
600
        PyModule_AddObject(m, "FRSAPI_REPLICA_SET_TYPE_DFS", PyInt_FromLong(FRSAPI_REPLICA_SET_TYPE_DFS));
 
601
        PyModule_AddObject(m, "FRSAPI_INFO_INLOG", PyInt_FromLong(FRSAPI_INFO_INLOG));
 
602
        PyModule_AddObject(m, "FRSAPI_WRITER_COMMAND_THAW", PyInt_FromLong(FRSAPI_WRITER_COMMAND_THAW));
 
603
        PyModule_AddObject(m, "FRSAPI_REPLICA_SET_TYPE_DOMAIN", PyInt_FromLong(FRSAPI_REPLICA_SET_TYPE_DOMAIN));
 
604
        PyModule_AddObject(m, "FRSAPI_INFO_OUTLOG", PyInt_FromLong(FRSAPI_INFO_OUTLOG));
 
605
        PyModule_AddObject(m, "FRSAPI_WRITER_COMMAND_FREEZE", PyInt_FromLong(FRSAPI_WRITER_COMMAND_FREEZE));
 
606
        PyModule_AddObject(m, "FRSAPI_INFO_STAGE", PyInt_FromLong(FRSAPI_INFO_STAGE));
 
607
        PyModule_AddObject(m, "FRSAPI_INFO_IDTABLE", PyInt_FromLong(FRSAPI_INFO_IDTABLE));
 
608
        PyModule_AddObject(m, "FRSAPI_INFO_THREADS", PyInt_FromLong(FRSAPI_INFO_THREADS));
 
609
        PyModule_AddObject(m, "FRSAPI_INFO_MEMORY", PyInt_FromLong(FRSAPI_INFO_MEMORY));
 
610
        PyModule_AddObject(m, "FRSAPI_REPLICA_SET_TYPE_0", PyInt_FromLong(FRSAPI_REPLICA_SET_TYPE_0));
 
611
        PyModule_AddObject(m, "FRSAPI_INFO_DS", PyInt_FromLong(FRSAPI_INFO_DS));
 
612
        Py_INCREF((PyObject *)(void *)&frsapi_Info_Type);
 
613
        PyModule_AddObject(m, "Info", (PyObject *)(void *)&frsapi_Info_Type);
 
614
        Py_INCREF((PyObject *)(void *)&frsapi_InterfaceType);
 
615
        PyModule_AddObject(m, "frsapi", (PyObject *)(void *)&frsapi_InterfaceType);
 
616
#ifdef PY_MOD_FRSAPI_PATCH
 
617
        PY_MOD_FRSAPI_PATCH(m);
 
618
#endif
 
619
 
 
620
}