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 <libioP.h>
28#include <stdio.h>
29#include <stdlib.h>
30#include <shlib-compat.h>
31
32/* Prototyped for local functions. */
33static _IO_ssize_t _IO_cookie_read (_IO_FILE* fp, void* buf,
34 _IO_ssize_t size);
35static _IO_ssize_t _IO_cookie_write (_IO_FILE* fp,
36 const void* buf, _IO_ssize_t size);
37static _IO_off64_t _IO_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir);
38static _IO_off64_t _IO_cookie_seekoff (_IO_FILE *fp, _IO_off64_t offset,
39 int dir, int mode);
40static int _IO_cookie_close (_IO_FILE* fp);
41
42static _IO_ssize_t
43_IO_cookie_read (_IO_FILE *fp, void *buf, _IO_ssize_t size)
44{
45 struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
46
47 if (cfile->__io_functions.read == NULL)
48 return -1;
49
50 return cfile->__io_functions.read (cfile->__cookie, buf, size);
51}
52
53static _IO_ssize_t
54_IO_cookie_write (_IO_FILE *fp, const void *buf, _IO_ssize_t size)
55{
56 struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
57
58 if (cfile->__io_functions.write == NULL)
59 {
60 fp->_flags |= _IO_ERR_SEEN;
61 return 0;
62 }
63
64 _IO_ssize_t n = cfile->__io_functions.write (cfile->__cookie, buf, size);
65 if (n < size)
66 fp->_flags |= _IO_ERR_SEEN;
67
68 return n;
69}
70
71static _IO_off64_t
72_IO_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
73{
74 struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
75
76 return ((cfile->__io_functions.seek == NULL
77 || (cfile->__io_functions.seek (cfile->__cookie, &offset, dir)
78 == -1)
79 || offset == (_IO_off64_t) -1)
80 ? _IO_pos_BAD : offset);
81}
82
83static int
84_IO_cookie_close (_IO_FILE *fp)
85{
86 struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
87
88 if (cfile->__io_functions.close == NULL)
89 return 0;
90
91 return cfile->__io_functions.close (cfile->__cookie);
92}
93
94
95static _IO_off64_t
96_IO_cookie_seekoff (_IO_FILE *fp, _IO_off64_t offset, int dir, int mode)
97{
98 /* We must force the fileops code to always use seek to determine
99 the position. */
100 fp->_offset = _IO_pos_BAD;
101 return _IO_file_seekoff (fp, offset, dir, mode);
102}
103
104
105static const struct _IO_jump_t _IO_cookie_jumps = {
106 JUMP_INIT_DUMMY,
107 JUMP_INIT(finish, _IO_file_finish),
108 JUMP_INIT(overflow, _IO_file_overflow),
109 JUMP_INIT(underflow, _IO_file_underflow),
110 JUMP_INIT(uflow, _IO_default_uflow),
111 JUMP_INIT(pbackfail, _IO_default_pbackfail),
112 JUMP_INIT(xsputn, _IO_file_xsputn),
113 JUMP_INIT(xsgetn, _IO_default_xsgetn),
114 JUMP_INIT(seekoff, _IO_cookie_seekoff),
115 JUMP_INIT(seekpos, _IO_default_seekpos),
116 JUMP_INIT(setbuf, _IO_file_setbuf),
117 JUMP_INIT(sync, _IO_file_sync),
118 JUMP_INIT(doallocate, _IO_file_doallocate),
119 JUMP_INIT(read, _IO_cookie_read),
120 JUMP_INIT(write, _IO_cookie_write),
121 JUMP_INIT(seek, _IO_cookie_seek),
122 JUMP_INIT(close, _IO_cookie_close),
123 JUMP_INIT(stat, _IO_default_stat),
124 JUMP_INIT(showmanyc, _IO_default_showmanyc),
125 JUMP_INIT(imbue, _IO_default_imbue),
126};
127
128
129void
130_IO_cookie_init (struct _IO_cookie_file *cfile, int read_write,
131 void *cookie, _IO_cookie_io_functions_t io_functions)
132{
133 _IO_init (&cfile->__fp.file, 0);
134 _IO_JUMPS (&cfile->__fp) = &_IO_cookie_jumps;
135
136 cfile->__cookie = cookie;
137 cfile->__io_functions = io_functions;
138
139 _IO_file_init (&cfile->__fp);
140
141 _IO_mask_flags (&cfile->__fp.file, read_write,
142 _IO_NO_READS+_IO_NO_WRITES+_IO_IS_APPENDING);
143
144 /* We use a negative number different from -1 for _fileno to mark that
145 this special stream is not associated with a real file, but still has
146 to be treated as such. */
147 cfile->__fp.file._fileno = -2;
148}
149
150
151_IO_FILE *
152_IO_fopencookie (void *cookie, const char *mode,
153 _IO_cookie_io_functions_t io_functions)
154{
155 int read_write;
156 struct locked_FILE
157 {
158 struct _IO_cookie_file cfile;
159#ifdef _IO_MTSAFE_IO
160 _IO_lock_t lock;
161#endif
162 } *new_f;
163
164 switch (*mode++)
165 {
166 case 'r':
167 read_write = _IO_NO_WRITES;
168 break;
169 case 'w':
170 read_write = _IO_NO_READS;
171 break;
172 case 'a':
173 read_write = _IO_NO_READS|_IO_IS_APPENDING;
174 break;
175 default:
176 __set_errno (EINVAL);
177 return NULL;
178 }
179 if (mode[0] == '+' || (mode[0] == 'b' && mode[1] == '+'))
180 read_write &= _IO_IS_APPENDING;
181
182 new_f = (struct locked_FILE *) malloc (sizeof (struct locked_FILE));
183 if (new_f == NULL)
184 return NULL;
185#ifdef _IO_MTSAFE_IO
186 new_f->cfile.__fp.file._lock = &new_f->lock;
187#endif
188
189 _IO_cookie_init (&new_f->cfile, read_write, cookie, io_functions);
190
191 return (_IO_FILE *) &new_f->cfile.__fp;
192}
193
194versioned_symbol (libc, _IO_fopencookie, fopencookie, GLIBC_2_2);
195
196#if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_2)
197
198static _IO_off64_t _IO_old_cookie_seek (_IO_FILE *fp, _IO_off64_t offset,
199 int dir);
200_IO_FILE * _IO_old_fopencookie (void *cookie, const char *mode,
201 _IO_cookie_io_functions_t io_functions);
202
203static _IO_off64_t
204attribute_compat_text_section
205_IO_old_cookie_seek (_IO_FILE *fp, _IO_off64_t offset, int dir)
206{
207 struct _IO_cookie_file *cfile = (struct _IO_cookie_file *) fp;
208 int (*seek) (_IO_FILE *, _IO_off_t, int);
209 int ret;
210
211 seek = (int (*)(_IO_FILE *, _IO_off_t, int)) cfile->__io_functions.seek;
212 if (seek == NULL)
213 return _IO_pos_BAD;
214
215 ret = seek (cfile->__cookie, offset, dir);
216
217 return (ret == -1) ? _IO_pos_BAD : ret;
218}
219
220static const struct _IO_jump_t _IO_old_cookie_jumps = {
221 JUMP_INIT_DUMMY,
222 JUMP_INIT(finish, _IO_file_finish),
223 JUMP_INIT(overflow, _IO_file_overflow),
224 JUMP_INIT(underflow, _IO_file_underflow),
225 JUMP_INIT(uflow, _IO_default_uflow),
226 JUMP_INIT(pbackfail, _IO_default_pbackfail),
227 JUMP_INIT(xsputn, _IO_file_xsputn),
228 JUMP_INIT(xsgetn, _IO_default_xsgetn),
229 JUMP_INIT(seekoff, _IO_cookie_seekoff),
230 JUMP_INIT(seekpos, _IO_default_seekpos),
231 JUMP_INIT(setbuf, _IO_file_setbuf),
232 JUMP_INIT(sync, _IO_file_sync),
233 JUMP_INIT(doallocate, _IO_file_doallocate),
234 JUMP_INIT(read, _IO_cookie_read),
235 JUMP_INIT(write, _IO_cookie_write),
236 JUMP_INIT(seek, _IO_old_cookie_seek),
237 JUMP_INIT(close, _IO_cookie_close),
238 JUMP_INIT(stat, _IO_default_stat),
239 JUMP_INIT(showmanyc, _IO_default_showmanyc),
240 JUMP_INIT(imbue, _IO_default_imbue),
241};
242
243_IO_FILE *
244attribute_compat_text_section
245_IO_old_fopencookie (void *cookie, const char *mode,
246 _IO_cookie_io_functions_t io_functions)
247{
248 _IO_FILE *ret;
249
250 ret = _IO_fopencookie (cookie, mode, io_functions);
251 if (ret != NULL)
252 _IO_JUMPS_FILE_plus (ret) = &_IO_old_cookie_jumps;
253
254 return ret;
255}
256
257compat_symbol (libc, _IO_old_fopencookie, fopencookie, GLIBC_2_0);
258
259#endif
260