e490fcdf73712355b8357b84edf4dd618dcefa2f
[openssl.git] / crypto / bio / bss_acpt.c
1 /*
2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include <errno.h>
12 #include "bio_lcl.h"
13
14 #ifndef OPENSSL_NO_SOCK
15
16 typedef struct bio_accept_st {
17     int state;
18     int accept_family;
19     int bind_mode;     /* Socket mode for BIO_listen */
20     int accepted_mode; /* Socket mode for BIO_accept (set on accepted sock) */
21     char *param_addr;
22     char *param_serv;
23
24     int accept_sock;
25
26     BIO_ADDRINFO *addr_first;
27     const BIO_ADDRINFO *addr_iter;
28     BIO_ADDR cache_accepting_addr;   /* Useful if we asked for port 0 */
29     char *cache_accepting_name, *cache_accepting_serv;
30     BIO_ADDR cache_peer_addr;
31     char *cache_peer_name, *cache_peer_serv;
32
33     BIO *bio_chain;
34 } BIO_ACCEPT;
35
36 static int acpt_write(BIO *h, const char *buf, int num);
37 static int acpt_read(BIO *h, char *buf, int size);
38 static int acpt_puts(BIO *h, const char *str);
39 static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);
40 static int acpt_new(BIO *h);
41 static int acpt_free(BIO *data);
42 static int acpt_state(BIO *b, BIO_ACCEPT *c);
43 static void acpt_close_socket(BIO *data);
44 static BIO_ACCEPT *BIO_ACCEPT_new(void);
45 static void BIO_ACCEPT_free(BIO_ACCEPT *a);
46
47 # define ACPT_S_BEFORE                   1
48 # define ACPT_S_GET_ADDR                 2
49 # define ACPT_S_CREATE_SOCKET            3
50 # define ACPT_S_LISTEN                   4
51 # define ACPT_S_ACCEPT                   5
52 # define ACPT_S_OK                       6
53
54 static const BIO_METHOD methods_acceptp = {
55     BIO_TYPE_ACCEPT,
56     "socket accept",
57     /* TODO: Convert to new style write function */
58     bwrite_conv,
59     acpt_write,
60     /* TODO: Convert to new style read function */
61     bread_conv,
62     acpt_read,
63     acpt_puts,
64     NULL,                       /* connect_gets, */
65     acpt_ctrl,
66     acpt_new,
67     acpt_free,
68     NULL,
69 };
70
71 const BIO_METHOD *BIO_s_accept(void)
72 {
73     return (&methods_acceptp);
74 }
75
76 static int acpt_new(BIO *bi)
77 {
78     BIO_ACCEPT *ba;
79
80     bi->init = 0;
81     bi->num = (int)INVALID_SOCKET;
82     bi->flags = 0;
83     if ((ba = BIO_ACCEPT_new()) == NULL)
84         return (0);
85     bi->ptr = (char *)ba;
86     ba->state = ACPT_S_BEFORE;
87     bi->shutdown = 1;
88     return (1);
89 }
90
91 static BIO_ACCEPT *BIO_ACCEPT_new(void)
92 {
93     BIO_ACCEPT *ret;
94
95     if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL)
96         return (NULL);
97     ret->accept_family = BIO_FAMILY_IPANY;
98     ret->accept_sock = (int)INVALID_SOCKET;
99     return (ret);
100 }
101
102 static void BIO_ACCEPT_free(BIO_ACCEPT *a)
103 {
104     if (a == NULL)
105         return;
106
107     OPENSSL_free(a->param_addr);
108     OPENSSL_free(a->param_serv);
109     BIO_ADDRINFO_free(a->addr_first);
110     OPENSSL_free(a->cache_accepting_name);
111     OPENSSL_free(a->cache_accepting_serv);
112     OPENSSL_free(a->cache_peer_name);
113     OPENSSL_free(a->cache_peer_serv);
114     BIO_free(a->bio_chain);
115     OPENSSL_free(a);
116 }
117
118 static void acpt_close_socket(BIO *bio)
119 {
120     BIO_ACCEPT *c;
121
122     c = (BIO_ACCEPT *)bio->ptr;
123     if (c->accept_sock != (int)INVALID_SOCKET) {
124         shutdown(c->accept_sock, 2);
125         closesocket(c->accept_sock);
126         c->accept_sock = (int)INVALID_SOCKET;
127         bio->num = (int)INVALID_SOCKET;
128     }
129 }
130
131 static int acpt_free(BIO *a)
132 {
133     BIO_ACCEPT *data;
134
135     if (a == NULL)
136         return (0);
137     data = (BIO_ACCEPT *)a->ptr;
138
139     if (a->shutdown) {
140         acpt_close_socket(a);
141         BIO_ACCEPT_free(data);
142         a->ptr = NULL;
143         a->flags = 0;
144         a->init = 0;
145     }
146     return (1);
147 }
148
149 static int acpt_state(BIO *b, BIO_ACCEPT *c)
150 {
151     BIO *bio = NULL, *dbio;
152     int s = -1, ret = -1;
153
154     for (;;) {
155         switch (c->state) {
156         case ACPT_S_BEFORE:
157             if (c->param_addr == NULL && c->param_serv == NULL) {
158                 BIOerr(BIO_F_ACPT_STATE, BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED);
159                 ERR_add_error_data(4,
160                                    "hostname=", c->param_addr,
161                                    " service=", c->param_serv);
162                 goto exit_loop;
163             }
164
165             /* Because we're starting a new bind, any cached name and serv
166              * are now obsolete and need to be cleaned out.
167              * QUESTION: should this be done in acpt_close_socket() instead?
168              */
169             OPENSSL_free(c->cache_accepting_name);
170             c->cache_accepting_name = NULL;
171             OPENSSL_free(c->cache_accepting_serv);
172             c->cache_accepting_serv = NULL;
173             OPENSSL_free(c->cache_peer_name);
174             c->cache_peer_name = NULL;
175             OPENSSL_free(c->cache_peer_serv);
176             c->cache_peer_serv = NULL;
177
178             c->state = ACPT_S_GET_ADDR;
179             break;
180
181         case ACPT_S_GET_ADDR:
182             {
183                 int family = AF_UNSPEC;
184                 switch (c->accept_family) {
185                 case BIO_FAMILY_IPV6:
186                     if (1) { /* This is a trick we use to avoid bit rot.
187                               * at least the "else" part will always be
188                               * compiled.
189                               */
190 #ifdef AF_INET6
191                         family = AF_INET6;
192                     } else {
193 #endif
194                         BIOerr(BIO_F_ACPT_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);
195                         goto exit_loop;
196                     }
197                     break;
198                 case BIO_FAMILY_IPV4:
199                     family = AF_INET;
200                     break;
201                 case BIO_FAMILY_IPANY:
202                     family = AF_UNSPEC;
203                     break;
204                 default:
205                     BIOerr(BIO_F_ACPT_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);
206                     goto exit_loop;
207                 }
208                 if (BIO_lookup(c->param_addr, c->param_serv, BIO_LOOKUP_SERVER,
209                                family, SOCK_STREAM, &c->addr_first) == 0)
210                     goto exit_loop;
211             }
212             if (c->addr_first == NULL) {
213                 BIOerr(BIO_F_ACPT_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);
214                 goto exit_loop;
215             }
216             /* We're currently not iterating, but set this as preparation
217              * for possible future development in that regard
218              */
219             c->addr_iter = c->addr_first;
220             c->state = ACPT_S_CREATE_SOCKET;
221             break;
222
223         case ACPT_S_CREATE_SOCKET:
224             ret = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),
225                              BIO_ADDRINFO_socktype(c->addr_iter),
226                              BIO_ADDRINFO_protocol(c->addr_iter), 0);
227             if (ret == (int)INVALID_SOCKET) {
228                 SYSerr(SYS_F_SOCKET, get_last_socket_error());
229                 ERR_add_error_data(4,
230                                    "hostname=", c->param_addr,
231                                    " service=", c->param_serv);
232                 BIOerr(BIO_F_ACPT_STATE, BIO_R_UNABLE_TO_CREATE_SOCKET);
233                 goto exit_loop;
234             }
235             c->accept_sock = ret;
236             b->num = ret;
237             c->state = ACPT_S_LISTEN;
238             break;
239
240         case ACPT_S_LISTEN:
241             {
242                 if (!BIO_listen(c->accept_sock,
243                                 BIO_ADDRINFO_address(c->addr_iter),
244                                 c->bind_mode)) {
245                     BIO_closesocket(c->accept_sock);
246                     goto exit_loop;
247                 }
248             }
249
250             {
251                 union BIO_sock_info_u info;
252
253                 info.addr = &c->cache_accepting_addr;
254                 if (!BIO_sock_info(c->accept_sock, BIO_SOCK_INFO_ADDRESS,
255                                    &info)) {
256                     BIO_closesocket(c->accept_sock);
257                     goto exit_loop;
258                 }
259             }
260
261             c->cache_accepting_name =
262                 BIO_ADDR_hostname_string(&c->cache_accepting_addr, 1);
263             c->cache_accepting_serv =
264                 BIO_ADDR_service_string(&c->cache_accepting_addr, 1);
265             c->state = ACPT_S_ACCEPT;
266             s = -1;
267             ret = 1;
268             goto end;
269
270         case ACPT_S_ACCEPT:
271             if (b->next_bio != NULL) {
272                 c->state = ACPT_S_OK;
273                 break;
274             }
275             BIO_clear_retry_flags(b);
276             b->retry_reason = 0;
277
278             s = BIO_accept_ex(c->accept_sock, &c->cache_peer_addr,
279                               c->accepted_mode);
280
281             /* If the returned socket is invalid, this might still be
282              * retryable
283              */
284             if (s < 0) {
285                 if (BIO_sock_should_retry(s)) {
286                     BIO_set_retry_special(b);
287                     b->retry_reason = BIO_RR_ACCEPT;
288                     goto end;
289                 }
290             }
291
292             /* If it wasn't retryable, we fail */
293             if (s < 0) {
294                 ret = s;
295                 goto exit_loop;
296             }
297
298             bio = BIO_new_socket(s, BIO_CLOSE);
299             if (bio == NULL)
300                 goto exit_loop;
301
302             BIO_set_callback(bio, BIO_get_callback(b));
303             BIO_set_callback_arg(bio, BIO_get_callback_arg(b));
304
305             /*
306              * If the accept BIO has an bio_chain, we dup it and put the new
307              * socket at the end.
308              */
309             if (c->bio_chain != NULL) {
310                 if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL)
311                     goto exit_loop;
312                 if (!BIO_push(dbio, bio))
313                     goto exit_loop;
314                 bio = dbio;
315             }
316             if (BIO_push(b, bio) == NULL)
317                 goto exit_loop;
318
319             c->cache_peer_name =
320                 BIO_ADDR_hostname_string(&c->cache_peer_addr, 1);
321             c->cache_peer_serv =
322                 BIO_ADDR_service_string(&c->cache_peer_addr, 1);
323             c->state = ACPT_S_OK;
324             bio = NULL;
325             ret = 1;
326             goto end;
327
328         case ACPT_S_OK:
329             if (b->next_bio == NULL) {
330                 c->state = ACPT_S_ACCEPT;
331                 break;
332             }
333             ret = 1;
334             goto end;
335
336         default:
337             ret = 0;
338             goto end;
339         }
340     }
341
342   exit_loop:
343     if (bio != NULL)
344         BIO_free(bio);
345     else if (s >= 0)
346         BIO_closesocket(s);
347   end:
348     return ret;
349 }
350
351 static int acpt_read(BIO *b, char *out, int outl)
352 {
353     int ret = 0;
354     BIO_ACCEPT *data;
355
356     BIO_clear_retry_flags(b);
357     data = (BIO_ACCEPT *)b->ptr;
358
359     while (b->next_bio == NULL) {
360         ret = acpt_state(b, data);
361         if (ret <= 0)
362             return (ret);
363     }
364
365     ret = BIO_read(b->next_bio, out, outl);
366     BIO_copy_next_retry(b);
367     return (ret);
368 }
369
370 static int acpt_write(BIO *b, const char *in, int inl)
371 {
372     int ret;
373     BIO_ACCEPT *data;
374
375     BIO_clear_retry_flags(b);
376     data = (BIO_ACCEPT *)b->ptr;
377
378     while (b->next_bio == NULL) {
379         ret = acpt_state(b, data);
380         if (ret <= 0)
381             return (ret);
382     }
383
384     ret = BIO_write(b->next_bio, in, inl);
385     BIO_copy_next_retry(b);
386     return (ret);
387 }
388
389 static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
390 {
391     int *ip;
392     long ret = 1;
393     BIO_ACCEPT *data;
394     char **pp;
395
396     data = (BIO_ACCEPT *)b->ptr;
397
398     switch (cmd) {
399     case BIO_CTRL_RESET:
400         ret = 0;
401         data->state = ACPT_S_BEFORE;
402         acpt_close_socket(b);
403         BIO_ADDRINFO_free(data->addr_first);
404         data->addr_first = NULL;
405         b->flags = 0;
406         break;
407     case BIO_C_DO_STATE_MACHINE:
408         /* use this one to start the connection */
409         ret = (long)acpt_state(b, data);
410         break;
411     case BIO_C_SET_ACCEPT:
412         if (ptr != NULL) {
413             if (num == 0) {
414                 char *hold_serv = data->param_serv;
415                 /* We affect the hostname regardless.  However, the input
416                  * string might contain a host:service spec, so we must
417                  * parse it, which might or might not affect the service
418                  */
419                 OPENSSL_free(data->param_addr);
420                 data->param_addr = NULL;
421                 ret = BIO_parse_hostserv(ptr,
422                                          &data->param_addr,
423                                          &data->param_serv,
424                                          BIO_PARSE_PRIO_SERV);
425                 if (hold_serv != data->param_serv)
426                     OPENSSL_free(hold_serv);
427                 b->init = 1;
428             } else if (num == 1) {
429                 OPENSSL_free(data->param_serv);
430                 data->param_serv = BUF_strdup(ptr);
431                 b->init = 1;
432             } else if (num == 2) {
433                 data->bind_mode |= BIO_SOCK_NONBLOCK;
434             } else if (num == 3) {
435                 BIO_free(data->bio_chain);
436                 data->bio_chain = (BIO *)ptr;
437             } else if (num == 4) {
438                 data->accept_family = *(int *)ptr;
439             }
440         } else {
441             if (num == 2) {
442                 data->bind_mode &= ~BIO_SOCK_NONBLOCK;
443             }
444         }
445         break;
446     case BIO_C_SET_NBIO:
447         if (num != 0)
448             data->accepted_mode |= BIO_SOCK_NONBLOCK;
449         else
450             data->accepted_mode &= ~BIO_SOCK_NONBLOCK;
451         break;
452     case BIO_C_SET_FD:
453         b->init = 1;
454         b->num = *((int *)ptr);
455         data->accept_sock = b->num;
456         data->state = ACPT_S_ACCEPT;
457         b->shutdown = (int)num;
458         b->init = 1;
459         break;
460     case BIO_C_GET_FD:
461         if (b->init) {
462             ip = (int *)ptr;
463             if (ip != NULL)
464                 *ip = data->accept_sock;
465             ret = data->accept_sock;
466         } else
467             ret = -1;
468         break;
469     case BIO_C_GET_ACCEPT:
470         if (b->init) {
471             if (num == 0 && ptr != NULL) {
472                 pp = (char **)ptr;
473                 *pp = data->cache_accepting_name;
474             } else if (num == 1 && ptr != NULL) {
475                 pp = (char **)ptr;
476                 *pp = data->cache_accepting_serv;
477             } else if (num == 2 && ptr != NULL) {
478                 pp = (char **)ptr;
479                 *pp = data->cache_peer_name;
480             } else if (num == 3 && ptr != NULL) {
481                 pp = (char **)ptr;
482                 *pp = data->cache_peer_serv;
483             } else if (num == 4) {
484                 switch (BIO_ADDRINFO_family(data->addr_iter)) {
485 #ifdef AF_INET6
486                 case AF_INET6:
487                     ret = BIO_FAMILY_IPV6;
488                     break;
489 #endif
490                 case AF_INET:
491                     ret = BIO_FAMILY_IPV4;
492                     break;
493                 case 0:
494                     ret = data->accept_family;
495                     break;
496                 default:
497                     ret = -1;
498                     break;
499                 }
500             } else
501                 ret = -1;
502         } else
503             ret = -1;
504         break;
505     case BIO_CTRL_GET_CLOSE:
506         ret = b->shutdown;
507         break;
508     case BIO_CTRL_SET_CLOSE:
509         b->shutdown = (int)num;
510         break;
511     case BIO_CTRL_PENDING:
512     case BIO_CTRL_WPENDING:
513         ret = 0;
514         break;
515     case BIO_CTRL_FLUSH:
516         break;
517     case BIO_C_SET_BIND_MODE:
518         data->bind_mode = (int)num;
519         break;
520     case BIO_C_GET_BIND_MODE:
521         ret = (long)data->bind_mode;
522         break;
523     case BIO_CTRL_DUP:
524 /*-     dbio=(BIO *)ptr;
525         if (data->param_port) EAY EAY
526                 BIO_set_port(dbio,data->param_port);
527         if (data->param_hostname)
528                 BIO_set_hostname(dbio,data->param_hostname);
529         BIO_set_nbio(dbio,data->nbio); */
530         break;
531
532     default:
533         ret = 0;
534         break;
535     }
536     return (ret);
537 }
538
539 static int acpt_puts(BIO *bp, const char *str)
540 {
541     int n, ret;
542
543     n = strlen(str);
544     ret = acpt_write(bp, str, n);
545     return (ret);
546 }
547
548 BIO *BIO_new_accept(const char *str)
549 {
550     BIO *ret;
551
552     ret = BIO_new(BIO_s_accept());
553     if (ret == NULL)
554         return (NULL);
555     if (BIO_set_accept_name(ret, str))
556         return (ret);
557     BIO_free(ret);
558     return (NULL);
559 }
560
561 #endif