/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2003, 2004 Silicon Graphics International Corp.
 * Copyright (c) 1997-2007 Kenneth D. Merry
 * Copyright (c) 2012 The FreeBSD Foundation
 * Copyright (c) 2017 Jakub Wojciech Klama <jceel@FreeBSD.org>
 * All rights reserved.
 * Copyright (c) 2025 Chelsio Communications, Inc.
 *
 * Portions of this software were 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,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
 *
 */

#include <sys/param.h>
#include <sys/linker.h>
#include <sys/module.h>
#include <sys/time.h>
#include <assert.h>
#include <libiscsiutil.h>
#include <stdio.h>
#include <stdlib.h>
#include <cam/ctl/ctl.h>
#include <cam/ctl/ctl_io.h>
#include <cam/ctl/ctl_ioctl.h>

#include "ctld.hh"
#include "iscsi.hh"

#define SOCKBUF_SIZE                    1048576

struct iscsi_portal final : public portal {
        iscsi_portal(struct portal_group *pg, const char *listen,
            portal_protocol protocol, freebsd::addrinfo_up ai) :
                portal(pg, listen, protocol, std::move(ai)) {}

        bool init_socket_options(int s) override;
        void handle_connection(freebsd::fd_up fd, const char *host,
            const struct sockaddr *client_sa) override;
};

struct iscsi_portal_group final : public portal_group {
        iscsi_portal_group(struct conf *conf, std::string_view name) :
                portal_group(conf, name) {}

        const char *keyword() const override
        { return "portal-group"; }

        void allocate_tag() override;
        bool add_portal(const char *value, portal_protocol protocol)
            override;
        void add_default_portals() override;
        bool set_filter(const char *str) override;

        virtual port_up create_port(struct target *target, auth_group_sp ag)
            override;
        virtual port_up create_port(struct target *target, uint32_t ctl_port)
            override;
private:
        static uint16_t last_portal_group_tag;
};

struct iscsi_port final : public portal_group_port {
        iscsi_port(struct target *target, struct portal_group *pg,
            auth_group_sp ag) :
                portal_group_port(target, pg, ag) {}
        iscsi_port(struct target *target, struct portal_group *pg,
            uint32_t ctl_port) :
                portal_group_port(target, pg, ctl_port) {}

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

private:
        static bool module_loaded;
        static void load_kernel_module();
};

struct iscsi_target final : public target {
        iscsi_target(struct conf *conf, std::string_view name) :
                target(conf, "target", name) {}

        bool add_initiator_name(std::string_view name) override;
        bool add_initiator_portal(const char *addr) override;
        bool add_lun(u_int id, const char *lun_name) override;
        bool add_portal_group(const char *pg_name, const char *ag_name)
            override;
        struct lun *start_lun(u_int id) override;

protected:
        struct portal_group *default_portal_group() override;
};

#ifdef ICL_KERNEL_PROXY
static void     pdu_receive_proxy(struct pdu *pdu);
static void     pdu_send_proxy(struct pdu *pdu);
#endif /* ICL_KERNEL_PROXY */
static void     pdu_fail(const struct connection *conn, const char *reason);

uint16_t iscsi_portal_group::last_portal_group_tag = 0xff;
bool    iscsi_port::module_loaded = false;

static struct connection_ops conn_ops = {
        .timed_out = timed_out,
#ifdef ICL_KERNEL_PROXY
        .pdu_receive_proxy = pdu_receive_proxy,
        .pdu_send_proxy = pdu_send_proxy,
#else
        .pdu_receive_proxy = nullptr,
        .pdu_send_proxy = nullptr,
#endif
        .fail = pdu_fail,
};

portal_group_up
iscsi_make_portal_group(struct conf *conf, std::string_view name)
{
        return std::make_unique<iscsi_portal_group>(conf, name);
}

target_up
iscsi_make_target(struct conf *conf, std::string_view name)
{
        return std::make_unique<iscsi_target>(conf, name);
}

void
iscsi_portal_group::allocate_tag()
{
        set_tag(++last_portal_group_tag);
}

bool
iscsi_portal_group::add_portal(const char *value, portal_protocol protocol)
{
        switch (protocol) {
        case portal_protocol::ISCSI:
        case portal_protocol::ISER:
                break;
        default:
                log_warnx("unsupported portal protocol for %s", value);
                return (false);
        }

        freebsd::addrinfo_up ai = parse_addr_port(value, "3260");
        if (!ai) {
                log_warnx("invalid listen address %s", value);
                return (false);
        }

        /*
         * XXX: getaddrinfo(3) may return multiple addresses; we should turn
         *      those into multiple portals.
         */

        pg_portals.emplace_back(std::make_unique<iscsi_portal>(this, value,
            protocol, std::move(ai)));
        return (true);
}

void
iscsi_portal_group::add_default_portals()
{
        add_portal("0.0.0.0", portal_protocol::ISCSI);
        add_portal("[::]", portal_protocol::ISCSI);
}

bool
iscsi_portal_group::set_filter(const char *str)
{
        enum discovery_filter filter;

        if (strcmp(str, "none") == 0) {
                filter = discovery_filter::NONE;
        } else if (strcmp(str, "portal") == 0) {
                filter = discovery_filter::PORTAL;
        } else if (strcmp(str, "portal-name") == 0) {
                filter = discovery_filter::PORTAL_NAME;
        } else if (strcmp(str, "portal-name-auth") == 0) {
                filter = discovery_filter::PORTAL_NAME_AUTH;
        } else {
                log_warnx("invalid discovery-filter \"%s\" for portal-group "
                    "\"%s\"; valid values are \"none\", \"portal\", "
                    "\"portal-name\", and \"portal-name-auth\"",
                    str, name());
                return (false);
        }

        if (pg_discovery_filter != discovery_filter::UNKNOWN &&
            pg_discovery_filter != filter) {
                log_warnx("cannot set discovery-filter to \"%s\" for "
                    "portal-group \"%s\"; already has a different "
                    "value", str, name());
                return (false);
        }

        pg_discovery_filter = filter;
        return (true);
}

port_up
iscsi_portal_group::create_port(struct target *target, auth_group_sp ag)
{
        return std::make_unique<iscsi_port>(target, this, ag);
}

port_up
iscsi_portal_group::create_port(struct target *target, uint32_t ctl_port)
{
        return std::make_unique<iscsi_port>(target, this, ctl_port);
}

void
iscsi_port::load_kernel_module()
{
        int saved_errno;

        if (module_loaded)
                return;

        saved_errno = errno;
        if (modfind("cfiscsi") == -1 && kldload("cfiscsi") == -1)
                log_warn("couldn't load cfiscsi");
        errno = saved_errno;
        module_loaded = true;
}

bool
iscsi_port::kernel_create_port()
{
        struct portal_group *pg = p_portal_group;
        struct target *targ = p_target;

        load_kernel_module();

        freebsd::nvlist_up nvl = pg->options();
        nvlist_add_string(nvl.get(), "cfiscsi_target", targ->name());
        nvlist_add_string(nvl.get(), "ctld_portal_group_name", pg->name());
        nvlist_add_stringf(nvl.get(), "cfiscsi_portal_group_tag", "%u",
            pg->tag());

        if (targ->has_alias()) {
                nvlist_add_string(nvl.get(), "cfiscsi_target_alias",
                    targ->alias());
        }

        return (ctl_create_port("iscsi", nvl.get(), &p_ctl_port));
}

bool
iscsi_port::kernel_remove_port()
{
        freebsd::nvlist_up nvl(nvlist_create(0));
        nvlist_add_string(nvl.get(), "cfiscsi_target", p_target->name());
        nvlist_add_stringf(nvl.get(), "cfiscsi_portal_group_tag", "%u",
            p_portal_group->tag());

        return (ctl_remove_port("iscsi", nvl.get()));
}

bool
iscsi_portal::init_socket_options(int s)
{
        int sockbuf;

        sockbuf = SOCKBUF_SIZE;
        if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &sockbuf,
            sizeof(sockbuf)) == -1) {
                log_warn("setsockopt(SO_RCVBUF) failed for %s", listen());
                return (false);
        }
        sockbuf = SOCKBUF_SIZE;
        if (setsockopt(s, SOL_SOCKET, SO_SNDBUF, &sockbuf,
            sizeof(sockbuf)) == -1) {
                log_warn("setsockopt(SO_SNDBUF) failed for %s", listen());
                return (false);
        }
        return (true);
}

bool
iscsi_target::add_initiator_name(std::string_view name)
{
        if (!use_private_auth("initiator-name"))
                return (false);
        return (t_auth_group->add_initiator_name(name));
}

bool
iscsi_target::add_initiator_portal(const char *addr)
{
        if (!use_private_auth("initiator-portal"))
                return (false);
        return (t_auth_group->add_initiator_portal(addr));
}

bool
iscsi_target::add_lun(u_int id, const char *lun_name)
{
        std::string lun_label = "LUN " + std::to_string(id);
        return target::add_lun(id, lun_label.c_str(), lun_name);
}

bool
iscsi_target::add_portal_group(const char *pg_name, const char *ag_name)
{
        struct portal_group *pg;
        auth_group_sp ag;

        pg = t_conf->find_portal_group(pg_name);
        if (pg == NULL) {
                log_warnx("unknown portal-group \"%s\" for %s", pg_name,
                    label());
                return (false);
        }

        if (ag_name != NULL) {
                ag = t_conf->find_auth_group(ag_name);
                if (ag == NULL) {
                        log_warnx("unknown auth-group \"%s\" for %s", ag_name,
                            label());
                        return (false);
                }
        }

        if (!t_conf->add_port(this, pg, std::move(ag))) {
                log_warnx("can't link portal-group \"%s\" to %s", pg_name,
                    label());
                return (false);
        }
        return (true);
}

struct lun *
iscsi_target::start_lun(u_int id)
{
        std::string lun_label = "LUN " + std::to_string(id);
        std::string lun_name = freebsd::stringf("%s,lun,%u", name(), id);
        return target::start_lun(id, lun_label.c_str(), lun_name.c_str());
}

struct portal_group *
iscsi_target::default_portal_group()
{
        return t_conf->find_portal_group("default");
}

#ifdef ICL_KERNEL_PROXY

static void
pdu_receive_proxy(struct pdu *pdu)
{
        struct connection *conn;
        size_t len;

        assert(proxy_mode);
        conn = pdu->pdu_connection;

        kernel_receive(pdu);

        len = pdu_ahs_length(pdu);
        if (len > 0)
                log_errx(1, "protocol error: non-empty AHS");

        len = pdu_data_segment_length(pdu);
        assert(len <= (size_t)conn->conn_max_recv_data_segment_length);
        pdu->pdu_data_len = len;
}

static void
pdu_send_proxy(struct pdu *pdu)
{

        assert(proxy_mode);

        pdu_set_data_segment_length(pdu, pdu->pdu_data_len);
        kernel_send(pdu);
}

#endif /* ICL_KERNEL_PROXY */

static void
pdu_fail(const struct connection *conn __unused, const char *reason __unused)
{
}

iscsi_connection::iscsi_connection(struct portal *portal, freebsd::fd_up fd,
    const char *host, const struct sockaddr *client_sa) :
        conn_portal(portal), conn_fd(std::move(fd)), conn_initiator_addr(host),
        conn_initiator_sa(client_sa)
{
        connection_init(&conn, &conn_ops, proxy_mode);
        conn.conn_socket = conn_fd;
}

iscsi_connection::~iscsi_connection()
{
        chap_delete(conn_chap);
}

void
iscsi_connection::kernel_handoff()
{
        struct portal_group *pg = conn_portal->portal_group();
        struct ctl_iscsi req;

        bzero(&req, sizeof(req));

        req.type = CTL_ISCSI_HANDOFF;
        strlcpy(req.data.handoff.initiator_name, conn_initiator_name.c_str(),
            sizeof(req.data.handoff.initiator_name));
        strlcpy(req.data.handoff.initiator_addr, conn_initiator_addr.c_str(),
            sizeof(req.data.handoff.initiator_addr));
        if (!conn_initiator_alias.empty()) {
                strlcpy(req.data.handoff.initiator_alias,
                    conn_initiator_alias.c_str(),
                    sizeof(req.data.handoff.initiator_alias));
        }
        memcpy(req.data.handoff.initiator_isid, conn_initiator_isid,
            sizeof(req.data.handoff.initiator_isid));
        strlcpy(req.data.handoff.target_name, conn_target->name(),
            sizeof(req.data.handoff.target_name));
        strlcpy(req.data.handoff.offload, pg->offload(),
            sizeof(req.data.handoff.offload));
#ifdef ICL_KERNEL_PROXY
        if (proxy_mode)
                req.data.handoff.connection_id = conn.conn_socket;
        else
                req.data.handoff.socket = conn.conn_socket;
#else
        req.data.handoff.socket = conn.conn_socket;
#endif
        req.data.handoff.portal_group_tag = pg->tag();
        if (conn.conn_header_digest == CONN_DIGEST_CRC32C)
                req.data.handoff.header_digest = CTL_ISCSI_DIGEST_CRC32C;
        if (conn.conn_data_digest == CONN_DIGEST_CRC32C)
                req.data.handoff.data_digest = CTL_ISCSI_DIGEST_CRC32C;
        req.data.handoff.cmdsn = conn.conn_cmdsn;
        req.data.handoff.statsn = conn.conn_statsn;
        req.data.handoff.max_recv_data_segment_length =
            conn.conn_max_recv_data_segment_length;
        req.data.handoff.max_send_data_segment_length =
            conn.conn_max_send_data_segment_length;
        req.data.handoff.max_burst_length = conn.conn_max_burst_length;
        req.data.handoff.first_burst_length = conn.conn_first_burst_length;
        req.data.handoff.immediate_data = conn.conn_immediate_data;

        if (ioctl(ctl_fd, CTL_ISCSI, &req) == -1) {
                log_err(1, "error issuing CTL_ISCSI ioctl; "
                    "dropping connection");
        }

        if (req.status != CTL_ISCSI_OK) {
                log_errx(1, "error returned from CTL iSCSI handoff request: "
                    "%s; dropping connection", req.error_str);
        }
}

void
iscsi_connection::handle()
{
        login();
        if (conn_session_type == CONN_SESSION_TYPE_NORMAL) {
                kernel_handoff();
                log_debugx("connection handed off to the kernel");
        } else {
                assert(conn_session_type == CONN_SESSION_TYPE_DISCOVERY);
                discovery();
        }
}

void
iscsi_portal::handle_connection(freebsd::fd_up fd, const char *host,
    const struct sockaddr *client_sa)
{
        struct conf *conf = portal_group()->conf();

        iscsi_connection conn(this, std::move(fd), host, client_sa);
        start_timer(conf->timeout(), true);
        kernel_capsicate();
        conn.handle();
}