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
34typedef struct fmemopen_cookie_struct fmemopen_cookie_t;
35struct 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
46static ssize_t
47fmemopen_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 if ((size_t) c->pos == c->maxpos)
54 return 0;
55 s = c->size - c->pos;
56 }
57
58 memcpy (b, &(c->buffer[c->pos]), s);
59
60 c->pos += s;
61 if ((size_t) c->pos > c->maxpos)
62 c->maxpos = c->pos;
63
64 return s;
65}
66
67
68static ssize_t
69fmemopen_write (void *cookie, const char *b, size_t s)
70{
71 fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie;;
72 _IO_off64_t pos = c->append ? c->maxpos : c->pos;
73 int addnullc;
74
75 addnullc = (s == 0 || b[s - 1] != '\0');
76
77 if (pos + s + addnullc > c->size)
78 {
79 if ((size_t) (c->pos + addnullc) >= c->size)
80 {
81 __set_errno (ENOSPC);
82 return 0;
83 }
84 s = c->size - pos - addnullc;
85 }
86
87 memcpy (&(c->buffer[pos]), b, s);
88
89 pos += s;
90 if ((size_t) pos > c->maxpos)
91 {
92 c->maxpos = pos;
93 if (addnullc)
94 c->buffer[c->maxpos] = '\0';
95 }
96
97 return s;
98}
99
100
101static int
102fmemopen_seek (void *cookie, _IO_off64_t *p, int w)
103{
104 _IO_off64_t np;
105 fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie;
106
107 switch (w)
108 {
109 case SEEK_SET:
110 np = *p;
111 break;
112
113 case SEEK_CUR:
114 np = c->pos + *p;
115 break;
116
117 case SEEK_END:
118 np = c->maxpos + *p;
119 break;
120
121 default:
122 return -1;
123 }
124
125 if (np < 0 || (size_t) np > c->size)
126 return -1;
127
128 *p = c->pos = np;
129
130 return 0;
131}
132
133
134static int
135fmemopen_close (void *cookie)
136{
137 fmemopen_cookie_t *c = (fmemopen_cookie_t *) cookie;
138
139 if (c->mybuffer)
140 free (c->buffer);
141 free (c);
142
143 return 0;
144}
145
146
147FILE *
148__fmemopen (void *buf, size_t len, const char *mode)
149{
150 cookie_io_functions_t iof;
151 fmemopen_cookie_t *c;
152 FILE *result;
153
154 c = (fmemopen_cookie_t *) calloc (sizeof (fmemopen_cookie_t), 1);
155 if (c == NULL)
156 return NULL;
157
158 c->mybuffer = (buf == NULL);
159
160 if (c->mybuffer)
161 {
162 c->buffer = (char *) malloc (len);
163 if (c->buffer == NULL)
164 {
165 free (c);
166 return NULL;
167 }
168 c->buffer[0] = '\0';
169 }
170 else
171 {
172 if (__glibc_unlikely ((uintptr_t) len > -(uintptr_t) buf))
173 {
174 free (c);
175 __set_errno (EINVAL);
176 return NULL;
177 }
178
179 c->buffer = buf;
180
181 /* POSIX states that w+ mode should truncate the buffer. */
182 if (mode[0] == 'w' && mode[1] == '+')
183 c->buffer[0] = '\0';
184
185 if (mode[0] == 'a')
186 c->maxpos = strnlen (c->buffer, len);
187 }
188
189
190 /* Mode | starting position (cookie::pos) | size (cookie::size)
191 ------ |----------------------------------|-----------------------------
192 read | beginning of the buffer | size argument
193 write | beginning of the buffer | zero
194 append | first null or size buffer + 1 | first null or size argument
195 */
196
197 c->size = len;
198
199 if (mode[0] == 'r')
200 c->maxpos = len;
201
202 c->append = mode[0] == 'a';
203 if (c->append)
204 c->pos = c->maxpos;
205 else
206 c->pos = 0;
207
208 iof.read = fmemopen_read;
209 iof.write = fmemopen_write;
210 iof.seek = fmemopen_seek;
211 iof.close = fmemopen_close;
212
213 result = _IO_fopencookie (c, mode, iof);
214 if (__glibc_unlikely (result == NULL))
215 {
216 if (c->mybuffer)
217 free (c->buffer);
218
219 free (c);
220 }
221
222 return result;
223}
224libc_hidden_def (__fmemopen)
225versioned_symbol (libc, __fmemopen, fmemopen, GLIBC_2_22);
226