Fix no-posix-io compile failure
[openssl.git] / test / testutil / tap_bio.c
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright (c) 2017, Oracle and/or its affiliates.  All rights reserved.
4  *
5  * Licensed under the OpenSSL license (the "License").  You may not use
6  * this file except in compliance with the License.  You can obtain a copy
7  * in the file LICENSE in the source distribution or at
8  * https://www.openssl.org/source/license.html
9  */
10
11 #include <string.h>
12 #include "tu_local.h"
13
14 static int tap_write_ex(BIO *b, const char *buf, size_t size, size_t *in_size);
15 static int tap_read_ex(BIO *b, char *buf, size_t size, size_t *out_size);
16 static int tap_puts(BIO *b, const char *str);
17 static int tap_gets(BIO *b, char *str, int size);
18 static long tap_ctrl(BIO *b, int cmd, long arg1, void *arg2);
19 static int tap_new(BIO *b);
20 static int tap_free(BIO *b);
21 static long tap_callback_ctrl(BIO *h, int cmd, BIO_info_cb *fp);
22
23 const BIO_METHOD *BIO_f_tap(void)
24 {
25     static BIO_METHOD *tap = NULL;
26
27     if (tap == NULL) {
28         tap = BIO_meth_new(BIO_TYPE_START | BIO_TYPE_FILTER, "tap");
29         if (tap != NULL) {
30             BIO_meth_set_write_ex(tap, tap_write_ex);
31             BIO_meth_set_read_ex(tap, tap_read_ex);
32             BIO_meth_set_puts(tap, tap_puts);
33             BIO_meth_set_gets(tap, tap_gets);
34             BIO_meth_set_ctrl(tap, tap_ctrl);
35             BIO_meth_set_create(tap, tap_new);
36             BIO_meth_set_destroy(tap, tap_free);
37             BIO_meth_set_callback_ctrl(tap, tap_callback_ctrl);
38         }
39     }
40     return tap;
41 }
42
43 static int tap_new(BIO *b)
44 {
45     BIO_set_data(b, NULL);
46     BIO_set_init(b, 1);
47     return 1;
48 }
49
50 static int tap_free(BIO *b)
51 {
52     if (b == NULL)
53         return 0;
54     BIO_set_data(b, NULL);
55     BIO_set_init(b, 0);
56     return 1;
57 }
58
59 static int tap_read_ex(BIO *b, char *buf, size_t size, size_t *out_size)
60 {
61     BIO *next = BIO_next(b);
62     int ret = 0;
63
64     ret = BIO_read_ex(next, buf, size, out_size);
65     BIO_clear_retry_flags(b);
66     BIO_copy_next_retry(b);
67     return ret;
68 }
69
70 /*
71  * Output a string to the specified bio and return 1 if successful.
72  */
73 static int write_string(BIO *b, const char *buf, size_t n)
74 {
75     size_t m;
76
77     return BIO_write_ex(b, buf, n, &m) != 0 && m == n;
78 }
79
80 /*
81  * Write some data.
82  *
83  * This function implements a simple state machine that detects new lines.
84  * It indents the output and prefixes it with a '#' character.
85  *
86  * It returns the number of input characters that were output in in_size.
87  * More characters than this will likely have been output however any calling
88  * code will be unable to correctly assess the actual number of characters
89  * emitted and would be prone to failure if the actual number were returned.
90  *
91  * The BIO_data field is used as our state.  If it is NULL, we've just
92  * seen a new line.  If it is not NULL, we're processing characters in a line.
93  */
94 static int tap_write_ex(BIO *b, const char *buf, size_t size, size_t *in_size)
95 {
96     BIO *next = BIO_next(b);
97     size_t i;
98     int j;
99
100     for (i = 0; i < size; i++) {
101         if (BIO_get_data(b) == NULL) {
102             BIO_set_data(b, "");
103             for (j = 0; j < subtest_level(); j++)
104                 if (!write_string(next, " ", 1))
105                     goto err;
106             if (!write_string(next, "# ", 2))
107                 goto err;
108         }
109         if (!write_string(next, buf + i, 1))
110             goto err;
111         if (buf[i] == '\n')
112             BIO_set_data(b, NULL);
113     }
114     *in_size = i;
115     return 1;
116
117 err:
118     *in_size = i;
119     return 0;
120 }
121
122 static long tap_ctrl(BIO *b, int cmd, long num, void *ptr)
123 {
124     BIO *next = BIO_next(b);
125
126     switch (cmd) {
127     case BIO_CTRL_RESET:
128         BIO_set_data(b, NULL);
129         break;
130
131     default:
132         break;
133     }
134     return BIO_ctrl(next, cmd, num, ptr);
135 }
136
137 static long tap_callback_ctrl(BIO *b, int cmd, BIO_info_cb *fp)
138 {
139     return BIO_callback_ctrl(BIO_next(b), cmd, fp);
140 }
141
142 static int tap_gets(BIO *b, char *buf, int size)
143 {
144     return BIO_gets(BIO_next(b), buf, size);
145 }
146
147 static int tap_puts(BIO *b, const char *str)
148 {
149     size_t m;
150
151     if (!tap_write_ex(b, str, strlen(str), &m))
152         return 0;
153     return m;
154 }