1/*
2 * Copyright 1995-2016 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
13#include "bio_local.h"
14
15#if defined(OPENSSL_NO_POSIX_IO)
16/*
17 * Dummy placeholder for BIO_s_fd...
18 */
19BIO *BIO_new_fd(int fd, int close_flag)
20{
21 return NULL;
22}
23
24int BIO_fd_non_fatal_error(int err)
25{
26 return 0;
27}
28
29int BIO_fd_should_retry(int i)
30{
31 return 0;
32}
33
34const BIO_METHOD *BIO_s_fd(void)
35{
36 return NULL;
37}
38#else
39/*
40 * As for unconditional usage of "UPLINK" interface in this module.
41 * Trouble is that unlike Unix file descriptors [which are indexes
42 * in kernel-side per-process table], corresponding descriptors on
43 * platforms which require "UPLINK" interface seem to be indexes
44 * in a user-land, non-global table. Well, in fact they are indexes
45 * in stdio _iob[], and recall that _iob[] was the very reason why
46 * "UPLINK" interface was introduced in first place. But one way on
47 * another. Neither libcrypto or libssl use this BIO meaning that
48 * file descriptors can only be provided by application. Therefore
49 * "UPLINK" calls are due...
50 */
51static int fd_write(BIO *h, const char *buf, int num);
52static int fd_read(BIO *h, char *buf, int size);
53static int fd_puts(BIO *h, const char *str);
54static int fd_gets(BIO *h, char *buf, int size);
55static long fd_ctrl(BIO *h, int cmd, long arg1, void *arg2);
56static int fd_new(BIO *h);
57static int fd_free(BIO *data);
58int BIO_fd_should_retry(int s);
59
60static const BIO_METHOD methods_fdp = {
61 BIO_TYPE_FD,
62 "file descriptor",
63 /* TODO: Convert to new style write function */
64 bwrite_conv,
65 fd_write,
66 /* TODO: Convert to new style read function */
67 bread_conv,
68 fd_read,
69 fd_puts,
70 fd_gets,
71 fd_ctrl,
72 fd_new,
73 fd_free,
74 NULL, /* fd_callback_ctrl */
75};
76
77const BIO_METHOD *BIO_s_fd(void)
78{
79 return &methods_fdp;
80}
81
82BIO *BIO_new_fd(int fd, int close_flag)
83{
84 BIO *ret;
85 ret = BIO_new(BIO_s_fd());
86 if (ret == NULL)
87 return NULL;
88 BIO_set_fd(ret, fd, close_flag);
89 return ret;
90}
91
92static int fd_new(BIO *bi)
93{
94 bi->init = 0;
95 bi->num = -1;
96 bi->ptr = NULL;
97 bi->flags = BIO_FLAGS_UPLINK_INTERNAL; /* essentially redundant */
98 return 1;
99}
100
101static int fd_free(BIO *a)
102{
103 if (a == NULL)
104 return 0;
105 if (a->shutdown) {
106 if (a->init) {
107 UP_close(a->num);
108 }
109 a->init = 0;
110 a->flags = BIO_FLAGS_UPLINK_INTERNAL;
111 }
112 return 1;
113}
114
115static int fd_read(BIO *b, char *out, int outl)
116{
117 int ret = 0;
118
119 if (out != NULL) {
120 clear_sys_error();
121 ret = UP_read(b->num, out, outl);
122 BIO_clear_retry_flags(b);
123 if (ret <= 0) {
124 if (BIO_fd_should_retry(ret))
125 BIO_set_retry_read(b);
126 }
127 }
128 return ret;
129}
130
131static int fd_write(BIO *b, const char *in, int inl)
132{
133 int ret;
134 clear_sys_error();
135 ret = UP_write(b->num, in, inl);
136 BIO_clear_retry_flags(b);
137 if (ret <= 0) {
138 if (BIO_fd_should_retry(ret))
139 BIO_set_retry_write(b);
140 }
141 return ret;
142}
143
144static long fd_ctrl(BIO *b, int cmd, long num, void *ptr)
145{
146 long ret = 1;
147 int *ip;
148
149 switch (cmd) {
150 case BIO_CTRL_RESET:
151 num = 0;
152 /* fall thru */
153 case BIO_C_FILE_SEEK:
154 ret = (long)UP_lseek(b->num, num, 0);
155 break;
156 case BIO_C_FILE_TELL:
157 case BIO_CTRL_INFO:
158 ret = (long)UP_lseek(b->num, 0, 1);
159 break;
160 case BIO_C_SET_FD:
161 fd_free(b);
162 b->num = *((int *)ptr);
163 b->shutdown = (int)num;
164 b->init = 1;
165 break;
166 case BIO_C_GET_FD:
167 if (b->init) {
168 ip = (int *)ptr;
169 if (ip != NULL)
170 *ip = b->num;
171 ret = b->num;
172 } else
173 ret = -1;
174 break;
175 case BIO_CTRL_GET_CLOSE:
176 ret = b->shutdown;
177 break;
178 case BIO_CTRL_SET_CLOSE:
179 b->shutdown = (int)num;
180 break;
181 case BIO_CTRL_PENDING:
182 case BIO_CTRL_WPENDING:
183 ret = 0;
184 break;
185 case BIO_CTRL_DUP:
186 case BIO_CTRL_FLUSH:
187 ret = 1;
188 break;
189 default:
190 ret = 0;
191 break;
192 }
193 return ret;
194}
195
196static int fd_puts(BIO *bp, const char *str)
197{
198 int n, ret;
199
200 n = strlen(str);
201 ret = fd_write(bp, str, n);
202 return ret;
203}
204
205static int fd_gets(BIO *bp, char *buf, int size)
206{
207 int ret = 0;
208 char *ptr = buf;
209 char *end = buf + size - 1;
210
211 while (ptr < end && fd_read(bp, ptr, 1) > 0) {
212 if (*ptr++ == '\n')
213 break;
214 }
215
216 ptr[0] = '\0';
217
218 if (buf[0] != '\0')
219 ret = strlen(buf);
220 return ret;
221}
222
223int BIO_fd_should_retry(int i)
224{
225 int err;
226
227 if ((i == 0) || (i == -1)) {
228 err = get_last_sys_error();
229
230 return BIO_fd_non_fatal_error(err);
231 }
232 return 0;
233}
234
235int BIO_fd_non_fatal_error(int err)
236{
237 switch (err) {
238
239# ifdef EWOULDBLOCK
240# ifdef WSAEWOULDBLOCK
241# if WSAEWOULDBLOCK != EWOULDBLOCK
242 case EWOULDBLOCK:
243# endif
244# else
245 case EWOULDBLOCK:
246# endif
247# endif
248
249# if defined(ENOTCONN)
250 case ENOTCONN:
251# endif
252
253# ifdef EINTR
254 case EINTR:
255# endif
256
257# ifdef EAGAIN
258# if EWOULDBLOCK != EAGAIN
259 case EAGAIN:
260# endif
261# endif
262
263# ifdef EPROTO
264 case EPROTO:
265# endif
266
267# ifdef EINPROGRESS
268 case EINPROGRESS:
269# endif
270
271# ifdef EALREADY
272 case EALREADY:
273# endif
274 return 1;
275 default:
276 break;
277 }
278 return 0;
279}
280#endif
281