← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source4/torture/rpc/frsapi.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source4/torture/rpc/frsapi.c
 
1
/*
 
2
   Unix SMB/CIFS implementation.
 
3
   test suite for rpc frsapi operations
 
4
 
 
5
   Copyright (C) Guenther Deschner 2007
 
6
 
 
7
   This program is free software; you can redistribute it and/or modify
 
8
   it under the terms of the GNU General Public License as published by
 
9
   the Free Software Foundation; either version 3 of the License, or
 
10
   (at your option) any later version.
 
11
 
 
12
   This program is distributed in the hope that it will be useful,
 
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
   GNU General Public License for more details.
 
16
 
 
17
   You should have received a copy of the GNU General Public License
 
18
   along with this program; if not, write to the Free Software
 
19
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
20
*/
 
21
 
 
22
#include "includes.h"
 
23
#include "torture/torture.h"
 
24
#include "torture/rpc/rpc.h"
 
25
#include "librpc/gen_ndr/ndr_frsapi_c.h"
 
26
#include "torture/util.h"
 
27
#include "param/param.h"
 
28
 
 
29
static bool test_GetDsPollingIntervalW(struct torture_context *tctx,
 
30
                                       struct dcerpc_pipe *p,
 
31
                                       uint32_t *CurrentInterval,
 
32
                                       uint32_t *DsPollingLongInterval,
 
33
                                       uint32_t *DsPollingShortInterval)
 
34
{
 
35
        struct frsapi_GetDsPollingIntervalW r;
 
36
 
 
37
        ZERO_STRUCT(r);
 
38
 
 
39
        r.out.CurrentInterval = CurrentInterval;
 
40
        r.out.DsPollingLongInterval = DsPollingLongInterval;
 
41
        r.out.DsPollingShortInterval = DsPollingShortInterval;
 
42
 
 
43
        torture_assert_ntstatus_ok(tctx,
 
44
                dcerpc_frsapi_GetDsPollingIntervalW(p, tctx, &r),
 
45
                "GetDsPollingIntervalW failed");
 
46
 
 
47
        torture_assert_werr_ok(tctx, r.out.result,
 
48
                               "GetDsPollingIntervalW failed");
 
49
 
 
50
        return true;
 
51
}
 
52
 
 
53
static bool test_SetDsPollingIntervalW(struct torture_context *tctx,
 
54
                                       struct dcerpc_pipe *p,
 
55
                                       uint32_t CurrentInterval,
 
56
                                       uint32_t DsPollingLongInterval,
 
57
                                       uint32_t DsPollingShortInterval)
 
58
{
 
59
        struct frsapi_SetDsPollingIntervalW r;
 
60
 
 
61
        ZERO_STRUCT(r);
 
62
 
 
63
        r.in.CurrentInterval = CurrentInterval;
 
64
        r.in.DsPollingLongInterval = DsPollingLongInterval;
 
65
        r.in.DsPollingShortInterval = DsPollingShortInterval;
 
66
 
 
67
        torture_assert_ntstatus_ok(tctx,
 
68
                dcerpc_frsapi_SetDsPollingIntervalW(p, tctx, &r),
 
69
                "SetDsPollingIntervalW failed");
 
70
 
 
71
        torture_assert_werr_ok(tctx, r.out.result,
 
72
                               "SetDsPollingIntervalW failed");
 
73
 
 
74
        return true;
 
75
}
 
76
 
 
77
static bool test_DsPollingIntervalW(struct torture_context *tctx,
 
78
                                    struct dcerpc_pipe *p)
 
79
{
 
80
        uint32_t i1, i2, i3;
 
81
        uint32_t k1, k2, k3;
 
82
 
 
83
        if (!test_GetDsPollingIntervalW(tctx, p, &i1, &i2, &i3)) {
 
84
                return false;
 
85
        }
 
86
 
 
87
        if (!test_SetDsPollingIntervalW(tctx, p, i1, i2, i3)) {
 
88
                return false;
 
89
        }
 
90
 
 
91
        k1 = i1;
 
92
        k2 = k3 = 0;
 
93
 
 
94
        if (!test_SetDsPollingIntervalW(tctx, p, k1, k2, k3)) {
 
95
                return false;
 
96
        }
 
97
 
 
98
        if (!test_GetDsPollingIntervalW(tctx, p, &k1, &k2, &k3)) {
 
99
                return false;
 
100
        }
 
101
 
 
102
        if ((i1 != k1) || (i2 != k2) || (i3 != k3)) {
 
103
                return false;
 
104
        }
 
105
 
 
106
        return true;
 
107
}
 
108
 
 
109
static bool test_IsPathReplicated_err(struct torture_context *tctx,
 
110
                                      struct dcerpc_pipe *p,
 
111
                                      const char *path,
 
112
                                      uint32_t type,
 
113
                                      WERROR werr)
 
114
{
 
115
        struct frsapi_IsPathReplicated r;
 
116
        struct GUID guid;
 
117
        uint32_t unknown1, unknown2, unknown3 = 0;
 
118
 
 
119
        ZERO_STRUCT(r);
 
120
 
 
121
        r.in.path = path;
 
122
        r.in.replica_set_type = type;
 
123
        r.out.unknown1 = &unknown1;
 
124
        r.out.unknown2 = &unknown2;
 
125
        r.out.unknown3 = &unknown3;
 
126
        r.out.replica_set_guid = &guid;
 
127
 
 
128
        torture_assert_ntstatus_ok(tctx,
 
129
                dcerpc_frsapi_IsPathReplicated(p, tctx, &r),
 
130
                "IsPathReplicated failed");
 
131
 
 
132
        torture_assert_werr_equal(tctx, r.out.result, werr,
 
133
                                  "GetDsPollingIntervalW failed");
 
134
 
 
135
        return true;
 
136
}
 
137
 
 
138
static bool _test_IsPathReplicated(struct torture_context *tctx,
 
139
                                  struct dcerpc_pipe *p,
 
140
                                  const char *path,
 
141
                                  uint32_t type)
 
142
{
 
143
        return test_IsPathReplicated_err(tctx, p, path, type, WERR_OK);
 
144
}
 
145
 
 
146
static bool test_IsPathReplicated(struct torture_context *tctx,
 
147
                                  struct dcerpc_pipe *p)
 
148
{
 
149
        const uint32_t lvls[] = {
 
150
                FRSAPI_REPLICA_SET_TYPE_0,
 
151
                FRSAPI_REPLICA_SET_TYPE_DOMAIN,
 
152
                FRSAPI_REPLICA_SET_TYPE_DFS };
 
153
        int i;
 
154
        bool ret = true;
 
155
 
 
156
        if (!test_IsPathReplicated_err(tctx, p, NULL, 0,
 
157
                                       WERR_FRS_INVALID_SERVICE_PARAMETER)) {
 
158
                ret = false;
 
159
        }
 
160
 
 
161
        for (i=0; i<ARRAY_SIZE(lvls); i++) {
 
162
                if (!_test_IsPathReplicated(tctx, p, dcerpc_server_name(p),
 
163
                                            lvls[i])) {
 
164
                        ret = false;
 
165
                }
 
166
        }
 
167
 
 
168
        for (i=0; i<ARRAY_SIZE(lvls); i++) {
 
169
                const char *path = talloc_asprintf(tctx, "\\\\%s\\SYSVOL",
 
170
                                                   dcerpc_server_name(p));
 
171
                if (!_test_IsPathReplicated(tctx, p, path, lvls[i])) {
 
172
                        ret = false;
 
173
                }
 
174
        }
 
175
 
 
176
        for (i=0; i<ARRAY_SIZE(lvls); i++) {
 
177
                if (!_test_IsPathReplicated(tctx, p,
 
178
                                            "C:\\windows\\sysvol\\domain",
 
179
                                            lvls[i])) {
 
180
                        ret = false;
 
181
                }
 
182
        }
 
183
 
 
184
        return ret;
 
185
}
 
186
 
 
187
static bool test_ForceReplication(struct torture_context *tctx,
 
188
                                  struct dcerpc_pipe *p)
 
189
{
 
190
        struct frsapi_ForceReplication r;
 
191
 
 
192
        ZERO_STRUCT(r);
 
193
 
 
194
        r.in.guid1 = NULL;
 
195
        r.in.guid2 = NULL;
 
196
        r.in.replica_set = talloc_asprintf(tctx, "%s",
 
197
                                           lp_realm(tctx->lp_ctx));
 
198
        r.in.partner_name = dcerpc_server_name(p);
 
199
 
 
200
        torture_assert_ntstatus_ok(tctx,
 
201
                dcerpc_frsapi_ForceReplication(p, tctx, &r),
 
202
                "ForceReplication failed");
 
203
 
 
204
        torture_assert_werr_ok(tctx, r.out.result,
 
205
                               "ForceReplication failed");
 
206
 
 
207
        return true;
 
208
}
 
209
 
 
210
static bool test_InfoW(struct torture_context *tctx,
 
211
                       struct dcerpc_pipe *p)
 
212
{
 
213
        int i;
 
214
 
 
215
        for (i=0; i<10; i++) {
 
216
 
 
217
                struct frsapi_InfoW r;
 
218
                struct frsapi_Info *info;
 
219
                int d;
 
220
                DATA_BLOB blob;
 
221
 
 
222
                ZERO_STRUCT(r);
 
223
 
 
224
                info = talloc_zero(tctx, struct frsapi_Info);
 
225
 
 
226
                r.in.length = 0x1000;
 
227
                r.in.info = r.out.info = info;
 
228
 
 
229
                info->length = r.in.length;
 
230
                info->length2 = r.in.length;
 
231
                info->level = i;
 
232
                info->offset = 0x2c;
 
233
                info->blob_len = 0x2c;
 
234
 
 
235
                torture_assert_ntstatus_ok(tctx,
 
236
                        dcerpc_frsapi_InfoW(p, tctx, &r),
 
237
                        "InfoW failed");
 
238
 
 
239
                torture_assert_werr_ok(tctx, r.out.result, "InfoW failed");
 
240
 
 
241
                /* display the formatted blob text */
 
242
                blob = r.out.info->blob;
 
243
                for (d = 0; d < blob.length; d++) {
 
244
                        if (blob.data[d]) {
 
245
                                printf("%c", blob.data[d]);
 
246
                        }
 
247
                }
 
248
                printf("\n");
 
249
        }
 
250
 
 
251
        return true;
 
252
}
 
253
 
 
254
struct torture_suite *torture_rpc_frsapi(TALLOC_CTX *mem_ctx)
 
255
{
 
256
        struct torture_rpc_tcase *tcase;
 
257
        struct torture_suite *suite = torture_suite_create(mem_ctx, "FRSAPI");
 
258
        struct torture_test *test;
 
259
 
 
260
        tcase = torture_suite_add_rpc_iface_tcase(suite, "frsapi",
 
261
                                                  &ndr_table_frsapi);
 
262
 
 
263
        test = torture_rpc_tcase_add_test(tcase, "DsPollingIntervalW",
 
264
                                          test_DsPollingIntervalW);
 
265
 
 
266
        test = torture_rpc_tcase_add_test(tcase, "IsPathReplicated",
 
267
                                          test_IsPathReplicated);
 
268
 
 
269
        test = torture_rpc_tcase_add_test(tcase, "ForceReplication",
 
270
                                          test_ForceReplication);
 
271
 
 
272
        test = torture_rpc_tcase_add_test(tcase, "InfoW",
 
273
                                          test_InfoW);
 
274
        return suite;
 
275
}