[PATCH V2 3/3] stk: Introduce BIP command handlers

[Philippe Nunes <philippe.nunes@linux.intel.com>]

[-- Attachment #1: Type: text/plain, Size: 13679 bytes --]

---
 src/stk.c |  425 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 424 insertions(+), 1 deletions(-)

diff --git a/src/stk.c b/src/stk.c
index 8214b65..dec0439 100644
--- a/src/stk.c
+++ b/src/stk.c
@@ -41,6 +41,7 @@
 #include "smsutil.h"
 #include "stkutil.h"
 #include "stkagent.h"
+#include "gprs.h"
 #include "util.h"
 
 static GSList *g_drivers = NULL;
@@ -79,6 +80,11 @@ struct ofono_stk {
 
 	__ofono_sms_sim_download_cb_t sms_pp_cb;
 	void *sms_pp_userdata;
+	struct stk_channel channel;
+	struct stk_channel_data rx_buffer;
+	struct stk_channel_data tx_buffer;
+	gboolean link_on_demand;
+	struct ofono_gprs *gprs;
 };
 
 struct envelope_op {
@@ -104,6 +110,13 @@ static void timers_update(struct ofono_stk *stk);
 		result.additional_len = sizeof(addn_info);	\
 		result.additional = addn_info;			\
 
+/*
+ * According the structure and coding of the Terminal response defined in
+ * TS 102 223 section 6.8, the maximum number of bytes possible for the channel
+ * data object is 243
+ */
+#define CHANNEL_DATA_OBJECT_MAX_LENGTH 243
+
 static int stk_respond(struct ofono_stk *stk, struct stk_response *rsp,
 			ofono_stk_generic_cb_t cb)
 {
@@ -474,12 +487,49 @@ static void emit_menu_changed(struct ofono_stk *stk)
 	g_dbus_send_message(conn, signal);
 }
 
+static void stk_close_channel(struct ofono_stk *stk)
+{
+	/*
+	 * TODO
+	 * Deactivate and remove PDP context
+	 * Send the Terminal Response once the PDP context is deactivated
+	 */
+
+	/* Temporary implementation */
+	g_free(stk->rx_buffer.data.array);
+	g_free(stk->tx_buffer.data.array);
+	stk->rx_buffer.data.array = NULL;
+	stk->tx_buffer.data.array = NULL;
+
+	stk->channel.id = 0;
+	stk->channel.status = STK_CHANNEL_PACKET_DATA_SERVICE_NOT_ACTIVATED;
+
+	if (stk->pending_cmd &&
+			stk->pending_cmd->type ==
+				STK_COMMAND_TYPE_CLOSE_CHANNEL)
+		send_simple_response(stk, STK_RESULT_TYPE_SUCCESS);
+	else {
+		/*
+		 * TODO
+		 * Send Event channel status
+		 */
+	}
+}
+
 static void user_termination_cb(enum stk_agent_result result, void *user_data)
 {
 	struct ofono_stk *stk = user_data;
 
-	if (result == STK_AGENT_RESULT_TERMINATE)
+	if (result != STK_AGENT_RESULT_TERMINATE)
+		return;
+
+	if (stk->pending_cmd) {
+		stk->cancel_cmd(stk);
 		send_simple_response(stk, STK_RESULT_TYPE_USER_TERMINATED);
+	}
+
+	if (stk->channel.id)
+		stk_close_channel(stk);
 }
 
 static void stk_alpha_id_set(struct ofono_stk *stk,
@@ -510,6 +560,143 @@ static void stk_alpha_id_unset(struct ofono_stk *stk)
 	stk_agent_request_cancel(stk->current_agent);
 }
 
+
+static void stk_open_channel(struct ofono_stk *stk)
+{
+	const struct stk_command_open_channel *oc;
+	struct stk_response rsp;
+	struct ofono_error failure = { .type = OFONO_ERROR_TYPE_FAILURE };
+
+	if (stk->pending_cmd == NULL ||
+		stk->pending_cmd->type != STK_COMMAND_TYPE_OPEN_CHANNEL)
+		return;
+
+	oc = &stk->pending_cmd->open_channel;
+
+	memset(&rsp, 0, sizeof(rsp));
+	rsp.result.type = STK_RESULT_TYPE_SUCCESS;
+
+	stk->rx_buffer.data.array = g_try_malloc(oc->buf_size);
+	if (stk->rx_buffer.data.array == NULL) {
+		rsp.result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+		goto out;
+	}
+
+	stk->tx_buffer.data.array = g_try_malloc(oc->buf_size);
+	if (stk->tx_buffer.data.array == NULL) {
+		rsp.result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+		goto out;
+	}
+
+	stk->rx_buffer.data.len = oc->buf_size;
+	stk->tx_buffer.data.len = oc->buf_size;
+	stk->link_on_demand = (stk->pending_cmd->qualifier &
+				STK_OPEN_CHANNEL_FLAG_IMMEDIATE) ? FALSE : TRUE;
+
+	/*
+	 * TODO
+	 * Add a new primary PDP context based on the provided settings
+	 * Send the Terminal Response or wait until the PDP context is activated
+	 * in case of immediate link establishment not in background.
+	 */
+out:
+	if (stk_respond(stk, &rsp, stk_command_cb))
+		stk_command_cb(&failure, stk);
+}
+
+static void stk_send_data(struct ofono_stk *stk,
+				struct stk_common_byte_array data,
+				unsigned char qualifier)
+{
+	struct stk_response rsp;
+	struct ofono_error failure = { .type = OFONO_ERROR_TYPE_FAILURE };
+	unsigned int offset;
+
+	memset(&rsp, 0, sizeof(rsp));
+	rsp.result.type = STK_RESULT_TYPE_SUCCESS;
+
+	if (data.len > stk->tx_buffer.data.len) {
+		rsp.result.type = STK_RESULT_TYPE_BIP_ERROR;
+		goto out;
+	}
+
+	if (qualifier == STK_SEND_DATA_STORE_DATA) {
+
+		/*
+		 * check if the requested number of bytes of empty space
+		 * is available
+		 */
+		if (data.len > stk->tx_buffer.tx_avail) {
+			rsp.result.type = STK_RESULT_TYPE_BIP_ERROR;
+			goto out;
+		}
+
+		offset = stk->tx_buffer.data.len - stk->tx_buffer.tx_avail;
+		memcpy(stk->tx_buffer.data.array + offset, data.array,
+				data.len);
+
+		stk->tx_buffer.tx_avail -= data.len;
+		rsp.send_data.tx_avail = stk->tx_buffer.tx_avail;
+		goto out;
+	}
+
+	if (stk->channel.status == STK_CHANNEL_PACKET_DATA_SERVICE_NOT_ACTIVATED
+			&& stk->link_on_demand == TRUE) {
+		/*
+		 * TODO
+		 * activate the context, update the channel status
+		 * once the context is activated, send the data immediately
+		 * and flush the tx buffer
+		 */
+	} else {
+		/*
+		 * TODO
+		 * send the data immediately, flush the tx buffer
+		 */
+		stk->tx_buffer.tx_avail = stk->tx_buffer.data.len;
+		rsp.send_data.tx_avail = stk->tx_buffer.data.len;
+	}
+
+out:
+	if (stk_respond(stk, &rsp, stk_command_cb))
+		stk_command_cb(&failure, stk);
+}
+
+static void stk_receive_data(struct ofono_stk *stk, unsigned char data_len)
+{
+	struct stk_response rsp;
+	struct ofono_error failure = { .type = OFONO_ERROR_TYPE_FAILURE };
+
+	memset(&rsp, 0, sizeof(rsp));
+	rsp.result.type = STK_RESULT_TYPE_SUCCESS;
+
+	if (stk->rx_buffer.rx_remaining == 0) {
+		rsp.result.type = STK_RESULT_TYPE_MISSING_INFO;
+		goto out;
+	}
+
+	if (data_len > stk->rx_buffer.rx_remaining) {
+		rsp.result.type = STK_RESULT_TYPE_MISSING_INFO;
+		data_len = stk->rx_buffer.rx_remaining;
+	}
+
+	if (data_len > CHANNEL_DATA_OBJECT_MAX_LENGTH)
+		data_len = CHANNEL_DATA_OBJECT_MAX_LENGTH;
+
+	rsp.receive_data.rx_data.array = stk->rx_buffer.data.array;
+	rsp.receive_data.rx_data.len = data_len;
+	stk->rx_buffer.rx_remaining -= data_len;
+	rsp.receive_data.rx_remaining = stk->rx_buffer.rx_remaining;
+
+out:
+	if (stk_respond(stk, &rsp, stk_command_cb))
+		stk_command_cb(&failure, stk);
+
+	if (rsp.receive_data.rx_data.len && stk->rx_buffer.rx_remaining > 0)
+		memmove(stk->rx_buffer.data.array, stk->rx_buffer.data.array +
+				data_len, stk->rx_buffer.rx_remaining);
+}
+
 static int duration_to_msecs(const struct stk_duration *duration)
 {
 	int msecs = duration->interval;
@@ -2589,6 +2776,217 @@ static gboolean handle_command_launch_browser(const struct stk_command *cmd,
 	return FALSE;
 }
 
+
+static void open_channel_cancel(struct ofono_stk *stk)
+{
+	/* TODO */
+}
+
+static void confirm_open_channel_cb(enum stk_agent_result result,
+					gboolean confirm,
+					void *user_data)
+{
+	struct ofono_stk *stk = user_data;
+
+	switch (result) {
+	case STK_AGENT_RESULT_TERMINATE:
+		send_simple_response(stk, STK_RESULT_TYPE_USER_TERMINATED);
+		return;
+
+	case STK_AGENT_RESULT_TIMEOUT:
+		confirm = FALSE;
+		/* Fall through */
+
+	case STK_AGENT_RESULT_OK:
+		if (confirm)
+			break;
+		/* Fall through */
+
+	default:
+		send_simple_response(stk, STK_RESULT_TYPE_TERMINAL_BUSY);
+		return;
+	}
+
+	stk_open_channel(stk);
+}
+
+static gboolean handle_command_open_channel(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	struct ofono_modem *modem = __ofono_atom_get_modem(stk->atom);
+	const struct stk_command_open_channel *oc = &cmd->open_channel;
+	struct ofono_atom *gprs_atom;
+	int err;
+
+	/* Check first if channel is available */
+	if (stk->channel.id) {
+		unsigned char addnl_info[1];
+
+		addnl_info[0] = STK_RESULT_ADDNL_BIP_PB_NO_CHANNEL_AVAIL;
+		ADD_ERROR_RESULT(rsp->result, STK_RESULT_TYPE_BIP_ERROR,
+				addnl_info);
+		return TRUE;
+	}
+
+	gprs_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_GPRS);
+	if (gprs_atom == NULL || !__ofono_atom_get_registered(gprs_atom)) {
+		rsp->result.type = STK_RESULT_TYPE_NOT_CAPABLE;
+		return TRUE;
+	}
+
+	stk->gprs = __ofono_atom_get_data(gprs_atom);
+	stk->respond_on_exit = TRUE;
+	stk->cancel_cmd = open_channel_cancel;
+
+	/*
+	 * Don't ask for user confirmation if AID is a null data object
+	 * or is not provided
+	 */
+	if (oc->alpha_id && strlen(oc->alpha_id) > 0) {
+		char *alpha_id;
+
+		alpha_id = dbus_apply_text_attributes(oc->alpha_id,
+								&oc->text_attr);
+		if (alpha_id == NULL) {
+			rsp->result.type = STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD;
+			return TRUE;
+		}
+
+		err = stk_agent_confirm_open_channel(stk->current_agent,
+							alpha_id,
+							&oc->icon_id,
+							confirm_open_channel_cb,
+							stk, NULL,
+							stk->timeout * 1000);
+		g_free(alpha_id);
+
+		if (err < 0) {
+			rsp->result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
+			return TRUE;
+		}
+
+		return FALSE;
+	}
+
+	stk_open_channel(stk);
+
+	return FALSE;
+}
+
+static gboolean handle_command_close_channel(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	const struct stk_command_close_channel *cc = &cmd->close_channel;
+
+	/* Check if channel identifier is valid */
+	if (cmd->dst != (stk->channel.id | 0x20)) {
+		unsigned char addnl_info[1];
+
+		addnl_info[1] = STK_RESULT_ADDNL_BIP_PB_CHANNEL_ID_NOT_VALID;
+		ADD_ERROR_RESULT(rsp->result, STK_RESULT_TYPE_BIP_ERROR,
+					addnl_info);
+		return TRUE;
+	}
+
+	/*
+	 * Don't inform the user about the link closing phase if AID is
+	 * a null data object or is not provided
+	 */
+	if (cc->alpha_id && strlen(cc->alpha_id) > 0)
+		stk_alpha_id_set(stk, cc->alpha_id, &cc->text_attr,
+							&cc->icon_id);
+
+	stk->respond_on_exit = TRUE;
+	stk->cancel_cmd = stk_request_cancel;
+
+	stk_close_channel(stk);
+
+	return FALSE;
+}
+
+static gboolean handle_command_receive_data(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	const struct stk_command_receive_data *rd = &cmd->receive_data;
+
+	/* Check if channel identifier is valid or already closed */
+	if (cmd->dst != (stk->channel.id | 0x20)) {
+		unsigned char addnl_info[1];
+
+		addnl_info[1] = STK_RESULT_ADDNL_BIP_PB_CHANNEL_ID_NOT_VALID;
+		ADD_ERROR_RESULT(rsp->result, STK_RESULT_TYPE_BIP_ERROR,
+					addnl_info);
+		return TRUE;
+	}
+
+	/*
+	 * Don't inform the user during data transfer if AID is
+	 * a null data object or is not provided
+	 */
+	if (rd->alpha_id && strlen(rd->alpha_id) > 0)
+		stk_alpha_id_set(stk, rd->alpha_id, &rd->text_attr,
+					&rd->icon_id);
+
+	stk->respond_on_exit = TRUE;
+	stk->cancel_cmd = stk_request_cancel;
+
+	stk_receive_data(stk, rd->data_len);
+
+	return FALSE;
+}
+
+static gboolean handle_command_send_data(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	const struct stk_command_send_data *sd = &cmd->send_data;
+	unsigned char addnl_info[1];
+
+	/* Check if channel identifier is valid or already closed */
+	if (cmd->dst != (stk->channel.id | 0x20)) {
+		addnl_info[1] = STK_RESULT_ADDNL_BIP_PB_CHANNEL_ID_NOT_VALID;
+		ADD_ERROR_RESULT(rsp->result, STK_RESULT_TYPE_BIP_ERROR,
+					addnl_info);
+		return TRUE;
+	}
+
+	/* Check if the link was dropped */
+	if (stk->channel.status == STK_CHANNEL_LINK_DROPPED) {
+		addnl_info[1] = STK_RESULT_ADDNL_BIP_PB_CHANNEL_CLOSED;
+		ADD_ERROR_RESULT(rsp->result, STK_RESULT_TYPE_BIP_ERROR,
+					addnl_info);
+		return TRUE;
+	}
+
+	/*
+	 * Don't inform the user during data transfer if AID is
+	 * a null data object or is not provided
+	 */
+	if (sd->alpha_id && strlen(sd->alpha_id) > 0)
+		stk_alpha_id_set(stk, sd->alpha_id, &sd->text_attr,
+							&sd->icon_id);
+
+	stk->respond_on_exit = TRUE;
+	stk->cancel_cmd = stk_request_cancel;
+
+	stk_send_data(stk, sd->data, cmd->qualifier);
+
+	return FALSE;
+}
+
+static gboolean handle_command_get_channel_status(const struct stk_command *cmd,
+						struct stk_response *rsp,
+						struct ofono_stk *stk)
+{
+	rsp->result.type = STK_RESULT_TYPE_SUCCESS;
+	rsp->channel_status.channel.id = stk->channel.id;
+	rsp->channel_status.channel.status = stk->channel.status;
+	return TRUE;
+}
+
 static void stk_proactive_command_cancel(struct ofono_stk *stk)
 {
 	if (stk->immediate_response)
@@ -2782,6 +3180,31 @@ void ofono_stk_proactive_command_notify(struct ofono_stk *stk,
 							&rsp, stk);
 		break;
 
+	case STK_COMMAND_TYPE_OPEN_CHANNEL:
+		respond = handle_command_open_channel(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
+	case STK_COMMAND_TYPE_CLOSE_CHANNEL:
+		respond = handle_command_close_channel(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
+	case STK_COMMAND_TYPE_RECEIVE_DATA:
+		respond = handle_command_receive_data(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
+	case STK_COMMAND_TYPE_SEND_DATA:
+		respond = handle_command_send_data(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
+	case STK_COMMAND_TYPE_GET_CHANNEL_STATUS:
+		respond = handle_command_get_channel_status(stk->pending_cmd,
+							&rsp, stk);
+		break;
+
 	default:
 		rsp.result.type = STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD;
 		break;
-- 
1.7.1