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