1 /* Test strncpy functions.
2 Copyright (C) 1999-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #ifdef WIDE
20 # include <wchar.h>
21 # define CHAR wchar_t
22 # define UCHAR wchar_t
23 # define BIG_CHAR WCHAR_MAX
24 # define SMALL_CHAR 1273
25 # define MEMCMP wmemcmp
26 # define MEMSET wmemset
27 # define STRNLEN wcsnlen
28 #else
29 # define CHAR char
30 # define UCHAR unsigned char
31 # define BIG_CHAR CHAR_MAX
32 # define SMALL_CHAR 127
33 # define MEMCMP memcmp
34 # define MEMSET memset
35 # define STRNLEN strnlen
36 #endif /* !WIDE */
37
38
39 #ifndef STRNCPY_RESULT
40 # define STRNCPY_RESULT(dst, len, n) dst
41 # define TEST_MAIN
42 # ifndef WIDE
43 # define TEST_NAME "strncpy"
44 # else
45 # define TEST_NAME "wcsncpy"
46 # endif /* WIDE */
47 # include "test-string.h"
48 # ifndef WIDE
49 # define SIMPLE_STRNCPY simple_strncpy
50 # define STRNCPY strncpy
51 # else
52 # define SIMPLE_STRNCPY simple_wcsncpy
53 # define STRNCPY wcsncpy
54 # endif /* WIDE */
55
56
57 IMPL (STRNCPY, 1)
58
59 /* Naive implementation to verify results. */
60 CHAR *
61 SIMPLE_STRNCPY (CHAR *dst, const CHAR *src, size_t n)
62 {
63 CHAR *ret = dst;
64 while (n--)
65 if ((*dst++ = *src++) == '\0')
66 {
67 while (n--)
68 *dst++ = '\0';
69 return ret;
70 }
71 return ret;
72 }
73
74 #endif /* !STRNCPY_RESULT */
75
76 typedef CHAR *(*proto_t) (CHAR *, const CHAR *, size_t);
77
78 static void
79 do_one_test (impl_t *impl, CHAR *dst, const CHAR *src, size_t len, size_t n)
80 {
81 if (CALL (impl, dst, src, n) != STRNCPY_RESULT (dst, len, n))
82 {
83 error (0, 0, "Wrong result in function %s %p %p", impl->name,
84 CALL (impl, dst, src, n), dst);
85 ret = 1;
86 return;
87 }
88
89 if (memcmp (dst, src, (len > n ? n : len) * sizeof (CHAR)) != 0)
90 {
91 error (0, 0, "Wrong result in function %s", impl->name);
92 ret = 1;
93 return;
94 }
95
96 if (n > len)
97 {
98 size_t i;
99
100 for (i = len; i < n; ++i)
101 if (dst [i] != '\0')
102 {
103 error (0, 0, "Wrong result in function %s", impl->name);
104 ret = 1;
105 return;
106 }
107 }
108 }
109
110 static void
111 do_test (size_t align1, size_t align2, size_t len, size_t n, int max_char)
112 {
113 size_t i;
114 CHAR *s1, *s2;
115
116 /* For wcsncpy: align1 and align2 here mean alignment not in bytes,
117 but in wchar_ts, in bytes it will equal to align * (sizeof (wchar_t)). */
118 align1 &= 7;
119 if ((align1 + len) * sizeof (CHAR) >= page_size)
120 return;
121
122 align2 &= 7;
123 if ((align2 + len) * sizeof (CHAR) >= page_size)
124 return;
125
126 s1 = (CHAR *) (buf1) + align1;
127 s2 = (CHAR *) (buf2) + align2;
128
129 for (i = 0; i < len; ++i)
130 s1[i] = 32 + 23 * i % (max_char - 32);
131 s1[len] = 0;
132 for (i = len + 1; (i + align1) * sizeof (CHAR) < page_size && i < len + 64;
133 ++i)
134 s1[i] = 32 + 32 * i % (max_char - 32);
135
136 FOR_EACH_IMPL (impl, 0)
137 do_one_test (impl, s2, s1, len, n);
138 }
139
140 static void
141 do_page_tests (void)
142 {
143 CHAR *s1, *s2;
144 const size_t maxoffset = 64;
145
146 /* Put s1 at the maxoffset from the edge of buf1's last page. */
147 s1 = (CHAR *) buf1 + BUF1PAGES * page_size / sizeof(CHAR) - maxoffset;
148 /* s2 needs room to put a string with size of maxoffset + 1 at s2 +
149 (maxoffset - 1). */
150 s2 = (CHAR *) buf2 + page_size / sizeof(CHAR) - maxoffset * 2;
151
152 MEMSET (s1, 'a', maxoffset - 1);
153 s1[maxoffset - 1] = '\0';
154
155 /* Both strings are bounded to a page with read/write access and the next
156 page is protected with PROT_NONE (meaning that any access outside of the
157 page regions will trigger an invalid memory access).
158
159 The loop copies the string s1 for all possible offsets up to maxoffset
160 for both inputs with a size larger than s1 (so memory access outside the
161 expected memory regions might trigger invalid access). */
162
163 for (size_t off1 = 0; off1 < maxoffset; off1++)
164 {
165 for (size_t off2 = 0; off2 < maxoffset; off2++)
166 {
167 FOR_EACH_IMPL (impl, 0)
168 do_one_test (impl, s2 + off2, s1 + off1, maxoffset - off1 - 1,
169 maxoffset + (maxoffset - off2));
170 }
171 }
172 }
173
174 static void
175 do_random_tests (void)
176 {
177 size_t i, j, n, align1, align2, len, size, mode;
178 UCHAR *p1 = (UCHAR *) (buf1 + page_size) - 512;
179 UCHAR *p2 = (UCHAR *) (buf2 + page_size) - 512;
180 UCHAR *res;
181
182 for (n = 0; n < ITERATIONS; n++)
183 {
184 /* For wcsncpy: align1 and align2 here mean align not in bytes,
185 but in wchar_ts, in bytes it will equal to align * (sizeof
186 (wchar_t)). */
187
188 mode = random ();
189 if (mode & 1)
190 {
191 size = random () & 255;
192 align1 = 512 - size - (random () & 15);
193 if (mode & 2)
194 align2 = align1 - (random () & 24);
195 else
196 align2 = align1 - (random () & 31);
197 if (mode & 4)
198 {
199 j = align1;
200 align1 = align2;
201 align2 = j;
202 }
203 if (mode & 8)
204 len = size - (random () & 31);
205 else
206 len = 512;
207 if (len >= 512)
208 len = random () & 511;
209 }
210 else
211 {
212 align1 = random () & 31;
213 if (mode & 2)
214 align2 = random () & 31;
215 else
216 align2 = align1 + (random () & 24);
217 len = random () & 511;
218 j = align1;
219 if (align2 > j)
220 j = align2;
221 if (mode & 4)
222 {
223 size = random () & 511;
224 if (size + j > 512)
225 size = 512 - j - (random () & 31);
226 }
227 else
228 size = 512 - j;
229 if ((mode & 8) && len + j >= 512)
230 len = 512 - j - (random () & 7);
231 }
232 j = len + align1 + 64;
233 if (j > 512)
234 j = 512;
235 for (i = 0; i < j; i++)
236 {
237 if (i == len + align1)
238 p1[i] = 0;
239 else
240 {
241 p1[i] = random () & BIG_CHAR;
242 if (i >= align1 && i < len + align1 && !p1[i])
243 p1[i] = (random () & SMALL_CHAR) + 3;
244 }
245 }
246
247 FOR_EACH_IMPL (impl, 1)
248 {
249 MEMSET (p2 - 64, '\1', 512 + 64);
250 res = (UCHAR *) CALL (impl, (CHAR *) (p2 + align2),
251 (CHAR *) (p1 + align1), size);
252 if (res != STRNCPY_RESULT (p2 + align2, len, size))
253 {
254 error (0, 0, "Iteration %zd - wrong result in function %s (%zd, %zd, %zd) %p != %p",
255 n, impl->name, align1, align2, len, res,
256 STRNCPY_RESULT (p2 + align2, len, size));
257 ret = 1;
258 }
259 for (j = 0; j < align2 + 64; ++j)
260 {
261 if (p2[j - 64] != '\1')
262 {
263 error (0, 0, "Iteration %zd - garbage before, %s (%zd, %zd, %zd)",
264 n, impl->name, align1, align2, len);
265 ret = 1;
266 break;
267 }
268 }
269 j = align2 + len + 1;
270 if (size + align2 > j)
271 j = size + align2;
272 for (; j < 512; ++j)
273 {
274 if (p2[j] != '\1')
275 {
276 error (0, 0, "Iteration %zd - garbage after, %s (%zd, %zd, %zd)",
277 n, impl->name, align1, align2, len);
278 ret = 1;
279 break;
280 }
281 }
282 for (j = align2 + len + 1; j < align2 + size; ++j)
283 if (p2[j])
284 {
285 error (0, 0, "Iteration %zd - garbage after size, %s (%zd, %zd, %zd)",
286 n, impl->name, align1, align2, len);
287 ret = 1;
288 break;
289 }
290 j = len + 1;
291 if (size < j)
292 j = size;
293 if (MEMCMP (p1 + align1, p2 + align2, j))
294 {
295 error (0, 0, "Iteration %zd - different strings, %s (%zd, %zd, %zd)",
296 n, impl->name, align1, align2, len);
297 ret = 1;
298 }
299 }
300 }
301 }
302
303 int
304 test_main (void)
305 {
306 size_t i;
307
308 test_init ();
309
310 printf ("%28s", "");
311 FOR_EACH_IMPL (impl, 0)
312 printf ("\t%s", impl->name);
313 putchar ('\n');
314
315 for (i = 1; i < 8; ++i)
316 {
317 do_test (i, i, 16, 16, SMALL_CHAR);
318 do_test (i, i, 16, 16, BIG_CHAR);
319 do_test (i, 2 * i, 16, 16, SMALL_CHAR);
320 do_test (2 * i, i, 16, 16, BIG_CHAR);
321 do_test (8 - i, 2 * i, 1 << i, 2 << i, SMALL_CHAR);
322 do_test (2 * i, 8 - i, 2 << i, 1 << i, SMALL_CHAR);
323 do_test (8 - i, 2 * i, 1 << i, 2 << i, BIG_CHAR);
324 do_test (2 * i, 8 - i, 2 << i, 1 << i, BIG_CHAR);
325 }
326
327 for (i = 1; i < 8; ++i)
328 {
329 do_test (0, 0, 4 << i, 8 << i, SMALL_CHAR);
330 do_test (0, 0, 16 << i, 8 << i, SMALL_CHAR);
331 do_test (8 - i, 2 * i, 4 << i, 8 << i, SMALL_CHAR);
332 do_test (8 - i, 2 * i, 16 << i, 8 << i, SMALL_CHAR);
333 }
334
335 do_random_tests ();
336 do_page_tests ();
337 return ret;
338 }
339
340 #include <support/test-driver.c>