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