ce775601f04b9e640e6864ce5bd280b371592fc8
[openssl.git] / crypto / bio / bss_bio.c
1 /*
2  * Copyright 1999-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (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 /*
11  * Special method for a BIO where the other endpoint is also a BIO of this
12  * kind, handled by the same thread (i.e. the "peer" is actually ourselves,
13  * wearing a different hat). Such "BIO pairs" are mainly for using the SSL
14  * library with I/O interfaces for which no specific BIO method is available.
15  * See ssl/ssltest.c for some hints on how this can be used.
16  */
17
18 #include <assert.h>
19 #include <limits.h>
20 #include <stdlib.h>
21 #include <string.h>
22
23 #include "bio_lcl.h"
24 #include <openssl/err.h>
25 #include <openssl/crypto.h>
26
27 #include "e_os.h"
28
29 static int bio_new(BIO *bio);
30 static int bio_free(BIO *bio);
31 static int bio_read(BIO *bio, char *buf, int size);
32 static int bio_write(BIO *bio, const char *buf, int num);
33 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr);
34 static int bio_puts(BIO *bio, const char *str);
35
36 static int bio_make_pair(BIO *bio1, BIO *bio2);
37 static void bio_destroy_pair(BIO *bio);
38
39 static const BIO_METHOD methods_biop = {
40     BIO_TYPE_BIO,
41     "BIO pair",
42     bio_write,
43     /* TODO: Convert to new style read function */
44     bread_conv,
45     bio_read,
46     bio_puts,
47     NULL /* no bio_gets */ ,
48     bio_ctrl,
49     bio_new,
50     bio_free,
51     NULL                        /* no bio_callback_ctrl */
52 };
53
54 const BIO_METHOD *BIO_s_bio(void)
55 {
56     return &methods_biop;
57 }
58
59 struct bio_bio_st {
60     BIO *peer;                  /* NULL if buf == NULL. If peer != NULL, then
61                                  * peer->ptr is also a bio_bio_st, and its
62                                  * "peer" member points back to us. peer !=
63                                  * NULL iff init != 0 in the BIO. */
64     /* This is for what we write (i.e. reading uses peer's struct): */
65     int closed;                 /* valid iff peer != NULL */
66     size_t len;                 /* valid iff buf != NULL; 0 if peer == NULL */
67     size_t offset;              /* valid iff buf != NULL; 0 if len == 0 */
68     size_t size;
69     char *buf;                  /* "size" elements (if != NULL) */
70     size_t request;             /* valid iff peer != NULL; 0 if len != 0,
71                                  * otherwise set by peer to number of bytes
72                                  * it (unsuccessfully) tried to read, never
73                                  * more than buffer space (size-len)
74                                  * warrants. */
75 };
76
77 static int bio_new(BIO *bio)
78 {
79     struct bio_bio_st *b = OPENSSL_zalloc(sizeof(*b));
80
81     if (b == NULL)
82         return 0;
83
84     /* enough for one TLS record (just a default) */
85     b->size = 17 * 1024;
86
87     bio->ptr = b;
88     return 1;
89 }
90
91 static int bio_free(BIO *bio)
92 {
93     struct bio_bio_st *b;
94
95     if (bio == NULL)
96         return 0;
97     b = bio->ptr;
98
99     assert(b != NULL);
100
101     if (b->peer)
102         bio_destroy_pair(bio);
103
104     OPENSSL_free(b->buf);
105     OPENSSL_free(b);
106
107     return 1;
108 }
109
110 static int bio_read(BIO *bio, char *buf, int size_)
111 {
112     size_t size = size_;
113     size_t rest;
114     struct bio_bio_st *b, *peer_b;
115
116     BIO_clear_retry_flags(bio);
117
118     if (!bio->init)
119         return 0;
120
121     b = bio->ptr;
122     assert(b != NULL);
123     assert(b->peer != NULL);
124     peer_b = b->peer->ptr;
125     assert(peer_b != NULL);
126     assert(peer_b->buf != NULL);
127
128     peer_b->request = 0;        /* will be set in "retry_read" situation */
129
130     if (buf == NULL || size == 0)
131         return 0;
132
133     if (peer_b->len == 0) {
134         if (peer_b->closed)
135             return 0;           /* writer has closed, and no data is left */
136         else {
137             BIO_set_retry_read(bio); /* buffer is empty */
138             if (size <= peer_b->size)
139                 peer_b->request = size;
140             else
141                 /*
142                  * don't ask for more than the peer can deliver in one write
143                  */
144                 peer_b->request = peer_b->size;
145             return -1;
146         }
147     }
148
149     /* we can read */
150     if (peer_b->len < size)
151         size = peer_b->len;
152
153     /* now read "size" bytes */
154
155     rest = size;
156
157     assert(rest > 0);
158     do {                        /* one or two iterations */
159         size_t chunk;
160
161         assert(rest <= peer_b->len);
162         if (peer_b->offset + rest <= peer_b->size)
163             chunk = rest;
164         else
165             /* wrap around ring buffer */
166             chunk = peer_b->size - peer_b->offset;
167         assert(peer_b->offset + chunk <= peer_b->size);
168
169         memcpy(buf, peer_b->buf + peer_b->offset, chunk);
170
171         peer_b->len -= chunk;
172         if (peer_b->len) {
173             peer_b->offset += chunk;
174             assert(peer_b->offset <= peer_b->size);
175             if (peer_b->offset == peer_b->size)
176                 peer_b->offset = 0;
177             buf += chunk;
178         } else {
179             /* buffer now empty, no need to advance "buf" */
180             assert(chunk == rest);
181             peer_b->offset = 0;
182         }
183         rest -= chunk;
184     }
185     while (rest);
186
187     return size;
188 }
189
190 /*-
191  * non-copying interface: provide pointer to available data in buffer
192  *    bio_nread0:  return number of available bytes
193  *    bio_nread:   also advance index
194  * (example usage:  bio_nread0(), read from buffer, bio_nread()
195  *  or just         bio_nread(), read from buffer)
196  */
197 /*
198  * WARNING: The non-copying interface is largely untested as of yet and may
199  * contain bugs.
200  */
201 static ossl_ssize_t bio_nread0(BIO *bio, char **buf)
202 {
203     struct bio_bio_st *b, *peer_b;
204     ossl_ssize_t num;
205
206     BIO_clear_retry_flags(bio);
207
208     if (!bio->init)
209         return 0;
210
211     b = bio->ptr;
212     assert(b != NULL);
213     assert(b->peer != NULL);
214     peer_b = b->peer->ptr;
215     assert(peer_b != NULL);
216     assert(peer_b->buf != NULL);
217
218     peer_b->request = 0;
219
220     if (peer_b->len == 0) {
221         char dummy;
222
223         /* avoid code duplication -- nothing available for reading */
224         return bio_read(bio, &dummy, 1); /* returns 0 or -1 */
225     }
226
227     num = peer_b->len;
228     if (peer_b->size < peer_b->offset + num)
229         /* no ring buffer wrap-around for non-copying interface */
230         num = peer_b->size - peer_b->offset;
231     assert(num > 0);
232
233     if (buf != NULL)
234         *buf = peer_b->buf + peer_b->offset;
235     return num;
236 }
237
238 static ossl_ssize_t bio_nread(BIO *bio, char **buf, size_t num_)
239 {
240     struct bio_bio_st *b, *peer_b;
241     ossl_ssize_t num, available;
242
243     if (num_ > OSSL_SSIZE_MAX)
244         num = OSSL_SSIZE_MAX;
245     else
246         num = (ossl_ssize_t) num_;
247
248     available = bio_nread0(bio, buf);
249     if (num > available)
250         num = available;
251     if (num <= 0)
252         return num;
253
254     b = bio->ptr;
255     peer_b = b->peer->ptr;
256
257     peer_b->len -= num;
258     if (peer_b->len) {
259         peer_b->offset += num;
260         assert(peer_b->offset <= peer_b->size);
261         if (peer_b->offset == peer_b->size)
262             peer_b->offset = 0;
263     } else
264         peer_b->offset = 0;
265
266     return num;
267 }
268
269 static int bio_write(BIO *bio, const char *buf, int num_)
270 {
271     size_t num = num_;
272     size_t rest;
273     struct bio_bio_st *b;
274
275     BIO_clear_retry_flags(bio);
276
277     if (!bio->init || buf == NULL || num == 0)
278         return 0;
279
280     b = bio->ptr;
281     assert(b != NULL);
282     assert(b->peer != NULL);
283     assert(b->buf != NULL);
284
285     b->request = 0;
286     if (b->closed) {
287         /* we already closed */
288         BIOerr(BIO_F_BIO_WRITE, BIO_R_BROKEN_PIPE);
289         return -1;
290     }
291
292     assert(b->len <= b->size);
293
294     if (b->len == b->size) {
295         BIO_set_retry_write(bio); /* buffer is full */
296         return -1;
297     }
298
299     /* we can write */
300     if (num > b->size - b->len)
301         num = b->size - b->len;
302
303     /* now write "num" bytes */
304
305     rest = num;
306
307     assert(rest > 0);
308     do {                        /* one or two iterations */
309         size_t write_offset;
310         size_t chunk;
311
312         assert(b->len + rest <= b->size);
313
314         write_offset = b->offset + b->len;
315         if (write_offset >= b->size)
316             write_offset -= b->size;
317         /* b->buf[write_offset] is the first byte we can write to. */
318
319         if (write_offset + rest <= b->size)
320             chunk = rest;
321         else
322             /* wrap around ring buffer */
323             chunk = b->size - write_offset;
324
325         memcpy(b->buf + write_offset, buf, chunk);
326
327         b->len += chunk;
328
329         assert(b->len <= b->size);
330
331         rest -= chunk;
332         buf += chunk;
333     }
334     while (rest);
335
336     return num;
337 }
338
339 /*-
340  * non-copying interface: provide pointer to region to write to
341  *   bio_nwrite0:  check how much space is available
342  *   bio_nwrite:   also increase length
343  * (example usage:  bio_nwrite0(), write to buffer, bio_nwrite()
344  *  or just         bio_nwrite(), write to buffer)
345  */
346 static ossl_ssize_t bio_nwrite0(BIO *bio, char **buf)
347 {
348     struct bio_bio_st *b;
349     size_t num;
350     size_t write_offset;
351
352     BIO_clear_retry_flags(bio);
353
354     if (!bio->init)
355         return 0;
356
357     b = bio->ptr;
358     assert(b != NULL);
359     assert(b->peer != NULL);
360     assert(b->buf != NULL);
361
362     b->request = 0;
363     if (b->closed) {
364         BIOerr(BIO_F_BIO_NWRITE0, BIO_R_BROKEN_PIPE);
365         return -1;
366     }
367
368     assert(b->len <= b->size);
369
370     if (b->len == b->size) {
371         BIO_set_retry_write(bio);
372         return -1;
373     }
374
375     num = b->size - b->len;
376     write_offset = b->offset + b->len;
377     if (write_offset >= b->size)
378         write_offset -= b->size;
379     if (write_offset + num > b->size)
380         /*
381          * no ring buffer wrap-around for non-copying interface (to fulfil
382          * the promise by BIO_ctrl_get_write_guarantee, BIO_nwrite may have
383          * to be called twice)
384          */
385         num = b->size - write_offset;
386
387     if (buf != NULL)
388         *buf = b->buf + write_offset;
389     assert(write_offset + num <= b->size);
390
391     return num;
392 }
393
394 static ossl_ssize_t bio_nwrite(BIO *bio, char **buf, size_t num_)
395 {
396     struct bio_bio_st *b;
397     ossl_ssize_t num, space;
398
399     if (num_ > OSSL_SSIZE_MAX)
400         num = OSSL_SSIZE_MAX;
401     else
402         num = (ossl_ssize_t) num_;
403
404     space = bio_nwrite0(bio, buf);
405     if (num > space)
406         num = space;
407     if (num <= 0)
408         return num;
409     b = bio->ptr;
410     assert(b != NULL);
411     b->len += num;
412     assert(b->len <= b->size);
413
414     return num;
415 }
416
417 static long bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
418 {
419     long ret;
420     struct bio_bio_st *b = bio->ptr;
421
422     assert(b != NULL);
423
424     switch (cmd) {
425         /* specific CTRL codes */
426
427     case BIO_C_SET_WRITE_BUF_SIZE:
428         if (b->peer) {
429             BIOerr(BIO_F_BIO_CTRL, BIO_R_IN_USE);
430             ret = 0;
431         } else if (num == 0) {
432             BIOerr(BIO_F_BIO_CTRL, BIO_R_INVALID_ARGUMENT);
433             ret = 0;
434         } else {
435             size_t new_size = num;
436
437             if (b->size != new_size) {
438                 OPENSSL_free(b->buf);
439                 b->buf = NULL;
440                 b->size = new_size;
441             }
442             ret = 1;
443         }
444         break;
445
446     case BIO_C_GET_WRITE_BUF_SIZE:
447         ret = (long)b->size;
448         break;
449
450     case BIO_C_MAKE_BIO_PAIR:
451         {
452             BIO *other_bio = ptr;
453
454             if (bio_make_pair(bio, other_bio))
455                 ret = 1;
456             else
457                 ret = 0;
458         }
459         break;
460
461     case BIO_C_DESTROY_BIO_PAIR:
462         /*
463          * Affects both BIOs in the pair -- call just once! Or let
464          * BIO_free(bio1); BIO_free(bio2); do the job.
465          */
466         bio_destroy_pair(bio);
467         ret = 1;
468         break;
469
470     case BIO_C_GET_WRITE_GUARANTEE:
471         /*
472          * How many bytes can the caller feed to the next write without
473          * having to keep any?
474          */
475         if (b->peer == NULL || b->closed)
476             ret = 0;
477         else
478             ret = (long)b->size - b->len;
479         break;
480
481     case BIO_C_GET_READ_REQUEST:
482         /*
483          * If the peer unsuccessfully tried to read, how many bytes were
484          * requested? (As with BIO_CTRL_PENDING, that number can usually be
485          * treated as boolean.)
486          */
487         ret = (long)b->request;
488         break;
489
490     case BIO_C_RESET_READ_REQUEST:
491         /*
492          * Reset request.  (Can be useful after read attempts at the other
493          * side that are meant to be non-blocking, e.g. when probing SSL_read
494          * to see if any data is available.)
495          */
496         b->request = 0;
497         ret = 1;
498         break;
499
500     case BIO_C_SHUTDOWN_WR:
501         /* similar to shutdown(..., SHUT_WR) */
502         b->closed = 1;
503         ret = 1;
504         break;
505
506     case BIO_C_NREAD0:
507         /* prepare for non-copying read */
508         ret = (long)bio_nread0(bio, ptr);
509         break;
510
511     case BIO_C_NREAD:
512         /* non-copying read */
513         ret = (long)bio_nread(bio, ptr, (size_t)num);
514         break;
515
516     case BIO_C_NWRITE0:
517         /* prepare for non-copying write */
518         ret = (long)bio_nwrite0(bio, ptr);
519         break;
520
521     case BIO_C_NWRITE:
522         /* non-copying write */
523         ret = (long)bio_nwrite(bio, ptr, (size_t)num);
524         break;
525
526         /* standard CTRL codes follow */
527
528     case BIO_CTRL_RESET:
529         if (b->buf != NULL) {
530             b->len = 0;
531             b->offset = 0;
532         }
533         ret = 0;
534         break;
535
536     case BIO_CTRL_GET_CLOSE:
537         ret = bio->shutdown;
538         break;
539
540     case BIO_CTRL_SET_CLOSE:
541         bio->shutdown = (int)num;
542         ret = 1;
543         break;
544
545     case BIO_CTRL_PENDING:
546         if (b->peer != NULL) {
547             struct bio_bio_st *peer_b = b->peer->ptr;
548
549             ret = (long)peer_b->len;
550         } else
551             ret = 0;
552         break;
553
554     case BIO_CTRL_WPENDING:
555         if (b->buf != NULL)
556             ret = (long)b->len;
557         else
558             ret = 0;
559         break;
560
561     case BIO_CTRL_DUP:
562         /* See BIO_dup_chain for circumstances we have to expect. */
563         {
564             BIO *other_bio = ptr;
565             struct bio_bio_st *other_b;
566
567             assert(other_bio != NULL);
568             other_b = other_bio->ptr;
569             assert(other_b != NULL);
570
571             assert(other_b->buf == NULL); /* other_bio is always fresh */
572
573             other_b->size = b->size;
574         }
575
576         ret = 1;
577         break;
578
579     case BIO_CTRL_FLUSH:
580         ret = 1;
581         break;
582
583     case BIO_CTRL_EOF:
584         if (b->peer != NULL) {
585             struct bio_bio_st *peer_b = b->peer->ptr;
586
587             if (peer_b->len == 0 && peer_b->closed)
588                 ret = 1;
589             else
590                 ret = 0;
591         } else {
592             ret = 1;
593         }
594         break;
595
596     default:
597         ret = 0;
598     }
599     return ret;
600 }
601
602 static int bio_puts(BIO *bio, const char *str)
603 {
604     return bio_write(bio, str, strlen(str));
605 }
606
607 static int bio_make_pair(BIO *bio1, BIO *bio2)
608 {
609     struct bio_bio_st *b1, *b2;
610
611     assert(bio1 != NULL);
612     assert(bio2 != NULL);
613
614     b1 = bio1->ptr;
615     b2 = bio2->ptr;
616
617     if (b1->peer != NULL || b2->peer != NULL) {
618         BIOerr(BIO_F_BIO_MAKE_PAIR, BIO_R_IN_USE);
619         return 0;
620     }
621
622     if (b1->buf == NULL) {
623         b1->buf = OPENSSL_malloc(b1->size);
624         if (b1->buf == NULL) {
625             BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
626             return 0;
627         }
628         b1->len = 0;
629         b1->offset = 0;
630     }
631
632     if (b2->buf == NULL) {
633         b2->buf = OPENSSL_malloc(b2->size);
634         if (b2->buf == NULL) {
635             BIOerr(BIO_F_BIO_MAKE_PAIR, ERR_R_MALLOC_FAILURE);
636             return 0;
637         }
638         b2->len = 0;
639         b2->offset = 0;
640     }
641
642     b1->peer = bio2;
643     b1->closed = 0;
644     b1->request = 0;
645     b2->peer = bio1;
646     b2->closed = 0;
647     b2->request = 0;
648
649     bio1->init = 1;
650     bio2->init = 1;
651
652     return 1;
653 }
654
655 static void bio_destroy_pair(BIO *bio)
656 {
657     struct bio_bio_st *b = bio->ptr;
658
659     if (b != NULL) {
660         BIO *peer_bio = b->peer;
661
662         if (peer_bio != NULL) {
663             struct bio_bio_st *peer_b = peer_bio->ptr;
664
665             assert(peer_b != NULL);
666             assert(peer_b->peer == bio);
667
668             peer_b->peer = NULL;
669             peer_bio->init = 0;
670             assert(peer_b->buf != NULL);
671             peer_b->len = 0;
672             peer_b->offset = 0;
673
674             b->peer = NULL;
675             bio->init = 0;
676             assert(b->buf != NULL);
677             b->len = 0;
678             b->offset = 0;
679         }
680     }
681 }
682
683 /* Exported convenience functions */
684 int BIO_new_bio_pair(BIO **bio1_p, size_t writebuf1,
685                      BIO **bio2_p, size_t writebuf2)
686 {
687     BIO *bio1 = NULL, *bio2 = NULL;
688     long r;
689     int ret = 0;
690
691     bio1 = BIO_new(BIO_s_bio());
692     if (bio1 == NULL)
693         goto err;
694     bio2 = BIO_new(BIO_s_bio());
695     if (bio2 == NULL)
696         goto err;
697
698     if (writebuf1) {
699         r = BIO_set_write_buf_size(bio1, writebuf1);
700         if (!r)
701             goto err;
702     }
703     if (writebuf2) {
704         r = BIO_set_write_buf_size(bio2, writebuf2);
705         if (!r)
706             goto err;
707     }
708
709     r = BIO_make_bio_pair(bio1, bio2);
710     if (!r)
711         goto err;
712     ret = 1;
713
714  err:
715     if (ret == 0) {
716         BIO_free(bio1);
717         bio1 = NULL;
718         BIO_free(bio2);
719         bio2 = NULL;
720     }
721
722     *bio1_p = bio1;
723     *bio2_p = bio2;
724     return ret;
725 }
726
727 size_t BIO_ctrl_get_write_guarantee(BIO *bio)
728 {
729     return BIO_ctrl(bio, BIO_C_GET_WRITE_GUARANTEE, 0, NULL);
730 }
731
732 size_t BIO_ctrl_get_read_request(BIO *bio)
733 {
734     return BIO_ctrl(bio, BIO_C_GET_READ_REQUEST, 0, NULL);
735 }
736
737 int BIO_ctrl_reset_read_request(BIO *bio)
738 {
739     return (BIO_ctrl(bio, BIO_C_RESET_READ_REQUEST, 0, NULL) != 0);
740 }
741
742 /*
743  * BIO_nread0/nread/nwrite0/nwrite are available only for BIO pairs for now
744  * (conceivably some other BIOs could allow non-copying reads and writes
745  * too.)
746  */
747 int BIO_nread0(BIO *bio, char **buf)
748 {
749     long ret;
750
751     if (!bio->init) {
752         BIOerr(BIO_F_BIO_NREAD0, BIO_R_UNINITIALIZED);
753         return -2;
754     }
755
756     ret = BIO_ctrl(bio, BIO_C_NREAD0, 0, buf);
757     if (ret > INT_MAX)
758         return INT_MAX;
759     else
760         return (int)ret;
761 }
762
763 int BIO_nread(BIO *bio, char **buf, int num)
764 {
765     int ret;
766
767     if (!bio->init) {
768         BIOerr(BIO_F_BIO_NREAD, BIO_R_UNINITIALIZED);
769         return -2;
770     }
771
772     ret = (int)BIO_ctrl(bio, BIO_C_NREAD, num, buf);
773     if (ret > 0)
774         bio->num_read += ret;
775     return ret;
776 }
777
778 int BIO_nwrite0(BIO *bio, char **buf)
779 {
780     long ret;
781
782     if (!bio->init) {
783         BIOerr(BIO_F_BIO_NWRITE0, BIO_R_UNINITIALIZED);
784         return -2;
785     }
786
787     ret = BIO_ctrl(bio, BIO_C_NWRITE0, 0, buf);
788     if (ret > INT_MAX)
789         return INT_MAX;
790     else
791         return (int)ret;
792 }
793
794 int BIO_nwrite(BIO *bio, char **buf, int num)
795 {
796     int ret;
797
798     if (!bio->init) {
799         BIOerr(BIO_F_BIO_NWRITE, BIO_R_UNINITIALIZED);
800         return -2;
801     }
802
803     ret = BIO_ctrl(bio, BIO_C_NWRITE, num, buf);
804     if (ret > 0)
805         bio->num_write += ret;
806     return ret;
807 }