Update from 1.0.0-stable.
[openssl.git] / crypto / bio / bss_dgram.c
1 /* crypto/bio/bio_dgram.c */
2 /* 
3  * DTLS implementation written by Nagendra Modadugu
4  * (nagendra@cs.stanford.edu) for the OpenSSL project 2005.  
5  */
6 /* ====================================================================
7  * Copyright (c) 1999-2005 The OpenSSL Project.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer. 
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in
18  *    the documentation and/or other materials provided with the
19  *    distribution.
20  *
21  * 3. All advertising materials mentioning features or use of this
22  *    software must display the following acknowledgment:
23  *    "This product includes software developed by the OpenSSL Project
24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25  *
26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For written permission, please contact
29  *    openssl-core@OpenSSL.org.
30  *
31  * 5. Products derived from this software may not be called "OpenSSL"
32  *    nor may "OpenSSL" appear in their names without prior written
33  *    permission of the OpenSSL Project.
34  *
35  * 6. Redistributions of any form whatsoever must retain the following
36  *    acknowledgment:
37  *    "This product includes software developed by the OpenSSL Project
38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51  * OF THE POSSIBILITY OF SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This product includes cryptographic software written by Eric Young
55  * (eay@cryptsoft.com).  This product includes software written by Tim
56  * Hudson (tjh@cryptsoft.com).
57  *
58  */
59
60 #ifndef OPENSSL_NO_DGRAM
61
62 #include <stdio.h>
63 #include <errno.h>
64 #define USE_SOCKETS
65 #include "cryptlib.h"
66
67 #include <openssl/bio.h>
68
69 #if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS)
70 #include <sys/timeb.h>
71 #endif
72
73 #ifdef OPENSSL_SYS_LINUX
74 #define IP_MTU      14 /* linux is lame */
75 #endif
76
77 #ifdef WATT32
78 #define sock_write SockWrite  /* Watt-32 uses same names */
79 #define sock_read  SockRead
80 #define sock_puts  SockPuts
81 #endif
82
83 static int dgram_write(BIO *h, const char *buf, int num);
84 static int dgram_read(BIO *h, char *buf, int size);
85 static int dgram_puts(BIO *h, const char *str);
86 static long dgram_ctrl(BIO *h, int cmd, long arg1, void *arg2);
87 static int dgram_new(BIO *h);
88 static int dgram_free(BIO *data);
89 static int dgram_clear(BIO *bio);
90
91 static int BIO_dgram_should_retry(int s);
92
93 static void get_current_time(struct timeval *t);
94
95 static BIO_METHOD methods_dgramp=
96         {
97         BIO_TYPE_DGRAM,
98         "datagram socket",
99         dgram_write,
100         dgram_read,
101         dgram_puts,
102         NULL, /* dgram_gets, */
103         dgram_ctrl,
104         dgram_new,
105         dgram_free,
106         NULL,
107         };
108
109 typedef struct bio_dgram_data_st
110         {
111         struct sockaddr peer;
112         unsigned int connected;
113         unsigned int _errno;
114         unsigned int mtu;
115         struct timeval next_timeout;
116         struct timeval socket_timeout;
117         } bio_dgram_data;
118
119 BIO_METHOD *BIO_s_datagram(void)
120         {
121         return(&methods_dgramp);
122         }
123
124 BIO *BIO_new_dgram(int fd, int close_flag)
125         {
126         BIO *ret;
127
128         ret=BIO_new(BIO_s_datagram());
129         if (ret == NULL) return(NULL);
130         BIO_set_fd(ret,fd,close_flag);
131         return(ret);
132         }
133
134 static int dgram_new(BIO *bi)
135         {
136         bio_dgram_data *data = NULL;
137
138         bi->init=0;
139         bi->num=0;
140         data = OPENSSL_malloc(sizeof(bio_dgram_data));
141         if (data == NULL)
142                 return 0;
143         memset(data, 0x00, sizeof(bio_dgram_data));
144     bi->ptr = data;
145
146         bi->flags=0;
147         return(1);
148         }
149
150 static int dgram_free(BIO *a)
151         {
152         bio_dgram_data *data;
153
154         if (a == NULL) return(0);
155         if ( ! dgram_clear(a))
156                 return 0;
157
158         data = (bio_dgram_data *)a->ptr;
159         if(data != NULL) OPENSSL_free(data);
160
161         return(1);
162         }
163
164 static int dgram_clear(BIO *a)
165         {
166         if (a == NULL) return(0);
167         if (a->shutdown)
168                 {
169                 if (a->init)
170                         {
171                         SHUTDOWN2(a->num);
172                         }
173                 a->init=0;
174                 a->flags=0;
175                 }
176         return(1);
177         }
178
179 static void dgram_adjust_rcv_timeout(BIO *b)
180         {
181 #if defined(SO_RCVTIMEO)
182         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
183         int sz = sizeof(int);
184
185         /* Is a timer active? */
186         if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0)
187                 {
188                 struct timeval timenow, timeleft;
189
190                 /* Read current socket timeout */
191 #ifdef OPENSSL_SYS_WINDOWS
192                 int timeout;
193                 if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
194                                            (void*)&timeout, &sz) < 0)
195                         { perror("getsockopt"); }
196                 else
197                         {
198                         data->socket_timeout.tv_sec = timeout / 1000;
199                         data->socket_timeout.tv_usec = (timeout % 1000) * 1000;
200                         }
201 #else
202                 if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, 
203                                                 &(data->socket_timeout), (void *)&sz) < 0)
204                         { perror("getsockopt"); }
205 #endif
206
207                 /* Get current time */
208                 get_current_time(&timenow);
209
210                 /* Calculate time left until timer expires */
211                 memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval));
212                 timeleft.tv_sec -= timenow.tv_sec;
213                 timeleft.tv_usec -= timenow.tv_usec;
214                 if (timeleft.tv_usec < 0)
215                         {
216                         timeleft.tv_sec--;
217                         timeleft.tv_usec += 1000000;
218                         }
219
220                 /* Adjust socket timeout if next handhake message timer
221                  * will expire earlier.
222                  */
223                 if (data->socket_timeout.tv_sec < timeleft.tv_sec ||
224                         (data->socket_timeout.tv_sec == timeleft.tv_sec &&
225                          data->socket_timeout.tv_usec <= timeleft.tv_usec))
226                         {
227 #ifdef OPENSSL_SYS_WINDOWS
228                         timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000;
229                         if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
230                                                    (void*)&timeout, sizeof(timeout)) < 0)
231                                 { perror("setsockopt"); }
232 #else
233                         if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft,
234                                                         sizeof(struct timeval)) < 0)
235                                 { perror("setsockopt"); }
236 #endif
237                         }
238                 }
239 #endif
240         }
241
242 static void dgram_reset_rcv_timeout(BIO *b)
243         {
244 #if defined(SO_RCVTIMEO)
245         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
246 #ifdef OPENSSL_SYS_WINDOWS
247         int timeout = data->socket_timeout.tv_sec * 1000 +
248                                   data->socket_timeout.tv_usec / 1000;
249         if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
250                                    (void*)&timeout, sizeof(timeout)) < 0)
251                 { perror("setsockopt"); }
252 #else
253         if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout),
254                                         sizeof(struct timeval)) < 0)
255                 { perror("setsockopt"); }
256 #endif
257 #endif
258         }
259
260 static int dgram_read(BIO *b, char *out, int outl)
261         {
262         int ret=0;
263         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
264
265         struct sockaddr peer;
266         int peerlen = sizeof(peer);
267
268         if (out != NULL)
269                 {
270                 clear_socket_error();
271                 memset(&peer, 0x00, peerlen);
272                 /* Last arg in recvfrom is signed on some platforms and
273                  * unsigned on others. It is of type socklen_t on some
274                  * but this is not universal. Cast to (void *) to avoid
275                  * compiler warnings.
276                  */
277                 dgram_adjust_rcv_timeout(b);
278                 ret=recvfrom(b->num,out,outl,0,&peer,(void *)&peerlen);
279                 dgram_reset_rcv_timeout(b);
280
281                 if ( ! data->connected  && ret > 0)
282                         BIO_ctrl(b, BIO_CTRL_DGRAM_CONNECT, 0, &peer);
283
284                 BIO_clear_retry_flags(b);
285                 if (ret <= 0)
286                         {
287                         if (BIO_dgram_should_retry(ret))
288                                 {
289                                 BIO_set_retry_read(b);
290                                 data->_errno = get_last_socket_error();
291                                 }
292                         }
293                 }
294         return(ret);
295         }
296
297 static int dgram_write(BIO *b, const char *in, int inl)
298         {
299         int ret;
300         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
301         clear_socket_error();
302
303     if ( data->connected )
304         ret=writesocket(b->num,in,inl);
305     else
306 #if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
307         ret=sendto(b->num, (char *)in, inl, 0, &data->peer, sizeof(data->peer));
308 #else
309         ret=sendto(b->num, in, inl, 0, &data->peer, sizeof(data->peer));
310 #endif
311
312         BIO_clear_retry_flags(b);
313         if (ret <= 0)
314                 {
315                 if (BIO_sock_should_retry(ret))
316                         {
317                         BIO_set_retry_write(b);  
318                         data->_errno = get_last_socket_error();
319
320 #if 0 /* higher layers are responsible for querying MTU, if necessary */
321                         if ( data->_errno == EMSGSIZE)
322                                 /* retrieve the new MTU */
323                                 BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
324 #endif
325                         }
326                 }
327         return(ret);
328         }
329
330 static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr)
331         {
332         long ret=1;
333         int *ip;
334         struct sockaddr *to = NULL;
335         bio_dgram_data *data = NULL;
336         long sockopt_val = 0;
337         unsigned int sockopt_len = 0;
338 #ifdef OPENSSL_SYS_LINUX
339         socklen_t addr_len;
340         struct sockaddr_storage addr;
341 #endif
342
343         data = (bio_dgram_data *)b->ptr;
344
345         switch (cmd)
346                 {
347         case BIO_CTRL_RESET:
348                 num=0;
349         case BIO_C_FILE_SEEK:
350                 ret=0;
351                 break;
352         case BIO_C_FILE_TELL:
353         case BIO_CTRL_INFO:
354                 ret=0;
355                 break;
356         case BIO_C_SET_FD:
357                 dgram_clear(b);
358                 b->num= *((int *)ptr);
359                 b->shutdown=(int)num;
360                 b->init=1;
361                 break;
362         case BIO_C_GET_FD:
363                 if (b->init)
364                         {
365                         ip=(int *)ptr;
366                         if (ip != NULL) *ip=b->num;
367                         ret=b->num;
368                         }
369                 else
370                         ret= -1;
371                 break;
372         case BIO_CTRL_GET_CLOSE:
373                 ret=b->shutdown;
374                 break;
375         case BIO_CTRL_SET_CLOSE:
376                 b->shutdown=(int)num;
377                 break;
378         case BIO_CTRL_PENDING:
379         case BIO_CTRL_WPENDING:
380                 ret=0;
381                 break;
382         case BIO_CTRL_DUP:
383         case BIO_CTRL_FLUSH:
384                 ret=1;
385                 break;
386         case BIO_CTRL_DGRAM_CONNECT:
387                 to = (struct sockaddr *)ptr;
388 #if 0
389                 if (connect(b->num, to, sizeof(struct sockaddr)) < 0)
390                         { perror("connect"); ret = 0; }
391                 else
392                         {
393 #endif
394                         memcpy(&(data->peer),to, sizeof(struct sockaddr));
395 #if 0
396                         }
397 #endif
398                 break;
399                 /* (Linux)kernel sets DF bit on outgoing IP packets */
400         case BIO_CTRL_DGRAM_MTU_DISCOVER:
401 #ifdef OPENSSL_SYS_LINUX
402                 addr_len = (socklen_t)sizeof(struct sockaddr_storage);
403                 memset((void *)&addr, 0, sizeof(struct sockaddr_storage));
404                 if (getsockname(b->num, (void *)&addr, &addr_len) < 0)
405                         {
406                         ret = 0;
407                         break;
408                         }
409                 sockopt_len = sizeof(sockopt_val);
410                 switch (addr.ss_family)
411                         {
412                 case AF_INET:
413                         sockopt_val = IP_PMTUDISC_DO;
414                         if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
415                                 &sockopt_val, sizeof(sockopt_val))) < 0)
416                                 perror("setsockopt");
417                         break;
418                 case AF_INET6:
419                         sockopt_val = IPV6_PMTUDISC_DO;
420                         if ((ret = setsockopt(b->num, IPPROTO_IPV6, IPV6_MTU_DISCOVER,
421                                 &sockopt_val, sizeof(sockopt_val))) < 0)
422                                 perror("setsockopt");
423                         break;
424                 default:
425                         ret = -1;
426                         break;
427                         }
428                 ret = -1;
429 #else
430                 break;
431 #endif
432         case BIO_CTRL_DGRAM_QUERY_MTU:
433 #ifdef OPENSSL_SYS_LINUX
434                 addr_len = (socklen_t)sizeof(struct sockaddr_storage);
435                 memset((void *)&addr, 0, sizeof(struct sockaddr_storage));
436                 if (getsockname(b->num, (void *)&addr, &addr_len) < 0)
437                         {
438                         ret = 0;
439                         break;
440                         }
441                 sockopt_len = sizeof(sockopt_val);
442                 switch (addr.ss_family)
443                         {
444                 case AF_INET:
445                         if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val,
446                                 &sockopt_len)) < 0 || sockopt_val < 0)
447                                 {
448                                 ret = 0;
449                                 }
450                         else
451                                 {
452                                 /* we assume that the transport protocol is UDP and no
453                                  * IP options are used.
454                                  */
455                                 data->mtu = sockopt_val - 8 - 20;
456                                 ret = data->mtu;
457                                 }
458                         break;
459                 case AF_INET6:
460                         if ((ret = getsockopt(b->num, IPPROTO_IPV6, IPV6_MTU, (void *)&sockopt_val,
461                                 &sockopt_len)) < 0 || sockopt_val < 0)
462                                 {
463                                 ret = 0;
464                                 }
465                         else
466                                 {
467                                 /* we assume that the transport protocol is UDP and no
468                                  * IPV6 options are used.
469                                  */
470                                 data->mtu = sockopt_val - 8 - 40;
471                                 ret = data->mtu;
472                                 }
473                         break;
474                 default:
475                         ret = 0;
476                         break;
477                         }
478 #else
479                 ret = 0;
480 #endif
481                 break;
482         case BIO_CTRL_DGRAM_GET_MTU:
483                 return data->mtu;
484                 break;
485         case BIO_CTRL_DGRAM_SET_MTU:
486                 data->mtu = num;
487                 ret = num;
488                 break;
489         case BIO_CTRL_DGRAM_SET_CONNECTED:
490                 to = (struct sockaddr *)ptr;
491
492                 if ( to != NULL)
493                         {
494                         data->connected = 1;
495                         memcpy(&(data->peer),to, sizeof(struct sockaddr));
496                         }
497                 else
498                         {
499                         data->connected = 0;
500                         memset(&(data->peer), 0x00, sizeof(struct sockaddr));
501                         }
502                 break;
503     case BIO_CTRL_DGRAM_SET_PEER:
504         to = (struct sockaddr *) ptr;
505
506         memcpy(&(data->peer), to, sizeof(struct sockaddr));
507         break;
508         case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
509                 memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));             
510                 break;
511 #if defined(SO_RCVTIMEO)
512         case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
513 #ifdef OPENSSL_SYS_WINDOWS
514                 {
515                 struct timeval *tv = (struct timeval *)ptr;
516                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
517                 if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
518                         (void*)&timeout, sizeof(timeout)) < 0)
519                         { perror("setsockopt"); ret = -1; }
520                 }
521 #else
522                 if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,
523                         sizeof(struct timeval)) < 0)
524                         { perror("setsockopt"); ret = -1; }
525 #endif
526                 break;
527         case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:
528 #ifdef OPENSSL_SYS_WINDOWS
529                 {
530                 int timeout, sz = sizeof(timeout);
531                 struct timeval *tv = (struct timeval *)ptr;
532                 if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
533                         (void*)&timeout, &sz) < 0)
534                         { perror("getsockopt"); ret = -1; }
535                 else
536                         {
537                         tv->tv_sec = timeout / 1000;
538                         tv->tv_usec = (timeout % 1000) * 1000;
539                         ret = sizeof(*tv);
540                         }
541                 }
542 #else
543                 if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, 
544                         ptr, (void *)&ret) < 0)
545                         { perror("getsockopt"); ret = -1; }
546 #endif
547                 break;
548 #endif
549 #if defined(SO_SNDTIMEO)
550         case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT:
551 #ifdef OPENSSL_SYS_WINDOWS
552                 {
553                 struct timeval *tv = (struct timeval *)ptr;
554                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
555                 if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
556                         (void*)&timeout, sizeof(timeout)) < 0)
557                         { perror("setsockopt"); ret = -1; }
558                 }
559 #else
560                 if ( setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,
561                         sizeof(struct timeval)) < 0)
562                         { perror("setsockopt"); ret = -1; }
563 #endif
564                 break;
565         case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:
566 #ifdef OPENSSL_SYS_WINDOWS
567                 {
568                 int timeout, sz = sizeof(timeout);
569                 struct timeval *tv = (struct timeval *)ptr;
570                 if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
571                         (void*)&timeout, &sz) < 0)
572                         { perror("getsockopt"); ret = -1; }
573                 else
574                         {
575                         tv->tv_sec = timeout / 1000;
576                         tv->tv_usec = (timeout % 1000) * 1000;
577                         ret = sizeof(*tv);
578                         }
579                 }
580 #else
581                 if ( getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, 
582                         ptr, (void *)&ret) < 0)
583                         { perror("getsockopt"); ret = -1; }
584 #endif
585                 break;
586 #endif
587         case BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP:
588                 /* fall-through */
589         case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP:
590 #ifdef OPENSSL_SYS_WINDOWS
591                 if ( data->_errno == WSAETIMEDOUT)
592 #else
593                 if ( data->_errno == EAGAIN)
594 #endif
595                         {
596                         ret = 1;
597                         data->_errno = 0;
598                         }
599                 else
600                         ret = 0;
601                 break;
602 #ifdef EMSGSIZE
603         case BIO_CTRL_DGRAM_MTU_EXCEEDED:
604                 if ( data->_errno == EMSGSIZE)
605                         {
606                         ret = 1;
607                         data->_errno = 0;
608                         }
609                 else
610                         ret = 0;
611                 break;
612 #endif
613         default:
614                 ret=0;
615                 break;
616                 }
617         return(ret);
618         }
619
620 static int dgram_puts(BIO *bp, const char *str)
621         {
622         int n,ret;
623
624         n=strlen(str);
625         ret=dgram_write(bp,str,n);
626         return(ret);
627         }
628
629 static int BIO_dgram_should_retry(int i)
630         {
631         int err;
632
633         if ((i == 0) || (i == -1))
634                 {
635                 err=get_last_socket_error();
636
637 #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
638                 if ((i == -1) && (err == 0))
639                         return(1);
640 #endif
641
642                 return(BIO_dgram_non_fatal_error(err));
643                 }
644         return(0);
645         }
646
647 int BIO_dgram_non_fatal_error(int err)
648         {
649         switch (err)
650                 {
651 #if defined(OPENSSL_SYS_WINDOWS)
652 # if defined(WSAEWOULDBLOCK)
653         case WSAEWOULDBLOCK:
654 # endif
655
656 # if 0 /* This appears to always be an error */
657 #  if defined(WSAENOTCONN)
658         case WSAENOTCONN:
659 #  endif
660 # endif
661 #endif
662
663 #ifdef EWOULDBLOCK
664 # ifdef WSAEWOULDBLOCK
665 #  if WSAEWOULDBLOCK != EWOULDBLOCK
666         case EWOULDBLOCK:
667 #  endif
668 # else
669         case EWOULDBLOCK:
670 # endif
671 #endif
672
673 #if defined(ENOTCONN)
674         case ENOTCONN:
675 #endif
676
677 #ifdef EINTR
678         case EINTR:
679 #endif
680
681 #ifdef EAGAIN
682 #if EWOULDBLOCK != EAGAIN
683         case EAGAIN:
684 # endif
685 #endif
686
687 #ifdef EPROTO
688         case EPROTO:
689 #endif
690
691 #ifdef EINPROGRESS
692         case EINPROGRESS:
693 #endif
694
695 #ifdef EALREADY
696         case EALREADY:
697 #endif
698
699 /* DF bit set, and packet larger than MTU */
700 #ifdef EMSGSIZE
701         case EMSGSIZE:
702 #endif
703
704                 return(1);
705                 /* break; */
706         default:
707                 break;
708                 }
709         return(0);
710         }
711 #endif
712
713 static void get_current_time(struct timeval *t)
714         {
715 #ifdef OPENSSL_SYS_WIN32
716         struct _timeb tb;
717         _ftime(&tb);
718         t->tv_sec = (long)tb.time;
719         t->tv_usec = (long)tb.millitm * 1000;
720 #elif defined(OPENSSL_SYS_VMS)
721         struct timeb tb;
722         ftime(&tb);
723         t->tv_sec = (long)tb.time;
724         t->tv_usec = (long)tb.millitm * 1000;
725 #else
726         gettimeofday(t, NULL);
727 #endif
728         }