Re: [PATCH v3 2/7] stk: Introduce BIP command handlers

[Andrzej Zaborowski <andrew.zaborowski@intel.com>]

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

Hi Philippe,

On 13 May 2011 19:21, Philippe Nunes <philippe.nunes@linux.intel.com> wrote:
> ---
>  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;
> +       }

A minor nitpick: we tend to return one of the temporary error codes
when out of memory.

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

According to 6.4.27 we should return STK_RESULT_TYPE_USER_REJECT if
the user does not accept the channel setup.

> +
> +       default:
> +               send_simple_response(stk, STK_RESULT_TYPE_TERMINAL_BUSY);
> +               return;
> +       }

I think Jeevaka determined that this needs an additional info field.

Best regards