1 | /* fmemopen implementation. |
2 | Copyright (C) 2015-2016 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 | <http://www.gnu.org/licenses/>. */ |
18 | |
19 | /* fmemopen() from 2.22 and forward works as defined by POSIX. It also |
20 | provides an older symbol, version 2.2.5, that behaves different regarding |
21 | SEEK_END (libio/oldfmemopen.c). */ |
22 | |
23 | |
24 | #include <errno.h> |
25 | #include <libio.h> |
26 | #include <stdio.h> |
27 | #include <stdlib.h> |
28 | #include <stdint.h> |
29 | #include <string.h> |
30 | #include <sys/types.h> |
31 | #include "libioP.h" |
32 | |
33 | |
34 | typedef struct fmemopen_cookie_struct fmemopen_cookie_t; |
35 | struct fmemopen_cookie_struct |
36 | { |
37 | char *buffer; /* memory buffer. */ |
38 | int mybuffer; /* allocated my buffer? */ |
39 | int append; /* buffer open for append? */ |
40 | size_t size; /* buffer length in bytes. */ |
41 | _IO_off64_t pos; /* current position at the buffer. */ |
42 | size_t maxpos; /* max position in buffer. */ |
43 | }; |
44 | |
45 | |
46 | static ssize_t |
47 | fmemopen_read (void *cookie, char *b, size_t s) |
48 | { |
49 | fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie; |
50 | |
51 | if (c->pos + s > c->maxpos) |
52 | { |
53 | s = c->maxpos - c->pos; |
54 | if ((size_t) c->pos > c->maxpos) |
55 | s = 0; |
56 | } |
57 | |
58 | memcpy (b, &(c->buffer[c->pos]), s); |
59 | |
60 | c->pos += s; |
61 | |
62 | return s; |
63 | } |
64 | |
65 | |
66 | static ssize_t |
67 | fmemopen_write (void *cookie, const char *b, size_t s) |
68 | { |
69 | fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie;; |
70 | _IO_off64_t pos = c->append ? c->maxpos : c->pos; |
71 | int addnullc = (s == 0 || b[s - 1] != '\0'); |
72 | |
73 | if (pos + s > c->size) |
74 | { |
75 | if ((size_t) (c->pos + addnullc) >= c->size) |
76 | { |
77 | __set_errno (ENOSPC); |
78 | return 0; |
79 | } |
80 | s = c->size - pos; |
81 | } |
82 | |
83 | memcpy (&(c->buffer[pos]), b, s); |
84 | |
85 | c->pos = pos + s; |
86 | if ((size_t) c->pos > c->maxpos) |
87 | { |
88 | c->maxpos = c->pos; |
89 | if (c->maxpos < c->size && addnullc) |
90 | c->buffer[c->maxpos] = '\0'; |
91 | /* A null byte is written in a stream open for update iff it fits. */ |
92 | else if (c->append == 0 && addnullc != 0) |
93 | c->buffer[c->size-1] = '\0'; |
94 | } |
95 | |
96 | return s; |
97 | } |
98 | |
99 | |
100 | static int |
101 | fmemopen_seek (void *cookie, _IO_off64_t *p, int w) |
102 | { |
103 | _IO_off64_t np; |
104 | fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie; |
105 | |
106 | switch (w) |
107 | { |
108 | case SEEK_SET: |
109 | np = *p; |
110 | break; |
111 | |
112 | case SEEK_CUR: |
113 | np = c->pos + *p; |
114 | break; |
115 | |
116 | case SEEK_END: |
117 | np = c->maxpos + *p; |
118 | break; |
119 | |
120 | default: |
121 | return -1; |
122 | } |
123 | |
124 | if (np < 0 || (size_t) np > c->size) |
125 | { |
126 | __set_errno (EINVAL); |
127 | return -1; |
128 | } |
129 | |
130 | *p = c->pos = np; |
131 | |
132 | return 0; |
133 | } |
134 | |
135 | |
136 | static int |
137 | fmemopen_close (void *cookie) |
138 | { |
139 | fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie; |
140 | |
141 | if (c->mybuffer) |
142 | free (c->buffer); |
143 | free (c); |
144 | |
145 | return 0; |
146 | } |
147 | |
148 | |
149 | FILE * |
150 | __fmemopen (void *buf, size_t len, const char *mode) |
151 | { |
152 | cookie_io_functions_t iof; |
153 | fmemopen_cookie_t *c; |
154 | FILE *result; |
155 | |
156 | c = (fmemopen_cookie_t *) calloc (sizeof (fmemopen_cookie_t), 1); |
157 | if (c == NULL) |
158 | return NULL; |
159 | |
160 | c->mybuffer = (buf == NULL); |
161 | |
162 | if (c->mybuffer) |
163 | { |
164 | c->buffer = (char *) malloc (len); |
165 | if (c->buffer == NULL) |
166 | { |
167 | free (c); |
168 | return NULL; |
169 | } |
170 | c->buffer[0] = '\0'; |
171 | } |
172 | else |
173 | { |
174 | if (__glibc_unlikely ((uintptr_t) len > -(uintptr_t) buf)) |
175 | { |
176 | free (c); |
177 | __set_errno (EINVAL); |
178 | return NULL; |
179 | } |
180 | |
181 | c->buffer = buf; |
182 | |
183 | /* POSIX states that w+ mode should truncate the buffer. */ |
184 | if (mode[0] == 'w' && mode[1] == '+') |
185 | c->buffer[0] = '\0'; |
186 | |
187 | if (mode[0] == 'a') |
188 | c->maxpos = strnlen (c->buffer, len); |
189 | } |
190 | |
191 | |
192 | /* Mode | starting position (cookie::pos) | size (cookie::size) |
193 | ------ |----------------------------------|----------------------------- |
194 | read | beginning of the buffer | size argument |
195 | write | beginning of the buffer | zero |
196 | append | first null or size buffer + 1 | first null or size argument |
197 | */ |
198 | |
199 | c->size = len; |
200 | |
201 | if (mode[0] == 'r') |
202 | c->maxpos = len; |
203 | |
204 | c->append = mode[0] == 'a'; |
205 | if (c->append) |
206 | c->pos = c->maxpos; |
207 | else |
208 | c->pos = 0; |
209 | |
210 | iof.read = fmemopen_read; |
211 | iof.write = fmemopen_write; |
212 | iof.seek = fmemopen_seek; |
213 | iof.close = fmemopen_close; |
214 | |
215 | result = _IO_fopencookie (c, mode, iof); |
216 | if (__glibc_unlikely (result == NULL)) |
217 | { |
218 | if (c->mybuffer) |
219 | free (c->buffer); |
220 | |
221 | free (c); |
222 | } |
223 | |
224 | return result; |
225 | } |
226 | libc_hidden_def (__fmemopen) |
227 | versioned_symbol (libc, __fmemopen, fmemopen, GLIBC_2_22); |
228 | |