]>
Commit | Line | Data |
---|---|---|
d614a753 | 1 | /* Copyright (C) 1993-2020 Free Software Foundation, Inc. |
41bdb6e2 | 2 | This file is part of the GNU C Library. |
40a55d20 | 3 | |
41bdb6e2 AJ |
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. | |
40a55d20 | 8 | |
41bdb6e2 AJ |
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 | |
40a55d20 | 11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
41bdb6e2 | 12 | Lesser General Public License for more details. |
40a55d20 | 13 | |
41bdb6e2 | 14 | You should have received a copy of the GNU Lesser General Public |
59ba27a6 | 15 | License along with the GNU C Library; if not, see |
5a82c748 | 16 | <https://www.gnu.org/licenses/>. |
40a55d20 | 17 | |
41bdb6e2 AJ |
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. */ | |
96aa2d94 RM |
26 | |
27 | #include <libioP.h> | |
fa0bc87c | 28 | #include <stdio.h> |
96aa2d94 | 29 | #include <stdlib.h> |
5d1fba6d | 30 | #include <shlib-compat.h> |
fa0bc87c | 31 | |
9964a145 ZW |
32 | static ssize_t |
33 | _IO_cookie_read (FILE *fp, void *buf, ssize_t size) | |
96aa2d94 RM |
34 | { |
35 | struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp; | |
983fd5c4 | 36 | cookie_read_function_t *read_cb = cfile->__io_functions.read; |
92777f34 | 37 | #ifdef PTR_DEMANGLE |
983fd5c4 | 38 | PTR_DEMANGLE (read_cb); |
92777f34 | 39 | #endif |
96aa2d94 | 40 | |
983fd5c4 | 41 | if (read_cb == NULL) |
96aa2d94 RM |
42 | return -1; |
43 | ||
983fd5c4 | 44 | return read_cb (cfile->__cookie, buf, size); |
96aa2d94 RM |
45 | } |
46 | ||
9964a145 ZW |
47 | static ssize_t |
48 | _IO_cookie_write (FILE *fp, const void *buf, ssize_t size) | |
96aa2d94 RM |
49 | { |
50 | struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp; | |
983fd5c4 | 51 | cookie_write_function_t *write_cb = cfile->__io_functions.write; |
92777f34 | 52 | #ifdef PTR_DEMANGLE |
983fd5c4 | 53 | PTR_DEMANGLE (write_cb); |
92777f34 | 54 | #endif |
96aa2d94 | 55 | |
983fd5c4 | 56 | if (write_cb == NULL) |
32053042 UD |
57 | { |
58 | fp->_flags |= _IO_ERR_SEEN; | |
59 | return 0; | |
60 | } | |
61 | ||
9964a145 | 62 | ssize_t n = write_cb (cfile->__cookie, buf, size); |
32053042 UD |
63 | if (n < size) |
64 | fp->_flags |= _IO_ERR_SEEN; | |
96aa2d94 | 65 | |
32053042 | 66 | return n; |
96aa2d94 RM |
67 | } |
68 | ||
9964a145 ZW |
69 | static off64_t |
70 | _IO_cookie_seek (FILE *fp, off64_t offset, int dir) | |
96aa2d94 RM |
71 | { |
72 | struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp; | |
983fd5c4 | 73 | cookie_seek_function_t *seek_cb = cfile->__io_functions.seek; |
92777f34 | 74 | #ifdef PTR_DEMANGLE |
983fd5c4 | 75 | PTR_DEMANGLE (seek_cb); |
92777f34 | 76 | #endif |
96aa2d94 | 77 | |
983fd5c4 FW |
78 | return ((seek_cb == NULL |
79 | || (seek_cb (cfile->__cookie, &offset, dir) | |
de153e7f | 80 | == -1) |
9964a145 | 81 | || offset == (off64_t) -1) |
b4e54243 | 82 | ? _IO_pos_BAD : offset); |
96aa2d94 RM |
83 | } |
84 | ||
85 | static int | |
9964a145 | 86 | _IO_cookie_close (FILE *fp) |
96aa2d94 RM |
87 | { |
88 | struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp; | |
983fd5c4 | 89 | cookie_close_function_t *close_cb = cfile->__io_functions.close; |
92777f34 | 90 | #ifdef PTR_DEMANGLE |
983fd5c4 | 91 | PTR_DEMANGLE (close_cb); |
92777f34 | 92 | #endif |
96aa2d94 | 93 | |
983fd5c4 | 94 | if (close_cb == NULL) |
96aa2d94 RM |
95 | return 0; |
96 | ||
983fd5c4 | 97 | return close_cb (cfile->__cookie); |
96aa2d94 RM |
98 | } |
99 | ||
100 | ||
9964a145 ZW |
101 | static off64_t |
102 | _IO_cookie_seekoff (FILE *fp, off64_t offset, int dir, int mode) | |
1e7cceb9 UD |
103 | { |
104 | /* We must force the fileops code to always use seek to determine | |
105 | the position. */ | |
106 | fp->_offset = _IO_pos_BAD; | |
d18ea0c5 | 107 | return _IO_file_seekoff (fp, offset, dir, mode); |
1e7cceb9 UD |
108 | } |
109 | ||
110 | ||
db3476af | 111 | static const struct _IO_jump_t _IO_cookie_jumps libio_vtable = { |
96aa2d94 | 112 | JUMP_INIT_DUMMY, |
d18ea0c5 AS |
113 | JUMP_INIT(finish, _IO_file_finish), |
114 | JUMP_INIT(overflow, _IO_file_overflow), | |
115 | JUMP_INIT(underflow, _IO_file_underflow), | |
116 | JUMP_INIT(uflow, _IO_default_uflow), | |
117 | JUMP_INIT(pbackfail, _IO_default_pbackfail), | |
118 | JUMP_INIT(xsputn, _IO_file_xsputn), | |
119 | JUMP_INIT(xsgetn, _IO_default_xsgetn), | |
1e7cceb9 | 120 | JUMP_INIT(seekoff, _IO_cookie_seekoff), |
96aa2d94 | 121 | JUMP_INIT(seekpos, _IO_default_seekpos), |
d18ea0c5 AS |
122 | JUMP_INIT(setbuf, _IO_file_setbuf), |
123 | JUMP_INIT(sync, _IO_file_sync), | |
124 | JUMP_INIT(doallocate, _IO_file_doallocate), | |
96aa2d94 RM |
125 | JUMP_INIT(read, _IO_cookie_read), |
126 | JUMP_INIT(write, _IO_cookie_write), | |
127 | JUMP_INIT(seek, _IO_cookie_seek), | |
128 | JUMP_INIT(close, _IO_cookie_close), | |
dfd2257a UD |
129 | JUMP_INIT(stat, _IO_default_stat), |
130 | JUMP_INIT(showmanyc, _IO_default_showmanyc), | |
131 | JUMP_INIT(imbue, _IO_default_imbue), | |
96aa2d94 RM |
132 | }; |
133 | ||
134 | ||
983fd5c4 FW |
135 | /* Copy the callbacks from SOURCE to *TARGET, with pointer |
136 | mangling. */ | |
137 | static void | |
9964a145 ZW |
138 | set_callbacks (cookie_io_functions_t *target, |
139 | cookie_io_functions_t source) | |
983fd5c4 | 140 | { |
92777f34 | 141 | #ifdef PTR_MANGLE |
983fd5c4 FW |
142 | PTR_MANGLE (source.read); |
143 | PTR_MANGLE (source.write); | |
144 | PTR_MANGLE (source.seek); | |
145 | PTR_MANGLE (source.close); | |
92777f34 | 146 | #endif |
983fd5c4 FW |
147 | *target = source; |
148 | } | |
149 | ||
b4e54243 RM |
150 | void |
151 | _IO_cookie_init (struct _IO_cookie_file *cfile, int read_write, | |
9964a145 | 152 | void *cookie, cookie_io_functions_t io_functions) |
b4e54243 | 153 | { |
db3476af | 154 | _IO_init_internal (&cfile->__fp.file, 0); |
2ca8b1ee | 155 | _IO_JUMPS (&cfile->__fp) = &_IO_cookie_jumps; |
b4e54243 RM |
156 | |
157 | cfile->__cookie = cookie; | |
983fd5c4 | 158 | set_callbacks (&cfile->__io_functions, io_functions); |
b4e54243 | 159 | |
db3476af | 160 | _IO_new_file_init_internal (&cfile->__fp); |
b4e54243 | 161 | |
817328ee AS |
162 | _IO_mask_flags (&cfile->__fp.file, read_write, |
163 | _IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING); | |
b4e54243 | 164 | |
d2e04918 SN |
165 | cfile->__fp.file._flags2 |= _IO_FLAGS2_NEED_LOCK; |
166 | ||
b4e54243 RM |
167 | /* We use a negative number different from -1 for _fileno to mark that |
168 | this special stream is not associated with a real file, but still has | |
169 | to be treated as such. */ | |
2ca8b1ee | 170 | cfile->__fp.file._fileno = -2; |
b4e54243 RM |
171 | } |
172 | ||
173 | ||
9964a145 | 174 | FILE * |
f63f2bfd | 175 | _IO_fopencookie (void *cookie, const char *mode, |
9964a145 | 176 | cookie_io_functions_t io_functions) |
96aa2d94 RM |
177 | { |
178 | int read_write; | |
edf5b2d7 UD |
179 | struct locked_FILE |
180 | { | |
181 | struct _IO_cookie_file cfile; | |
499e7464 | 182 | #ifdef _IO_MTSAFE_IO |
edf5b2d7 | 183 | _IO_lock_t lock; |
499e7464 | 184 | #endif |
edf5b2d7 | 185 | } *new_f; |
96aa2d94 RM |
186 | |
187 | switch (*mode++) | |
188 | { | |
189 | case 'r': | |
190 | read_write = _IO_NO_WRITES; | |
191 | break; | |
192 | case 'w': | |
193 | read_write = _IO_NO_READS; | |
194 | break; | |
195 | case 'a': | |
196 | read_write = _IO_NO_READS|_IO_IS_APPENDING; | |
197 | break; | |
198 | default: | |
2d8e36e6 | 199 | __set_errno (EINVAL); |
96aa2d94 RM |
200 | return NULL; |
201 | } | |
202 | if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+')) | |
203 | read_write &= _IO_IS_APPENDING; | |
204 | ||
edf5b2d7 UD |
205 | new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE)); |
206 | if (new_f == NULL) | |
96aa2d94 | 207 | return NULL; |
499e7464 | 208 | #ifdef _IO_MTSAFE_IO |
2ca8b1ee | 209 | new_f->cfile.__fp.file._lock = &new_f->lock; |
499e7464 | 210 | #endif |
96aa2d94 | 211 | |
b4e54243 | 212 | _IO_cookie_init (&new_f->cfile, read_write, cookie, io_functions); |
110215a9 | 213 | |
9964a145 | 214 | return (FILE *) &new_f->cfile.__fp; |
96aa2d94 | 215 | } |
5d1fba6d AJ |
216 | |
217 | versioned_symbol (libc, _IO_fopencookie, fopencookie, GLIBC_2_2); | |
218 | ||
219 | #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2) | |
220 | ||
9964a145 | 221 | static off64_t |
4a381a81 | 222 | attribute_compat_text_section |
9964a145 | 223 | _IO_old_cookie_seek (FILE *fp, off64_t offset, int dir) |
5d1fba6d AJ |
224 | { |
225 | struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp; | |
9964a145 ZW |
226 | int (*seek_cb) (FILE *, off_t, int) |
227 | = (int (*) (FILE *, off_t, int)) cfile->__io_functions.seek; | |
92777f34 | 228 | #ifdef PTR_DEMANGLE |
983fd5c4 | 229 | PTR_DEMANGLE (seek_cb); |
92777f34 | 230 | #endif |
5d1fba6d | 231 | |
983fd5c4 | 232 | if (seek_cb == NULL) |
5d1fba6d AJ |
233 | return _IO_pos_BAD; |
234 | ||
983fd5c4 | 235 | int ret = seek_cb (cfile->__cookie, offset, dir); |
5d1fba6d AJ |
236 | |
237 | return (ret == -1) ? _IO_pos_BAD : ret; | |
238 | } | |
239 | ||
db3476af | 240 | static const struct _IO_jump_t _IO_old_cookie_jumps libio_vtable = { |
5d1fba6d | 241 | JUMP_INIT_DUMMY, |
d18ea0c5 AS |
242 | JUMP_INIT(finish, _IO_file_finish), |
243 | JUMP_INIT(overflow, _IO_file_overflow), | |
244 | JUMP_INIT(underflow, _IO_file_underflow), | |
245 | JUMP_INIT(uflow, _IO_default_uflow), | |
246 | JUMP_INIT(pbackfail, _IO_default_pbackfail), | |
247 | JUMP_INIT(xsputn, _IO_file_xsputn), | |
248 | JUMP_INIT(xsgetn, _IO_default_xsgetn), | |
1e7cceb9 | 249 | JUMP_INIT(seekoff, _IO_cookie_seekoff), |
5d1fba6d | 250 | JUMP_INIT(seekpos, _IO_default_seekpos), |
d18ea0c5 AS |
251 | JUMP_INIT(setbuf, _IO_file_setbuf), |
252 | JUMP_INIT(sync, _IO_file_sync), | |
253 | JUMP_INIT(doallocate, _IO_file_doallocate), | |
5d1fba6d AJ |
254 | JUMP_INIT(read, _IO_cookie_read), |
255 | JUMP_INIT(write, _IO_cookie_write), | |
256 | JUMP_INIT(seek, _IO_old_cookie_seek), | |
257 | JUMP_INIT(close, _IO_cookie_close), | |
258 | JUMP_INIT(stat, _IO_default_stat), | |
259 | JUMP_INIT(showmanyc, _IO_default_showmanyc), | |
260 | JUMP_INIT(imbue, _IO_default_imbue), | |
261 | }; | |
262 | ||
9964a145 | 263 | FILE * |
4a381a81 | 264 | attribute_compat_text_section |
f63f2bfd | 265 | _IO_old_fopencookie (void *cookie, const char *mode, |
9964a145 | 266 | cookie_io_functions_t io_functions) |
5d1fba6d | 267 | { |
9964a145 | 268 | FILE *ret; |
5d1fba6d AJ |
269 | |
270 | ret = _IO_fopencookie (cookie, mode, io_functions); | |
271 | if (ret != NULL) | |
e69dcccb | 272 | _IO_JUMPS_FILE_plus (ret) = &_IO_old_cookie_jumps; |
5d1fba6d AJ |
273 | |
274 | return ret; | |
275 | } | |
276 | ||
277 | compat_symbol (libc, _IO_old_fopencookie, fopencookie, GLIBC_2_0); | |
278 | ||
279 | #endif |