bss_sock.c revision 296465 
1/* crypto/bio/bss_sock.c */
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 <stdio.h>
60#include <errno.h>
61#define USE_SOCKETS
62#include "cryptlib.h"
63
64#ifndef OPENSSL_NO_SOCK
65
66# include <openssl/bio.h>
67
68# ifdef WATT32
69#  define sock_write SockWrite  /* Watt-32 uses same names */
70#  define sock_read  SockRead
71#  define sock_puts  SockPuts
72# endif
73
74static int sock_write(BIO *h, const char *buf, int num);
75static int sock_read(BIO *h, char *buf, int size);
76static int sock_puts(BIO *h, const char *str);
77static long sock_ctrl(BIO *h, int cmd, long arg1, void *arg2);
78static int sock_new(BIO *h);
79static int sock_free(BIO *data);
80int BIO_sock_should_retry(int s);
81
82static BIO_METHOD methods_sockp = {
83    BIO_TYPE_SOCKET,
84    "socket",
85    sock_write,
86    sock_read,
87    sock_puts,
88    NULL,                       /* sock_gets, */
89    sock_ctrl,
90    sock_new,
91    sock_free,
92    NULL,
93};
94
95BIO_METHOD *BIO_s_socket(void)
96{
97    return (&methods_sockp);
98}
99
100BIO *BIO_new_socket(int fd, int close_flag)
101{
102    BIO *ret;
103
104    ret = BIO_new(BIO_s_socket());
105    if (ret == NULL)
106        return (NULL);
107    BIO_set_fd(ret, fd, close_flag);
108    return (ret);
109}
110
111static int sock_new(BIO *bi)
112{
113    bi->init = 0;
114    bi->num = 0;
115    bi->ptr = NULL;
116    bi->flags = 0;
117    return (1);
118}
119
120static int sock_free(BIO *a)
121{
122    if (a == NULL)
123        return (0);
124    if (a->shutdown) {
125        if (a->init) {
126            SHUTDOWN2(a->num);
127        }
128        a->init = 0;
129        a->flags = 0;
130    }
131    return (1);
132}
133
134static int sock_read(BIO *b, char *out, int outl)
135{
136    int ret = 0;
137
138    if (out != NULL) {
139        clear_socket_error();
140        ret = readsocket(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
150static int sock_write(BIO *b, const char *in, int inl)
151{
152    int ret;
153
154    clear_socket_error();
155    ret = writesocket(b->num, in, inl);
156    BIO_clear_retry_flags(b);
157    if (ret <= 0) {
158        if (BIO_sock_should_retry(ret))
159            BIO_set_retry_write(b);
160    }
161    return (ret);
162}
163
164static long sock_ctrl(BIO *b, int cmd, long num, void *ptr)
165{
166    long ret = 1;
167    int *ip;
168
169    switch (cmd) {
170    case BIO_C_SET_FD:
171        sock_free(b);
172        b->num = *((int *)ptr);
173        b->shutdown = (int)num;
174        b->init = 1;
175        break;
176    case BIO_C_GET_FD:
177        if (b->init) {
178            ip = (int *)ptr;
179            if (ip != NULL)
180                *ip = b->num;
181            ret = b->num;
182        } else
183            ret = -1;
184        break;
185    case BIO_CTRL_GET_CLOSE:
186        ret = b->shutdown;
187        break;
188    case BIO_CTRL_SET_CLOSE:
189        b->shutdown = (int)num;
190        break;
191    case BIO_CTRL_DUP:
192    case BIO_CTRL_FLUSH:
193        ret = 1;
194        break;
195    default:
196        ret = 0;
197        break;
198    }
199    return (ret);
200}
201
202static int sock_puts(BIO *bp, const char *str)
203{
204    int n, ret;
205
206    n = strlen(str);
207    ret = sock_write(bp, str, n);
208    return (ret);
209}
210
211int BIO_sock_should_retry(int i)
212{
213    int err;
214
215    if ((i == 0) || (i == -1)) {
216        err = get_last_socket_error();
217
218# if defined(OPENSSL_SYS_WINDOWS) && 0/* more microsoft stupidity? perhaps
219                                       * not? Ben 4/1/99 */
220        if ((i == -1) && (err == 0))
221            return (1);
222# endif
223
224        return (BIO_sock_non_fatal_error(err));
225    }
226    return (0);
227}
228
229int BIO_sock_non_fatal_error(int err)
230{
231    switch (err) {
232# if defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_NETWARE)
233#  if defined(WSAEWOULDBLOCK)
234    case WSAEWOULDBLOCK:
235#  endif
236
237#  if 0                         /* This appears to always be an error */
238#   if defined(WSAENOTCONN)
239    case WSAENOTCONN:
240#   endif
241#  endif
242# endif
243
244# ifdef EWOULDBLOCK
245#  ifdef WSAEWOULDBLOCK
246#   if WSAEWOULDBLOCK != EWOULDBLOCK
247    case EWOULDBLOCK:
248#   endif
249#  else
250    case EWOULDBLOCK:
251#  endif
252# endif
253
254# if defined(ENOTCONN)
255    case ENOTCONN:
256# endif
257
258# ifdef EINTR
259    case EINTR:
260# endif
261
262# ifdef EAGAIN
263#  if EWOULDBLOCK != EAGAIN
264    case EAGAIN:
265#  endif
266# endif
267
268# ifdef EPROTO
269    case EPROTO:
270# endif
271
272# ifdef EINPROGRESS
273    case EINPROGRESS:
274# endif
275
276# ifdef EALREADY
277    case EALREADY:
278# endif
279        return (1);
280        /* break; */
281    default:
282        break;
283    }
284    return (0);
285}
286
287#endif                          /* #ifndef OPENSSL_NO_SOCK */
288