Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : test suite for basic tdr functions
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/torture.h"
23 : #include "torture/local/proto.h"
24 : #include "lib/tdr/tdr.h"
25 :
26 0 : static bool test_push_uint8(struct torture_context *tctx)
27 : {
28 0 : uint8_t v = 4;
29 0 : struct tdr_push *tdr = tdr_push_init(tctx);
30 :
31 0 : torture_assert_ntstatus_ok(tctx, tdr_push_uint8(tdr, &v), "push failed");
32 0 : torture_assert_int_equal(tctx, tdr->data.length, 1, "length incorrect");
33 0 : torture_assert_int_equal(tctx, tdr->data.data[0], 4, "data incorrect");
34 0 : return true;
35 : }
36 :
37 0 : static bool test_pull_uint8(struct torture_context *tctx)
38 : {
39 0 : uint8_t d = 2;
40 : uint8_t l;
41 0 : struct tdr_pull *tdr = tdr_pull_init(tctx);
42 0 : tdr->data.data = &d;
43 0 : tdr->data.length = 1;
44 0 : tdr->offset = 0;
45 0 : tdr->flags = 0;
46 0 : torture_assert_ntstatus_ok(tctx, tdr_pull_uint8(tdr, tctx, &l),
47 : "pull failed");
48 0 : torture_assert_int_equal(tctx, 1, tdr->offset,
49 : "offset invalid");
50 0 : return true;
51 : }
52 :
53 0 : static bool test_push_uint16(struct torture_context *tctx)
54 : {
55 0 : uint16_t v = 0xF32;
56 0 : struct tdr_push *tdr = tdr_push_init(tctx);
57 :
58 0 : torture_assert_ntstatus_ok(tctx, tdr_push_uint16(tdr, &v), "push failed");
59 0 : torture_assert_int_equal(tctx, tdr->data.length, 2, "length incorrect");
60 0 : torture_assert_int_equal(tctx, tdr->data.data[0], 0x32, "data incorrect");
61 0 : torture_assert_int_equal(tctx, tdr->data.data[1], 0x0F, "data incorrect");
62 0 : return true;
63 : }
64 :
65 0 : static bool test_pull_uint16(struct torture_context *tctx)
66 : {
67 0 : uint8_t d[2] = { 782 & 0xFF, (782 & 0xFF00) / 0x100 };
68 : uint16_t l;
69 0 : struct tdr_pull *tdr = tdr_pull_init(tctx);
70 0 : tdr->data.data = d;
71 0 : tdr->data.length = 2;
72 0 : tdr->offset = 0;
73 0 : tdr->flags = 0;
74 0 : torture_assert_ntstatus_ok(tctx, tdr_pull_uint16(tdr, tctx, &l),
75 : "pull failed");
76 0 : torture_assert_int_equal(tctx, 2, tdr->offset, "offset invalid");
77 0 : torture_assert_int_equal(tctx, 782, l, "right int read");
78 0 : return true;
79 : }
80 :
81 0 : static bool test_push_uint32(struct torture_context *tctx)
82 : {
83 0 : uint32_t v = 0x100F32;
84 0 : struct tdr_push *tdr = tdr_push_init(tctx);
85 :
86 0 : torture_assert_ntstatus_ok(tctx, tdr_push_uint32(tdr, &v), "push failed");
87 0 : torture_assert_int_equal(tctx, tdr->data.length, 4, "length incorrect");
88 0 : torture_assert_int_equal(tctx, tdr->data.data[0], 0x32, "data incorrect");
89 0 : torture_assert_int_equal(tctx, tdr->data.data[1], 0x0F, "data incorrect");
90 0 : torture_assert_int_equal(tctx, tdr->data.data[2], 0x10, "data incorrect");
91 0 : torture_assert_int_equal(tctx, tdr->data.data[3], 0x00, "data incorrect");
92 0 : return true;
93 : }
94 :
95 0 : static bool test_pull_uint32(struct torture_context *tctx)
96 : {
97 0 : uint8_t d[4] = { 782 & 0xFF, (782 & 0xFF00) / 0x100, 0, 0 };
98 : uint32_t l;
99 0 : struct tdr_pull *tdr = tdr_pull_init(tctx);
100 0 : tdr->data.data = d;
101 0 : tdr->data.length = 4;
102 0 : tdr->offset = 0;
103 0 : tdr->flags = 0;
104 0 : torture_assert_ntstatus_ok(tctx, tdr_pull_uint32(tdr, tctx, &l),
105 : "pull failed");
106 0 : torture_assert_int_equal(tctx, 4, tdr->offset, "offset invalid");
107 0 : torture_assert_int_equal(tctx, 782, l, "right int read");
108 0 : return true;
109 : }
110 :
111 0 : static bool test_pull_charset(struct torture_context *tctx)
112 : {
113 0 : struct tdr_pull *tdr = tdr_pull_init(tctx);
114 0 : const char *l = NULL;
115 0 : tdr->data.data = (uint8_t *)talloc_strdup(tctx, "bla");
116 0 : tdr->data.length = 4;
117 0 : tdr->offset = 0;
118 0 : tdr->flags = 0;
119 0 : torture_assert_ntstatus_ok(tctx, tdr_pull_charset(tdr, tctx, &l, -1, 1, CH_DOS),
120 : "pull failed");
121 0 : torture_assert_int_equal(tctx, 4, tdr->offset, "offset invalid");
122 0 : torture_assert_str_equal(tctx, "bla", l, "right int read");
123 :
124 0 : tdr->offset = 0;
125 0 : torture_assert_ntstatus_ok(tctx, tdr_pull_charset(tdr, tctx, &l, 2, 1, CH_UNIX),
126 : "pull failed");
127 0 : torture_assert_int_equal(tctx, 2, tdr->offset, "offset invalid");
128 0 : torture_assert_str_equal(tctx, "bl", l, "right int read");
129 :
130 0 : return true;
131 : }
132 :
133 0 : static bool test_pull_charset_empty(struct torture_context *tctx)
134 : {
135 0 : struct tdr_pull *tdr = tdr_pull_init(tctx);
136 0 : const char *l = NULL;
137 0 : tdr->data.data = (uint8_t *)talloc_strdup(tctx, "bla");
138 0 : tdr->data.length = 4;
139 0 : tdr->offset = 0;
140 0 : tdr->flags = 0;
141 0 : torture_assert_ntstatus_ok(tctx, tdr_pull_charset(tdr, tctx, &l, 0, 1, CH_DOS),
142 : "pull failed");
143 0 : torture_assert_int_equal(tctx, 0, tdr->offset, "offset invalid");
144 0 : torture_assert_str_equal(tctx, "", l, "right string read");
145 :
146 0 : return true;
147 : }
148 :
149 :
150 :
151 0 : static bool test_push_charset(struct torture_context *tctx)
152 : {
153 0 : const char *l = "bloe";
154 0 : struct tdr_push *tdr = tdr_push_init(tctx);
155 0 : torture_assert_ntstatus_ok(tctx, tdr_push_charset(tdr, &l, 4, 1, CH_UTF8),
156 : "push failed");
157 0 : torture_assert_int_equal(tctx, 4, tdr->data.length, "offset invalid");
158 0 : torture_assert(tctx, strncmp("bloe", (const char *)tdr->data.data, 4) == 0, "right string push");
159 :
160 0 : torture_assert_ntstatus_ok(tctx, tdr_push_charset(tdr, &l, -1, 1, CH_UTF8),
161 : "push failed");
162 0 : torture_assert_int_equal(tctx, 9, tdr->data.length, "offset invalid");
163 0 : torture_assert_str_equal(tctx, "bloe", (const char *)tdr->data.data+4, "right string read");
164 :
165 0 : return true;
166 : }
167 :
168 964 : struct torture_suite *torture_local_tdr(TALLOC_CTX *mem_ctx)
169 : {
170 964 : struct torture_suite *suite = torture_suite_create(mem_ctx, "tdr");
171 :
172 964 : torture_suite_add_simple_test(suite, "pull_uint8", test_pull_uint8);
173 964 : torture_suite_add_simple_test(suite, "push_uint8", test_push_uint8);
174 :
175 964 : torture_suite_add_simple_test(suite, "pull_uint16", test_pull_uint16);
176 964 : torture_suite_add_simple_test(suite, "push_uint16", test_push_uint16);
177 :
178 964 : torture_suite_add_simple_test(suite, "pull_uint32", test_pull_uint32);
179 964 : torture_suite_add_simple_test(suite, "push_uint32", test_push_uint32);
180 :
181 964 : torture_suite_add_simple_test(suite, "pull_charset", test_pull_charset);
182 964 : torture_suite_add_simple_test(suite, "pull_charset", test_pull_charset_empty);
183 964 : torture_suite_add_simple_test(suite, "push_charset", test_push_charset);
184 :
185 964 : return suite;
186 : }
|
