d809a3585765b6bbf1cd5e0aeef00923098451ed
[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 #define IP_MTU      14 /* linux is lame */
74
75 #ifdef WATT32
76 #define sock_write SockWrite  /* Watt-32 uses same names */
77 #define sock_read  SockRead
78 #define sock_puts  SockPuts
79 #endif
80
81 static int dgram_write(BIO *h, const char *buf, int num);
82 static int dgram_read(BIO *h, char *buf, int size);
83 static int dgram_puts(BIO *h, const char *str);
84 static long dgram_ctrl(BIO *h, int cmd, long arg1, void *arg2);
85 static int dgram_new(BIO *h);
86 static int dgram_free(BIO *data);
87 static int dgram_clear(BIO *bio);
88
89 static int BIO_dgram_should_retry(int s);
90
91 static void get_current_time(struct timeval *t);
92
93 static BIO_METHOD methods_dgramp=
94         {
95         BIO_TYPE_DGRAM,
96         "datagram socket",
97         dgram_write,
98         dgram_read,
99         dgram_puts,
100         NULL, /* dgram_gets, */
101         dgram_ctrl,
102         dgram_new,
103         dgram_free,
104         NULL,
105         };
106
107 typedef struct bio_dgram_data_st
108         {
109         struct sockaddr peer;
110         unsigned int connected;
111         unsigned int _errno;
112         unsigned int mtu;
113         struct timeval next_timeout;
114         struct timeval socket_timeout;
115         } bio_dgram_data;
116
117 BIO_METHOD *BIO_s_datagram(void)
118         {
119         return(&methods_dgramp);
120         }
121
122 BIO *BIO_new_dgram(int fd, int close_flag)
123         {
124         BIO *ret;
125
126         ret=BIO_new(BIO_s_datagram());
127         if (ret == NULL) return(NULL);
128         BIO_set_fd(ret,fd,close_flag);
129         return(ret);
130         }
131
132 static int dgram_new(BIO *bi)
133         {
134         bio_dgram_data *data = NULL;
135
136         bi->init=0;
137         bi->num=0;
138         data = OPENSSL_malloc(sizeof(bio_dgram_data));
139         if (data == NULL)
140                 return 0;
141         memset(data, 0x00, sizeof(bio_dgram_data));
142     bi->ptr = data;
143
144         bi->flags=0;
145         return(1);
146         }
147
148 static int dgram_free(BIO *a)
149         {
150         bio_dgram_data *data;
151
152         if (a == NULL) return(0);
153         if ( ! dgram_clear(a))
154                 return 0;
155
156         data = (bio_dgram_data *)a->ptr;
157         if(data != NULL) OPENSSL_free(data);
158
159         return(1);
160         }
161
162 static int dgram_clear(BIO *a)
163         {
164         if (a == NULL) return(0);
165         if (a->shutdown)
166                 {
167                 if (a->init)
168                         {
169                         SHUTDOWN2(a->num);
170                         }
171                 a->init=0;
172                 a->flags=0;
173                 }
174         return(1);
175         }
176
177 static void dgram_adjust_rcv_timeout(BIO *b)
178         {
179 #if defined(SO_RCVTIMEO)
180         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
181         int sz = sizeof(int);
182
183         /* Is a timer active? */
184         if (data->next_timeout.tv_sec > 0 || data->next_timeout.tv_usec > 0)
185                 {
186                 struct timeval timenow, timeleft;
187
188                 /* Read current socket timeout */
189 #ifdef OPENSSL_SYS_WINDOWS
190                 int timeout;
191                 if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
192                                            (void*)&timeout, &sz) < 0)
193                         { perror("getsockopt"); }
194                 else
195                         {
196                         data->socket_timeout.tv_sec = timeout / 1000;
197                         data->socket_timeout.tv_usec = (timeout % 1000) * 1000;
198                         }
199 #else
200                 if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, 
201                                                 &(data->socket_timeout), (void *)&sz) < 0)
202                         { perror("getsockopt"); }
203 #endif
204
205                 /* Get current time */
206                 get_current_time(&timenow);
207
208                 /* Calculate time left until timer expires */
209                 memcpy(&timeleft, &(data->next_timeout), sizeof(struct timeval));
210                 timeleft.tv_sec -= timenow.tv_sec;
211                 timeleft.tv_usec -= timenow.tv_usec;
212                 if (timeleft.tv_usec < 0)
213                         {
214                         timeleft.tv_sec--;
215                         timeleft.tv_usec += 1000000;
216                         }
217
218                 /* Adjust socket timeout if next handhake message timer
219                  * will expire earlier.
220                  */
221                 if (data->socket_timeout.tv_sec < timeleft.tv_sec ||
222                         (data->socket_timeout.tv_sec == timeleft.tv_sec &&
223                          data->socket_timeout.tv_usec <= timeleft.tv_usec))
224                         {
225 #ifdef OPENSSL_SYS_WINDOWS
226                         timeout = timeleft.tv_sec * 1000 + timeleft.tv_usec / 1000;
227                         if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
228                                                    (void*)&timeout, sizeof(timeout)) < 0)
229                                 { perror("setsockopt"); }
230 #else
231                         if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &timeleft,
232                                                         sizeof(struct timeval)) < 0)
233                                 { perror("setsockopt"); }
234 #endif
235                         }
236                 }
237 #endif
238         }
239
240 static void dgram_reset_rcv_timeout(BIO *b)
241         {
242 #if defined(SO_RCVTIMEO)
243         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
244 #ifdef OPENSSL_SYS_WINDOWS
245         int timeout = data->socket_timeout.tv_sec * 1000 +
246                                   data->socket_timeout.tv_usec / 1000;
247         if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
248                                    (void*)&timeout, sizeof(timeout)) < 0)
249                 { perror("setsockopt"); }
250 #else
251         if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, &(data->socket_timeout),
252                                         sizeof(struct timeval)) < 0)
253                 { perror("setsockopt"); }
254 #endif
255 #endif
256         }
257
258 static int dgram_read(BIO *b, char *out, int outl)
259         {
260         int ret=0;
261         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
262
263         struct sockaddr peer;
264         int peerlen = sizeof(peer);
265
266         if (out != NULL)
267                 {
268                 clear_socket_error();
269                 memset(&peer, 0x00, peerlen);
270                 /* Last arg in recvfrom is signed on some platforms and
271                  * unsigned on others. It is of type socklen_t on some
272                  * but this is not universal. Cast to (void *) to avoid
273                  * compiler warnings.
274                  */
275                 dgram_adjust_rcv_timeout(b);
276                 ret=recvfrom(b->num,out,outl,0,&peer,(void *)&peerlen);
277                 dgram_reset_rcv_timeout(b);
278
279                 if ( ! data->connected  && ret > 0)
280                         BIO_ctrl(b, BIO_CTRL_DGRAM_CONNECT, 0, &peer);
281
282                 BIO_clear_retry_flags(b);
283                 if (ret <= 0)
284                         {
285                         if (BIO_dgram_should_retry(ret))
286                                 {
287                                 BIO_set_retry_read(b);
288                                 data->_errno = get_last_socket_error();
289                                 }
290 #if 0
291                         memset(&(data->hstimeout), 0, sizeof(struct timeval));
292 #endif
293                         }
294                 }
295         return(ret);
296         }
297
298 static int dgram_write(BIO *b, const char *in, int inl)
299         {
300         int ret;
301         bio_dgram_data *data = (bio_dgram_data *)b->ptr;
302         clear_socket_error();
303
304     if ( data->connected )
305         ret=writesocket(b->num,in,inl);
306     else
307 #if defined(NETWARE_CLIB) && defined(NETWARE_BSDSOCK)
308         ret=sendto(b->num, (char *)in, inl, 0, &data->peer, sizeof(data->peer));
309 #else
310         ret=sendto(b->num, in, inl, 0, &data->peer, sizeof(data->peer));
311 #endif
312
313         BIO_clear_retry_flags(b);
314         if (ret <= 0)
315                 {
316                 if (BIO_sock_should_retry(ret))
317                         {
318                         BIO_set_retry_write(b);  
319                         data->_errno = get_last_socket_error();
320
321 #if 0 /* higher layers are responsible for querying MTU, if necessary */
322                         if ( data->_errno == EMSGSIZE)
323                                 /* retrieve the new MTU */
324                                 BIO_ctrl(b, BIO_CTRL_DGRAM_QUERY_MTU, 0, NULL);
325 #endif
326                         }
327                 }
328         return(ret);
329         }
330
331 static long dgram_ctrl(BIO *b, int cmd, long num, void *ptr)
332         {
333         long ret=1;
334         int *ip;
335         struct sockaddr *to = NULL;
336         bio_dgram_data *data = NULL;
337         long sockopt_val = 0;
338         unsigned int sockopt_len = 0;
339
340         data = (bio_dgram_data *)b->ptr;
341
342         switch (cmd)
343                 {
344         case BIO_CTRL_RESET:
345                 num=0;
346         case BIO_C_FILE_SEEK:
347                 ret=0;
348                 break;
349         case BIO_C_FILE_TELL:
350         case BIO_CTRL_INFO:
351                 ret=0;
352                 break;
353         case BIO_C_SET_FD:
354                 dgram_clear(b);
355                 b->num= *((int *)ptr);
356                 b->shutdown=(int)num;
357                 b->init=1;
358                 break;
359         case BIO_C_GET_FD:
360                 if (b->init)
361                         {
362                         ip=(int *)ptr;
363                         if (ip != NULL) *ip=b->num;
364                         ret=b->num;
365                         }
366                 else
367                         ret= -1;
368                 break;
369         case BIO_CTRL_GET_CLOSE:
370                 ret=b->shutdown;
371                 break;
372         case BIO_CTRL_SET_CLOSE:
373                 b->shutdown=(int)num;
374                 break;
375         case BIO_CTRL_PENDING:
376         case BIO_CTRL_WPENDING:
377                 ret=0;
378                 break;
379         case BIO_CTRL_DUP:
380         case BIO_CTRL_FLUSH:
381                 ret=1;
382                 break;
383         case BIO_CTRL_DGRAM_CONNECT:
384                 to = (struct sockaddr *)ptr;
385 #if 0
386                 if (connect(b->num, to, sizeof(struct sockaddr)) < 0)
387                         { perror("connect"); ret = 0; }
388                 else
389                         {
390 #endif
391                         memcpy(&(data->peer),to, sizeof(struct sockaddr));
392 #if 0
393                         }
394 #endif
395                 break;
396                 /* (Linux)kernel sets DF bit on outgoing IP packets */
397 #ifdef IP_MTU_DISCOVER
398         case BIO_CTRL_DGRAM_MTU_DISCOVER:
399                 sockopt_val = IP_PMTUDISC_DO;
400                 if ((ret = setsockopt(b->num, IPPROTO_IP, IP_MTU_DISCOVER,
401                         &sockopt_val, sizeof(sockopt_val))) < 0)
402                         perror("setsockopt");
403                 break;
404 #endif
405         case BIO_CTRL_DGRAM_QUERY_MTU:
406          sockopt_len = sizeof(sockopt_val);
407                 if ((ret = getsockopt(b->num, IPPROTO_IP, IP_MTU, (void *)&sockopt_val,
408                         &sockopt_len)) < 0 || sockopt_val < 0)
409                         { ret = 0; }
410                 else
411                         {
412                         data->mtu = sockopt_val;
413                         ret = data->mtu;
414                         }
415                 break;
416         case BIO_CTRL_DGRAM_GET_MTU:
417                 return data->mtu;
418                 break;
419         case BIO_CTRL_DGRAM_SET_MTU:
420                 data->mtu = num;
421                 ret = num;
422                 break;
423         case BIO_CTRL_DGRAM_SET_CONNECTED:
424                 to = (struct sockaddr *)ptr;
425
426                 if ( to != NULL)
427                         {
428                         data->connected = 1;
429                         memcpy(&(data->peer),to, sizeof(struct sockaddr));
430                         }
431                 else
432                         {
433                         data->connected = 0;
434                         memset(&(data->peer), 0x00, sizeof(struct sockaddr));
435                         }
436                 break;
437     case BIO_CTRL_DGRAM_SET_PEER:
438         to = (struct sockaddr *) ptr;
439
440         memcpy(&(data->peer), to, sizeof(struct sockaddr));
441         break;
442         case BIO_CTRL_DGRAM_SET_NEXT_TIMEOUT:
443                 memcpy(&(data->next_timeout), ptr, sizeof(struct timeval));             
444                 break;
445 #if defined(SO_RCVTIMEO)
446         case BIO_CTRL_DGRAM_SET_RECV_TIMEOUT:
447 #ifdef OPENSSL_SYS_WINDOWS
448                 {
449                 struct timeval *tv = (struct timeval *)ptr;
450                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
451                 if (setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
452                         (void*)&timeout, sizeof(timeout)) < 0)
453                         { perror("setsockopt"); ret = -1; }
454                 }
455 #else
456                 if ( setsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, ptr,
457                         sizeof(struct timeval)) < 0)
458                         { perror("setsockopt"); ret = -1; }
459 #endif
460                 break;
461         case BIO_CTRL_DGRAM_GET_RECV_TIMEOUT:
462 #ifdef OPENSSL_SYS_WINDOWS
463                 {
464                 int timeout, sz = sizeof(timeout);
465                 struct timeval *tv = (struct timeval *)ptr;
466                 if (getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO,
467                         (void*)&timeout, &sz) < 0)
468                         { perror("getsockopt"); ret = -1; }
469                 else
470                         {
471                         tv->tv_sec = timeout / 1000;
472                         tv->tv_usec = (timeout % 1000) * 1000;
473                         ret = sizeof(*tv);
474                         }
475                 }
476 #else
477                 if ( getsockopt(b->num, SOL_SOCKET, SO_RCVTIMEO, 
478                         ptr, (void *)&ret) < 0)
479                         { perror("getsockopt"); ret = -1; }
480 #endif
481                 break;
482 #endif
483 #if defined(SO_SNDTIMEO)
484         case BIO_CTRL_DGRAM_SET_SEND_TIMEOUT:
485 #ifdef OPENSSL_SYS_WINDOWS
486                 {
487                 struct timeval *tv = (struct timeval *)ptr;
488                 int timeout = tv->tv_sec * 1000 + tv->tv_usec/1000;
489                 if (setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
490                         (void*)&timeout, sizeof(timeout)) < 0)
491                         { perror("setsockopt"); ret = -1; }
492                 }
493 #else
494                 if ( setsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, ptr,
495                         sizeof(struct timeval)) < 0)
496                         { perror("setsockopt"); ret = -1; }
497 #endif
498                 break;
499         case BIO_CTRL_DGRAM_GET_SEND_TIMEOUT:
500 #ifdef OPENSSL_SYS_WINDOWS
501                 {
502                 int timeout, sz = sizeof(timeout);
503                 struct timeval *tv = (struct timeval *)ptr;
504                 if (getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO,
505                         (void*)&timeout, &sz) < 0)
506                         { perror("getsockopt"); ret = -1; }
507                 else
508                         {
509                         tv->tv_sec = timeout / 1000;
510                         tv->tv_usec = (timeout % 1000) * 1000;
511                         ret = sizeof(*tv);
512                         }
513                 }
514 #else
515                 if ( getsockopt(b->num, SOL_SOCKET, SO_SNDTIMEO, 
516                         ptr, (void *)&ret) < 0)
517                         { perror("getsockopt"); ret = -1; }
518 #endif
519                 break;
520 #endif
521         case BIO_CTRL_DGRAM_GET_SEND_TIMER_EXP:
522                 /* fall-through */
523         case BIO_CTRL_DGRAM_GET_RECV_TIMER_EXP:
524 #ifdef OPENSSL_SYS_WINDOWS
525                 if ( data->_errno == WSAETIMEDOUT)
526 #else
527                 if ( data->_errno == EAGAIN)
528 #endif
529                         {
530                         ret = 1;
531                         data->_errno = 0;
532                         }
533                 else
534                         ret = 0;
535                 break;
536 #ifdef EMSGSIZE
537         case BIO_CTRL_DGRAM_MTU_EXCEEDED:
538                 if ( data->_errno == EMSGSIZE)
539                         {
540                         ret = 1;
541                         data->_errno = 0;
542                         }
543                 else
544                         ret = 0;
545                 break;
546 #endif
547         default:
548                 ret=0;
549                 break;
550                 }
551         return(ret);
552         }
553
554 static int dgram_puts(BIO *bp, const char *str)
555         {
556         int n,ret;
557
558         n=strlen(str);
559         ret=dgram_write(bp,str,n);
560         return(ret);
561         }
562
563 static int BIO_dgram_should_retry(int i)
564         {
565         int err;
566
567         if ((i == 0) || (i == -1))
568                 {
569                 err=get_last_socket_error();
570
571 #if defined(OPENSSL_SYS_WINDOWS) && 0 /* more microsoft stupidity? perhaps not? Ben 4/1/99 */
572                 if ((i == -1) && (err == 0))
573                         return(1);
574 #endif
575
576                 return(BIO_dgram_non_fatal_error(err));
577                 }
578         return(0);
579         }
580
581 int BIO_dgram_non_fatal_error(int err)
582         {
583         switch (err)
584                 {
585 #if defined(OPENSSL_SYS_WINDOWS)
586 # if defined(WSAEWOULDBLOCK)
587         case WSAEWOULDBLOCK:
588 # endif
589
590 # if 0 /* This appears to always be an error */
591 #  if defined(WSAENOTCONN)
592         case WSAENOTCONN:
593 #  endif
594 # endif
595 #endif
596
597 #ifdef EWOULDBLOCK
598 # ifdef WSAEWOULDBLOCK
599 #  if WSAEWOULDBLOCK != EWOULDBLOCK
600         case EWOULDBLOCK:
601 #  endif
602 # else
603         case EWOULDBLOCK:
604 # endif
605 #endif
606
607 #if defined(ENOTCONN)
608         case ENOTCONN:
609 #endif
610
611 #ifdef EINTR
612         case EINTR:
613 #endif
614
615 #ifdef EAGAIN
616 #if EWOULDBLOCK != EAGAIN
617         case EAGAIN:
618 # endif
619 #endif
620
621 #ifdef EPROTO
622         case EPROTO:
623 #endif
624
625 #ifdef EINPROGRESS
626         case EINPROGRESS:
627 #endif
628
629 #ifdef EALREADY
630         case EALREADY:
631 #endif
632
633 /* DF bit set, and packet larger than MTU */
634 #ifdef EMSGSIZE
635         case EMSGSIZE:
636 #endif
637
638                 return(1);
639                 /* break; */
640         default:
641                 break;
642                 }
643         return(0);
644         }
645 #endif
646
647 static void get_current_time(struct timeval *t)
648         {
649 #ifdef OPENSSL_SYS_WIN32
650         struct _timeb tb;
651         _ftime(&tb);
652         t->tv_sec = (long)tb.time;
653         t->tv_usec = (long)tb.millitm * 1000;
654 #elif defined(OPENSSL_SYS_VMS)
655         struct timeb tb;
656         ftime(&tb);
657         t->tv_sec = (long)tb.time;
658         t->tv_usec = (long)tb.millitm * 1000;
659 #else
660         gettimeofday(t, NULL);
661 #endif
662         }