bluetooth/mesh/blob_cli.c

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#include <string.h>
#include <zephyr/bluetooth/mesh.h>
#include <common/bt_str.h>
#include "mesh.h"
#include "blob.h"
#include "net.h"
#include "transport.h"

#define LOG_LEVEL CONFIG_BT_MESH_MODEL_LOG_LEVEL
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(bt_mesh_blob_cli);

#define TARGETS_FOR_EACH(cli, target)                                          \
	SYS_SLIST_FOR_EACH_CONTAINER((sys_slist_t *)&(cli)->inputs->targets,   \
				     target, n)

/* The Maximum BLOB Poll Interval - T_MBPI */
#define BLOB_POLL_TIME_MAX_SECS 30

#define CLIENT_TIMEOUT_MSEC(cli) (10 * MSEC_PER_SEC * (cli->inputs->timeout_base + 2) + \
				  100 * cli->inputs->ttl)
#define BLOCK_REPORT_TIME_MSEC ((BLOB_POLL_TIME_MAX_SECS * 2 + 7) * 1000)

/* BLOB Client is running Send Data State Machine from section 6.2.4.2. */
#define SENDING_CHUNKS_IN_PULL_MODE(cli) ((cli)->state == BT_MESH_BLOB_CLI_STATE_BLOCK_SEND && \
					  (cli)->xfer->mode == BT_MESH_BLOB_XFER_MODE_PULL)
#define UNICAST_MODE(cli) ((cli)->inputs->group == BT_MESH_ADDR_UNASSIGNED || \
			   (cli)->tx.ctx.force_unicast)

BUILD_ASSERT((BLOB_XFER_STATUS_MSG_MAXLEN + BT_MESH_MODEL_OP_LEN(BT_MESH_BLOB_OP_XFER_STATUS) +
	      BT_MESH_MIC_SHORT) <= BT_MESH_RX_SDU_MAX,
	     "The BLOB Transfer Status message does not fit into the maximum incoming SDU size.");

BUILD_ASSERT((BLOB_BLOCK_REPORT_STATUS_MSG_MAXLEN +
	      BT_MESH_MODEL_OP_LEN(BT_MESH_BLOB_OP_BLOCK_REPORT) + BT_MESH_MIC_SHORT)
	     <= BT_MESH_RX_SDU_MAX,
	     "The BLOB Partial Block Report message does not fit into the maximum incoming SDU "
	     "size.");

BUILD_ASSERT((BLOB_BLOCK_STATUS_MSG_MAXLEN + BT_MESH_MODEL_OP_LEN(BT_MESH_BLOB_OP_BLOCK_STATUS) +
	      BT_MESH_MIC_SHORT) <= BT_MESH_RX_SDU_MAX,
	     "The BLOB Block Status message does not fit into the maximum incoming SDU size.");


struct block_status {
	enum bt_mesh_blob_status status;
	enum bt_mesh_blob_chunks_missing missing;
	struct bt_mesh_blob_block block;
};

static struct bt_mesh_blob_target *next_target(struct bt_mesh_blob_cli *cli,
					       struct bt_mesh_blob_target **current);
static void transfer_cancel(struct bt_mesh_blob_cli *cli);

static void start_retry_timer(struct bt_mesh_blob_cli *cli)
{
	k_timeout_t next_timeout;

	if (SENDING_CHUNKS_IN_PULL_MODE(cli)) {
		int64_t next_timeout_ms = cli->tx.cli_timestamp;
		struct bt_mesh_blob_target *target = NULL;

		TARGETS_FOR_EACH(cli, target) {
			if (!target->procedure_complete &&
			    target->status == BT_MESH_BLOB_SUCCESS &&
			    target->pull->block_report_timestamp < next_timeout_ms) {
				next_timeout_ms = target->pull->block_report_timestamp;
			}
		}

		/* cli_timestamp and block_report_timestamp represent absolute time, while
		 * k_work_* functions use relative time.
		 */
		next_timeout_ms -= k_uptime_get();
		next_timeout = next_timeout_ms <= 0 ? K_NO_WAIT : K_MSEC(next_timeout_ms);
	} else {
		next_timeout = K_MSEC(CLIENT_TIMEOUT_MSEC(cli) /
				      CONFIG_BT_MESH_BLOB_CLI_BLOCK_RETRIES);
	}

	(void)k_work_reschedule(&cli->tx.retry, next_timeout);
}

static void cli_state_reset(struct bt_mesh_blob_cli *cli)
{
	k_work_cancel_delayable(&cli->tx.retry);
	cli->xfer = NULL;
	cli->state = BT_MESH_BLOB_CLI_STATE_NONE;
	cli->tx.ctx.is_inited = 0;
	cli->tx.cli_timestamp = 0ll;
	cli->tx.sending = 0;
}

static struct bt_mesh_blob_target *target_get(struct bt_mesh_blob_cli *cli,
					      uint16_t addr)
{
	struct bt_mesh_blob_target *target;

	TARGETS_FOR_EACH(cli, target) {
		if (target->addr == addr) {
			return target;
		}
	}

	LOG_ERR("Unknown target 0x%04x", addr);
	return NULL;
}

static void target_drop(struct bt_mesh_blob_cli *cli,
			struct bt_mesh_blob_target *target,
			enum bt_mesh_blob_status reason)
{
	LOG_WRN("Dropping 0x%04x: %u", target->addr, reason);

	target->status = reason;
	if (cli->cb && cli->cb->lost_target) {
		cli->cb->lost_target(cli, target, reason);
	}
}

static uint32_t targets_reset(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;
	uint32_t count = 0;

	TARGETS_FOR_EACH(cli, target) {
		if (target->status == BT_MESH_BLOB_SUCCESS) {
			target->acked = 0U;
			count++;
		}
	}

	return count;
}

static bool targets_active(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;

	TARGETS_FOR_EACH(cli, target) {
		if (target->status == BT_MESH_BLOB_SUCCESS) {
			return true;
		}
	}

	return false;
}

static bool targets_timedout(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;

	TARGETS_FOR_EACH(cli, target) {
		if (!!target->timedout) {
			return true;
		}
	}

	return false;
}

static int io_open(struct bt_mesh_blob_cli *cli)
{
	if (!cli->io->open) {
		return 0;
	}

	return cli->io->open(cli->io, cli->xfer, BT_MESH_BLOB_READ);
}

static void io_close(struct bt_mesh_blob_cli *cli)
{
	if (!cli->io->close) {
		return;
	}

	cli->io->close(cli->io, cli->xfer);
}

static uint16_t next_missing_chunk(struct bt_mesh_blob_cli *cli,
				   const uint8_t *missing_chunks,
				   uint16_t idx)
{
	do {
		if (blob_chunk_missing_get(missing_chunks, idx)) {
			break;
		}
	} while (++idx < cli->block.chunk_count);

	return idx;
}

/* Used in Pull mode to collect all missing chunks from each target in cli->block.missing. */
static void update_missing_chunks(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;

	memset(cli->block.missing, 0, sizeof(cli->block.missing));

	TARGETS_FOR_EACH(cli, target) {
		if (target->procedure_complete || target->timedout) {
			continue;
		}

		for (size_t idx = 0; idx < cli->block.chunk_count; idx++) {
			bool missing = blob_chunk_missing_get(cli->block.missing, idx) ||
				       blob_chunk_missing_get(target->pull->missing, idx);
			blob_chunk_missing_set(cli->block.missing, idx, missing);
		}
	}
}

static inline size_t chunk_size(const struct bt_mesh_blob_xfer *xfer,
				const struct bt_mesh_blob_block *block,
				uint16_t chunk_idx)
{
	if ((chunk_idx == block->chunk_count - 1) &&
	    (block->size % xfer->chunk_size)) {
		return block->size % xfer->chunk_size;
	}

	return xfer->chunk_size;
}

static int chunk_idx_decode(struct net_buf_simple *buf)
{
	uint16_t data;
	uint8_t byte;

	if (buf->len == 0) {
		return -EINVAL;
	}

	byte = net_buf_simple_pull_u8(buf);

	/* utf-8 decoding */
	if ((byte & 0xf0) == 0xe0) { /* 0x800 - 0xffff */
		if (buf->len < 2) {
			return -EINVAL;
		}

		data = (byte & 0x0f) << 12;
		data |= (net_buf_simple_pull_u8(buf) & 0x3f) << 6;
		data |= (net_buf_simple_pull_u8(buf) & 0x3f);
	} else if ((byte & 0xe0) == 0xc0) { /* 0x80 - 0x7ff */
		if (buf->len < 1) {
			return -EINVAL;
		}

		data = (byte & 0x1f) << 6;
		data |= (net_buf_simple_pull_u8(buf) & 0x3f);
	} else { /* 0x00 - 0x7f */
		data = byte & 0x7f;
	}

	return data;
}

static void block_set(struct bt_mesh_blob_cli *cli, uint16_t block_idx)
{
	cli->block.number = block_idx;
	cli->block.offset = block_idx * (1UL << cli->xfer->block_size_log);
	cli->block.size = blob_block_size(cli->xfer->size, cli->xfer->block_size_log,
					  block_idx);
	cli->block.chunk_count =
		DIV_ROUND_UP(cli->block.size, cli->xfer->chunk_size);

	if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PUSH) {
		blob_chunk_missing_set_all(&cli->block);
	} else {
		struct bt_mesh_blob_target *target;

		/* In pull mode, the server will tell us which blocks are missing. */
		memset(cli->block.missing, 0, sizeof(cli->block.missing));

		TARGETS_FOR_EACH(cli, target) {
			memset(target->pull->missing, 0, sizeof(target->pull->missing));
		}
	}

	LOG_DBG("%u size: %u chunks: %u", block_idx, cli->block.size,
		cli->block.chunk_count);
}

static void suspend(struct bt_mesh_blob_cli *cli)
{
	cli->state = BT_MESH_BLOB_CLI_STATE_SUSPENDED;

	if (cli->cb && cli->cb->suspended) {
		cli->cb->suspended(cli);
	}
}

static void end(struct bt_mesh_blob_cli *cli, bool success)
{
	const struct bt_mesh_blob_xfer *xfer = cli->xfer;

	LOG_DBG("%u", success);

	io_close(cli);
	cli_state_reset(cli);
	if (cli->cb && cli->cb->end) {
		cli->cb->end(cli, xfer, success);
	}
}

static enum bt_mesh_blob_status caps_adjust(struct bt_mesh_blob_cli *cli,
					    const struct bt_mesh_blob_cli_caps *in)
{
	if (!(in->modes & cli->caps.modes)) {
		return BT_MESH_BLOB_ERR_UNSUPPORTED_MODE;
	}

	if ((in->min_block_size_log > cli->caps.max_block_size_log) ||
	    (in->max_block_size_log < cli->caps.min_block_size_log)) {
		return BT_MESH_BLOB_ERR_INVALID_BLOCK_SIZE;
	}

	cli->caps.min_block_size_log =
		MAX(cli->caps.min_block_size_log, in->min_block_size_log);
	cli->caps.max_block_size_log =
		MIN(cli->caps.max_block_size_log, in->max_block_size_log);
	cli->caps.max_chunks = MIN(cli->caps.max_chunks, in->max_chunks);
	cli->caps.mtu_size = MIN(cli->caps.mtu_size, in->mtu_size);
	cli->caps.max_chunk_size = MIN(cli->caps.max_chunk_size, in->max_chunk_size);
	cli->caps.modes &= in->modes;
	cli->caps.max_size = MIN(cli->caps.max_size, in->max_size);

	return BT_MESH_BLOB_SUCCESS;
}

/*******************************************************************************
 * TX State machine
 *
 * All messages in the transfer are going out to all the targets, either through
 * group messaging or directly to each. The TX state machine implements this
 * pattern for the transfer state machine to use. It will send the messages to
 * all devices (through the group or directly), repeating until it receives a
 * response from each device, or the attempts run out. Messages may also be
 * marked as unacked if they require no response.
 ******************************************************************************/

static struct bt_mesh_blob_target *next_target(struct bt_mesh_blob_cli *cli,
					       struct bt_mesh_blob_target **current)
{
	if (*current) {
		*current = SYS_SLIST_PEEK_NEXT_CONTAINER(*current, n);
	} else {
		*current = SYS_SLIST_PEEK_HEAD_CONTAINER(
			(sys_slist_t *)&cli->inputs->targets, *current, n);
	}

	while (*current) {
		if ((*current)->acked || (*current)->procedure_complete ||
		    (*current)->status != BT_MESH_BLOB_SUCCESS || (*current)->timedout ||
		    (*current)->skip) {
			goto next;
		}

		if (SENDING_CHUNKS_IN_PULL_MODE(cli) &&
		    (k_uptime_get() < (*current)->pull->block_report_timestamp ||
		     !blob_chunk_missing_get((*current)->pull->missing, cli->chunk_idx))) {
			/* Skip targets that didn't time out or timed out, but confirmed
			 * the currently transmitted chunk (cli->chunk_idx).
			 */
			goto next;
		}

		break;

next:
		*current = SYS_SLIST_PEEK_NEXT_CONTAINER(*current, n);
	}

	return *current;
}

static void send(struct bt_mesh_blob_cli *cli)
{
	cli->tx.sending = 1U;
	if (UNICAST_MODE(cli)) {
		cli->tx.ctx.send(cli, cli->tx.target->addr);
	} else {
		cli->tx.ctx.send(cli, cli->inputs->group);
	}
}

static void broadcast_complete(struct bt_mesh_blob_cli *cli)
{
	LOG_DBG("%s", cli->tx.cancelled ? "cancelling" : "continuing");

	cli->tx.ctx.is_inited = 0;
	k_work_cancel_delayable(&cli->tx.retry);

	if (cli->tx.cancelled) {
		transfer_cancel(cli);
	} else {
		__ASSERT(cli->tx.ctx.next, "No next callback");
		cli->tx.ctx.next(cli);
	}
}

static void tx_complete(struct k_work *work)
{
	struct k_work_delayable *dwork = k_work_delayable_from_work(work);
	struct bt_mesh_blob_cli *cli = CONTAINER_OF(dwork, struct bt_mesh_blob_cli, tx.complete);

	if (!cli->tx.ctx.is_inited || !cli->tx.sending) {
		return;
	}

	cli->tx.sending = 0U;

	if (cli->tx.cancelled) {
		broadcast_complete(cli);
		return;
	}

	if (cli->tx.ctx.send_complete) {
		cli->tx.ctx.send_complete(cli, cli->tx.target->addr);
	}

	if (UNICAST_MODE(cli) && next_target(cli, &cli->tx.target)) {
		send(cli);
		return;
	}

	if (cli->tx.ctx.acked && cli->tx.pending) {
		start_retry_timer(cli);
		return;
	}

	broadcast_complete(cli);
}

static void drop_remaining_targets(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;

	LOG_DBG("");

	cli->tx.pending = 0;

	TARGETS_FOR_EACH(cli, target) {
		if (!target->acked && !target->timedout && !target->procedure_complete &&
		    !target->skip) {
			target->timedout = 1U;
			target_drop(cli, target, BT_MESH_BLOB_ERR_INTERNAL);
		}
	}

	/* Update missing chunks to exclude chunks from dropped targets. */
	if (SENDING_CHUNKS_IN_PULL_MODE(cli)) {
		update_missing_chunks(cli);
	}
}

static void retry_timeout(struct k_work *work)
{
	struct bt_mesh_blob_cli *cli =
		CONTAINER_OF(work, struct bt_mesh_blob_cli, tx.retry.work);

	/* When sending chunks in Pull mode, timeout is handled differently. Client will drop all
	 * non-responsive servers by cli_timestamp. By calling broadcast_complete(), client will
	 * either retransmit the missing chunks (if any), or proceed to the next block, or suspend
	 * the transfer if all targets timed out. All this is handled in block_check_end().
	 * Retry logic for all other procedures in Pull mode is handled as in Push mode.
	 */
	if (SENDING_CHUNKS_IN_PULL_MODE(cli)) {
		if (k_uptime_get() >= cli->tx.cli_timestamp) {
			LOG_DBG("Transfer timed out.");

			if (!cli->tx.ctx.optional) {
				drop_remaining_targets(cli);
			}
		}

		broadcast_complete(cli);
		return;
	}

	LOG_DBG("%u", cli->tx.retries);

	cli->tx.retries--;
	cli->tx.target = NULL;

	__ASSERT(!cli->tx.sending, "still sending");
	__ASSERT(cli->tx.ctx.is_inited, "ctx is not initialized");

	if (!cli->tx.retries) {
		LOG_DBG("Transfer timed out.");

		if (!cli->tx.ctx.optional) {
			drop_remaining_targets(cli);
		}

		broadcast_complete(cli);
		return;
	}

	if (!cli->tx.ctx.acked || !next_target(cli, &cli->tx.target) || cli->tx.cancelled) {
		broadcast_complete(cli);
		return;
	}

	send(cli);
}

void blob_cli_broadcast(struct bt_mesh_blob_cli *cli,
			const struct blob_cli_broadcast_ctx *ctx)
{
	if (cli->tx.ctx.is_inited || cli->tx.sending) {
		LOG_ERR("BLOB cli busy");
		return;
	}

	cli->tx.cancelled = 0U;
	cli->tx.retries = CONFIG_BT_MESH_BLOB_CLI_BLOCK_RETRIES;
	cli->tx.ctx = *ctx;
	cli->tx.ctx.is_inited = 1U;

	cli->tx.pending = targets_reset(cli);

	LOG_DBG("%u targets", cli->tx.pending);

	cli->tx.target = NULL;
	if (!next_target(cli, &cli->tx.target)) {
		LOG_DBG("No active targets");
		broadcast_complete(cli);
		return;
	}

	send(cli);
}

void blob_cli_broadcast_tx_complete(struct bt_mesh_blob_cli *cli)
{
	k_work_schedule(&cli->tx.complete, K_MSEC(cli->tx.ctx.post_send_delay_ms));
}

void blob_cli_broadcast_rsp(struct bt_mesh_blob_cli *cli,
			    struct bt_mesh_blob_target *target)
{
	if (target->acked) {
		return;
	}

	LOG_DBG("0x%04x, pending: %d", target->addr, cli->tx.pending);

	target->acked = 1U;

	if (!--cli->tx.pending && !cli->tx.sending) {
		broadcast_complete(cli);
	}
}

void blob_cli_broadcast_abort(struct bt_mesh_blob_cli *cli)
{
	if (!cli->tx.ctx.is_inited) {
		return;
	}

	if ((cli)->state >= BT_MESH_BLOB_CLI_STATE_START) {
		io_close(cli);
	}

	cli_state_reset(cli);
}

static void send_start(uint16_t duration, int err, void *cb_data);
static void send_end(int err, void *user_data);

static int tx(struct bt_mesh_blob_cli *cli, uint16_t addr,
	      struct net_buf_simple *buf)
{
	static const struct bt_mesh_send_cb end_cb = {
		.start = send_start,
		.end = send_end,
	};
	struct bt_mesh_msg_ctx ctx = {
		.app_idx = cli->inputs->app_idx,
		.addr = addr,
		.send_ttl = cli->inputs->ttl,
	};
	int err;

	err = bt_mesh_model_send(cli->mod, &ctx, buf, &end_cb, cli);
	if (err) {
		LOG_ERR("Send err: %d", err);
		send_end(err, cli);
		return err;
	}

	return 0;
}

static void send_start(uint16_t duration, int err, void *cb_data)
{
	if (err) {
		LOG_ERR("TX Start failed: %d", err);
		send_end(err, cb_data);
	}
}

static void send_end(int err, void *user_data)
{
	struct bt_mesh_blob_cli *cli = user_data;

	if (!cli->tx.ctx.is_inited) {
		return;
	}

	blob_cli_broadcast_tx_complete(cli);
}

/*******************************************************************************
 * TX
 ******************************************************************************/

static void info_get_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	BT_MESH_MODEL_BUF_DEFINE(buf, BT_MESH_BLOB_OP_INFO_GET, 0);
	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_INFO_GET);

	tx(cli, dst, &buf);
}

static void xfer_start_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	BT_MESH_MODEL_BUF_DEFINE(buf, BT_MESH_BLOB_OP_XFER_START, 16);
	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_XFER_START);
	net_buf_simple_add_u8(&buf, cli->xfer->mode << 6);
	net_buf_simple_add_le64(&buf, cli->xfer->id);
	net_buf_simple_add_le32(&buf, cli->xfer->size);
	net_buf_simple_add_u8(&buf, cli->xfer->block_size_log);
	net_buf_simple_add_le16(&buf, BT_MESH_TX_SDU_MAX);

	tx(cli, dst, &buf);
}

static void xfer_get_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	BT_MESH_MODEL_BUF_DEFINE(buf, BT_MESH_BLOB_OP_XFER_GET, 0);
	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_XFER_GET);

	tx(cli, dst, &buf);
}

static void xfer_cancel_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	BT_MESH_MODEL_BUF_DEFINE(buf, BT_MESH_BLOB_OP_XFER_CANCEL, 8);
	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_XFER_CANCEL);
	net_buf_simple_add_le64(&buf, cli->xfer->id);

	tx(cli, dst, &buf);
}

static void block_start_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	BT_MESH_MODEL_BUF_DEFINE(buf, BT_MESH_BLOB_OP_BLOCK_START, 4);
	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_BLOCK_START);
	net_buf_simple_add_le16(&buf, cli->block.number);
	net_buf_simple_add_le16(&buf, cli->xfer->chunk_size);

	tx(cli, dst, &buf);
}

static void chunk_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	NET_BUF_SIMPLE_DEFINE(buf, BT_MESH_TX_SDU_MAX);
	struct bt_mesh_blob_chunk chunk;
	int err;

	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_CHUNK);
	net_buf_simple_add_le16(&buf, cli->chunk_idx);

	chunk.size = chunk_size(cli->xfer, &cli->block, cli->chunk_idx);
	chunk.offset = cli->xfer->chunk_size * cli->chunk_idx;
	chunk.data = net_buf_simple_add(&buf, chunk.size);

	err = cli->io->rd(cli->io, cli->xfer, &cli->block, &chunk);
	if (err || cli->state == BT_MESH_BLOB_CLI_STATE_NONE) {
		bt_mesh_blob_cli_cancel(cli);
		return;
	}

	tx(cli, dst, &buf);
}

static void block_get_tx(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	BT_MESH_MODEL_BUF_DEFINE(buf, BT_MESH_BLOB_OP_BLOCK_GET, 0);
	bt_mesh_model_msg_init(&buf, BT_MESH_BLOB_OP_BLOCK_GET);

	tx(cli, dst, &buf);
}

/**************************************************************************************************
 * State machine
 *
 * The BLOB Client state machine walks through the steps in the BLOB transfer in the following
 * fashion:
 *
 *                                                 .---------------------------------------.
 *                                                 V                                       |
 * xfer_start -> block_set -> block_start -> chunk_send -> chunk_send_end                  |
 *                   A                                           |                         |
 *                   |                                           V                         |
 *                   |                                [more missing chunks?]-----[Yes]-----+
 *                   |                                           |                         |
 *                   |                                         [No]                        |
 *                   |                                           |                         |
 *                   |                                           V                         |
 *                   |                                         [mode?]                     |
 *                   |                             .---[Push]---'   '---[Pull]---.         |
 *                   |                             |                             |         |
 *                   |                             V                             V         |
 *                   |                        block_check               block_report_wait  |
 *                   |                             |                             |         |
 *                   |                             '-----------.   .-------------'         |
 *                   |                                         |   |                       |
 *                   |                                         V   V                       |
 *                   |                                    block_check_end                  |
 *                   |                                           |                         |
 *                   |                                           V                         |
 *                   |                                   [block completed?]------[No]------'
 *                   |                                           |
 *                   |                                         [Yes]
 *                   |                                           |
 *                   |                                           V
 *                   '-------------------[No]------------[last block sent?]
 *                                                               |
 *                                                             [Yes]
 *                                                               |
 *                                                               V
 *                                                        confirm_transfer
 *                                                               |
 *                                                               V
 *                                                        transfer_complete
 *
 * In each state, the Client transmits a message to all target nodes. In each state, except when
 * sending chunks (chunk_send), the Client expects a response from all target nodes, before
 * proceeding to the next state.
 *
 * When a target node responds, the Client calls @ref blob_cli_broadcast_rsp for the corresponding
 * target. Once all target nodes has responded, the Client proceeds to the next state.
 *
 * When sending chunks in Push mode, the Client will proceed to the next state (block_check) after
 * transmitting all missing chunks. In the block_check state, the Client will request a block status
 * from all target nodes. If any targets have missing chunks, the Client will resend them.
 *
 * When sending chunks in Pull mode, the Client addresses each target node individually using
 * @ref bt_mesh_blob_target_pull structure. The Client uses @ref bt_mesh_blob_cli::block::missing
 * to keep all missing chunks for the current block. Missing chunks for an individual target
 * is kept in @ref bt_mesh_blob_target_pull::missing. The Client uses @ref
 * bt_mesh_blob_target_pull::block_report_timeout to decide if it can send a chunk to this target.
 *
 * After sending all reported missing chunks to each target, the Client updates
 * @ref bt_mesh_blob_target_pull::block_report_timestamp value for every target individually in
 * chunk_tx_complete. The Client then proceeds to block_report_wait state and uses the earliest of
 * all block_report_timestamp and cli_timestamp to schedule the retry timer. When the retry
 * timer expires, the Client proceeds to the block_check_end state.
 *
 * In Pull mode, target nodes send a Partial Block Report message to the Client to inform about
 * missing chunks. The Client doesn't control when these messages are sent by target nodes, and
 * therefore it can't use @ref blob_cli_broadcast_rsp when it receives them. When the Client
 * receives the Partial Block Report message, it updates missing chunks, resets
 * block_report_timestamp, and explicitly calls @ref broadcast_complete to proceed to
 * block_check_end state.
 *
 **************************************************************************************************/
static void caps_collected(struct bt_mesh_blob_cli *cli);
static void block_start(struct bt_mesh_blob_cli *cli);
static void chunk_send(struct bt_mesh_blob_cli *cli);
static void block_check(struct bt_mesh_blob_cli *cli);
static void block_check_end(struct bt_mesh_blob_cli *cli);
static void block_report_wait(struct bt_mesh_blob_cli *cli);
static void chunk_send_end(struct bt_mesh_blob_cli *cli);
static void confirm_transfer(struct bt_mesh_blob_cli *cli);
static void transfer_complete(struct bt_mesh_blob_cli *cli);

static void caps_get(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = info_get_tx,
		.next = caps_collected,
		.acked = true,
	};

	cli->state = BT_MESH_BLOB_CLI_STATE_CAPS_GET;
	blob_cli_broadcast(cli, &ctx);
}

static void caps_collected(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;
	bool success = false;

	cli->state = BT_MESH_BLOB_CLI_STATE_NONE;

	cli_state_reset(cli);

	TARGETS_FOR_EACH(cli, target) {
		if (target->status == BT_MESH_BLOB_SUCCESS) {
			success = true;
			break;
		}
	}

	while (success &&
	       (1UL << cli->caps.max_block_size_log) >
	       (cli->caps.max_chunk_size * cli->caps.max_chunks)) {
		cli->caps.max_block_size_log--;
	}

	if (cli->cb && cli->cb->caps) {
		cli->cb->caps(cli, success ? &cli->caps : NULL);
	}
}

static int xfer_start(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = xfer_start_tx,
		.next = block_start,
		.acked = true,
	};
	int err;

	err = io_open(cli);
	if (err) {
		return -EIO;
	}

	cli->state = BT_MESH_BLOB_CLI_STATE_START;

	blob_cli_broadcast(cli, &ctx);
	return 0;
}

static void block_start(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = block_start_tx,
		.next = chunk_send,
		.acked = true,
	};
	struct bt_mesh_blob_target *target;


	if (!targets_active(cli)) {
		if (targets_timedout(cli)) {
			suspend(cli);
			return;
		}

		end(cli, false);
		return;
	}

	LOG_DBG("%u (%u chunks, %u/%u)", cli->block.number,
		cli->block.chunk_count, cli->block.number + 1, cli->block_count);

	cli->chunk_idx = 0;
	cli->state = BT_MESH_BLOB_CLI_STATE_BLOCK_START;
	/* Client Timeout Timer in Send Data State Machine is initialized initially after
	 * transmitting the first bunch of chunks (see block_report_wait()). Next time it will be
	 * updated after every Partial Block Report message.
	 */
	cli->tx.cli_timestamp = 0ll;

	TARGETS_FOR_EACH(cli, target) {
		target->procedure_complete = 0U;

		if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PULL) {
			target->pull->block_report_timestamp = 0ll;
		}
	}

	if (cli->io->block_start) {
		cli->io->block_start(cli->io, cli->xfer, &cli->block);
		if (cli->state == BT_MESH_BLOB_CLI_STATE_NONE) {
			return;
		}
	}

	blob_cli_broadcast(cli, &ctx);
}

static void chunk_tx_complete(struct bt_mesh_blob_cli *cli, uint16_t dst)
{
	if (cli->xfer->mode != BT_MESH_BLOB_XFER_MODE_PULL) {
		return;
	}

	/* Update Block Report Timer individually for each target after sending out the last chunk
	 * in current iteration.
	 */
	uint16_t chunk_idx = next_missing_chunk(cli, cli->tx.target->pull->missing,
						cli->chunk_idx + 1);
	if (chunk_idx < cli->block.chunk_count) {
		/* Will send more chunks to this target in this iteration. */
		return;
	}

	/* This was the last chunk sent for this target. Now start the Block Report Timeout Timer.
	 */
	struct bt_mesh_blob_target *target;
	int64_t timestamp = k_uptime_get() + BLOCK_REPORT_TIME_MSEC;

	if (!UNICAST_MODE(cli)) {
		/* If using group addressing, reset timestamp for all targets after all chunks are
		 * sent to the group address
		 */
		TARGETS_FOR_EACH(cli, target) {
			target->pull->block_report_timestamp = timestamp;
		}
		return;
	}

	cli->tx.target->pull->block_report_timestamp = timestamp;
}

static void chunk_send(struct bt_mesh_blob_cli *cli)
{
	struct blob_cli_broadcast_ctx ctx = {
		.send = chunk_tx,
		.next = chunk_send_end,
		.acked = false,
		.post_send_delay_ms = cli->chunk_interval_ms,
	};

	if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PULL) {
		ctx.send_complete = chunk_tx_complete;
	}

	if (!targets_active(cli)) {
		if (targets_timedout(cli)) {
			suspend(cli);
			return;
		}

		end(cli, false);
		return;
	}

	LOG_DBG("%u / %u size: %u", cli->chunk_idx + 1, cli->block.chunk_count,
		chunk_size(cli->xfer, &cli->block, cli->chunk_idx));

	cli->state = BT_MESH_BLOB_CLI_STATE_BLOCK_SEND;
	blob_cli_broadcast(cli, &ctx);
}

static void chunk_send_end(struct bt_mesh_blob_cli *cli)
{
	/* In pull mode, the partial block reports are used to confirm which
	 * chunks have been received, while in push mode, we just assume that a
	 * sent chunk has been received.
	 */
	if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PUSH) {
		blob_chunk_missing_set(cli->block.missing, cli->chunk_idx, false);
	}

	cli->chunk_idx = next_missing_chunk(cli, cli->block.missing, cli->chunk_idx + 1);
	if (cli->chunk_idx < cli->block.chunk_count) {
		chunk_send(cli);
		return;
	}

	if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PUSH) {
		block_check(cli);
	} else {
		block_report_wait(cli);
	}
}

/* The block checking pair(block_check - block_check_end)
 * is relevant only for Push mode.
 */
static void block_check(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = block_get_tx,
		.next = block_check_end,
		.acked = true,
	};

	cli->state = BT_MESH_BLOB_CLI_STATE_BLOCK_CHECK;

	LOG_DBG("");

	blob_cli_broadcast(cli, &ctx);
}

static void block_report_wait(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.next = block_check_end,
		.acked = false,
	};

	/* Check if all servers already confirmed all chunks during the transmission. */
	if (next_missing_chunk(cli, cli->block.missing, 0) >= cli->block.chunk_count) {
		block_check_end(cli);
		return;
	}

	LOG_DBG("Waiting for partial block report...");
	cli->tx.ctx = ctx;

	/* Start Client Timeout Timer in Send Data sub-procedure for the first time. */
	if (!cli->tx.cli_timestamp) {
		cli->tx.cli_timestamp = k_uptime_get() + CLIENT_TIMEOUT_MSEC(cli);
	}

	start_retry_timer(cli);
}

static void block_check_end(struct bt_mesh_blob_cli *cli)
{
	LOG_DBG("");

	if (!targets_active(cli)) {
		if (targets_timedout(cli)) {
			suspend(cli);
			return;
		}

		end(cli, false);
		return;
	}

	cli->chunk_idx = next_missing_chunk(cli, cli->block.missing, 0);
	if (cli->chunk_idx < cli->block.chunk_count) {
		chunk_send(cli);
		return;
	}

	LOG_DBG("No more missing chunks for block %u", cli->block.number);

	if (cli->io->block_end) {
		cli->io->block_end(cli->io, cli->xfer, &cli->block);
		if (cli->state == BT_MESH_BLOB_CLI_STATE_NONE) {
			return;
		}
	}

	if (cli->block.number == cli->block_count - 1) {
		struct bt_mesh_blob_target *target;

		TARGETS_FOR_EACH(cli, target) {
			target->procedure_complete = 0U;
		}

		confirm_transfer(cli);
		return;
	}

	block_set(cli, cli->block.number + 1);
	block_start(cli);
}

static void confirm_transfer(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = xfer_get_tx,
		.next = transfer_complete,
		.acked = true,
	};

	LOG_DBG("");

	cli->state = BT_MESH_BLOB_CLI_STATE_XFER_CHECK;

	blob_cli_broadcast(cli, &ctx);
}

static void progress_checked(struct bt_mesh_blob_cli *cli)
{
	LOG_DBG("");

	cli->state = BT_MESH_BLOB_CLI_STATE_NONE;

	if (cli->cb && cli->cb->end) {
		cli->cb->xfer_progress_complete(cli);
	}
}

static void check_transfer(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = xfer_get_tx,
		.next = progress_checked,
		.acked = true,
	};

	LOG_DBG("");

	cli->state = BT_MESH_BLOB_CLI_STATE_XFER_PROGRESS_GET;

	blob_cli_broadcast(cli, &ctx);
}

static void transfer_cancel(struct bt_mesh_blob_cli *cli)
{
	const struct blob_cli_broadcast_ctx ctx = {
		.send = xfer_cancel_tx,
		.next = transfer_complete,
		.acked = true,
	};

	LOG_DBG("");

	cli->state = BT_MESH_BLOB_CLI_STATE_CANCEL;

	blob_cli_broadcast(cli, &ctx);
}

static void transfer_complete(struct bt_mesh_blob_cli *cli)
{
	bool success = targets_active(cli) &&
		       cli->state == BT_MESH_BLOB_CLI_STATE_XFER_CHECK;

	end(cli, success);
}

/*******************************************************************************
 * RX
 ******************************************************************************/

static void rx_block_status(struct bt_mesh_blob_cli *cli,
			    struct bt_mesh_blob_target *target,
			    struct block_status *block)
{
	if (cli->state != BT_MESH_BLOB_CLI_STATE_BLOCK_START &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_BLOCK_SEND &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_BLOCK_CHECK) {
		LOG_WRN("Invalid state %u", cli->state);
		return;
	}

	LOG_DBG("0x%04x: block: %u status: %u", target->addr, block->block.number, block->status);

	if (block->status != BT_MESH_BLOB_SUCCESS) {
		target_drop(cli, target, block->status);
		blob_cli_broadcast_rsp(cli, target);
		return;
	}

	if (block->block.number != cli->block.number) {
		LOG_DBG("Invalid block num (expected %u)", cli->block.number);
		return;
	}

	if (block->missing == BT_MESH_BLOB_CHUNKS_MISSING_NONE) {
		target->procedure_complete = 1U;

		if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PULL) {
			memset(target->pull->missing, 0, sizeof(target->pull->missing));
			update_missing_chunks(cli);
		}

		LOG_DBG("Target 0x%04x received all chunks", target->addr);
	} else if (block->missing == BT_MESH_BLOB_CHUNKS_MISSING_ALL) {
		blob_chunk_missing_set_all(&cli->block);
	} else if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PULL) {
		memcpy(target->pull->missing, block->block.missing, sizeof(block->block.missing));

		LOG_DBG("Missing: %s", bt_hex(target->pull->missing, cli->block.chunk_count));

		update_missing_chunks(cli);

		/* Target has responded. Reset the timestamp so that client can start transmitting
		 * missing chunks to it.
		 */
		target->pull->block_report_timestamp = 0ll;
	} else {
		for (int i = 0; i < ARRAY_SIZE(block->block.missing); ++i) {
			cli->block.missing[i] |= block->block.missing[i];
		}
	}

	if (SENDING_CHUNKS_IN_PULL_MODE(cli)) {
		if (!cli->tx.sending) {
			/* If not sending, then the retry timer is running. Call
			 * broadcast_complete() to proceed to block_check_end() and start
			 * transmitting missing chunks.
			 */
			broadcast_complete(cli);
		}

		/* When sending chunks in Pull mode, we don't confirm transaction when receiving
		 * Partial Block Report message.
		 */
		return;
	}

	blob_cli_broadcast_rsp(cli, target);
}

static int handle_xfer_status(const struct bt_mesh_model *mod, struct bt_mesh_msg_ctx *ctx,
			      struct net_buf_simple *buf)
{
	struct bt_mesh_blob_cli *cli = mod->rt->user_data;
	enum bt_mesh_blob_xfer_phase expected_phase;
	struct bt_mesh_blob_target *target;
	struct bt_mesh_blob_xfer_info info = { 0 };
	uint8_t status_and_mode;

	status_and_mode = net_buf_simple_pull_u8(buf);
	info.status = status_and_mode & BIT_MASK(4);
	info.mode = status_and_mode >> 6;
	info.phase = net_buf_simple_pull_u8(buf);

	if (buf->len) {
		info.id = net_buf_simple_pull_le64(buf);
	}

	if (buf->len >= 7) {
		info.size = net_buf_simple_pull_le32(buf);
		info.block_size_log = net_buf_simple_pull_u8(buf);
		info.mtu_size = net_buf_simple_pull_le16(buf);
		info.missing_blocks = net_buf_simple_pull(buf, buf->len);
	}

	LOG_DBG("status: %u %s phase: %u %s", info.status,
		info.mode == BT_MESH_BLOB_XFER_MODE_PUSH ? "push" : "pull",
		info.phase, bt_hex(&info.id, 8));


	if (cli->state != BT_MESH_BLOB_CLI_STATE_START &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_XFER_CHECK &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_CANCEL &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_XFER_PROGRESS_GET) {
		LOG_WRN("Wrong state: %d", cli->state);
		return -EBUSY;
	}

	target = target_get(cli, ctx->addr);
	if (!target) {
		return -ENOENT;
	}

	if (cli->state == BT_MESH_BLOB_CLI_STATE_START) {
		expected_phase = BT_MESH_BLOB_XFER_PHASE_WAITING_FOR_BLOCK;
	} else if (cli->state == BT_MESH_BLOB_CLI_STATE_XFER_CHECK) {
		expected_phase = BT_MESH_BLOB_XFER_PHASE_COMPLETE;
	} else if (cli->state != BT_MESH_BLOB_CLI_STATE_XFER_PROGRESS_GET) {
		expected_phase = BT_MESH_BLOB_XFER_PHASE_INACTIVE;
	} else { /* cli->state == BT_MESH_BLOB_CLI_STATE_XFER_PROGRESS_GET */
		blob_cli_broadcast_rsp(cli, target);
		if (cli->cb && cli->cb->xfer_progress) {
			cli->cb->xfer_progress(cli, target, &info);
		}
		return 0;
	}

	if (info.status != BT_MESH_BLOB_SUCCESS) {
		target_drop(cli, target, info.status);
	} else if (info.phase != expected_phase) {
		LOG_WRN("Wrong phase: %u != %u", expected_phase, info.phase);
		return -EINVAL;
	} else if (info.phase != BT_MESH_BLOB_XFER_PHASE_INACTIVE &&
		   info.id != cli->xfer->id) {
		target_drop(cli, target, BT_MESH_BLOB_ERR_WRONG_BLOB_ID);
	}

	blob_cli_broadcast_rsp(cli, target);

	return 0;
}

static int handle_block_report(const struct bt_mesh_model *mod, struct bt_mesh_msg_ctx *ctx,
			       struct net_buf_simple *buf)
{
	struct bt_mesh_blob_cli *cli = mod->rt->user_data;
	struct block_status status = {
		.status = BT_MESH_BLOB_SUCCESS,
		.block.number = cli->block.number,
		.missing = (buf->len ? BT_MESH_BLOB_CHUNKS_MISSING_ENCODED :
				       BT_MESH_BLOB_CHUNKS_MISSING_NONE),
	};
	struct bt_mesh_blob_target *target;

	if (!cli->xfer) {
		return -EINVAL;
	}

	if (cli->xfer->mode == BT_MESH_BLOB_XFER_MODE_PUSH) {
		LOG_WRN("Unexpected encoded block report in push mode");
		return -EINVAL;
	}

	LOG_DBG("");

	target = target_get(cli, ctx->addr);
	if (!target) {
		return -ENOENT;
	}

	while (buf->len) {
		int idx;

		idx = chunk_idx_decode(buf);
		if (idx < 0) {
			return idx;
		}

		blob_chunk_missing_set(status.block.missing, idx, true);
	}

	/* If all chunks were already confirmed by this target, Send Data State Machine is in Final
	 * state for this target. Therefore, the message should be ignored.
	 */
	if (next_missing_chunk(cli, target->pull->missing, 0) >= cli->block.chunk_count) {
		LOG_DBG("All chunks already confirmed");
		return 0;
	}

	cli->tx.cli_timestamp = k_uptime_get() + CLIENT_TIMEOUT_MSEC(cli);

	rx_block_status(cli, target, &status);

	return 0;
}

static int handle_block_status(const struct bt_mesh_model *mod, struct bt_mesh_msg_ctx *ctx,
			       struct net_buf_simple *buf)
{
	struct bt_mesh_blob_cli *cli = mod->rt->user_data;
	struct bt_mesh_blob_target *target;
	struct block_status status = { 0 };
	uint8_t status_and_format;
	uint16_t chunk_size;
	size_t len;
	int idx;

	target = target_get(cli, ctx->addr);
	if (!target) {
		return -ENOENT;
	}

	status_and_format = net_buf_simple_pull_u8(buf);
	status.status = status_and_format & BIT_MASK(4);
	status.missing = status_and_format >> 6;
	status.block.number = net_buf_simple_pull_le16(buf);
	chunk_size = net_buf_simple_pull_le16(buf);
	status.block.chunk_count =
		DIV_ROUND_UP(cli->block.size, chunk_size);

	LOG_DBG("status: %u block: %u encoding: %u", status.status,
		status.block.number, status.missing);

	switch (status.missing) {
	case BT_MESH_BLOB_CHUNKS_MISSING_ALL:
		blob_chunk_missing_set_all(&status.block);
		break;
	case BT_MESH_BLOB_CHUNKS_MISSING_NONE:
		break;
	case BT_MESH_BLOB_CHUNKS_MISSING_SOME:
		if (buf->len > sizeof(status.block.missing)) {
			return -EINVAL;
		}

		len = buf->len;
		memcpy(status.block.missing, net_buf_simple_pull_mem(buf, len),
		       len);

		LOG_DBG("Missing: %s", bt_hex(status.block.missing, len));
		break;
	case BT_MESH_BLOB_CHUNKS_MISSING_ENCODED:
		/** MshMBTv1.0: 5.3.8: An empty Missing Chunks field entails that there are no
		 * missing chunks for this block.
		 */
		if (!buf->len) {
			status.missing = BT_MESH_BLOB_CHUNKS_MISSING_NONE;
		}

		while (buf->len) {
			idx = chunk_idx_decode(buf);
			if (idx < 0 || idx >= status.block.chunk_count) {
				LOG_ERR("Invalid encoding");
				return -EINVAL;
			}

			LOG_DBG("Missing %d", idx);

			blob_chunk_missing_set(status.block.missing, idx, true);
		}
		break;
	}

	rx_block_status(cli, target, &status);

	return 0;
}

static int handle_info_status(const struct bt_mesh_model *mod, struct bt_mesh_msg_ctx *ctx,
			      struct net_buf_simple *buf)
{
	struct bt_mesh_blob_cli *cli = mod->rt->user_data;
	struct bt_mesh_blob_cli_caps caps;
	enum bt_mesh_blob_status status;
	struct bt_mesh_blob_target *target;

	if (cli->state != BT_MESH_BLOB_CLI_STATE_CAPS_GET) {
		return -EBUSY;
	}

	caps.min_block_size_log = net_buf_simple_pull_u8(buf);
	caps.max_block_size_log = net_buf_simple_pull_u8(buf);
	caps.max_chunks = net_buf_simple_pull_le16(buf);
	caps.max_chunk_size = net_buf_simple_pull_le16(buf);
	caps.max_size = net_buf_simple_pull_le32(buf);
	caps.mtu_size = net_buf_simple_pull_le16(buf);
	caps.modes = net_buf_simple_pull_u8(buf);

	if (caps.min_block_size_log < 0x06 ||
	    caps.max_block_size_log > 0x20 ||
	    caps.max_block_size_log < caps.min_block_size_log ||
	    caps.max_chunks == 0 || caps.max_chunk_size < 8 ||
	    caps.max_size == 0 || caps.mtu_size < 0x14) {
		return -EINVAL;
	}

	LOG_DBG("0x%04x\n\tblock size: %u - %u\n\tchunks: %u\n\tchunk size: %u\n"
	       "\tblob size: %u\n\tmtu size: %u\n\tmodes: %x",
	       ctx->addr, caps.min_block_size_log, caps.max_block_size_log,
	       caps.max_chunks, caps.max_chunk_size, caps.max_size,
	       caps.mtu_size, caps.modes);

	target = target_get(cli, ctx->addr);
	if (!target) {
		return -ENOENT;
	}

	status = caps_adjust(cli, &caps);
	if (status != BT_MESH_BLOB_SUCCESS) {
		target_drop(cli, target, status);
	}

	blob_cli_broadcast_rsp(cli, target);

	return 0;
}

const struct bt_mesh_model_op _bt_mesh_blob_cli_op[] = {
	{ BT_MESH_BLOB_OP_XFER_STATUS, BT_MESH_LEN_MIN(2), handle_xfer_status },
	{ BT_MESH_BLOB_OP_BLOCK_REPORT, BT_MESH_LEN_MIN(0), handle_block_report },
	{ BT_MESH_BLOB_OP_BLOCK_STATUS, BT_MESH_LEN_MIN(5), handle_block_status },
	{ BT_MESH_BLOB_OP_INFO_STATUS, BT_MESH_LEN_EXACT(13), handle_info_status },
	BT_MESH_MODEL_OP_END,
};

static int blob_cli_init(const struct bt_mesh_model *mod)
{
	struct bt_mesh_blob_cli *cli = mod->rt->user_data;

	cli->mod = mod;

	bt_mesh_blob_cli_set_chunk_interval_ms(cli, CONFIG_BT_MESH_TX_BLOB_CHUNK_SEND_INTERVAL);
	cli->tx.cli_timestamp = 0ll;
	k_work_init_delayable(&cli->tx.retry, retry_timeout);
	k_work_init_delayable(&cli->tx.complete, tx_complete);

	return 0;
}

static void blob_cli_reset(const struct bt_mesh_model *mod)
{
	struct bt_mesh_blob_cli *cli = mod->rt->user_data;

	cli_state_reset(cli);
}

const struct bt_mesh_model_cb _bt_mesh_blob_cli_cb = {
	.init = blob_cli_init,
	.reset = blob_cli_reset,
};


int bt_mesh_blob_cli_caps_get(struct bt_mesh_blob_cli *cli,
			      const struct bt_mesh_blob_cli_inputs *inputs)
{
	if (bt_mesh_blob_cli_is_busy(cli)) {
		return -EBUSY;
	}

	cli->inputs = inputs;

	cli->caps.min_block_size_log = 0x06;
	cli->caps.max_block_size_log = 0x20;
	cli->caps.max_chunks = CONFIG_BT_MESH_BLOB_CHUNK_COUNT_MAX;
	cli->caps.max_chunk_size = BLOB_TX_CHUNK_SIZE;
	cli->caps.max_size = 0xffffffff;
	cli->caps.mtu_size = 0xffff;
	cli->caps.modes = BT_MESH_BLOB_XFER_MODE_ALL;

	if (!targets_reset(cli)) {
		LOG_ERR("No valid targets");
		return -ENODEV;
	}

	caps_get(cli);

	return 0;
}

int bt_mesh_blob_cli_send(struct bt_mesh_blob_cli *cli,
			  const struct bt_mesh_blob_cli_inputs *inputs,
			  const struct bt_mesh_blob_xfer *xfer,
			  const struct bt_mesh_blob_io *io)
{
	if (bt_mesh_blob_cli_is_busy(cli)) {
		LOG_ERR("BLOB Client is busy");
		return -EBUSY;
	}

	if (!(xfer->mode & BT_MESH_BLOB_XFER_MODE_ALL) || xfer->block_size_log < 0x06 ||
	    xfer->block_size_log > 0x20 || xfer->chunk_size < 8 ||
	    xfer->chunk_size > BLOB_TX_CHUNK_SIZE) {
		LOG_ERR("Incompatible transfer parameters");
		return -EINVAL;
	}

	cli->xfer = xfer;
	cli->inputs = inputs;
	cli->io = io;

	if (cli->xfer->block_size_log == 0x20) {
		cli->block_count = 1;
	} else {
		cli->block_count = DIV_ROUND_UP(cli->xfer->size, (1U << cli->xfer->block_size_log));
	}

	block_set(cli, 0);

	if (cli->block.chunk_count > CONFIG_BT_MESH_BLOB_CHUNK_COUNT_MAX) {
		LOG_ERR("Too many chunks");
		return -EINVAL;
	}

	if (!targets_reset(cli)) {
		LOG_ERR("No valid targets");
		return -ENODEV;
	}

	LOG_DBG("\n\tblock size log: %u\n\tchunk size: %u\n"
		"\tblob size: %u\n\tmode: %x",
		cli->xfer->block_size_log, cli->xfer->chunk_size,
		cli->xfer->size, cli->xfer->mode);

	return xfer_start(cli);
}

int bt_mesh_blob_cli_suspend(struct bt_mesh_blob_cli *cli)
{
	if (cli->state == BT_MESH_BLOB_CLI_STATE_SUSPENDED) {
		return 0;
	}

	if (cli->state != BT_MESH_BLOB_CLI_STATE_BLOCK_START &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_BLOCK_SEND &&
	    cli->state != BT_MESH_BLOB_CLI_STATE_BLOCK_CHECK) {
		LOG_WRN("BLOB xfer not started: %d", cli->state);
		return -EINVAL;
	}

	cli->state = BT_MESH_BLOB_CLI_STATE_SUSPENDED;
	(void)k_work_cancel_delayable(&cli->tx.retry);
	cli->tx.ctx.is_inited = 0;
	cli->tx.sending = 0;
	cli->tx.cli_timestamp = 0ll;
	return 0;
}

int bt_mesh_blob_cli_resume(struct bt_mesh_blob_cli *cli)
{
	struct bt_mesh_blob_target *target;

	if (cli->state != BT_MESH_BLOB_CLI_STATE_SUSPENDED) {
		LOG_WRN("Not suspended");
		return -EINVAL;
	}

	/* Restore timed out targets. */
	TARGETS_FOR_EACH(cli, target) {
		if (!!target->timedout) {
			target->status = BT_MESH_BLOB_SUCCESS;
			target->timedout = 0U;
		}
	}

	if (!targets_reset(cli)) {
		LOG_ERR("No valid targets");
		return -ENODEV;
	}

	block_set(cli, 0);
	return xfer_start(cli);
}

void bt_mesh_blob_cli_cancel(struct bt_mesh_blob_cli *cli)
{
	if (!bt_mesh_blob_cli_is_busy(cli)) {
		LOG_WRN("BLOB xfer already cancelled");
		return;
	}

	LOG_DBG("");

	if (cli->state == BT_MESH_BLOB_CLI_STATE_CAPS_GET ||
	    cli->state == BT_MESH_BLOB_CLI_STATE_SUSPENDED) {
		cli_state_reset(cli);
		return;
	}

	cli->tx.cancelled = 1U;
	cli->state = BT_MESH_BLOB_CLI_STATE_CANCEL;
}

int bt_mesh_blob_cli_xfer_progress_get(struct bt_mesh_blob_cli *cli,
				       const struct bt_mesh_blob_cli_inputs *inputs)
{
	if (bt_mesh_blob_cli_is_busy(cli)) {
		return -EBUSY;
	}

	cli->inputs = inputs;

	check_transfer(cli);

	return 0;
}

uint8_t bt_mesh_blob_cli_xfer_progress_active_get(struct bt_mesh_blob_cli *cli)
{
	if (cli->state < BT_MESH_BLOB_CLI_STATE_START) {
		return 0;
	}

	return (100U * cli->block.number) / cli->block_count;
}

bool bt_mesh_blob_cli_is_busy(struct bt_mesh_blob_cli *cli)
{
	return cli->state != BT_MESH_BLOB_CLI_STATE_NONE;
}

void bt_mesh_blob_cli_set_chunk_interval_ms(struct bt_mesh_blob_cli *cli, uint32_t interval_ms)
{
	cli->chunk_interval_ms = interval_ms;
}