1/*
2 * Copyright 1995-2018 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10#include <stdio.h>
11#include <errno.h>
12#include "bio_local.h"
13#include "internal/cryptlib.h"
14#include <openssl/evp.h>
15
16static int linebuffer_write(BIO *h, const char *buf, int num);
17static int linebuffer_read(BIO *h, char *buf, int size);
18static int linebuffer_puts(BIO *h, const char *str);
19static int linebuffer_gets(BIO *h, char *str, int size);
20static long linebuffer_ctrl(BIO *h, int cmd, long arg1, void *arg2);
21static int linebuffer_new(BIO *h);
22static int linebuffer_free(BIO *data);
23static long linebuffer_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fp);
24
25/* A 10k maximum should be enough for most purposes */
26#define DEFAULT_LINEBUFFER_SIZE 1024*10
27
28/* #define DEBUG */
29
30static const BIO_METHOD methods_linebuffer = {
31 BIO_TYPE_LINEBUFFER,
32 "linebuffer",
33 /* TODO: Convert to new style write function */
34 bwrite_conv,
35 linebuffer_write,
36 /* TODO: Convert to new style read function */
37 bread_conv,
38 linebuffer_read,
39 linebuffer_puts,
40 linebuffer_gets,
41 linebuffer_ctrl,
42 linebuffer_new,
43 linebuffer_free,
44 linebuffer_callback_ctrl,
45};
46
47const BIO_METHOD *BIO_f_linebuffer(void)
48{
49 return &methods_linebuffer;
50}
51
52typedef struct bio_linebuffer_ctx_struct {
53 char *obuf; /* the output char array */
54 int obuf_size; /* how big is the output buffer */
55 int obuf_len; /* how many bytes are in it */
56} BIO_LINEBUFFER_CTX;
57
58static int linebuffer_new(BIO *bi)
59{
60 BIO_LINEBUFFER_CTX *ctx;
61
62 if ((ctx = OPENSSL_malloc(sizeof(*ctx))) == NULL) {
63 BIOerr(BIO_F_LINEBUFFER_NEW, ERR_R_MALLOC_FAILURE);
64 return 0;
65 }
66 ctx->obuf = OPENSSL_malloc(DEFAULT_LINEBUFFER_SIZE);
67 if (ctx->obuf == NULL) {
68 BIOerr(BIO_F_LINEBUFFER_NEW, ERR_R_MALLOC_FAILURE);
69 OPENSSL_free(ctx);
70 return 0;
71 }
72 ctx->obuf_size = DEFAULT_LINEBUFFER_SIZE;
73 ctx->obuf_len = 0;
74
75 bi->init = 1;
76 bi->ptr = (char *)ctx;
77 bi->flags = 0;
78 return 1;
79}
80
81static int linebuffer_free(BIO *a)
82{
83 BIO_LINEBUFFER_CTX *b;
84
85 if (a == NULL)
86 return 0;
87 b = (BIO_LINEBUFFER_CTX *)a->ptr;
88 OPENSSL_free(b->obuf);
89 OPENSSL_free(a->ptr);
90 a->ptr = NULL;
91 a->init = 0;
92 a->flags = 0;
93 return 1;
94}
95
96static int linebuffer_read(BIO *b, char *out, int outl)
97{
98 int ret = 0;
99
100 if (out == NULL)
101 return 0;
102 if (b->next_bio == NULL)
103 return 0;
104 ret = BIO_read(b->next_bio, out, outl);
105 BIO_clear_retry_flags(b);
106 BIO_copy_next_retry(b);
107 return ret;
108}
109
110static int linebuffer_write(BIO *b, const char *in, int inl)
111{
112 int i, num = 0, foundnl;
113 BIO_LINEBUFFER_CTX *ctx;
114
115 if ((in == NULL) || (inl <= 0))
116 return 0;
117 ctx = (BIO_LINEBUFFER_CTX *)b->ptr;
118 if ((ctx == NULL) || (b->next_bio == NULL))
119 return 0;
120
121 BIO_clear_retry_flags(b);
122
123 do {
124 const char *p;
125 char c;
126
127 for (p = in, c = '\0'; p < in + inl && (c = *p) != '\n'; p++) ;
128 if (c == '\n') {
129 p++;
130 foundnl = 1;
131 } else
132 foundnl = 0;
133
134 /*
135 * If a NL was found and we already have text in the save buffer,
136 * concatenate them and write
137 */
138 while ((foundnl || p - in > ctx->obuf_size - ctx->obuf_len)
139 && ctx->obuf_len > 0) {
140 int orig_olen = ctx->obuf_len;
141
142 i = ctx->obuf_size - ctx->obuf_len;
143 if (p - in > 0) {
144 if (i >= p - in) {
145 memcpy(&(ctx->obuf[ctx->obuf_len]), in, p - in);
146 ctx->obuf_len += p - in;
147 inl -= p - in;
148 num += p - in;
149 in = p;
150 } else {
151 memcpy(&(ctx->obuf[ctx->obuf_len]), in, i);
152 ctx->obuf_len += i;
153 inl -= i;
154 in += i;
155 num += i;
156 }
157 }
158 i = BIO_write(b->next_bio, ctx->obuf, ctx->obuf_len);
159 if (i <= 0) {
160 ctx->obuf_len = orig_olen;
161 BIO_copy_next_retry(b);
162
163 if (i < 0)
164 return ((num > 0) ? num : i);
165 if (i == 0)
166 return num;
167 }
168 if (i < ctx->obuf_len)
169 memmove(ctx->obuf, ctx->obuf + i, ctx->obuf_len - i);
170 ctx->obuf_len -= i;
171 }
172
173 /*
174 * Now that the save buffer is emptied, let's write the input buffer
175 * if a NL was found and there is anything to write.
176 */
177 if ((foundnl || p - in > ctx->obuf_size) && p - in > 0) {
178 i = BIO_write(b->next_bio, in, p - in);
179 if (i <= 0) {
180 BIO_copy_next_retry(b);
181 if (i < 0)
182 return ((num > 0) ? num : i);
183 if (i == 0)
184 return num;
185 }
186 num += i;
187 in += i;
188 inl -= i;
189 }
190 }
191 while (foundnl && inl > 0);
192 /*
193 * We've written as much as we can. The rest of the input buffer, if
194 * any, is text that doesn't and with a NL and therefore needs to be
195 * saved for the next trip.
196 */
197 if (inl > 0) {
198 memcpy(&(ctx->obuf[ctx->obuf_len]), in, inl);
199 ctx->obuf_len += inl;
200 num += inl;
201 }
202 return num;
203}
204
205static long linebuffer_ctrl(BIO *b, int cmd, long num, void *ptr)
206{
207 BIO *dbio;
208 BIO_LINEBUFFER_CTX *ctx;
209 long ret = 1;
210 char *p;
211 int r;
212 int obs;
213
214 ctx = (BIO_LINEBUFFER_CTX *)b->ptr;
215
216 switch (cmd) {
217 case BIO_CTRL_RESET:
218 ctx->obuf_len = 0;
219 if (b->next_bio == NULL)
220 return 0;
221 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
222 break;
223 case BIO_CTRL_INFO:
224 ret = (long)ctx->obuf_len;
225 break;
226 case BIO_CTRL_WPENDING:
227 ret = (long)ctx->obuf_len;
228 if (ret == 0) {
229 if (b->next_bio == NULL)
230 return 0;
231 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
232 }
233 break;
234 case BIO_C_SET_BUFF_SIZE:
235 obs = (int)num;
236 p = ctx->obuf;
237 if ((obs > DEFAULT_LINEBUFFER_SIZE) && (obs != ctx->obuf_size)) {
238 p = OPENSSL_malloc((int)num);
239 if (p == NULL)
240 goto malloc_error;
241 }
242 if (ctx->obuf != p) {
243 if (ctx->obuf_len > obs) {
244 ctx->obuf_len = obs;
245 }
246 memcpy(p, ctx->obuf, ctx->obuf_len);
247 OPENSSL_free(ctx->obuf);
248 ctx->obuf = p;
249 ctx->obuf_size = obs;
250 }
251 break;
252 case BIO_C_DO_STATE_MACHINE:
253 if (b->next_bio == NULL)
254 return 0;
255 BIO_clear_retry_flags(b);
256 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
257 BIO_copy_next_retry(b);
258 break;
259
260 case BIO_CTRL_FLUSH:
261 if (b->next_bio == NULL)
262 return 0;
263 if (ctx->obuf_len <= 0) {
264 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
265 break;
266 }
267
268 for (;;) {
269 BIO_clear_retry_flags(b);
270 if (ctx->obuf_len > 0) {
271 r = BIO_write(b->next_bio, ctx->obuf, ctx->obuf_len);
272 BIO_copy_next_retry(b);
273 if (r <= 0)
274 return (long)r;
275 if (r < ctx->obuf_len)
276 memmove(ctx->obuf, ctx->obuf + r, ctx->obuf_len - r);
277 ctx->obuf_len -= r;
278 } else {
279 ctx->obuf_len = 0;
280 break;
281 }
282 }
283 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
284 break;
285 case BIO_CTRL_DUP:
286 dbio = (BIO *)ptr;
287 if (!BIO_set_write_buffer_size(dbio, ctx->obuf_size))
288 ret = 0;
289 break;
290 default:
291 if (b->next_bio == NULL)
292 return 0;
293 ret = BIO_ctrl(b->next_bio, cmd, num, ptr);
294 break;
295 }
296 return ret;
297 malloc_error:
298 BIOerr(BIO_F_LINEBUFFER_CTRL, ERR_R_MALLOC_FAILURE);
299 return 0;
300}
301
302static long linebuffer_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
303{
304 long ret = 1;
305
306 if (b->next_bio == NULL)
307 return 0;
308 switch (cmd) {
309 default:
310 ret = BIO_callback_ctrl(b->next_bio, cmd, fp);
311 break;
312 }
313 return ret;
314}
315
316static int linebuffer_gets(BIO *b, char *buf, int size)
317{
318 if (b->next_bio == NULL)
319 return 0;
320 return BIO_gets(b->next_bio, buf, size);
321}
322
323static int linebuffer_puts(BIO *b, const char *str)
324{
325 return linebuffer_write(b, str, strlen(str));
326}
327