1 /* $OpenBSD: bss_sock.c,v 1.25 2022/01/07 09:02:17 tb Exp $ */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 
59 #include <sys/socket.h>
60 
61 #include <errno.h>
62 #include <stdio.h>
63 #include <string.h>
64 #include <unistd.h>
65 
66 #include <openssl/bio.h>
67 
68 #include "bio_local.h"
69 
70 static int sock_write(BIO *h, const char *buf, int num);
71 static int sock_read(BIO *h, char *buf, int size);
72 static int sock_puts(BIO *h, const char *str);
73 static long sock_ctrl(BIO *h, int cmd, long arg1, void *arg2);
74 static int sock_new(BIO *h);
75 static int sock_free(BIO *data);
76 int BIO_sock_should_retry(int s);
77 
78 static const BIO_METHOD methods_sockp = {
79 	.type = BIO_TYPE_SOCKET,
80 	.name = "socket",
81 	.bwrite = sock_write,
82 	.bread = sock_read,
83 	.bputs = sock_puts,
84 	.ctrl = sock_ctrl,
85 	.create = sock_new,
86 	.destroy = sock_free
87 };
88 
89 const BIO_METHOD *
BIO_s_socket(void)90 BIO_s_socket(void)
91 {
92 	return (&methods_sockp);
93 }
94 
95 BIO *
BIO_new_socket(int fd,int close_flag)96 BIO_new_socket(int fd, int close_flag)
97 {
98 	BIO *ret;
99 
100 	ret = BIO_new(BIO_s_socket());
101 	if (ret == NULL)
102 		return (NULL);
103 	BIO_set_fd(ret, fd, close_flag);
104 	return (ret);
105 }
106 
107 static int
sock_new(BIO * bi)108 sock_new(BIO *bi)
109 {
110 	bi->init = 0;
111 	bi->num = 0;
112 	bi->ptr = NULL;
113 	bi->flags = 0;
114 	return (1);
115 }
116 
117 static int
sock_free(BIO * a)118 sock_free(BIO *a)
119 {
120 	if (a == NULL)
121 		return (0);
122 	if (a->shutdown) {
123 		if (a->init) {
124 			shutdown(a->num, SHUT_RDWR);
125 			close(a->num);
126 		}
127 		a->init = 0;
128 		a->flags = 0;
129 	}
130 	return (1);
131 }
132 
133 static int
sock_read(BIO * b,char * out,int outl)134 sock_read(BIO *b, char *out, int outl)
135 {
136 	int ret = 0;
137 
138 	if (out != NULL) {
139 		errno = 0;
140 		ret = read(b->num, out, outl);
141 		BIO_clear_retry_flags(b);
142 		if (ret <= 0) {
143 			if (BIO_sock_should_retry(ret))
144 				BIO_set_retry_read(b);
145 		}
146 	}
147 	return (ret);
148 }
149 
150 static int
sock_write(BIO * b,const char * in,int inl)151 sock_write(BIO *b, const char *in, int inl)
152 {
153 	int ret;
154 
155 	errno = 0;
156 	ret = write(b->num, in, inl);
157 	BIO_clear_retry_flags(b);
158 	if (ret <= 0) {
159 		if (BIO_sock_should_retry(ret))
160 			BIO_set_retry_write(b);
161 	}
162 	return (ret);
163 }
164 
165 static long
sock_ctrl(BIO * b,int cmd,long num,void * ptr)166 sock_ctrl(BIO *b, int cmd, long num, void *ptr)
167 {
168 	long ret = 1;
169 	int *ip;
170 
171 	switch (cmd) {
172 	case BIO_C_SET_FD:
173 		sock_free(b);
174 		b->num= *((int *)ptr);
175 		b->shutdown = (int)num;
176 		b->init = 1;
177 		break;
178 	case BIO_C_GET_FD:
179 		if (b->init) {
180 			ip = (int *)ptr;
181 			if (ip != NULL)
182 				*ip = b->num;
183 			ret = b->num;
184 		} else
185 			ret = -1;
186 		break;
187 	case BIO_CTRL_GET_CLOSE:
188 		ret = b->shutdown;
189 		break;
190 	case BIO_CTRL_SET_CLOSE:
191 		b->shutdown = (int)num;
192 		break;
193 	case BIO_CTRL_DUP:
194 	case BIO_CTRL_FLUSH:
195 		ret = 1;
196 		break;
197 	default:
198 		ret = 0;
199 		break;
200 	}
201 	return (ret);
202 }
203 
204 static int
sock_puts(BIO * bp,const char * str)205 sock_puts(BIO *bp, const char *str)
206 {
207 	int n, ret;
208 
209 	n = strlen(str);
210 	ret = sock_write(bp, str, n);
211 	return (ret);
212 }
213 
214 int
BIO_sock_should_retry(int i)215 BIO_sock_should_retry(int i)
216 {
217 	int err;
218 
219 	if ((i == 0) || (i == -1)) {
220 		err = errno;
221 		return (BIO_sock_non_fatal_error(err));
222 	}
223 	return (0);
224 }
225 
226 int
BIO_sock_non_fatal_error(int err)227 BIO_sock_non_fatal_error(int err)
228 {
229 	switch (err) {
230 	case ENOTCONN:
231 	case EINTR:
232 	case EAGAIN:
233 	case EINPROGRESS:
234 	case EALREADY:
235 		return (1);
236 	default:
237 		break;
238 	}
239 	return (0);
240 }
241 
242