← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/torture/utable.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:
source3/torture/utable.c
 
1
/* 
 
2
   Unix SMB/CIFS implementation.
 
3
   SMB torture tester - unicode table dumper
 
4
   Copyright (C) Andrew Tridgell 2001
 
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
 
 
22
bool torture_utable(int dummy)
 
23
{
 
24
        struct cli_state *cli;
 
25
        fstring fname, alt_name;
 
26
        int fnum;
 
27
        smb_ucs2_t c2;
 
28
        int c, len, fd;
 
29
        int chars_allowed=0, alt_allowed=0;
 
30
        uint8 valid[0x10000];
 
31
 
 
32
        printf("starting utable\n");
 
33
 
 
34
        if (!torture_open_connection(&cli, 0)) {
 
35
                return False;
 
36
        }
 
37
 
 
38
        memset(valid, 0, sizeof(valid));
 
39
 
 
40
        cli_mkdir(cli, "\\utable");
 
41
        cli_unlink(cli, "\\utable\\*");
 
42
 
 
43
        for (c=1; c < 0x10000; c++) {
 
44
                char *p;
 
45
 
 
46
                SSVAL(&c2, 0, c);
 
47
                fstrcpy(fname, "\\utable\\x");
 
48
                p = fname+strlen(fname);
 
49
                len = convert_string(CH_UTF16LE, CH_UNIX, 
 
50
                                     &c2, 2, 
 
51
                                     p, sizeof(fname)-strlen(fname), True);
 
52
                p[len] = 0;
 
53
                fstrcat(fname,"_a_long_extension");
 
54
 
 
55
                fnum = cli_open(cli, fname, O_RDWR | O_CREAT | O_TRUNC, 
 
56
                                DENY_NONE);
 
57
                if (fnum == -1) continue;
 
58
 
 
59
                chars_allowed++;
 
60
 
 
61
                cli_qpathinfo_alt_name(cli, fname, alt_name);
 
62
 
 
63
                if (strncmp(alt_name, "X_A_L", 5) != 0) {
 
64
                        alt_allowed++;
 
65
                        valid[c] = 1;
 
66
                        d_printf("fname=[%s] alt_name=[%s]\n", fname, alt_name);
 
67
                }
 
68
 
 
69
                cli_close(cli, fnum);
 
70
                cli_unlink(cli, fname);
 
71
 
 
72
                if (c % 100 == 0) {
 
73
                        printf("%d (%d/%d)\r", c, chars_allowed, alt_allowed);
 
74
                }
 
75
        }
 
76
        printf("%d (%d/%d)\n", c, chars_allowed, alt_allowed);
 
77
 
 
78
        cli_rmdir(cli, "\\utable");
 
79
 
 
80
        d_printf("%d chars allowed   %d alt chars allowed\n", chars_allowed, alt_allowed);
 
81
 
 
82
        fd = open("valid.dat", O_WRONLY|O_CREAT|O_TRUNC, 0644);
 
83
        if (fd == -1) {
 
84
                d_printf("Failed to create valid.dat - %s", strerror(errno));
 
85
                return False;
 
86
        }
 
87
        if (write(fd, valid, 0x10000) != 0x10000) {
 
88
                d_printf("Failed to create valid.dat - %s", strerror(errno));
 
89
                close(fd);
 
90
                return false;
 
91
        }
 
92
        close(fd);
 
93
        d_printf("wrote valid.dat\n");
 
94
 
 
95
        return True;
 
96
}
 
97
 
 
98
 
 
99
static char *form_name(int c)
 
100
{
 
101
        static fstring fname;
 
102
        smb_ucs2_t c2;
 
103
        char *p;
 
104
        int len;
 
105
 
 
106
        fstrcpy(fname, "\\utable\\");
 
107
        p = fname+strlen(fname);
 
108
        SSVAL(&c2, 0, c);
 
109
 
 
110
        len = convert_string(CH_UTF16LE, CH_UNIX, 
 
111
                             &c2, 2, 
 
112
                             p, sizeof(fname)-strlen(fname), True);
 
113
        p[len] = 0;
 
114
        return fname;
 
115
}
 
116
 
 
117
bool torture_casetable(int dummy)
 
118
{
 
119
        static struct cli_state *cli;
 
120
        char *fname;
 
121
        int fnum;
 
122
        int c, i;
 
123
#define MAX_EQUIVALENCE 8
 
124
        smb_ucs2_t equiv[0x10000][MAX_EQUIVALENCE];
 
125
        printf("starting casetable\n");
 
126
 
 
127
        if (!torture_open_connection(&cli, 0)) {
 
128
                return False;
 
129
        }
 
130
 
 
131
        memset(equiv, 0, sizeof(equiv));
 
132
 
 
133
        cli_unlink(cli, "\\utable\\*");
 
134
        cli_rmdir(cli, "\\utable");
 
135
        if (!cli_mkdir(cli, "\\utable")) {
 
136
                printf("Failed to create utable directory!\n");
 
137
                return False;
 
138
        }
 
139
 
 
140
        for (c=1; c < 0x10000; c++) {
 
141
                SMB_OFF_T size;
 
142
 
 
143
                if (c == '.' || c == '\\') continue;
 
144
 
 
145
                printf("%04x (%c)\n", c, isprint(c)?c:'.');
 
146
 
 
147
                fname = form_name(c);
 
148
                fnum = cli_nt_create_full(cli, fname, 0,
 
149
                                          GENERIC_ALL_ACCESS, 
 
150
                                          FILE_ATTRIBUTE_NORMAL,
 
151
                                          FILE_SHARE_NONE,
 
152
                                          FILE_OPEN_IF, 0, 0);
 
153
 
 
154
                if (fnum == -1) {
 
155
                        printf("Failed to create file with char %04x\n", c);
 
156
                        continue;
 
157
                }
 
158
 
 
159
                size = 0;
 
160
 
 
161
                if (!cli_qfileinfo(cli, fnum, NULL, &size, 
 
162
                                   NULL, NULL, NULL, NULL, NULL)) continue;
 
163
 
 
164
                if (size > 0) {
 
165
                        /* found a character equivalence! */
 
166
                        int c2[MAX_EQUIVALENCE];
 
167
 
 
168
                        if (size/sizeof(int) >= MAX_EQUIVALENCE) {
 
169
                                printf("too many chars match?? size=%ld c=0x%04x\n",
 
170
                                       (unsigned long)size, c);
 
171
                                cli_close(cli, fnum);
 
172
                                return False;
 
173
                        }
 
174
 
 
175
                        cli_read(cli, fnum, (char *)c2, 0, size);
 
176
                        printf("%04x: ", c);
 
177
                        equiv[c][0] = c;
 
178
                        for (i=0; i<size/sizeof(int); i++) {
 
179
                                printf("%04x ", c2[i]);
 
180
                                equiv[c][i+1] = c2[i];
 
181
                        }
 
182
                        printf("\n");
 
183
                        fflush(stdout);
 
184
                }
 
185
 
 
186
                cli_write(cli, fnum, 0, (char *)&c, size, sizeof(c));
 
187
                cli_close(cli, fnum);
 
188
        }
 
189
 
 
190
        cli_unlink(cli, "\\utable\\*");
 
191
        cli_rmdir(cli, "\\utable");
 
192
 
 
193
        return True;
 
194
}