1 /* fmemopen tests for append and read mode.
2 Copyright (C) 2015-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 #include <assert.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <sys/types.h>
23
24 #include <support/xstdio.h>
25
26 static void
27 print_buffer (const char *s, size_t n)
28 {
29 size_t i;
30 printf ("{");
31 for (i=0; i<n; ++i)
32 {
33 printf ("0x%02X (%c)", s[i], s[i]);
34 if (i != n)
35 printf (", ");
36 }
37 }
38
39 /* This test check append mode initial position (a/a+) based on POSIX definition
40 (BZ#6544 and BZ#13151). */
41 static int
42 do_test_write_append (const char *mode)
43 {
44 char buf[32] = "testing buffer";
45 char exp[32] = "testing bufferXX";
46
47 FILE *fp = fmemopen (buf, sizeof (buf), mode);
48
49 fflush (fp);
50 fprintf (fp, "X");
51 fseek (fp, 0, SEEK_SET);
52 fprintf (fp, "X");
53 fclose (fp);
54
55 if (strcmp (buf, exp) != 0)
56 {
57 printf ("%s: check failed: %s != %s\n", __FUNCTION__, buf, exp);
58 return 1;
59 }
60
61 return 0;
62 }
63
64 /* This test check append mode initial position (a/a+) based on POSIX definition
65 (BZ#6544 and BZ#13151) for buffer without null byte end. */
66 static int
67 do_test_write_append_without_null (const char *mode)
68 {
69 char buf[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
70 char exp[] = { 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55 };
71
72 /* If '\0' is not found in buffer, POSIX states that SEEK_SET should be
73 the size argument. */
74 FILE *fp = fmemopen (buf, sizeof (buf) - 2, "a");
75
76 fflush (fp);
77 fputc (0x70, fp);
78 fseek (fp, 0, SEEK_SET);
79 fputc (0x70, fp);
80 fputc (0x70, fp);
81 fclose (fp);
82
83 /* POSIX also states that a write operation on the stream shall not advance
84 the current buffer size beyond the size given in fmemopen, so the string
85 should be same. */
86 if (memcmp (buf, exp, sizeof (buf)) != 0)
87 {
88 printf ("%s: check failed: ", __FUNCTION__);
89 print_buffer (buf, sizeof (buf));
90 printf ("!= ");
91 print_buffer (exp, sizeof (exp));
92 printf ("\n");
93 return 1;
94 }
95
96 return 0;
97 }
98
99 /* This test check for initial position and seek value for fmemopen objects
100 opened with append mode. */
101 static int
102 do_test_read_append (void)
103 {
104 char buf[32] = "testing buffer";
105 size_t buflen = strlen (buf);
106 long fpos;
107
108 /* POSIX defines for 'a+' the initial position is the first null byte. */
109 FILE *fp = fmemopen (buf, sizeof (buf), "a+");
110
111 fpos = ftell (fp);
112 if (fpos != buflen)
113 {
114 printf ("%s: ftell|SEEK_SET (fp) %li != strlen (%s) %zu\n",
115 __FUNCTION__, fpos, buf, buflen);
116 fclose (fp);
117 return 1;
118 }
119
120 fseek (fp, 0, SEEK_END);
121
122 if (fpos != buflen)
123 {
124 printf ("%s: ftell|SEEK_END (fp) %li != strlen (%s) %zu\n",
125 __FUNCTION__, fpos, buf, buflen);
126 fclose (fp);
127 return 1;
128 }
129 fclose (fp);
130
131 /* Check if attempting to read past the current size, defined as strlen (buf)
132 yield an EOF. */
133 fp = fmemopen (buf, sizeof (buf), "a+");
134 if (getc(fp) != EOF)
135 {
136 printf ("%s: getc(fp) != EOF\n", __FUNCTION__);
137 fclose (fp);
138 return -1;
139 }
140
141 fclose (fp);
142
143 return 0;
144 }
145
146 /* This test check for fseek (SEEK_END) using negative offsets (BZ#14292). The
147 starting position of descriptor is different base on the opening mode. */
148 static int
149 do_test_read_seek_neg (const char *mode, const char *expected)
150 {
151 char buf[] = "abcdefghijklmnopqrstuvxz0123456789";
152 char tmp[10];
153 size_t tmps = sizeof (tmps);
154 long offset = -11;
155
156 FILE *fp = fmemopen (buf, sizeof (buf), mode);
157 fseek (fp, offset, SEEK_END);
158 xfread (tmp, tmps, 1, fp);
159
160 if (memcmp (tmp, expected, tmps) != 0)
161 {
162 printf ("%s: fmemopen(%s) - fseek (fp, %li, SEEK_END):\n",
163 __FUNCTION__, mode, offset);
164 printf (" returned: ");
165 print_buffer (tmp, tmps);
166 printf ("\n");
167 printf (" expected: ");
168 print_buffer (expected, tmps);
169 printf ("\n");
170 return 1;
171 }
172
173 fclose (fp);
174
175 return 0;
176 }
177
178 static int
179 do_test_read_seek_negative (void)
180 {
181 int ret = 0;
182
183 /* 'r' and 'w' modes defines the initial position at the buffer start and
184 seek with SEEK_END shall seek relative to its size give in fmemopen
185 call. The expected tmp result is 0 to 9 *without* the ending null */
186 ret += do_test_read_seek_neg ("r", "0123456789");
187 /* 'a+' mode sets the initial position at the first null byte in buffer and
188 SEEK_END shall seek relative to its size as well. The expected result is
189 z012345678, since SEEK_END plus a+ start at '\0', not size. */
190 ret += do_test_read_seek_neg ("a+", "z012345678");
191
192 return ret;
193 }
194
195 static int
196 do_test_write_append_2 (const char *str)
197 {
198 char buf[10];
199 size_t strn = strlen (str);
200 strcpy (buf, str);
201
202 FILE *fp = fmemopen (buf, sizeof (buf), "a+");
203 size_t r = ftell (fp);
204 size_t e = strlen (buf);
205 if (r != e)
206 {
207 printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e);
208 return 1;
209 }
210
211 if (fseek (fp, 0, SEEK_SET) == -1)
212 {
213 printf ("%s: fseek returned -1\n", __FUNCTION__);
214 return 1;
215 }
216
217 int gr;
218 for (int i=0; i<strn; ++i)
219 {
220 if ((gr = getc (fp)) != str[i])
221 {
222 printf ("%s: getc failed returned %d, expected %d\n", __FUNCTION__,
223 gr, str[i]);
224 return 1;
225 }
226 }
227 if ((gr = getc (fp)) != EOF)
228 {
229 printf ("%s: getc failed returned %d, expected EOF\n", __FUNCTION__,
230 gr);
231 return 1;
232 }
233
234 if (fseek (fp, e+1, SEEK_SET) == -1)
235 {
236 printf ("%s: fseek returned -1\n", __FUNCTION__);
237 return 1;
238 }
239
240 if ((r = ftell (fp)) != e+1)
241 {
242 printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+1);
243 return 1;
244 }
245
246 if ((gr = getc (fp)) != EOF)
247 {
248 printf ("%s: getc failed returned %i\n", __FUNCTION__, gr);
249 return 1;
250 }
251
252 /* Check if internal position is not changed with a getc returning EOF. */
253 if ((r = ftell (fp)) != e+1)
254 {
255 printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+1);
256 return 1;
257 }
258
259 if (fseek (fp, 0, SEEK_CUR) == -1)
260 {
261 printf ("%s: fseek returned -1\n", __FUNCTION__);
262 return 1;
263 }
264
265 /* This should be overwritten by fprintf + fflush. */
266 buf[e+2] = 'X';
267
268 if ((r = fprintf (fp, "%d", 101)) != 3)
269 {
270 printf ("%s: fprintf returned %zu, expected %d\n", __FUNCTION__, r, 3);
271 return 1;
272 }
273
274 fflush (fp);
275
276 /* Check if internal position is changed by 3 (strlen of '101'). */
277 if ((r = ftell (fp)) != e+3)
278 {
279 printf ("%s: ftell returned %zu, expected %zu\n", __FUNCTION__, r, e+3);
280 return 1;
281 }
282
283 char exp[20];
284 sprintf (exp, "%s%d", str, 101);
285 if (memcmp (buf, exp, strlen (exp)) != 0)
286 {
287 printf ("%s: check failed:", __FUNCTION__);
288 printf ("\nexpected: ");
289 print_buffer (buf, sizeof (buf));
290 printf ("\nbuffer: ");
291 print_buffer (exp, sizeof (exp));
292 printf ("\n");
293 return 1;
294 }
295
296 fclose(fp);
297
298 return 0;
299 }
300
301 static int
302 do_test (void)
303 {
304 int ret = 0;
305
306 ret += do_test_write_append ("a");
307 ret += do_test_write_append_without_null ("a");
308 ret += do_test_write_append ("a+");
309 ret += do_test_write_append_without_null ("a+");
310
311 ret += do_test_read_append ();
312
313 ret += do_test_read_seek_negative ();
314
315 /* First test plus addend will fit in the define buffer of size 10. */
316 ret += do_test_write_append_2 ("test");
317 /* The second test will also fit, but not the final '\0'. */
318 ret += do_test_write_append_2 ("testing");
319
320 return ret;
321 }
322
323 #define TEST_FUNCTION do_test ()
324 #include "../test-skeleton.c"