source: trunk/server/source4/torture/masktest.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: 10.3 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 mask_match tester
4 Copyright (C) Andrew Tridgell 1999
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18*/
19
20#include "includes.h"
21#include "lib/cmdline/popt_common.h"
22#include "system/filesys.h"
23#include "system/dir.h"
24#include "libcli/libcli.h"
25#include "system/time.h"
26#include "auth/credentials/credentials.h"
27#include "auth/gensec/gensec.h"
28#include "param/param.h"
29#include "libcli/resolve/resolve.h"
30#include "lib/events/events.h"
31
32static bool showall = false;
33static bool old_list = false;
34static const char *maskchars = "<>\"?*abc.";
35static const char *filechars = "abcdefghijklm.";
36static int die_on_error;
37static int NumLoops = 0;
38static int max_length = 20;
39struct masktest_state {
40 TALLOC_CTX *mem_ctx;
41};
42
43static bool reg_match_one(struct smbcli_state *cli, const char *pattern, const char *file)
44{
45 /* oh what a weird world this is */
46 if (old_list && strcmp(pattern, "*.*") == 0) return true;
47
48 if (ISDOT(pattern)) return false;
49
50 if (ISDOTDOT(file)) file = ".";
51
52 return ms_fnmatch(pattern, file, cli->transport->negotiate.protocol)==0;
53}
54
55static char *reg_test(struct smbcli_state *cli, TALLOC_CTX *mem_ctx, const char *pattern, const char *long_name, const char *short_name)
56{
57 char *ret;
58 ret = talloc_strdup(mem_ctx, "---");
59
60 pattern = 1+strrchr_m(pattern,'\\');
61
62 if (reg_match_one(cli, pattern, ".")) ret[0] = '+';
63 if (reg_match_one(cli, pattern, "..")) ret[1] = '+';
64 if (reg_match_one(cli, pattern, long_name) ||
65 (*short_name && reg_match_one(cli, pattern, short_name))) ret[2] = '+';
66 return ret;
67}
68
69
70/*****************************************************
71return a connection to a server
72*******************************************************/
73static struct smbcli_state *connect_one(struct resolve_context *resolve_ctx,
74 struct tevent_context *ev,
75 TALLOC_CTX *mem_ctx,
76 char *share, const char **ports,
77 const char *socket_options,
78 struct smbcli_options *options,
79 struct smbcli_session_options *session_options,
80 struct gensec_settings *gensec_settings)
81{
82 struct smbcli_state *c;
83 char *server;
84 NTSTATUS status;
85
86 server = talloc_strdup(mem_ctx, share+2);
87 share = strchr_m(server,'\\');
88 if (!share) return NULL;
89 *share = 0;
90 share++;
91
92 cli_credentials_set_workstation(cmdline_credentials, "masktest", CRED_SPECIFIED);
93
94 status = smbcli_full_connection(NULL, &c,
95 server,
96 ports,
97 share, NULL,
98 socket_options,
99 cmdline_credentials, resolve_ctx, ev,
100 options, session_options,
101 gensec_settings);
102
103 if (!NT_STATUS_IS_OK(status)) {
104 return NULL;
105 }
106
107 return c;
108}
109
110static char *resultp;
111static struct {
112 char *long_name;
113 char *short_name;
114} last_hit;
115static bool f_info_hit;
116
117static void listfn(struct clilist_file_info *f, const char *s, void *state)
118{
119 struct masktest_state *m = (struct masktest_state *)state;
120
121 if (ISDOT(f->name)) {
122 resultp[0] = '+';
123 } else if (ISDOTDOT(f->name)) {
124 resultp[1] = '+';
125 } else {
126 resultp[2] = '+';
127 }
128
129 last_hit.long_name = talloc_strdup(m->mem_ctx, f->name);
130 last_hit.short_name = talloc_strdup(m->mem_ctx, f->short_name);
131 f_info_hit = true;
132}
133
134static void get_real_name(TALLOC_CTX *mem_ctx, struct smbcli_state *cli,
135 char **long_name, char **short_name)
136{
137 const char *mask;
138 struct masktest_state state;
139
140 if (cli->transport->negotiate.protocol <= PROTOCOL_LANMAN1) {
141 mask = "\\masktest\\*.*";
142 } else {
143 mask = "\\masktest\\*";
144 }
145
146 f_info_hit = false;
147
148 state.mem_ctx = mem_ctx;
149
150 smbcli_list_new(cli->tree, mask,
151 FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,
152 RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
153 listfn, &state);
154
155 if (f_info_hit) {
156 *short_name = talloc_strdup(mem_ctx, last_hit.short_name);
157 strlower(*short_name);
158 *long_name = talloc_strdup(mem_ctx, last_hit.long_name);
159 strlower(*long_name);
160 }
161
162 if (*short_name == '\0') {
163 *short_name = talloc_strdup(mem_ctx, *long_name);
164 }
165}
166
167static void testpair(TALLOC_CTX *mem_ctx, struct smbcli_state *cli, char *mask,
168 char *file)
169{
170 int fnum;
171 char res1[256];
172 char *res2;
173 static int count;
174 char *short_name = NULL;
175 char *long_name = NULL;
176 struct masktest_state state;
177
178 count++;
179
180 safe_strcpy(res1, "---", sizeof(res1));
181
182 state.mem_ctx = mem_ctx;
183
184 fnum = smbcli_open(cli->tree, file, O_CREAT|O_TRUNC|O_RDWR, 0);
185 if (fnum == -1) {
186 DEBUG(0,("Can't create %s\n", file));
187 return;
188 }
189 smbcli_close(cli->tree, fnum);
190
191 resultp = res1;
192 short_name = talloc_strdup(mem_ctx, "");
193 get_real_name(mem_ctx, cli, &long_name, &short_name);
194 safe_strcpy(res1, "---", sizeof(res1));
195 smbcli_list_new(cli->tree, mask,
196 FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY,
197 RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO,
198 listfn, &state);
199
200 res2 = reg_test(cli, mem_ctx, mask, long_name, short_name);
201
202 if (showall || strcmp(res1, res2)) {
203 d_printf("%s %s %d mask=[%s] file=[%s] rfile=[%s/%s]\n",
204 res1, res2, count, mask, file, long_name, short_name);
205 if (die_on_error) exit(1);
206 }
207
208 smbcli_unlink(cli->tree, file);
209
210 if (count % 100 == 0) DEBUG(0,("%d\n", count));
211
212 resultp = NULL;
213}
214
215static void test_mask(int argc, char *argv[],
216 TALLOC_CTX *mem_ctx,
217 struct smbcli_state *cli)
218{
219 char *mask, *file;
220 int l1, l2, i, l;
221 int mc_len = strlen(maskchars);
222 int fc_len = strlen(filechars);
223
224 smbcli_mkdir(cli->tree, "\\masktest");
225
226 smbcli_unlink(cli->tree, "\\masktest\\*");
227
228 if (argc >= 2) {
229 while (argc >= 2) {
230 mask = talloc_strdup(mem_ctx, "\\masktest\\");
231 file = talloc_strdup(mem_ctx, "\\masktest\\");
232 mask = talloc_strdup_append(mask, argv[0]);
233 file = talloc_strdup_append(file, argv[1]);
234 testpair(mem_ctx, cli, mask, file);
235 argv += 2;
236 argc -= 2;
237 }
238 goto finished;
239 }
240
241 while (1) {
242 l1 = 1 + random() % max_length;
243 l2 = 1 + random() % max_length;
244 mask = talloc_strdup(mem_ctx, "\\masktest\\");
245 file = talloc_strdup(mem_ctx, "\\masktest\\");
246 mask = talloc_realloc_size(mem_ctx, mask, strlen(mask)+l1+1);
247 file = talloc_realloc_size(mem_ctx, file, strlen(file)+l2+1);
248 l = strlen(mask);
249 for (i=0;i<l1;i++) {
250 mask[i+l] = maskchars[random() % mc_len];
251 }
252 mask[l+l1] = 0;
253
254 for (i=0;i<l2;i++) {
255 file[i+l] = filechars[random() % fc_len];
256 }
257 file[l+l2] = 0;
258
259 if (ISDOT(file+l) || ISDOTDOT(file+l) || ISDOTDOT(mask+l)) {
260 continue;
261 }
262
263 if (strspn(file+l, ".") == strlen(file+l)) continue;
264
265 testpair(mem_ctx, cli, mask, file);
266 if (NumLoops && (--NumLoops == 0))
267 break;
268 }
269
270 finished:
271 smbcli_rmdir(cli->tree, "\\masktest");
272 talloc_free(mem_ctx);
273}
274
275
276static void usage(poptContext pc)
277{
278 printf(
279"Usage:\n\
280 masktest //server/share [options..]\n\
281\n\
282 This program tests wildcard matching between two servers. It generates\n\
283 random pairs of filenames/masks and tests that they match in the same\n\
284 way on the servers and internally\n");
285 poptPrintUsage(pc, stdout, 0);
286}
287
288/****************************************************************************
289 main program
290****************************************************************************/
291 int main(int argc,char *argv[])
292{
293 char *share;
294 struct smbcli_state *cli;
295 int opt;
296 int seed;
297 struct tevent_context *ev;
298 struct loadparm_context *lp_ctx;
299 struct smbcli_options options;
300 struct smbcli_session_options session_options;
301 poptContext pc;
302 int argc_new, i;
303 char **argv_new;
304 TALLOC_CTX *mem_ctx;
305 enum {OPT_UNCLIST=1000};
306 struct poptOption long_options[] = {
307 POPT_AUTOHELP
308 {"seed", 0, POPT_ARG_INT, &seed, 0, "Seed to use for randomizer", NULL},
309 {"num-ops", 0, POPT_ARG_INT, &NumLoops, 0, "num ops", NULL},
310 {"maxlength", 0, POPT_ARG_INT, &max_length,0, "maximum length", NULL},
311 {"dieonerror", 0, POPT_ARG_NONE, &die_on_error, 0, "die on errors", NULL},
312 {"showall", 0, POPT_ARG_NONE, &showall, 0, "display all operations", NULL},
313 {"oldlist", 0, POPT_ARG_NONE, &old_list, 0, "use old list call", NULL},
314 {"maskchars", 0, POPT_ARG_STRING, &maskchars, 0,"mask characters", NULL},
315 {"filechars", 0, POPT_ARG_STRING, &filechars, 0,"file characters", NULL},
316 POPT_COMMON_SAMBA
317 POPT_COMMON_CONNECTION
318 POPT_COMMON_CREDENTIALS
319 POPT_COMMON_VERSION
320 { NULL }
321 };
322
323 setlinebuf(stdout);
324 seed = time(NULL);
325
326 pc = poptGetContext("locktest", argc, (const char **) argv, long_options,
327 POPT_CONTEXT_KEEP_FIRST);
328
329 poptSetOtherOptionHelp(pc, "<unc>");
330
331 while((opt = poptGetNextOpt(pc)) != -1) {
332 switch (opt) {
333 case OPT_UNCLIST:
334 lpcfg_set_cmdline(cmdline_lp_ctx, "torture:unclist", poptGetOptArg(pc));
335 break;
336 }
337 }
338
339 argv_new = discard_const_p(char *, poptGetArgs(pc));
340 argc_new = argc;
341 for (i=0; i<argc; i++) {
342 if (argv_new[i] == NULL) {
343 argc_new = i;
344 break;
345 }
346 }
347
348 if (!(argc_new >= 2)) {
349 usage(pc);
350 exit(1);
351 }
352
353 setup_logging("masktest", DEBUG_STDOUT);
354
355 share = argv_new[1];
356
357 all_string_sub(share,"/","\\",0);
358
359 lp_ctx = cmdline_lp_ctx;
360
361 mem_ctx = talloc_autofree_context();
362
363 ev = s4_event_context_init(mem_ctx);
364
365 gensec_init(lp_ctx);
366
367 lpcfg_smbcli_options(lp_ctx, &options);
368 lpcfg_smbcli_session_options(lp_ctx, &session_options);
369
370 cli = connect_one(lpcfg_resolve_context(lp_ctx), ev, mem_ctx, share,
371 lpcfg_smb_ports(lp_ctx), lpcfg_socket_options(lp_ctx),
372 &options, &session_options,
373 lpcfg_gensec_settings(mem_ctx, lp_ctx));
374 if (!cli) {
375 DEBUG(0,("Failed to connect to %s\n", share));
376 exit(1);
377 }
378
379 /* need to init seed after connect as clientgen uses random numbers */
380 DEBUG(0,("seed=%d format --- --- (server, correct)\n", seed));
381 srandom(seed);
382
383 test_mask(argc_new-1, argv_new+1, mem_ctx, cli);
384
385 return(0);
386}
Note: See TracBrowser for help on using the repository browser.