/*-
 * 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.
 */

#include <sys/types.h>
#include <netinet/in.h>

#include <stdlib.h>
#include <string.h>

#include <iscsi_proto.h>
#include "libiscsiutil.h"

/* Construct a new TextRequest PDU. */
static struct pdu *
text_new_request(struct connection *conn, uint32_t ttt)
{
	struct pdu *request;
	struct iscsi_bhs_text_request *bhstr;

	request = pdu_new(conn);
	bhstr = (struct iscsi_bhs_text_request *)request->pdu_bhs;
	bhstr->bhstr_opcode = ISCSI_BHS_OPCODE_TEXT_REQUEST |
	    ISCSI_BHS_OPCODE_IMMEDIATE;
	bhstr->bhstr_flags = BHSTR_FLAGS_FINAL;
	bhstr->bhstr_initiator_task_tag = 0;
	bhstr->bhstr_target_transfer_tag = ttt;

	bhstr->bhstr_cmdsn = conn->conn_cmdsn;
	bhstr->bhstr_expstatsn = htonl(conn->conn_statsn + 1);

	return (request);
}

/* Receive a TextRequest PDU from a connection. */
static struct pdu *
text_receive_request(struct connection *conn)
{
	struct pdu *request;
	struct iscsi_bhs_text_request *bhstr;

	request = pdu_new(conn);
	pdu_receive(request);
	if ((request->pdu_bhs->bhs_opcode & ~ISCSI_BHS_OPCODE_IMMEDIATE) !=
	    ISCSI_BHS_OPCODE_TEXT_REQUEST)
		log_errx(1, "protocol error: received invalid opcode 0x%x",
		    request->pdu_bhs->bhs_opcode);
	bhstr = (struct iscsi_bhs_text_request *)request->pdu_bhs;

	/*
	 * XXX: Implement the C flag some day.
	 */
	if ((bhstr->bhstr_flags & (BHSTR_FLAGS_FINAL | BHSTR_FLAGS_CONTINUE)) !=
	    BHSTR_FLAGS_FINAL)
		log_errx(1, "received TextRequest PDU with invalid "
		    "flags: %u", bhstr->bhstr_flags);
	if (ISCSI_SNLT(ntohl(bhstr->bhstr_cmdsn), conn->conn_cmdsn)) {
		log_errx(1, "received TextRequest PDU with decreasing CmdSN: "
		    "was %u, is %u", conn->conn_cmdsn, ntohl(bhstr->bhstr_cmdsn));
	}
	conn->conn_cmdsn = ntohl(bhstr->bhstr_cmdsn);
	if ((bhstr->bhstr_opcode & ISCSI_BHS_OPCODE_IMMEDIATE) == 0)
		conn->conn_cmdsn++;

	return (request);
}

/* Construct a new TextResponse PDU in reply to a request. */
static struct pdu *
text_new_response(struct pdu *request, uint32_t ttt, bool final)
{
	struct pdu *response;
	struct connection *conn;
	struct iscsi_bhs_text_request *bhstr;
	struct iscsi_bhs_text_response *bhstr2;

	bhstr = (struct iscsi_bhs_text_request *)request->pdu_bhs;
	conn = request->pdu_connection;

	response = pdu_new_response(request);
	bhstr2 = (struct iscsi_bhs_text_response *)response->pdu_bhs;
	bhstr2->bhstr_opcode = ISCSI_BHS_OPCODE_TEXT_RESPONSE;
	if (final)
		bhstr2->bhstr_flags = BHSTR_FLAGS_FINAL;
	else
		bhstr2->bhstr_flags = BHSTR_FLAGS_CONTINUE;
	bhstr2->bhstr_lun = bhstr->bhstr_lun;
	bhstr2->bhstr_initiator_task_tag = bhstr->bhstr_initiator_task_tag;
	bhstr2->bhstr_target_transfer_tag = ttt;
	bhstr2->bhstr_statsn = htonl(conn->conn_statsn++);
	bhstr2->bhstr_expcmdsn = htonl(conn->conn_cmdsn);
	bhstr2->bhstr_maxcmdsn = htonl(conn->conn_cmdsn);

	return (response);
}

/* Receive a TextResponse PDU from a connection. */
static struct pdu *
text_receive_response(struct connection *conn)
{
	struct pdu *response;
	struct iscsi_bhs_text_response *bhstr;
	uint8_t flags;

	response = pdu_new(conn);
	pdu_receive(response);
	if (response->pdu_bhs->bhs_opcode != ISCSI_BHS_OPCODE_TEXT_RESPONSE)
		log_errx(1, "protocol error: received invalid opcode 0x%x",
		    response->pdu_bhs->bhs_opcode);
	bhstr = (struct iscsi_bhs_text_response *)response->pdu_bhs;
	flags = bhstr->bhstr_flags & (BHSTR_FLAGS_FINAL | BHSTR_FLAGS_CONTINUE);
	switch (flags) {
	case BHSTR_FLAGS_CONTINUE:
		if (bhstr->bhstr_target_transfer_tag == 0xffffffff)
			log_errx(1, "received continue TextResponse PDU with "
			    "invalid TTT 0x%x",
			    bhstr->bhstr_target_transfer_tag);
		break;
	case BHSTR_FLAGS_FINAL:
		if (bhstr->bhstr_target_transfer_tag != 0xffffffff)
			log_errx(1, "received final TextResponse PDU with "
			    "invalid TTT 0x%x",
			    bhstr->bhstr_target_transfer_tag);
		break;
	default:
		log_errx(1, "received TextResponse PDU with invalid "
		    "flags: %u", bhstr->bhstr_flags);
	}
	if (ntohl(bhstr->bhstr_statsn) != conn->conn_statsn + 1) {
		log_errx(1, "received TextResponse PDU with wrong StatSN: "
		    "is %u, should be %u", ntohl(bhstr->bhstr_statsn),
		    conn->conn_statsn + 1);
	}
	conn->conn_statsn = ntohl(bhstr->bhstr_statsn);

	return (response);
}

/*
 * Send a list of keys from the initiator to the target in a
 * TextRequest PDU.
 */
void
text_send_request(struct connection *conn, struct keys *request_keys)
{
	struct pdu *request;

	request = text_new_request(conn, 0xffffffff);
	keys_save_pdu(request_keys, request);
	if (request->pdu_data_len == 0)
		log_errx(1, "No keys to send in a TextRequest");
	if (request->pdu_data_len >
	    (size_t)conn->conn_max_send_data_segment_length)
		log_errx(1, "Keys to send in TextRequest are too long");

	pdu_send(request);
	pdu_delete(request);
}

/*
 * Read a list of keys from the target in a series of TextResponse
 * PDUs.
 */
struct keys *
text_read_response(struct connection *conn)
{
	struct keys *response_keys;
	char *keys_data;
	size_t keys_len;
	uint32_t ttt;

	keys_data = NULL;
	keys_len = 0;
	ttt = 0xffffffff;
	for (;;) {
		struct pdu *request, *response;
		struct iscsi_bhs_text_response *bhstr;

		response = text_receive_response(conn);
		bhstr = (struct iscsi_bhs_text_response *)response->pdu_bhs;
		if (keys_data == NULL) {
			ttt = bhstr->bhstr_target_transfer_tag;
			keys_data = response->pdu_data;
			keys_len = response->pdu_data_len;
			response->pdu_data = NULL;
		} else {
			keys_data = realloc(keys_data,
			    keys_len + response->pdu_data_len);
			if (keys_data == NULL)
				log_err(1, "failed to grow keys block");
			memcpy(keys_data + keys_len, response->pdu_data,
			    response->pdu_data_len);
			keys_len += response->pdu_data_len;
		}
		if ((bhstr->bhstr_flags & BHSTR_FLAGS_FINAL) != 0) {
			pdu_delete(response);
			break;
		}
		if (bhstr->bhstr_target_transfer_tag != ttt)
			log_errx(1, "received non-final TextRequest PDU with "
			    "invalid TTT 0x%x",
			    bhstr->bhstr_target_transfer_tag);
		pdu_delete(response);

		/* Send an empty request. */
		request = text_new_request(conn, ttt);
		pdu_send(request);
		pdu_delete(request);
	}

	response_keys = keys_new();
	keys_load(response_keys, keys_data, keys_len);
	free(keys_data);
	return (response_keys);
}

/*
 * Read a list of keys from the initiator in a TextRequest PDU.
 */
struct keys *
text_read_request(struct connection *conn, struct pdu **requestp)
{
	struct iscsi_bhs_text_request *bhstr;
	struct pdu *request;
	struct keys *request_keys;

	request = text_receive_request(conn);
	bhstr = (struct iscsi_bhs_text_request *)request->pdu_bhs;
	if (bhstr->bhstr_target_transfer_tag != 0xffffffff)
		log_errx(1, "received TextRequest PDU with invalid TTT 0x%x",
		    bhstr->bhstr_target_transfer_tag);
	if (ntohl(bhstr->bhstr_expstatsn) != conn->conn_statsn) {
		log_errx(1, "received TextRequest PDU with wrong ExpStatSN: "
		    "is %u, should be %u", ntohl(bhstr->bhstr_expstatsn),
		    conn->conn_statsn);
	}

	request_keys = keys_new();
	keys_load_pdu(request_keys, request);
	*requestp = request;
	return (request_keys);
}

/*
 * Send a response back to the initiator as a series of TextResponse
 * PDUs.
 */
void
text_send_response(struct pdu *request, struct keys *response_keys)
{
	struct connection *conn = request->pdu_connection;
	char *keys_data;
	size_t keys_len;
	size_t keys_offset;
	uint32_t ttt;

	keys_save(response_keys, &keys_data, &keys_len);
	keys_offset = 0;
	ttt = keys_len;
	for (;;) {
		struct pdu *request2, *response;
		struct iscsi_bhs_text_request *bhstr;
		size_t todo;
		bool final;

		todo = keys_len - keys_offset;
		if (todo > (size_t)conn->conn_max_send_data_segment_length) {
			final = false;
			todo = conn->conn_max_send_data_segment_length;
		} else {
			final = true;
			ttt = 0xffffffff;
		}

		response = text_new_response(request, ttt, final);
		response->pdu_data = keys_data + keys_offset;
		response->pdu_data_len = todo;
		keys_offset += todo;

		pdu_send(response);
		response->pdu_data = NULL;
		pdu_delete(response);

		if (final)
			break;

		/*
		 * Wait for an empty request.
		 *
		 * XXX: Linux's Open-iSCSI initiator doesn't update
		 * ExpStatSN when receiving a TextResponse PDU.
		 */
		request2 = text_receive_request(conn);
		bhstr = (struct iscsi_bhs_text_request *)request2->pdu_bhs;
		if ((bhstr->bhstr_flags & BHSTR_FLAGS_FINAL) == 0)
			log_errx(1, "received continuation TextRequest PDU "
			    "without F set");
		if (pdu_data_segment_length(request2) != 0)
			log_errx(1, "received non-empty continuation "
			    "TextRequest PDU");
		if (bhstr->bhstr_target_transfer_tag != ttt)
			log_errx(1, "received TextRequest PDU with invalid "
			    "TTT 0x%x", bhstr->bhstr_target_transfer_tag);
		pdu_delete(request2);
	}
	free(keys_data);
}