/*

 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.

 *

 * Licensed under the OpenSSL license (the "License").  You may not use

 * this file except in compliance with the License.  You can obtain a copy

 * in the file LICENSE in the source distribution or at

 * https://www.openssl.org/source/license.html

 */

#include <stdio.h>

#include <errno.h>

#include "bio_local.h"

#ifndef OPENSSL_NO_SOCK

typedef struct bio_accept_st {

    int state;

    int accept_family;

    int bind_mode;     /* Socket mode for BIO_listen */

    int accepted_mode; /* Socket mode for BIO_accept (set on accepted sock) */

    char *param_addr;

    char *param_serv;

    int accept_sock;

    BIO_ADDRINFO *addr_first;

    const BIO_ADDRINFO *addr_iter;

    BIO_ADDR cache_accepting_addr;   /* Useful if we asked for port 0 */

    char *cache_accepting_name, *cache_accepting_serv;

    BIO_ADDR cache_peer_addr;

    char *cache_peer_name, *cache_peer_serv;

    BIO *bio_chain;

} BIO_ACCEPT;

static int acpt_write(BIO *h, const char *buf, int num);

static int acpt_read(BIO *h, char *buf, int size);

static int acpt_puts(BIO *h, const char *str);

static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);

static int acpt_new(BIO *h);

static int acpt_free(BIO *data);

static int acpt_state(BIO *b, BIO_ACCEPT *c);

static void acpt_close_socket(BIO *data);

static BIO_ACCEPT *BIO_ACCEPT_new(void);

static void BIO_ACCEPT_free(BIO_ACCEPT *a);

# define ACPT_S_BEFORE                   1

# define ACPT_S_GET_ADDR                 2

# define ACPT_S_CREATE_SOCKET            3

# define ACPT_S_LISTEN                   4

# define ACPT_S_ACCEPT                   5

# define ACPT_S_OK                       6

static const BIO_METHOD methods_acceptp = {

    BIO_TYPE_ACCEPT,

    "socket accept",

    /* TODO: Convert to new style write function */

    bwrite_conv,

    acpt_write,

    /* TODO: Convert to new style read function */

    bread_conv,

    acpt_read,

    acpt_puts,

    NULL,                       /* connect_gets,         */

    acpt_ctrl,

    acpt_new,

    acpt_free,

    NULL,                       /* connect_callback_ctrl */

};

const BIO_METHOD *BIO_s_accept(void)

{

    return &methods_acceptp;

}

static int acpt_new(BIO *bi)

{

    BIO_ACCEPT *ba;

    bi->init = 0;

    bi->num = (int)INVALID_SOCKET;

    bi->flags = 0;

    if ((ba = BIO_ACCEPT_new()) == NULL)

        return 0;

    bi->ptr = (char *)ba;

    ba->state = ACPT_S_BEFORE;

    bi->shutdown = 1;

    return 1;

}

static BIO_ACCEPT *BIO_ACCEPT_new(void)

{

    BIO_ACCEPT *ret;

    if ((ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {

        BIOerr(BIO_F_BIO_ACCEPT_NEW, ERR_R_MALLOC_FAILURE);

        return NULL;

    }

    ret->accept_family = BIO_FAMILY_IPANY;

    ret->accept_sock = (int)INVALID_SOCKET;

    return ret;

}

static void BIO_ACCEPT_free(BIO_ACCEPT *a)

{

    if (a == NULL)

        return;

    OPENSSL_free(a->param_addr);

    OPENSSL_free(a->param_serv);

    BIO_ADDRINFO_free(a->addr_first);

    OPENSSL_free(a->cache_accepting_name);

    OPENSSL_free(a->cache_accepting_serv);

    OPENSSL_free(a->cache_peer_name);

    OPENSSL_free(a->cache_peer_serv);

    BIO_free(a->bio_chain);

    OPENSSL_free(a);

}

static void acpt_close_socket(BIO *bio)

{

    BIO_ACCEPT *c;

    c = (BIO_ACCEPT *)bio->ptr;

    if (c->accept_sock != (int)INVALID_SOCKET) {

        shutdown(c->accept_sock, 2);

        closesocket(c->accept_sock);

        c->accept_sock = (int)INVALID_SOCKET;

        bio->num = (int)INVALID_SOCKET;

    }

}

static int acpt_free(BIO *a)

{

    BIO_ACCEPT *data;

    if (a == NULL)

        return 0;

    data = (BIO_ACCEPT *)a->ptr;

    if (a->shutdown) {

        acpt_close_socket(a);

        BIO_ACCEPT_free(data);

        a->ptr = NULL;

        a->flags = 0;

        a->init = 0;

    }

    return 1;

}

static int acpt_state(BIO *b, BIO_ACCEPT *c)

{

    BIO *bio = NULL, *dbio;

    int s = -1, ret = -1;

    for (;;) {

        switch (c->state) {

        case ACPT_S_BEFORE:

            if (c->param_addr == NULL && c->param_serv == NULL) {

                BIOerr(BIO_F_ACPT_STATE, BIO_R_NO_ACCEPT_ADDR_OR_SERVICE_SPECIFIED);

                ERR_add_error_data(4,

                                   "hostname=", c->param_addr,

                                   " service=", c->param_serv);

                goto exit_loop;

            }

            /* Because we're starting a new bind, any cached name and serv

             * are now obsolete and need to be cleaned out.

             * QUESTION: should this be done in acpt_close_socket() instead?

             */

            OPENSSL_free(c->cache_accepting_name);

            c->cache_accepting_name = NULL;

            OPENSSL_free(c->cache_accepting_serv);

            c->cache_accepting_serv = NULL;

            OPENSSL_free(c->cache_peer_name);

            c->cache_peer_name = NULL;

            OPENSSL_free(c->cache_peer_serv);

            c->cache_peer_serv = NULL;

            c->state = ACPT_S_GET_ADDR;

            break;

        case ACPT_S_GET_ADDR:

            {

                int family = AF_UNSPEC;

                switch (c->accept_family) {

                case BIO_FAMILY_IPV6:

                    if (1) { /* This is a trick we use to avoid bit rot.

                              * at least the "else" part will always be

                              * compiled.

                              */

#ifdef AF_INET6

                        family = AF_INET6;

                    } else {

#endif

                        BIOerr(BIO_F_ACPT_STATE, BIO_R_UNAVAILABLE_IP_FAMILY);

                        goto exit_loop;

                    }

                    break;

                case BIO_FAMILY_IPV4:

                    family = AF_INET;

                    break;

                case BIO_FAMILY_IPANY:

                    family = AF_UNSPEC;

                    break;

                default:

                    BIOerr(BIO_F_ACPT_STATE, BIO_R_UNSUPPORTED_IP_FAMILY);

                    goto exit_loop;

                }

                if (BIO_lookup(c->param_addr, c->param_serv, BIO_LOOKUP_SERVER,

                               family, SOCK_STREAM, &c->addr_first) == 0)

                    goto exit_loop;

            }

            if (c->addr_first == NULL) {

                BIOerr(BIO_F_ACPT_STATE, BIO_R_LOOKUP_RETURNED_NOTHING);

                goto exit_loop;

            }

            /* We're currently not iterating, but set this as preparation

             * for possible future development in that regard

             */

            c->addr_iter = c->addr_first;

            c->state = ACPT_S_CREATE_SOCKET;

            break;

        case ACPT_S_CREATE_SOCKET:

            s = BIO_socket(BIO_ADDRINFO_family(c->addr_iter),

                           BIO_ADDRINFO_socktype(c->addr_iter),

                           BIO_ADDRINFO_protocol(c->addr_iter), 0);

            if (s == (int)INVALID_SOCKET) {

                SYSerr(SYS_F_SOCKET, get_last_socket_error());

                ERR_add_error_data(4,

                                   "hostname=", c->param_addr,

                                   " service=", c->param_serv);

                BIOerr(BIO_F_ACPT_STATE, BIO_R_UNABLE_TO_CREATE_SOCKET);

                goto exit_loop;

            }

            c->accept_sock = s;

            b->num = s;

            c->state = ACPT_S_LISTEN;

            s = -1;

            break;

        case ACPT_S_LISTEN:

            {

                if (!BIO_listen(c->accept_sock,

                                BIO_ADDRINFO_address(c->addr_iter),

                                c->bind_mode)) {

                    BIO_closesocket(c->accept_sock);

                    goto exit_loop;

                }

            }

            {

                union BIO_sock_info_u info;

                info.addr = &c->cache_accepting_addr;

                if (!BIO_sock_info(c->accept_sock, BIO_SOCK_INFO_ADDRESS,

                                   &info)) {

                    BIO_closesocket(c->accept_sock);

                    goto exit_loop;

                }

            }

            c->cache_accepting_name =

                BIO_ADDR_hostname_string(&c->cache_accepting_addr, 1);

            c->cache_accepting_serv =

                BIO_ADDR_service_string(&c->cache_accepting_addr, 1);

            c->state = ACPT_S_ACCEPT;

            s = -1;

            ret = 1;

            goto end;

        case ACPT_S_ACCEPT:

            if (b->next_bio != NULL) {

                c->state = ACPT_S_OK;

                break;

            }

            BIO_clear_retry_flags(b);

            b->retry_reason = 0;

            OPENSSL_free(c->cache_peer_name);

            c->cache_peer_name = NULL;

            OPENSSL_free(c->cache_peer_serv);

            c->cache_peer_serv = NULL;

            s = BIO_accept_ex(c->accept_sock, &c->cache_peer_addr,

                              c->accepted_mode);

            /* If the returned socket is invalid, this might still be

             * retryable

             */

            if (s < 0) {

                if (BIO_sock_should_retry(s)) {

                    BIO_set_retry_special(b);

                    b->retry_reason = BIO_RR_ACCEPT;

                    goto end;

                }

            }

            /* If it wasn't retryable, we fail */

            if (s < 0) {

                ret = s;

                goto exit_loop;

            }

            bio = BIO_new_socket(s, BIO_CLOSE);

            if (bio == NULL)

                goto exit_loop;

            BIO_set_callback(bio, BIO_get_callback(b));

            BIO_set_callback_arg(bio, BIO_get_callback_arg(b));

            /*

             * If the accept BIO has an bio_chain, we dup it and put the new

             * socket at the end.

             */

            if (c->bio_chain != NULL) {

                if ((dbio = BIO_dup_chain(c->bio_chain)) == NULL)

                    goto exit_loop;

                if (!BIO_push(dbio, bio))

                    goto exit_loop;

                bio = dbio;

            }

            if (BIO_push(b, bio) == NULL)

                goto exit_loop;

            c->cache_peer_name =

                BIO_ADDR_hostname_string(&c->cache_peer_addr, 1);

            c->cache_peer_serv =

                BIO_ADDR_service_string(&c->cache_peer_addr, 1);

            c->state = ACPT_S_OK;

            bio = NULL;

            ret = 1;

            goto end;

        case ACPT_S_OK:

            if (b->next_bio == NULL) {

                c->state = ACPT_S_ACCEPT;

                break;

            }

            ret = 1;

            goto end;

        default:

            ret = 0;

            goto end;

        }

    }

  exit_loop:

    if (bio != NULL)

        BIO_free(bio);

    else if (s >= 0)

        BIO_closesocket(s);

  end:

    return ret;

}

static int acpt_read(BIO *b, char *out, int outl)

{

    int ret = 0;

    BIO_ACCEPT *data;

    BIO_clear_retry_flags(b);

    data = (BIO_ACCEPT *)b->ptr;

    while (b->next_bio == NULL) {

        ret = acpt_state(b, data);

        if (ret <= 0)

            return ret;

    }

    ret = BIO_read(b->next_bio, out, outl);

    BIO_copy_next_retry(b);

    return ret;

}

static int acpt_write(BIO *b, const char *in, int inl)

{

    int ret;

    BIO_ACCEPT *data;

    BIO_clear_retry_flags(b);

    data = (BIO_ACCEPT *)b->ptr;

    while (b->next_bio == NULL) {

        ret = acpt_state(b, data);

        if (ret <= 0)

            return ret;

    }

    ret = BIO_write(b->next_bio, in, inl);

    BIO_copy_next_retry(b);

    return ret;

}

static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)

{

    int *ip;

    long ret = 1;

    BIO_ACCEPT *data;

    char **pp;

    data = (BIO_ACCEPT *)b->ptr;

    switch (cmd) {

    case BIO_CTRL_RESET:

        ret = 0;

        data->state = ACPT_S_BEFORE;

        acpt_close_socket(b);

        BIO_ADDRINFO_free(data->addr_first);

        data->addr_first = NULL;

        b->flags = 0;

        break;

    case BIO_C_DO_STATE_MACHINE:

        /* use this one to start the connection */

        ret = (long)acpt_state(b, data);

        break;

    case BIO_C_SET_ACCEPT:

        if (ptr != NULL) {

            if (num == 0) {

                char *hold_serv = data->param_serv;

                /* We affect the hostname regardless.  However, the input

                 * string might contain a host:service spec, so we must

                 * parse it, which might or might not affect the service

                 */

                OPENSSL_free(data->param_addr);

                data->param_addr = NULL;

                ret = BIO_parse_hostserv(ptr,

                                         &data->param_addr,

                                         &data->param_serv,

                                         BIO_PARSE_PRIO_SERV);

                if (hold_serv != data->param_serv)

                    OPENSSL_free(hold_serv);

                b->init = 1;

            } else if (num == 1) {

                OPENSSL_free(data->param_serv);

                data->param_serv = BUF_strdup(ptr);

                b->init = 1;

            } else if (num == 2) {

                data->bind_mode |= BIO_SOCK_NONBLOCK;

            } else if (num == 3) {

                BIO_free(data->bio_chain);

                data->bio_chain = (BIO *)ptr;

            } else if (num == 4) {

                data->accept_family = *(int *)ptr;

            }

        } else {

            if (num == 2) {

                data->bind_mode &= ~BIO_SOCK_NONBLOCK;

            }

        }

        break;

    case BIO_C_SET_NBIO:

        if (num != 0)

            data->accepted_mode |= BIO_SOCK_NONBLOCK;

        else

            data->accepted_mode &= ~BIO_SOCK_NONBLOCK;

        break;

    case BIO_C_SET_FD:

        b->num = *((int *)ptr);

        data->accept_sock = b->num;

        data->state = ACPT_S_ACCEPT;

        b->shutdown = (int)num;

        b->init = 1;

        break;

    case BIO_C_GET_FD:

        if (b->init) {

            ip = (int *)ptr;

            if (ip != NULL)

                *ip = data->accept_sock;

            ret = data->accept_sock;

        } else

            ret = -1;

        break;

    case BIO_C_GET_ACCEPT:

        if (b->init) {

            if (num == 0 && ptr != NULL) {

                pp = (char **)ptr;

                *pp = data->cache_accepting_name;

            } else if (num == 1 && ptr != NULL) {

                pp = (char **)ptr;

                *pp = data->cache_accepting_serv;

            } else if (num == 2 && ptr != NULL) {

                pp = (char **)ptr;

                *pp = data->cache_peer_name;

            } else if (num == 3 && ptr != NULL) {

                pp = (char **)ptr;

                *pp = data->cache_peer_serv;

            } else if (num == 4) {

                switch (BIO_ADDRINFO_family(data->addr_iter)) {

#ifdef AF_INET6

                case AF_INET6:

                    ret = BIO_FAMILY_IPV6;

                    break;

#endif

                case AF_INET:

                    ret = BIO_FAMILY_IPV4;

                    break;

                case 0:

                    ret = data->accept_family;

                    break;

                default:

                    ret = -1;

                    break;

                }

            } else

                ret = -1;

        } else

            ret = -1;

        break;

    case BIO_CTRL_GET_CLOSE:

        ret = b->shutdown;

        break;

    case BIO_CTRL_SET_CLOSE:

        b->shutdown = (int)num;

        break;

    case BIO_CTRL_PENDING:

    case BIO_CTRL_WPENDING:

        ret = 0;

        break;

    case BIO_CTRL_FLUSH:

        break;

    case BIO_C_SET_BIND_MODE:

        data->bind_mode = (int)num;

        break;

    case BIO_C_GET_BIND_MODE:

        ret = (long)data->bind_mode;

        break;

    case BIO_CTRL_DUP:

        break;

    case BIO_CTRL_EOF:

        if (b->next_bio == NULL)

            ret = 0;

        else

            ret = BIO_ctrl(b->next_bio, cmd, num, ptr);

        break;

    default:

        ret = 0;

        break;

    }

    return ret;

}

static int acpt_puts(BIO *bp, const char *str)

{

    int n, ret;

    n = strlen(str);

    ret = acpt_write(bp, str, n);

    return ret;

}

BIO *BIO_new_accept(const char *str)

{

    BIO *ret;

    ret = BIO_new(BIO_s_accept());

    if (ret == NULL)

        return NULL;

    if (BIO_set_accept_name(ret, str))

        return ret;

    BIO_free(ret);

    return NULL;

}

#endif