3d08102ea37ce2ff026bf720bd6f970c0e2c3fd1
[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 #if 0
293                         memset(&(data->hstimeout), 0, sizeof(struct timeval));
294 #endif
295                         }
296                 }
297         return(ret);
298         }
299
300 static int dgram_write(BIO *b, const char *in, int inl)
301         {
302         int ret;
303         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
304         clear_socket_error();
305
306     if ( data->connected )
307         ret=writesocket(b->num,in,inl);
308     else
309 #if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
310         ret=sendto(b->num, (char *)in, inl, 0, &data->peer, sizeof(data->peer));
311 #else
312         ret=sendto(b->num, in, inl, 0, &data->peer, sizeof(data->peer));
313 #endif
314
315         BIO_clear_retry_flags(b);
316         if (ret <= 0)
317                 {
318                 if (BIO_sock_should_retry(ret))
319                         {
320                         BIO_set_retry_write(b);  
321                         data->_errno = get_last_socket_error();
322
323 #if 0 /* higher layers are responsible for querying MTU, if necessary */
324                         if ( data->_errno == EMSGSIZE)
325                                 /* retrieve the new MTU */
326                                 BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
327 #endif
328                         }
329                 }
330         return(ret);
331         }
332
333 static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr)
334         {
335         long ret=1;
336         int *ip;
337         struct sockaddr *to = NULL;
338         bio_dgram_data *data = NULL;
339         long sockopt_val = 0;
340         unsigned int sockopt_len = 0;
341
342         data = (bio_dgram_data *)b->ptr;
343
344         switch (cmd)
345                 {
346         case BIO_CTRL_RESET:
347                 num=0;
348         case BIO_C_FILE_SEEK:
349                 ret=0;
350                 break;
351         case BIO_C_FILE_TELL:
352         case BIO_CTRL_INFO:
353                 ret=0;
354                 break;
355         case BIO_C_SET_FD:
356                 dgram_clear(b);
357                 b->num= *((int *)ptr);
358                 b->shutdown=(int)num;
359                 b->init=1;
360                 break;
361         case BIO_C_GET_FD:
362                 if (b->init)
363                         {
364                         ip=(int *)ptr;
365                         if (ip != NULL) *ip=b->num;
366                         ret=b->num;
367                         }
368                 else
369                         ret= -1;
370                 break;
371         case BIO_CTRL_GET_CLOSE:
372                 ret=b->shutdown;
373                 break;
374         case BIO_CTRL_SET_CLOSE:
375                 b->shutdown=(int)num;
376                 break;
377         case BIO_CTRL_PENDING:
378         case BIO_CTRL_WPENDING:
379                 ret=0;
380                 break;
381         case BIO_CTRL_DUP:
382         case BIO_CTRL_FLUSH:
383                 ret=1;
384                 break;
385         case BIO_CTRL_DGRAM_CONNECT:
386                 to = (struct sockaddr *)ptr;
387 #if 0
388                 if (connect(b->num, to, sizeof(struct sockaddr)) < 0)
389                         { perror("connect"); ret = 0; }
390                 else
391                         {
392 #endif
393                         memcpy(&(data->peer),to, sizeof(struct sockaddr));
394 #if 0
395                         }
396 #endif
397                 break;
398                 /* (Linux)kernel sets DF bit on outgoing IP packets */
399 #ifdef IP_MTU_DISCOVER
400         case BIO_CTRL_DGRAM_MTU_DISCOVER:
401                 sockopt_val = IP_PMTUDISC_DO;
402                 if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
403                         &sockopt_val, sizeof(sockopt_val))) < 0)
404                         perror("setsockopt");
405                 break;
406 #endif
407         case BIO_CTRL_DGRAM_QUERY_MTU:
408 #ifdef IP_MTU
409         sockopt_len = sizeof(sockopt_val);
410                 if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val,
411                         &sockopt_len)) < 0 || sockopt_val < 0)
412                         { ret = 0; }
413                 else
414                         {
415                         data->mtu = sockopt_val - 20 - 8; /* Subtract IP and UDP header */
416                         ret = data->mtu;
417                         }
418 #else
419                 ret = 0;
420 #endif
421                 break;
422         case BIO_CTRL_DGRAM_GET_MTU:
423                 return data->mtu;
424                 break;
425         case BIO_CTRL_DGRAM_SET_MTU:
426                 data->mtu = num - 20 - 8; /* Subtract IP and UDP header */
427                 ret = data->mtu;
428                 break;
429         case BIO_CTRL_DGRAM_SET_CONNECTED:
430                 to = (struct sockaddr *)ptr;
431
432                 if ( to != NULL)
433                         {
434                         data->connected = 1;
435                         memcpy(&(data->peer),to, sizeof(struct sockaddr));
436                         }
437                 else
438                         {
439                         data->connected = 0;
440                         memset(&(data->peer), 0x00, sizeof(struct sockaddr));
441                         }
442                 break;
443     case BIO_CTRL_DGRAM_SET_PEER:
444         to = (struct sockaddr *) ptr;
445
446         memcpy(&(data->peer), to, sizeof(struct sockaddr));
447         break;
448         case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
449                 memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));             
450                 break;
451 #if defined(SO_RCVTIMEO)
452         case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
453 #ifdef OPENSSL_SYS_WINDOWS
454                 {
455                 struct timeval *tv = (struct timeval *)ptr;
456                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
457                 if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
458                         (void*)&timeout, sizeof(timeout)) < 0)
459                         { perror("setsockopt"); ret = -1; }
460                 }
461 #else
462                 if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,
463                         sizeof(struct timeval)) < 0)
464                         { perror("setsockopt"); ret = -1; }
465 #endif
466                 break;
467         case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:
468 #ifdef OPENSSL_SYS_WINDOWS
469                 {
470                 int timeout, sz = sizeof(timeout);
471                 struct timeval *tv = (struct timeval *)ptr;
472                 if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
473                         (void*)&timeout, &sz) < 0)
474                         { perror("getsockopt"); ret = -1; }
475                 else
476                         {
477                         tv->tv_sec = timeout / 1000;
478                         tv->tv_usec = (timeout % 1000) * 1000;
479                         ret = sizeof(*tv);
480                         }
481                 }
482 #else
483                 if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, 
484                         ptr, (void *)&ret) < 0)
485                         { perror("getsockopt"); ret = -1; }
486 #endif
487                 break;
488 #endif
489 #if defined(SO_SNDTIMEO)
490         case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT:
491 #ifdef OPENSSL_SYS_WINDOWS
492                 {
493                 struct timeval *tv = (struct timeval *)ptr;
494                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
495                 if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
496                         (void*)&timeout, sizeof(timeout)) < 0)
497                         { perror("setsockopt"); ret = -1; }
498                 }
499 #else
500                 if ( setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,
501                         sizeof(struct timeval)) < 0)
502                         { perror("setsockopt"); ret = -1; }
503 #endif
504                 break;
505         case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:
506 #ifdef OPENSSL_SYS_WINDOWS
507                 {
508                 int timeout, sz = sizeof(timeout);
509                 struct timeval *tv = (struct timeval *)ptr;
510                 if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
511                         (void*)&timeout, &sz) < 0)
512                         { perror("getsockopt"); ret = -1; }
513                 else
514                         {
515                         tv->tv_sec = timeout / 1000;
516                         tv->tv_usec = (timeout % 1000) * 1000;
517                         ret = sizeof(*tv);
518                         }
519                 }
520 #else
521                 if ( getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, 
522                         ptr, (void *)&ret) < 0)
523                         { perror("getsockopt"); ret = -1; }
524 #endif
525                 break;
526 #endif
527         case BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP:
528                 /* fall-through */
529         case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP:
530 #ifdef OPENSSL_SYS_WINDOWS
531                 if ( data->_errno == WSAETIMEDOUT)
532 #else
533                 if ( data->_errno == EAGAIN)
534 #endif
535                         {
536                         ret = 1;
537                         data->_errno = 0;
538                         }
539                 else
540                         ret = 0;
541                 break;
542 #ifdef EMSGSIZE
543         case BIO_CTRL_DGRAM_MTU_EXCEEDED:
544                 if ( data->_errno == EMSGSIZE)
545                         {
546                         ret = 1;
547                         data->_errno = 0;
548                         }
549                 else
550                         ret = 0;
551                 break;
552 #endif
553         default:
554                 ret=0;
555                 break;
556                 }
557         return(ret);
558         }
559
560 static int dgram_puts(BIO *bp, const char *str)
561         {
562         int n,ret;
563
564         n=strlen(str);
565         ret=dgram_write(bp,str,n);
566         return(ret);
567         }
568
569 static int BIO_dgram_should_retry(int i)
570         {
571         int err;
572
573         if ((i == 0) || (i == -1))
574                 {
575                 err=get_last_socket_error();
576
577 #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
578                 if ((i == -1) && (err == 0))
579                         return(1);
580 #endif
581
582                 return(BIO_dgram_non_fatal_error(err));
583                 }
584         return(0);
585         }
586
587 int BIO_dgram_non_fatal_error(int err)
588         {
589         switch (err)
590                 {
591 #if defined(OPENSSL_SYS_WINDOWS)
592 # if defined(WSAEWOULDBLOCK)
593         case WSAEWOULDBLOCK:
594 # endif
595
596 # if 0 /* This appears to always be an error */
597 #  if defined(WSAENOTCONN)
598         case WSAENOTCONN:
599 #  endif
600 # endif
601 #endif
602
603 #ifdef EWOULDBLOCK
604 # ifdef WSAEWOULDBLOCK
605 #  if WSAEWOULDBLOCK != EWOULDBLOCK
606         case EWOULDBLOCK:
607 #  endif
608 # else
609         case EWOULDBLOCK:
610 # endif
611 #endif
612
613 #if defined(ENOTCONN)
614         case ENOTCONN:
615 #endif
616
617 #ifdef EINTR
618         case EINTR:
619 #endif
620
621 #ifdef EAGAIN
622 #if EWOULDBLOCK != EAGAIN
623         case EAGAIN:
624 # endif
625 #endif
626
627 #ifdef EPROTO
628         case EPROTO:
629 #endif
630
631 #ifdef EINPROGRESS
632         case EINPROGRESS:
633 #endif
634
635 #ifdef EALREADY
636         case EALREADY:
637 #endif
638
639 /* DF bit set, and packet larger than MTU */
640 #ifdef EMSGSIZE
641         case EMSGSIZE:
642 #endif
643
644                 return(1);
645                 /* break; */
646         default:
647                 break;
648                 }
649         return(0);
650         }
651 #endif
652
653 static void get_current_time(struct timeval *t)
654         {
655 #ifdef OPENSSL_SYS_WIN32
656         struct _timeb tb;
657         _ftime(&tb);
658         t->tv_sec = (long)tb.time;
659         t->tv_usec = (long)tb.millitm * 1000;
660 #elif defined(OPENSSL_SYS_VMS)
661         struct timeb tb;
662         ftime(&tb);
663         t->tv_sec = (long)tb.time;
664         t->tv_usec = (long)tb.millitm * 1000;
665 #else
666         gettimeofday(t, NULL);
667 #endif
668         }