source: trunk/server/source4/torture/ndr/winreg.c

Last change on this file was 745, checked in by Silvan Scherrer, 13 years ago

Samba Server: updated trunk to 3.6.0
File size: 28.0 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 test suite for winreg ndr operations
4
5 Copyright (C) Jelmer Vernooij 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, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22#include "torture/ndr/ndr.h"
23#include "librpc/gen_ndr/ndr_winreg.h"
24#include "librpc/gen_ndr/ndr_security.h"
25#include "libcli/security/security.h"
26
27static const uint8_t closekey_in_data[] = {
28 0x00, 0x00, 0x00, 0x00, 0x1d, 0xd8, 0xd7, 0xaa, 0x8d, 0x6c, 0x3f, 0x48,
29 0xa7, 0x1e, 0x02, 0x6a, 0x47, 0xf6, 0x7b, 0xae
30};
31
32static bool closekey_in_check(struct torture_context *tctx,
33 struct winreg_CloseKey *ck)
34{
35 torture_assert(tctx, ck->in.handle != NULL, "handle invalid");
36 torture_assert_int_equal(tctx, ck->in.handle->handle_type, 0, "handle type");
37 return true;
38}
39
40const static uint8_t closekey_out_data[] = {
41 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
42 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
43};
44
45static bool closekey_out_check(struct torture_context *tctx,
46 struct winreg_CloseKey *ck)
47{
48 torture_assert_int_equal(tctx, ck->out.handle->handle_type, 0, "handle type");
49 torture_assert_werr_ok(tctx, ck->out.result, "return code");
50 return true;
51}
52
53static const uint8_t OpenHKLM_In[] = {
54 0x01, 0x00, 0x00, 0x00, 0xe0, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
55};
56
57static bool openhklm_in_check(struct torture_context *tctx,
58 struct winreg_OpenHKLM *r)
59{
60 torture_assert(tctx, r->in.system_name != NULL, "system name pointer");
61 torture_assert_int_equal(tctx, *r->in.system_name, 34016, "system name");
62 torture_assert_int_equal(tctx, r->in.access_mask, 0x02000000, "access mask");
63 return true;
64}
65
66static const uint8_t openhklm_out_data[] = {
67 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
68 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x00, 0x00, 0x00, 0x00
69};
70
71static bool openhklm_out_check(struct torture_context *tctx,
72 struct winreg_OpenHKLM *r)
73{
74 torture_assert(tctx, r->out.handle != NULL, "handle pointer");
75 torture_assert_int_equal(tctx, r->out.handle->handle_type, 0, "handle_type");
76 torture_assert_werr_ok(tctx, r->out.result, "return code");
77 return true;
78}
79
80static const uint8_t createkey_in_data[] = {
81 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
82 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x16, 0x00, 0x16, 0x00,
83 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
84 0x0b, 0x00, 0x00, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x74, 0x00,
85 0x74, 0x00, 0x79, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00,
86 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
87 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,
88 0x00, 0x00, 0x00, 0x00
89};
90
91static bool createkey_in_check(struct torture_context *tctx,
92 struct winreg_CreateKey *r)
93{
94 torture_assert_str_equal(tctx, r->in.name.name, "spottyfoot", "name");
95 torture_assert(tctx, r->in.keyclass.name == NULL, "keyclass");
96 torture_assert_int_equal(tctx, r->in.options, 0, "option");
97 torture_assert_int_equal(tctx, r->in.access_mask, 0x2000000, "access mask");
98 torture_assert(tctx, r->in.secdesc == NULL, "secdesc");
99 torture_assert(tctx, r->in.action_taken == NULL, "action_taken");
100
101 return true;
102}
103
104static const uint8_t createkey_out_data[] = {
105 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107 0x57, 0x00, 0x00, 0x00
108};
109
110static bool createkey_out_check(struct torture_context *tctx,
111 struct winreg_CreateKey *r)
112{
113 torture_assert(tctx, GUID_all_zero(&r->out.new_handle->uuid), "new_handle");
114 torture_assert(tctx, r->out.action_taken == NULL, "action_taken pointer");
115 torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM,
116 "return code");
117
118 return true;
119}
120
121static const uint8_t enumvalue_in_data[] = {
122 0x00, 0x00, 0x00, 0x00, 0xae, 0x1a, 0xbd, 0xbe, 0xbb, 0x94, 0xce, 0x4e,
123 0xba, 0xcf, 0x56, 0xeb, 0xe5, 0xb3, 0x6c, 0xa3, 0x05, 0x00, 0x00, 0x00,
124 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
125 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
126 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
127 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
128 0xff, 0xff, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
129};
130
131static bool enumvalue_in_check(struct torture_context *tctx,
132 struct winreg_EnumValue *r)
133{
134 torture_assert_int_equal(tctx, r->in.enum_index, 5, "enum index");
135 torture_assert(tctx, r->in.type != NULL, "type pointer");
136 torture_assert_int_equal(tctx, *r->in.type, 0, "type");
137 torture_assert_int_equal(tctx, *r->in.size, 65535, "size");
138 torture_assert_int_equal(tctx, *r->in.length, 0, "length");
139 torture_assert_int_equal(tctx, r->in.name->size, 512, "name size");
140 torture_assert_int_equal(tctx, r->in.name->length, 0, "name length");
141
142 return true;
143}
144
145static const uint8_t enumvalue_out_data[] = {
146 0x12, 0x00, 0x00, 0x02, 0x28, 0x91, 0x08, 0x00, 0x00, 0x01, 0x00, 0x00,
147 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4f, 0x00,
148 0x4d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x41, 0x00, 0x54, 0x00, 0x48, 0x00,
149 0x00, 0x00, 0x00, 0x00, 0xd8, 0x8c, 0x07, 0x00, 0x01, 0x00, 0x00, 0x00,
150 0xe0, 0x00, 0x0c, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
151 0x4c, 0x00, 0x00, 0x00, 0x5c, 0x00, 0x44, 0x00, 0x6f, 0x00, 0x63, 0x00,
152 0x75, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x73, 0x00,
153 0x20, 0x00, 0x61, 0x00, 0x6e, 0x00, 0x64, 0x00, 0x20, 0x00, 0x53, 0x00,
154 0x65, 0x00, 0x74, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x67, 0x00,
155 0x73, 0x00, 0x5c, 0x00, 0x41, 0x00, 0x64, 0x00, 0x6d, 0x00, 0x69, 0x00,
156 0x6e, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61, 0x00,
157 0x74, 0x00, 0x6f, 0x00, 0x72, 0x00, 0x00, 0x00, 0xf0, 0x8c, 0x07, 0x00,
158 0x4c, 0x00, 0x00, 0x00, 0xf8, 0x8c, 0x07, 0x00, 0x4c, 0x00, 0x00, 0x00,
159 0x00, 0x00, 0x00, 0x00
160};
161
162static bool enumvalue_out_check(struct torture_context *tctx,
163 struct winreg_EnumValue *r)
164{
165 torture_assert_int_equal(tctx, r->out.name->size, 512, "name size");
166 torture_assert_int_equal(tctx, r->out.name->length, 18, "name length");
167 torture_assert_str_equal(tctx, r->out.name->name, "HOMEPATH", "name");
168 torture_assert_int_equal(tctx, *r->out.type, 1, "type");
169 torture_assert_int_equal(tctx, *r->out.size, 76, "size");
170 torture_assert_int_equal(tctx, *r->out.length, 76, "length");
171 torture_assert_werr_ok(tctx, r->out.result, "return code");
172
173 return true;
174}
175
176unsigned char enumvalue_in_data2[] = {
177 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
178 0xda, 0x45, 0x9c, 0xed, 0xe2, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
179 0x00, 0x00, 0x00, 0x02, 0xcc, 0xf9, 0x06, 0x00, 0x00, 0x01, 0x00, 0x00,
180 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0, 0xf9, 0x06, 0x00,
181 0x39, 0xa6, 0x07, 0x00, 0x00, 0xc4, 0x04, 0x01, 0x00, 0x80, 0x00, 0x00,
182 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xb0, 0xf9, 0x06, 0x00,
183 0x00, 0x80, 0x00, 0x00, 0x94, 0xf9, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00
184};
185
186static const uint8_t queryvalue_in_data[] = {
187 0x00, 0x00, 0x00, 0x00, 0xae, 0x1a, 0xbd, 0xbe, 0xbb, 0x94, 0xce, 0x4e,
188 0xba, 0xcf, 0x56, 0xeb, 0xe5, 0xb3, 0x6c, 0xa3, 0x12, 0x00, 0x12, 0x00,
189 0x01, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
190 0x09, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4f, 0x00, 0x4d, 0x00, 0x45, 0x00,
191 0x50, 0x00, 0x41, 0x00, 0x54, 0x00, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00,
192 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
193 0x03, 0x00, 0x00, 0x00, 0xff, 0x0f, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
194 0x00, 0x00, 0x00, 0x00
195};
196
197static bool queryvalue_in_check(struct torture_context *tctx,
198 struct winreg_QueryValue *r)
199{
200 torture_assert_str_equal(tctx, r->in.value_name->name, "HOMEPATH", "name");
201 torture_assert_int_equal(tctx, *r->in.type, 0, "type");
202 torture_assert_int_equal(tctx, *r->in.data_size, 4095, "size");
203 torture_assert_int_equal(tctx, *r->in.data_length, 0, "length");
204 torture_assert(tctx, r->in.data == NULL, "data pointer");
205
206 return true;
207}
208
209static const uint8_t queryvalue_out_data[] = {
210 0xd8, 0xf5, 0x0b, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
211 0xe4, 0xf5, 0x0b, 0x00, 0x4c, 0x00, 0x00, 0x00, 0xec, 0xf5, 0x0b, 0x00,
212 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
213};
214
215static bool queryvalue_out_check(struct torture_context *tctx,
216 struct winreg_QueryValue *r)
217{
218 torture_assert_werr_ok(tctx, r->out.result, "return code");
219 torture_assert_int_equal(tctx, *r->out.type, 1, "type");
220 torture_assert(tctx, r->out.data == NULL, "data pointer");
221 torture_assert_int_equal(tctx, *r->out.data_size, 76, "size");
222 torture_assert_int_equal(tctx, *r->out.data_length, 0, "length");
223
224 return true;
225}
226
227static const uint8_t querymultiplevalues_in_data[] = {
228 0x00, 0x00, 0x00, 0x00, 0xae, 0x1a, 0xbd, 0xbe, 0xbb, 0x94, 0xce, 0x4e,
229 0xba, 0xcf, 0x56, 0xeb, 0xe5, 0xb3, 0x6c, 0xa3, 0x01, 0x00, 0x00, 0x00,
230 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
231 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
232 0x12, 0x00, 0x12, 0x00, 0x02, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x48, 0x00, 0x4f, 0x00,
234 0x4d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x41, 0x00, 0x54, 0x00, 0x48, 0x00,
235 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
236 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00
240};
241
242static bool querymultiplevalues_in_check(struct torture_context *tctx,
243 struct winreg_QueryMultipleValues *r)
244{
245 torture_assert_int_equal(tctx, r->in.num_values, 1, "num values");
246 torture_assert_str_equal(tctx, r->in.values_in[0].ve_valuename->name, "HOMEPATH", "name");
247 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valuename->length, 18, "name len");
248 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valuename->size, 18, "name size");
249 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valuelen, 0, "length");
250 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valueptr, 0, "ve_valueptr");
251 torture_assert_int_equal(tctx, r->in.values_in[0].ve_type, 0, "type");
252 torture_assert_int_equal(tctx, *r->in.buffer_size, 32, "buffer size");
253
254 return true;
255}
256
257static const uint8_t querymultiplevalues_out_data[] = {
258 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
259 0xd8, 0x8c, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
260 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x12, 0x00, 0x38, 0x87, 0x07, 0x00,
261 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
262 0x48, 0x00, 0x4f, 0x00, 0x4d, 0x00, 0x45, 0x00, 0x50, 0x00, 0x41, 0x00,
263 0x54, 0x00, 0x48, 0x00, 0xc8, 0x95, 0x08, 0x00, 0x4c, 0x00, 0x00, 0x00,
264 0x00, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
265 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
266 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
267 0x00, 0x00, 0x00, 0x00, 0x4c, 0x4d, 0x45, 0x4d, 0xc8, 0x95, 0x08, 0x00,
268 0x50, 0x87, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x07, 0x00,
269 0x00, 0x01, 0x0c, 0x00, 0x50, 0x95, 0x08, 0x00, 0x48, 0x96, 0x08, 0x00,
270 0xdc, 0x00, 0x00, 0x00, 0xc0, 0x83, 0x00, 0x01, 0x0d, 0xf0, 0xff, 0xff,
271 0x4c, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00
272};
273
274static bool querymultiplevalues_out_check(struct torture_context *tctx,
275 struct winreg_QueryMultipleValues *r)
276{
277 torture_assert_str_equal(tctx, r->out.values_out[0].ve_valuename->name, "HOMEPATH", "name");
278 torture_assert_int_equal(tctx, r->out.values_out[0].ve_type, 0, "type");
279 torture_assert_int_equal(tctx, r->out.values_out[0].ve_valuelen, 0, "length");
280 /* FIXME: r->out.buffer */
281 torture_assert_int_equal(tctx, *r->out.buffer_size, 76, "buffer size");
282 torture_assert_werr_equal(tctx, r->out.result, WERR_MORE_DATA, "return code");
283
284 return true;
285}
286
287const uint8_t querymultiplevalues2_in_data[] = {
288 0x00, 0x00, 0x00, 0x00, 0x98, 0xe4, 0xdf, 0x3c, 0x70, 0xde, 0x69, 0x4a,
289 0x90, 0xb4, 0x85, 0x36, 0x33, 0x79, 0x89, 0x32, 0x01, 0x00, 0x00, 0x00,
290 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,
291 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
292 0x0a, 0x00, 0x0a, 0x00, 0x04, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00,
293 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x54, 0x00, 0x45, 0x00,
294 0x4d, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
295 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
296};
297
298static bool querymultiplevalues2_in_check(struct torture_context *tctx,
299 struct winreg_QueryMultipleValues2 *r)
300{
301 torture_assert_int_equal(tctx, r->in.num_values, 1, "num values");
302 torture_assert_str_equal(tctx, r->in.values_in[0].ve_valuename->name, "TEMP", "name");
303 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valuename->length, 10, "name len");
304 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valuename->size, 10, "name size");
305 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valuelen, 0, "length");
306 torture_assert_int_equal(tctx, r->in.values_in[0].ve_valueptr, 0, "ve_valueptr");
307 torture_assert_int_equal(tctx, r->in.values_in[0].ve_type, 0, "type");
308 torture_assert_int_equal(tctx, *r->in.offered, 0, "buffer size");
309
310 return true;
311}
312
313const uint8_t querymultiplevalues2_out_data[] = {
314 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
315 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
316 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x0a, 0x00, 0x04, 0x00, 0x02, 0x00,
317 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
318 0x54, 0x00, 0x45, 0x00, 0x4d, 0x00, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00,
319 0x42, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00
320};
321
322static bool querymultiplevalues2_out_check(struct torture_context *tctx,
323 struct winreg_QueryMultipleValues2 *r)
324{
325 return true;
326}
327
328static const uint8_t flushkey_in_data[] = {
329 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
330 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3
331};
332
333static bool flushkey_in_check(struct torture_context *tctx,
334 struct winreg_FlushKey *r)
335{
336 torture_assert_int_equal(tctx, r->in.handle->handle_type, 0, "handle type");
337 return true;
338}
339
340static const uint8_t flushkey_out_data[] = {
341 0x00, 0x00, 0x00, 0x00
342};
343
344static bool flushkey_out_check(struct torture_context *tctx,
345 struct winreg_FlushKey *r)
346{
347 torture_assert_werr_ok(tctx, r->out.result, "return code");
348 return true;
349}
350
351
352static const uint8_t openkey_in_data[] = {
353 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
354 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x16, 0x00, 0x16, 0x00,
355 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
356 0x0b, 0x00, 0x00, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x74, 0x00,
357 0x74, 0x00, 0x79, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00,
358 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02
359};
360
361static bool openkey_in_check(struct torture_context *tctx, struct winreg_OpenKey *r)
362{
363 torture_assert_int_equal(tctx, r->in.options, 0, "unknown");
364 torture_assert_int_equal(tctx, r->in.access_mask, 0x02000000, "access mask");
365 torture_assert_str_equal(tctx, r->in.keyname.name, "spottyfoot", "keyname");
366 /* FIXME: parent handle */
367 return true;
368}
369
370static const uint8_t openkey_out_data[] = {
371 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
372 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00
373};
374
375static bool openkey_out_check(struct torture_context *tctx, struct winreg_OpenKey *r)
376{
377 torture_assert(tctx, GUID_all_zero(&r->out.handle->uuid), "handle");
378 torture_assert_werr_equal(tctx, r->out.result, WERR_BADFILE, "return code");
379 return true;
380}
381
382static const uint8_t deletekey_in_data[] = {
383 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
384 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x16, 0x00, 0x16, 0x00,
385 0x01, 0x00, 0x00, 0x00, 0x0b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
386 0x0b, 0x00, 0x00, 0x00, 0x73, 0x00, 0x70, 0x00, 0x6f, 0x00, 0x74, 0x00,
387 0x74, 0x00, 0x79, 0x00, 0x66, 0x00, 0x6f, 0x00, 0x6f, 0x00, 0x74, 0x00,
388 0x00, 0x00
389};
390
391static bool deletekey_in_check(struct torture_context *tctx, struct winreg_DeleteKey *r)
392{
393 /* FIXME: Handle */
394 torture_assert_str_equal(tctx, r->in.key.name, "spottyfoot", "key name");
395 return true;
396}
397
398static const uint8_t deletekey_out_data[] = {
399 0x02, 0x00, 0x00, 0x00
400};
401
402static bool deletekey_out_check(struct torture_context *tctx, struct winreg_DeleteKey *r)
403{
404 torture_assert_werr_equal(tctx, r->out.result, WERR_BADFILE, "return code");
405 return true;
406}
407
408static const uint8_t getversion_in_data[] = {
409 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
410 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3
411};
412
413static bool getversion_in_check(struct torture_context *tctx, struct winreg_GetVersion *r)
414{
415 /* FIXME: Handle */
416 return true;
417}
418
419static const uint8_t getversion_out_data[] = {
420 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
421};
422
423static bool getversion_out_check(struct torture_context *tctx, struct winreg_GetVersion *r)
424{
425 torture_assert_int_equal(tctx, *r->out.version, 5, "version");
426 torture_assert_werr_ok(tctx, r->out.result, "return code");
427 return true;
428}
429
430static const uint8_t queryinfokey_in_data[] = {
431 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
432 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x00, 0x00, 0x00, 0x00,
433 0x00, 0x00, 0x00, 0x00
434};
435
436static bool queryinfokey_in_check(struct torture_context *tctx, struct winreg_QueryInfoKey *r)
437{
438 /* FIXME: Handle */
439 torture_assert(tctx, r->in.classname->name == NULL, "class in");
440 return true;
441}
442
443static const uint8_t queryinfokey_out_data[] = {
444 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
445 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
446 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00,
447 0x10, 0x48, 0x02, 0x3a, 0xcf, 0xfd, 0xc4, 0x01, 0x00, 0x00, 0x00, 0x00
448};
449
450static bool queryinfokey_out_check(struct torture_context *tctx, struct winreg_QueryInfoKey *r)
451{
452 torture_assert(tctx, r->out.classname != NULL, "class out");
453 torture_assert(tctx, r->out.classname->name != NULL, "class out name");
454 torture_assert_str_equal(tctx, r->out.classname->name, "", "class out name");
455 torture_assert_int_equal(tctx, *r->out.num_subkeys, 0, "num subkeys");
456 torture_assert_int_equal(tctx, *r->out.max_subkeylen, 0, "subkey length");
457 torture_assert_int_equal(tctx, *r->out.max_classlen, 140, "subkey size");
458 torture_assert_werr_ok(tctx, r->out.result, "return code");
459 return true;
460}
461
462static const uint8_t notifychangekeyvalue_in_data[] = {
463 0x00, 0x00, 0x00, 0x00, 0xb2, 0x64, 0xbc, 0xb3, 0x7f, 0x90, 0x29, 0x4a,
464 0xb4, 0xb3, 0x91, 0xe7, 0xe4, 0x4a, 0x58, 0xe3, 0x01, 0x00, 0x00, 0x00,
465 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
466 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
467 0x00, 0x00, 0x00, 0x00
468};
469
470static bool notifychangekeyvalue_in_check(struct torture_context *tctx, struct winreg_NotifyChangeKeyValue *r)
471{
472 torture_assert_int_equal(tctx, r->in.watch_subtree, 1, "watch subtree");
473 torture_assert_int_equal(tctx, r->in.notify_filter, 0, "notify filter");
474 torture_assert_int_equal(tctx, r->in.unknown, 0, "unknown");
475 torture_assert(tctx, r->in.string1.name == NULL, "string1");
476 torture_assert(tctx, r->in.string2.name == NULL, "string2");
477 torture_assert_int_equal(tctx, r->in.unknown2, 0, "unknown2");
478 return true;
479}
480
481static const uint8_t notifychangekeyvalue_out_data[] = {
482 0x57, 0x00, 0x00, 0x00
483};
484
485static bool notifychangekeyvalue_out_check(struct torture_context *tctx, struct winreg_NotifyChangeKeyValue *r)
486{
487 torture_assert_werr_equal(tctx, r->out.result, WERR_INVALID_PARAM, "notify change key value");
488 return true;
489}
490
491static const uint8_t getkeysecurity_in_data[] = {
492 0x00, 0x00, 0x00, 0x00, 0xbd, 0xaa, 0xf6, 0x59, 0xc1, 0x82, 0x1f, 0x4d,
493 0x84, 0xa9, 0xdd, 0xae, 0x60, 0x77, 0x1e, 0x45, 0x00, 0x00, 0x00, 0x02,
494 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
495};
496
497static bool getkeysecurity_in_check(struct torture_context *tctx,
498 struct winreg_GetKeySecurity *r)
499{
500 /* FIXME: Handle */
501 torture_assert_int_equal(tctx, r->in.sec_info, 2, "sec info");
502 torture_assert_int_equal(tctx, r->in.sd->size, 65536, "sd size");
503 torture_assert_int_equal(tctx, r->in.sd->len, 0, "sd len");
504 torture_assert(tctx, r->in.sd->data == NULL, "sd data");
505 return true;
506}
507
508static const uint8_t getkeysecurity_out_data[] = {
509 0x08, 0x91, 0x08, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
510 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
511 0x01, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
512 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
513};
514
515static bool getkeysecurity_out_check(struct torture_context *tctx,
516 struct winreg_GetKeySecurity *r)
517{
518 torture_assert_int_equal(tctx, r->in.sd->size, 20, "sd size");
519 torture_assert_int_equal(tctx, r->in.sd->len, 20, "sd len");
520 torture_assert_werr_ok(tctx, r->out.result, "return code");
521 return true;
522}
523
524static const uint8_t enumkey_in_data[] = {
525 0x00, 0x00, 0x00, 0x00, 0x85, 0xb8, 0x41, 0xb0, 0x17, 0xe4, 0x28, 0x45,
526 0x8a, 0x69, 0xbf, 0x40, 0x79, 0x82, 0x8b, 0xcb, 0x00, 0x00, 0x00, 0x00,
527 0x00, 0x00, 0x14, 0x04, 0x01, 0x00, 0x00, 0x00, 0x0a, 0x02, 0x00, 0x00,
528 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
529 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
530 0xff, 0xff, 0xff, 0x7f, 0xff, 0xff, 0xff, 0x7f
531};
532
533static bool enumkey_in_check(struct torture_context *tctx, struct winreg_EnumKey *r)
534{
535 torture_assert_int_equal(tctx, r->in.enum_index, 0, "enum index");
536 torture_assert_int_equal(tctx, r->in.name->size, 1044, "name size");
537 torture_assert_int_equal(tctx, r->in.name->length, 0, "name len");
538 torture_assert(tctx, r->in.keyclass != NULL, "keyclass pointer");
539 torture_assert(tctx, r->in.keyclass->name == NULL, "keyclass");
540 torture_assert(tctx, r->in.last_changed_time != NULL, "last_changed_time != NULL");
541 return true;
542}
543
544static const uint8_t enumkey_out_data[] = {
545 0x08, 0x00, 0x14, 0x04, 0x18, 0xe8, 0x07, 0x00, 0x0a, 0x02, 0x00, 0x00,
546 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x53, 0x00, 0x41, 0x00,
547 0x4d, 0x00, 0x00, 0x00, 0xd0, 0x62, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
548 0x00, 0x00, 0x00, 0x00, 0xdc, 0x62, 0x07, 0x00, 0x50, 0x67, 0xd0, 0x8b,
549 0x16, 0x06, 0xc2, 0x01, 0x00, 0x00, 0x00, 0x00
550};
551
552static bool enumkey_out_check(struct torture_context *tctx, struct winreg_EnumKey *r)
553{
554 torture_assert_int_equal(tctx, r->out.name->size, 1044, "name size");
555 torture_assert_int_equal(tctx, r->out.name->length, 8, "name len");
556 torture_assert(tctx, r->out.keyclass != NULL, "keyclass pointer");
557 torture_assert(tctx, r->out.keyclass->name == NULL, "keyclass");
558 torture_assert(tctx, r->out.last_changed_time != NULL, "last_changed_time pointer");
559 /* FIXME: *last_changed_time */
560 return true;
561}
562
563struct torture_suite *ndr_winreg_suite(TALLOC_CTX *ctx)
564{
565 struct torture_suite *suite = torture_suite_create(ctx, "winreg");
566
567 torture_suite_add_ndr_pull_fn_test(suite, winreg_CloseKey, closekey_in_data, NDR_IN, closekey_in_check );
568 torture_suite_add_ndr_pull_fn_test(suite, winreg_CloseKey, closekey_out_data, NDR_OUT, closekey_out_check );
569
570 torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenHKLM, OpenHKLM_In, NDR_IN, openhklm_in_check );
571 torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenHKLM, openhklm_out_data, NDR_OUT, openhklm_out_check );
572
573 torture_suite_add_ndr_pull_fn_test(suite, winreg_CreateKey, createkey_in_data, NDR_IN, createkey_in_check );
574 torture_suite_add_ndr_pull_fn_test(suite, winreg_CreateKey, createkey_out_data, NDR_OUT, createkey_out_check );
575
576 torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumValue, enumvalue_in_data, NDR_IN, enumvalue_in_check );
577 torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumValue, enumvalue_out_data, NDR_OUT, enumvalue_out_check );
578 torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumValue, enumvalue_in_data2, NDR_IN, NULL);
579
580 torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryValue, queryvalue_in_data, NDR_IN, queryvalue_in_check );
581 torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryValue, queryvalue_out_data, NDR_OUT, queryvalue_out_check );
582
583 torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryMultipleValues, querymultiplevalues_in_data, NDR_IN, querymultiplevalues_in_check );
584 torture_suite_add_ndr_pull_io_test(suite, winreg_QueryMultipleValues, querymultiplevalues_in_data, querymultiplevalues_out_data, querymultiplevalues_out_check);
585
586 torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryMultipleValues2, querymultiplevalues2_in_data, NDR_IN, querymultiplevalues2_in_check );
587 torture_suite_add_ndr_pull_io_test(suite, winreg_QueryMultipleValues2, querymultiplevalues2_in_data, querymultiplevalues2_out_data, querymultiplevalues2_out_check);
588
589 torture_suite_add_ndr_pull_fn_test(suite, winreg_FlushKey, flushkey_in_data, NDR_IN, flushkey_in_check );
590 torture_suite_add_ndr_pull_fn_test(suite, winreg_FlushKey, flushkey_out_data, NDR_OUT, flushkey_out_check );
591
592 torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenKey, openkey_in_data, NDR_IN, openkey_in_check );
593 torture_suite_add_ndr_pull_fn_test(suite, winreg_OpenKey, openkey_out_data, NDR_OUT, openkey_out_check );
594
595 torture_suite_add_ndr_pull_fn_test(suite, winreg_DeleteKey, deletekey_in_data, NDR_IN, deletekey_in_check );
596 torture_suite_add_ndr_pull_fn_test(suite, winreg_DeleteKey, deletekey_out_data, NDR_OUT, deletekey_out_check );
597
598 torture_suite_add_ndr_pull_fn_test(suite, winreg_GetVersion, getversion_in_data, NDR_IN, getversion_in_check );
599 torture_suite_add_ndr_pull_fn_test(suite, winreg_GetVersion, getversion_out_data, NDR_OUT, getversion_out_check );
600
601 torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryInfoKey, queryinfokey_in_data, NDR_IN, queryinfokey_in_check );
602 /*torture_suite_add_ndr_pull_fn_test(suite, winreg_QueryInfoKey, queryinfokey_out_data, NDR_OUT, queryinfokey_out_check );*/
603
604 torture_suite_add_ndr_pull_fn_test(suite, winreg_NotifyChangeKeyValue, notifychangekeyvalue_in_data, NDR_IN, notifychangekeyvalue_in_check );
605 torture_suite_add_ndr_pull_fn_test(suite, winreg_NotifyChangeKeyValue, notifychangekeyvalue_out_data, NDR_OUT, notifychangekeyvalue_out_check );
606
607 /*torture_suite_add_ndr_pull_fn_test(suite, winreg_GetKeySecurity, getkeysecurity_in_data, NDR_IN, getkeysecurity_in_check );
608 torture_suite_add_ndr_pull_fn_test(suite, winreg_GetKeySecurity, getkeysecurity_out_data, NDR_OUT, getkeysecurity_out_check );*/
609
610 torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumKey, enumkey_in_data, NDR_IN, enumkey_in_check );
611 torture_suite_add_ndr_pull_fn_test(suite, winreg_EnumKey, enumkey_out_data, NDR_OUT, enumkey_out_check );
612
613 return suite;
614}
615
Note: See TracBrowser for help on using the repository browser.