/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2012 The FreeBSD Foundation
 *
 * This software was developed by Edward Tomasz Napierala under sponsorship
 * from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef __CTLD_HH__
#define __CTLD_HH__

#include <sys/_nv.h>
#include <sys/queue.h>
#ifdef ICL_KERNEL_PROXY
#include <sys/types.h>
#endif
#include <sys/socket.h>
#include <stdbool.h>
#include <libiscsiutil.h>
#include <libutil.h>

#include <array>
#include <list>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <unordered_set>
#include <libutil++.hh>

#define DEFAULT_CONFIG_PATH             "/etc/ctl.conf"
#define DEFAULT_PIDFILE                 "/var/run/ctld.pid"
#define DEFAULT_BLOCKSIZE               512
#define DEFAULT_CD_BLOCKSIZE            2048

#define MAX_LUNS                        1024

struct isns_req;
struct port;

struct auth {
        auth(std::string_view secret) : a_secret(secret) {}
        auth(std::string_view secret, std::string_view mutual_user,
            std::string_view mutual_secret) :
                a_secret(secret), a_mutual_user(mutual_user),
                a_mutual_secret(mutual_secret) {}

        bool mutual() const { return !a_mutual_user.empty(); }

        const char *secret() const { return a_secret.c_str(); }
        const char *mutual_user() const { return a_mutual_user.c_str(); }
        const char *mutual_secret() const { return a_mutual_secret.c_str(); }

private:
        std::string                     a_secret;
        std::string                     a_mutual_user;
        std::string                     a_mutual_secret;
};

struct auth_portal {
        bool matches(const struct sockaddr *sa) const;
        bool parse(const char *portal);

private:
        struct sockaddr_storage         ap_sa;
        int                             ap_mask = 0;
};

enum class auth_type {
        UNKNOWN,
        DENY,
        NO_AUTHENTICATION,
        CHAP,
        CHAP_MUTUAL
};

struct auth_group {
        auth_group(std::string label) : ag_label(label) {}

        auth_type type() const { return ag_type; }
        bool set_type(const char *str);
        void set_type(auth_type type);

        const char *label() const { return ag_label.c_str(); }

        bool add_chap(const char *user, const char *secret);
        bool add_chap_mutual(const char *user, const char *secret,
            const char *user2, const char *secret2);
        const struct auth *find_auth(std::string_view user) const;

        bool add_host_nqn(std::string_view nqn);
        bool host_permitted(std::string_view nqn) const;

        bool add_host_address(const char *address);
        bool host_permitted(const struct sockaddr *sa) const;

        bool add_initiator_name(std::string_view initiator_name);
        bool initiator_permitted(std::string_view initiator_name) const;

        bool add_initiator_portal(const char *initiator_portal);
        bool initiator_permitted(const struct sockaddr *sa) const;

private:
        void check_secret_length(const char *user, const char *secret,
            const char *secret_type);

        std::string                     ag_label;
        auth_type                       ag_type = auth_type::UNKNOWN;
        std::unordered_map<std::string, auth> ag_auths;
        std::unordered_set<std::string> ag_host_names;
        std::list<auth_portal>          ag_host_addresses;
        std::unordered_set<std::string> ag_initiator_names;
        std::list<auth_portal>          ag_initiator_portals;
};

using auth_group_sp = std::shared_ptr<auth_group>;

enum class portal_protocol {
        ISCSI,
        ISER,
        NVME_TCP,
        NVME_DISCOVERY_TCP,
};

struct portal {
        portal(struct portal_group *pg, std::string_view listen,
            portal_protocol protocol, freebsd::addrinfo_up ai) :
                p_portal_group(pg), p_listen(listen), p_ai(std::move(ai)),
                p_protocol(protocol) {}
        virtual ~portal() = default;

        virtual bool prepare() { return true; }
        bool reuse_socket(portal &oldp);
        bool init_socket();
        virtual bool init_socket_options(int s __unused) { return true; }
        virtual void handle_connection(freebsd::fd_up fd, const char *host,
            const struct sockaddr *client_sa) = 0;

        struct portal_group *portal_group() const { return p_portal_group; }
        const char *listen() const { return p_listen.c_str(); }
        const addrinfo *ai() const { return p_ai.get(); }
        portal_protocol protocol() const { return p_protocol; }
        int socket() const { return p_socket; }
        void close() { p_socket.reset(); }

private:
        struct portal_group             *p_portal_group;
        std::string                     p_listen;
        freebsd::addrinfo_up            p_ai;
        portal_protocol                 p_protocol;

        freebsd::fd_up                  p_socket;
};

using portal_up = std::unique_ptr<portal>;
using port_up = std::unique_ptr<port>;

enum class discovery_filter {
        UNKNOWN,
        NONE,
        PORTAL,
        PORTAL_NAME,
        PORTAL_NAME_AUTH
};

struct portal_group {
        portal_group(struct conf *conf, std::string_view name);
        virtual ~portal_group() = default;

        struct conf *conf() const { return pg_conf; }
        virtual const char *keyword() const = 0;
        const char *name() const { return pg_name.c_str(); }
        bool assigned() const { return pg_assigned; }
        bool is_dummy() const;
        bool is_redirecting() const { return !pg_redirection.empty(); }
        struct auth_group *discovery_auth_group() const
        { return pg_discovery_auth_group.get(); }
        enum discovery_filter discovery_filter() const
        { return pg_discovery_filter; }
        int dscp() const { return pg_dscp; }
        const char *offload() const { return pg_offload.c_str(); }
        const char *redirection() const { return pg_redirection.c_str(); }
        int pcp() const { return pg_pcp; }
        uint16_t tag() const { return pg_tag; }

        freebsd::nvlist_up options() const;

        const std::list<portal_up> &portals() const { return pg_portals; }
        const std::unordered_map<std::string, port *> &ports() const
        { return pg_ports; }

        virtual void allocate_tag() = 0;
        virtual bool add_portal(const char *value,
            portal_protocol protocol) = 0;
        virtual void add_default_portals() = 0;
        bool add_option(const char *name, const char *value);
        bool set_discovery_auth_group(const char *name);
        bool set_dscp(u_int dscp);
        virtual bool set_filter(const char *str) = 0;
        void set_foreign();
        bool set_offload(const char *offload);
        bool set_pcp(u_int pcp);
        bool set_redirection(const char *addr);
        void set_tag(uint16_t tag);

        virtual port_up create_port(struct target *target, auth_group_sp ag) =
            0;
        virtual port_up create_port(struct target *target, uint32_t ctl_port) =
            0;

        void add_port(struct portal_group_port *port);
        const struct port *find_port(std::string_view target) const;
        void remove_port(struct portal_group_port *port);
        void verify(struct conf *conf);

        bool reuse_socket(struct portal &newp);
        int open_sockets(struct conf &oldconf);
        void close_sockets();

protected:
        struct conf                     *pg_conf;
        freebsd::nvlist_up              pg_options;
        const char                      *pg_keyword;
        std::string                     pg_name;
        auth_group_sp                   pg_discovery_auth_group;
        enum discovery_filter           pg_discovery_filter =
            discovery_filter::UNKNOWN;
        bool                            pg_foreign = false;
        bool                            pg_assigned = false;
        std::list<portal_up>            pg_portals;
        std::unordered_map<std::string, port *> pg_ports;
        std::string                     pg_offload;
        std::string                     pg_redirection;
        int                             pg_dscp = -1;
        int                             pg_pcp = -1;

        uint16_t                        pg_tag = 0;
};

using portal_group_up = std::unique_ptr<portal_group>;

struct port {
        port(struct target *target);
        virtual ~port() = default;

        struct target *target() const { return p_target; }
        virtual struct auth_group *auth_group() const { return nullptr; }
        virtual struct portal_group *portal_group() const { return nullptr; }

        virtual bool is_dummy() const { return true; }

        virtual void clear_references();

        bool kernel_add();
        bool kernel_update(const port *oport);
        bool kernel_remove();

        virtual bool kernel_create_port() = 0;
        virtual bool kernel_remove_port() = 0;

protected:
        struct target                   *p_target;

        uint32_t                        p_ctl_port = 0;
};

struct portal_group_port : public port {
        portal_group_port(struct target *target, struct portal_group *pg,
            auth_group_sp ag);
        portal_group_port(struct target *target, struct portal_group *pg,
            uint32_t ctl_port);
        ~portal_group_port() override = default;

        struct auth_group *auth_group() const override
        { return p_auth_group.get(); }
        struct portal_group *portal_group() const override
        { return p_portal_group; }

        bool is_dummy() const override;

        void clear_references() override;

protected:
        auth_group_sp                   p_auth_group;
        struct portal_group             *p_portal_group;
};

struct ioctl_port final : public port {
        ioctl_port(struct target *target, int pp, int vp) :
                port(target), p_ioctl_pp(pp), p_ioctl_vp(vp) {}
        ~ioctl_port() override = default;

        bool kernel_create_port() override;
        bool kernel_remove_port() override;

private:
        int                             p_ioctl_pp;
        int                             p_ioctl_vp;
};

struct kernel_port final : public port {
        kernel_port(struct target *target, struct pport *pp) :
                port(target), p_pport(pp) {}
        ~kernel_port() override = default;

        bool kernel_create_port() override;
        bool kernel_remove_port() override;

private:
        struct pport                    *p_pport;
};

struct lun {
        lun(struct conf *conf, std::string_view name);

        const char *name() const { return l_name.c_str(); }
        const std::string &path() const { return l_path; }
        int ctl_lun() const { return l_ctl_lun; }

        freebsd::nvlist_up options() const;

        bool add_option(const char *name, const char *value);
        bool set_backend(std::string_view value);
        bool set_blocksize(size_t value);
        bool set_ctl_lun(uint32_t value);
        bool set_device_type(uint8_t device_type);
        bool set_device_type(const char *value);
        bool set_device_id(std::string_view value);
        bool set_path(std::string_view value);
        void set_scsiname(std::string_view value);
        bool set_serial(std::string_view value);
        bool set_size(uint64_t value);

        bool changed(const struct lun &old) const;
        bool verify();

        bool kernel_add();
        bool kernel_modify() const;
        bool kernel_remove() const;

private:
        struct conf                     *l_conf;
        freebsd::nvlist_up              l_options;
        std::string                     l_name;
        std::string                     l_backend;
        uint8_t                         l_device_type = 0;
        int                             l_blocksize = 0;
        std::string                     l_device_id;
        std::string                     l_path;
        std::string                     l_scsiname;
        std::string                     l_serial;
        uint64_t                        l_size = 0;

        int                             l_ctl_lun = -1;
};

struct target {
        target(struct conf *conf, const char *keyword, std::string_view name);
        virtual ~target() = default;

        bool has_alias() const { return !t_alias.empty(); }
        bool has_pport() const { return !t_pport.empty(); }
        bool has_redirection() const { return !t_redirection.empty(); }
        const char *alias() const { return t_alias.c_str(); }
        const char *name() const { return t_name.c_str(); }
        const char *label() const { return t_label.c_str(); }
        const char *pport() const { return t_pport.c_str(); }
        bool private_auth() const { return t_private_auth; }
        const char *redirection() const { return t_redirection.c_str(); }

        struct auth_group *auth_group() const { return t_auth_group.get(); }
        const std::list<port *> &ports() const { return t_ports; }
        const struct lun *lun(int idx) const { return t_luns[idx]; }

        bool add_chap(const char *user, const char *secret);
        bool add_chap_mutual(const char *user, const char *secret,
            const char *user2, const char *secret2);
        virtual bool add_host_address(const char *) { return false; }
        virtual bool add_host_nqn(std::string_view) { return false; }
        virtual bool add_initiator_name(std::string_view) { return false; }
        virtual bool add_initiator_portal(const char *) { return false; }
        virtual bool add_lun(u_int, const char *) { return false; }
        virtual bool add_namespace(u_int, const char *) { return false; }
        virtual bool add_portal_group(const char *pg_name,
            const char *ag_name) = 0;
        bool set_alias(std::string_view alias);
        bool set_auth_group(const char *ag_name);
        bool set_auth_type(const char *type);
        bool set_physical_port(std::string_view pport);
        bool set_redirection(const char *addr);
        virtual struct lun *start_lun(u_int) { return nullptr; }
        virtual struct lun *start_namespace(u_int) { return nullptr; }

        void add_port(struct port *port);
        void remove_lun(struct lun *lun);
        void remove_port(struct port *port);
        void verify();

protected:
        bool use_private_auth(const char *keyword);
        bool add_lun(u_int id, const char *lun_label, const char *lun_name);
        struct lun *start_lun(u_int id, const char *lun_label,
            const char *lun_name);
        virtual struct portal_group *default_portal_group() = 0;

        struct conf                     *t_conf;
        std::array<struct lun *, MAX_LUNS> t_luns = {};
        auth_group_sp                   t_auth_group;
        std::list<port *>               t_ports;
        std::string                     t_name;
        std::string                     t_label;
        std::string                     t_alias;
        std::string                     t_redirection;
        /* Name of this target's physical port, if any, i.e. "isp0" */
        std::string                     t_pport;
        bool                            t_private_auth = false;
};

using target_up = std::unique_ptr<target>;

struct isns {
        isns(std::string_view addr, freebsd::addrinfo_up ai) :
                i_addr(addr), i_ai(std::move(ai)) {}

        const char *addr() const { return i_addr.c_str(); }

        freebsd::fd_up connect();
        bool send_request(int s, struct isns_req req);

private:
        std::string                     i_addr;
        freebsd::addrinfo_up            i_ai;
};

struct conf {
        conf();

        int maxproc() const { return conf_maxproc; }
        int timeout() const { return conf_timeout; }
        uint32_t genctr() const { return conf_genctr; }

        bool default_auth_group_defined() const
        { return conf_default_ag_defined; }
        bool default_portal_group_defined() const
        { return conf_default_pg_defined; }
        bool default_transport_group_defined() const
        { return conf_default_tg_defined; }

        struct auth_group *add_auth_group(const char *ag_name);
        struct auth_group *define_default_auth_group();
        auth_group_sp find_auth_group(std::string_view ag_name);

        struct portal_group *add_portal_group(const char *name);
        struct portal_group *define_default_portal_group();
        struct portal_group *find_portal_group(std::string_view name);

        struct portal_group *add_transport_group(const char *name);
        struct portal_group *define_default_transport_group();
        struct portal_group *find_transport_group(std::string_view name);

        bool add_port(struct target *target, struct portal_group *pg,
            auth_group_sp ag);
        bool add_port(struct target *target, struct portal_group *pg,
            uint32_t ctl_port);
        bool add_port(struct target *target, struct pport *pp);
        bool add_port(struct kports &kports, struct target *target, int pp,
            int vp);
        bool add_pports(struct kports &kports);

        struct target *add_controller(const char *name);
        struct target *find_controller(std::string_view name);

        struct target *add_target(const char *name);
        struct target *find_target(std::string_view name);

        struct lun *add_lun(const char *name);
        struct lun *find_lun(std::string_view name);

        void set_debug(int debug);
        void set_isns_period(int period);
        void set_isns_timeout(int timeout);
        void set_maxproc(int maxproc);
        bool set_pidfile_path(std::string_view path);
        void set_timeout(int timeout);

        void open_pidfile();
        void write_pidfile();
        void close_pidfile();

        bool add_isns(const char *addr);
        void isns_register_targets(struct isns *isns, struct conf *oldconf);
        void isns_deregister_targets(struct isns *isns);
        void isns_schedule_update();
        void isns_update();

        int apply(struct conf *oldconf);
        void delete_target_luns(struct lun *lun);
        bool reuse_portal_group_socket(struct portal &newp);
        bool verify();

private:
        struct isns_req isns_register_request(const char *hostname);
        struct isns_req isns_check_request(const char *hostname);
        struct isns_req isns_deregister_request(const char *hostname);
        void isns_check(struct isns *isns);

        std::string                     conf_pidfile_path;
        std::unordered_map<std::string, std::unique_ptr<lun>> conf_luns;
        std::unordered_map<std::string, target_up> conf_targets;
        std::unordered_map<std::string, target_up> conf_controllers;
        std::unordered_map<std::string, auth_group_sp> conf_auth_groups;
        std::unordered_map<std::string, std::unique_ptr<port>> conf_ports;
        std::unordered_map<std::string, portal_group_up> conf_portal_groups;
        std::unordered_map<std::string, portal_group_up> conf_transport_groups;
        std::unordered_map<std::string, isns> conf_isns;
        struct target                   *conf_first_target = nullptr;
        int                             conf_isns_period = 900;
        int                             conf_isns_timeout = 5;
        int                             conf_debug = 0;
        int                             conf_timeout = 60;
        int                             conf_maxproc = 30;
        uint32_t                        conf_genctr = 0;

        freebsd::pidfile                conf_pidfile;

        bool                            conf_default_pg_defined = false;
        bool                            conf_default_tg_defined = false;
        bool                            conf_default_ag_defined = false;

        static uint32_t                 global_genctr;

#ifdef ICL_KERNEL_PROXY
public:
        int add_proxy_portal(portal *);
        portal *proxy_portal(int);
private:
        std::vector<portal *>           conf_proxy_portals;
#endif
};

using conf_up = std::unique_ptr<conf>;

/* Physical ports exposed by the kernel */
struct pport {
        pport(std::string_view name, uint32_t ctl_port) : pp_name(name),
            pp_ctl_port(ctl_port) {}

        const char *name() const { return pp_name.c_str(); }
        uint32_t ctl_port() const { return pp_ctl_port; }

        bool linked() const { return pp_linked; }
        void link() { pp_linked = true; }

private:
        std::string                     pp_name;
        uint32_t                        pp_ctl_port;
        bool                            pp_linked = false;
};

struct kports {
        bool add_port(std::string &name, uint32_t ctl_port);
        bool has_port(std::string_view name);
        struct pport *find_port(std::string_view name);

private:
        std::unordered_map<std::string, struct pport> pports;
};

extern bool proxy_mode;
extern int ctl_fd;

bool                    parse_conf(const char *path);
bool                    uclparse_conf(const char *path);

conf_up                 conf_new_from_kernel(struct kports &kports);
void                    conf_finish(void);
void                    conf_start(struct conf *new_conf);

bool                    option_new(nvlist_t *nvl,
                            const char *name, const char *value);

freebsd::addrinfo_up    parse_addr_port(const char *address,
                            const char *def_port);

void                    kernel_init(void);
void                    kernel_capsicate(void);

#ifdef ICL_KERNEL_PROXY
void                    kernel_listen(struct addrinfo *ai, bool iser,
                            int portal_id);
void                    kernel_accept(int *connection_id, int *portal_id,
                            struct sockaddr *client_sa,
                            socklen_t *client_salen);
void                    kernel_send(struct pdu *pdu);
void                    kernel_receive(struct pdu *pdu);
#endif

bool                    ctl_create_port(const char *driver,
                            const nvlist_t *nvl, uint32_t *ctl_port);
bool                    ctl_remove_port(const char *driver, nvlist_t *nvl);

portal_group_up         iscsi_make_portal_group(struct conf *conf,
                            std::string_view name);
target_up               iscsi_make_target(struct conf *conf,
                            std::string_view name);

portal_group_up         nvmf_make_transport_group(struct conf *conf,
                            std::string_view name);
target_up               nvmf_make_controller(struct conf *conf,
                            std::string_view name);

void                    start_timer(int timeout, bool fatal = false);
void                    stop_timer();
bool                    timed_out();

#endif /* !__CTLD_HH__ */