1/* Copyright (C) 1993-2016 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>.
17
18 As a special exception, if you link the code in this file with
19 files compiled with a GNU compiler to produce an executable,
20 that does not cause the resulting executable to be covered by
21 the GNU Lesser General Public License. This exception does not
22 however invalidate any other reasons why the executable file
23 might be covered by the GNU Lesser General Public License.
24 This exception applies to code released by its copyright holders
25 in files containing the exception. */
26
27#include <assert.h>
28#include "strfile.h"
29#include "libioP.h"
30#include <string.h>
31#include <stdio_ext.h>
32
33void
34_IO_str_init_static_internal (_IO_strfile *sf, char *ptr, _IO_size_t size,
35 char *pstart)
36{
37 _IO_FILE *fp = &sf->_sbf._f;
38 char *end;
39
40 if (size == 0)
41 end = __rawmemchr (ptr, '\0');
42 else if ((_IO_size_t) ptr + size > (_IO_size_t) ptr)
43 end = ptr + size;
44 else
45 end = (char *) -1;
46 _IO_setb (fp, ptr, end, 0);
47
48 fp->_IO_write_base = ptr;
49 fp->_IO_read_base = ptr;
50 fp->_IO_read_ptr = ptr;
51 if (pstart)
52 {
53 fp->_IO_write_ptr = pstart;
54 fp->_IO_write_end = end;
55 fp->_IO_read_end = pstart;
56 }
57 else
58 {
59 fp->_IO_write_ptr = ptr;
60 fp->_IO_write_end = ptr;
61 fp->_IO_read_end = end;
62 }
63 /* A null _allocate_buffer function flags the strfile as being static. */
64 sf->_s._allocate_buffer = (_IO_alloc_type) 0;
65}
66
67void
68_IO_str_init_static (_IO_strfile *sf, char *ptr, int size, char *pstart)
69{
70 return _IO_str_init_static_internal (sf, ptr, size < 0 ? -1 : size, pstart);
71}
72
73void
74_IO_str_init_readonly (_IO_strfile *sf, const char *ptr, int size)
75{
76 _IO_str_init_static_internal (sf, (char *) ptr, size < 0 ? -1 : size, NULL);
77 sf->_sbf._f._IO_file_flags |= _IO_NO_WRITES;
78}
79
80int
81_IO_str_overflow (_IO_FILE *fp, int c)
82{
83 int flush_only = c == EOF;
84 _IO_size_t pos;
85 if (fp->_flags & _IO_NO_WRITES)
86 return flush_only ? 0 : EOF;
87 if ((fp->_flags & _IO_TIED_PUT_GET) && !(fp->_flags & _IO_CURRENTLY_PUTTING))
88 {
89 fp->_flags |= _IO_CURRENTLY_PUTTING;
90 fp->_IO_write_ptr = fp->_IO_read_ptr;
91 fp->_IO_read_ptr = fp->_IO_read_end;
92 }
93 pos = fp->_IO_write_ptr - fp->_IO_write_base;
94 if (pos >= (_IO_size_t) (_IO_blen (fp) + flush_only))
95 {
96 if (fp->_flags & _IO_USER_BUF) /* not allowed to enlarge */
97 return EOF;
98 else
99 {
100 char *new_buf;
101 char *old_buf = fp->_IO_buf_base;
102 size_t old_blen = _IO_blen (fp);
103 _IO_size_t new_size = 2 * old_blen + 100;
104 if (new_size < old_blen)
105 return EOF;
106 new_buf
107 = (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (new_size);
108 if (new_buf == NULL)
109 {
110 /* __ferror(fp) = 1; */
111 return EOF;
112 }
113 if (old_buf)
114 {
115 memcpy (new_buf, old_buf, old_blen);
116 (*((_IO_strfile *) fp)->_s._free_buffer) (old_buf);
117 /* Make sure _IO_setb won't try to delete _IO_buf_base. */
118 fp->_IO_buf_base = NULL;
119 }
120 memset (new_buf + old_blen, '\0', new_size - old_blen);
121
122 _IO_setb (fp, new_buf, new_buf + new_size, 1);
123 fp->_IO_read_base = new_buf + (fp->_IO_read_base - old_buf);
124 fp->_IO_read_ptr = new_buf + (fp->_IO_read_ptr - old_buf);
125 fp->_IO_read_end = new_buf + (fp->_IO_read_end - old_buf);
126 fp->_IO_write_ptr = new_buf + (fp->_IO_write_ptr - old_buf);
127
128 fp->_IO_write_base = new_buf;
129 fp->_IO_write_end = fp->_IO_buf_end;
130 }
131 }
132
133 if (!flush_only)
134 *fp->_IO_write_ptr++ = (unsigned char) c;
135 if (fp->_IO_write_ptr > fp->_IO_read_end)
136 fp->_IO_read_end = fp->_IO_write_ptr;
137 return c;
138}
139libc_hidden_def (_IO_str_overflow)
140
141int
142_IO_str_underflow (_IO_FILE *fp)
143{
144 if (fp->_IO_write_ptr > fp->_IO_read_end)
145 fp->_IO_read_end = fp->_IO_write_ptr;
146 if ((fp->_flags & _IO_TIED_PUT_GET) && (fp->_flags & _IO_CURRENTLY_PUTTING))
147 {
148 fp->_flags &= ~_IO_CURRENTLY_PUTTING;
149 fp->_IO_read_ptr = fp->_IO_write_ptr;
150 fp->_IO_write_ptr = fp->_IO_write_end;
151 }
152 if (fp->_IO_read_ptr < fp->_IO_read_end)
153 return *((unsigned char *) fp->_IO_read_ptr);
154 else
155 return EOF;
156}
157libc_hidden_def (_IO_str_underflow)
158
159/* The size of the valid part of the buffer. */
160
161_IO_ssize_t
162_IO_str_count (_IO_FILE *fp)
163{
164 return ((fp->_IO_write_ptr > fp->_IO_read_end
165 ? fp->_IO_write_ptr : fp->_IO_read_end)
166 - fp->_IO_read_base);
167}
168
169
170static int
171enlarge_userbuf (_IO_FILE *fp, _IO_off64_t offset, int reading)
172{
173 if ((_IO_ssize_t) offset <= _IO_blen (fp))
174 return 0;
175
176 _IO_ssize_t oldend = fp->_IO_write_end - fp->_IO_write_base;
177
178 /* Try to enlarge the buffer. */
179 if (fp->_flags & _IO_USER_BUF)
180 /* User-provided buffer. */
181 return 1;
182
183 _IO_size_t newsize = offset + 100;
184 char *oldbuf = fp->_IO_buf_base;
185 char *newbuf
186 = (char *) (*((_IO_strfile *) fp)->_s._allocate_buffer) (newsize);
187 if (newbuf == NULL)
188 return 1;
189
190 if (oldbuf != NULL)
191 {
192 memcpy (newbuf, oldbuf, _IO_blen (fp));
193 (*((_IO_strfile *) fp)->_s._free_buffer) (oldbuf);
194 /* Make sure _IO_setb won't try to delete
195 _IO_buf_base. */
196 fp->_IO_buf_base = NULL;
197 }
198
199 _IO_setb (fp, newbuf, newbuf + newsize, 1);
200
201 if (reading)
202 {
203 fp->_IO_write_base = newbuf + (fp->_IO_write_base - oldbuf);
204 fp->_IO_write_ptr = newbuf + (fp->_IO_write_ptr - oldbuf);
205 fp->_IO_write_end = newbuf + (fp->_IO_write_end - oldbuf);
206 fp->_IO_read_ptr = newbuf + (fp->_IO_read_ptr - oldbuf);
207
208 fp->_IO_read_base = newbuf;
209 fp->_IO_read_end = fp->_IO_buf_end;
210 }
211 else
212 {
213 fp->_IO_read_base = newbuf + (fp->_IO_read_base - oldbuf);
214 fp->_IO_read_ptr = newbuf + (fp->_IO_read_ptr - oldbuf);
215 fp->_IO_read_end = newbuf + (fp->_IO_read_end - oldbuf);
216 fp->_IO_write_ptr = newbuf + (fp->_IO_write_ptr - oldbuf);
217
218 fp->_IO_write_base = newbuf;
219 fp->_IO_write_end = fp->_IO_buf_end;
220 }
221
222 /* Clear the area between the last write position and th
223 new position. */
224 assert (offset >= oldend);
225 if (reading)
226 memset (fp->_IO_read_base + oldend, '\0', offset - oldend);
227 else
228 memset (fp->_IO_write_base + oldend, '\0', offset - oldend);
229
230 return 0;
231}
232
233
234_IO_off64_t
235_IO_str_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
236{
237 _IO_off64_t new_pos;
238
239 if (mode == 0 && (fp->_flags & _IO_TIED_PUT_GET))
240 mode = (fp->_flags & _IO_CURRENTLY_PUTTING ? _IOS_OUTPUT : _IOS_INPUT);
241
242 if (mode == 0)
243 {
244 /* Don't move any pointers. But there is no clear indication what
245 mode FP is in. Let's guess. */
246 if (fp->_IO_file_flags & _IO_NO_WRITES)
247 new_pos = fp->_IO_read_ptr - fp->_IO_read_base;
248 else
249 new_pos = fp->_IO_write_ptr - fp->_IO_write_base;
250 }
251 else
252 {
253 _IO_ssize_t cur_size = _IO_str_count(fp);
254 new_pos = EOF;
255
256 /* Move the get pointer, if requested. */
257 if (mode & _IOS_INPUT)
258 {
259 switch (dir)
260 {
261 case _IO_seek_end:
262 offset += cur_size;
263 break;
264 case _IO_seek_cur:
265 offset += fp->_IO_read_ptr - fp->_IO_read_base;
266 break;
267 default: /* case _IO_seek_set: */
268 break;
269 }
270 if (offset < 0)
271 return EOF;
272 if ((_IO_ssize_t) offset > cur_size
273 && enlarge_userbuf (fp, offset, 1) != 0)
274 return EOF;
275 fp->_IO_read_ptr = fp->_IO_read_base + offset;
276 fp->_IO_read_end = fp->_IO_read_base + cur_size;
277 new_pos = offset;
278 }
279
280 /* Move the put pointer, if requested. */
281 if (mode & _IOS_OUTPUT)
282 {
283 switch (dir)
284 {
285 case _IO_seek_end:
286 offset += cur_size;
287 break;
288 case _IO_seek_cur:
289 offset += fp->_IO_write_ptr - fp->_IO_write_base;
290 break;
291 default: /* case _IO_seek_set: */
292 break;
293 }
294 if (offset < 0)
295 return EOF;
296 if ((_IO_ssize_t) offset > cur_size
297 && enlarge_userbuf (fp, offset, 0) != 0)
298 return EOF;
299 fp->_IO_write_ptr = fp->_IO_write_base + offset;
300 new_pos = offset;
301 }
302 }
303 return new_pos;
304}
305libc_hidden_def (_IO_str_seekoff)
306
307int
308_IO_str_pbackfail (_IO_FILE *fp, int c)
309{
310 if ((fp->_flags & _IO_NO_WRITES) && c != EOF)
311 return EOF;
312 return _IO_default_pbackfail (fp, c);
313}
314libc_hidden_def (_IO_str_pbackfail)
315
316void
317_IO_str_finish (_IO_FILE *fp, int dummy)
318{
319 if (fp->_IO_buf_base && !(fp->_flags & _IO_USER_BUF))
320 (((_IO_strfile *) fp)->_s._free_buffer) (fp->_IO_buf_base);
321 fp->_IO_buf_base = NULL;
322
323 _IO_default_finish (fp, 0);
324}
325
326const struct _IO_jump_t _IO_str_jumps =
327{
328 JUMP_INIT_DUMMY,
329 JUMP_INIT(finish, _IO_str_finish),
330 JUMP_INIT(overflow, _IO_str_overflow),
331 JUMP_INIT(underflow, _IO_str_underflow),
332 JUMP_INIT(uflow, _IO_default_uflow),
333 JUMP_INIT(pbackfail, _IO_str_pbackfail),
334 JUMP_INIT(xsputn, _IO_default_xsputn),
335 JUMP_INIT(xsgetn, _IO_default_xsgetn),
336 JUMP_INIT(seekoff, _IO_str_seekoff),
337 JUMP_INIT(seekpos, _IO_default_seekpos),
338 JUMP_INIT(setbuf, _IO_default_setbuf),
339 JUMP_INIT(sync, _IO_default_sync),
340 JUMP_INIT(doallocate, _IO_default_doallocate),
341 JUMP_INIT(read, _IO_default_read),
342 JUMP_INIT(write, _IO_default_write),
343 JUMP_INIT(seek, _IO_default_seek),
344 JUMP_INIT(close, _IO_default_close),
345 JUMP_INIT(stat, _IO_default_stat),
346 JUMP_INIT(showmanyc, _IO_default_showmanyc),
347 JUMP_INIT(imbue, _IO_default_imbue)
348};
349