Hi Andrew,

On 10/13/2010 08:54 AM, Andrzej Zaborowski wrote:
> A memory leak in error path has been fixed since the previous version.
> ---
>  src/stk.c |  139 
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 files changed, 139 insertions(+), 0 deletions(-)
> 
> diff --git a/src/stk.c b/src/stk.c
> index c06bf99..b3d2b40 100644
> --- a/src/stk.c
> +++ b/src/stk.c
> @@ -89,6 +89,11 @@ struct extern_req {
>       gboolean cancelled;
>  };
>  
> +struct tone_info {
> +     const char *name;
> +     gboolean continuous;
> +};
> +

Can we make this into an anonymous struct inside handle_command_play_tone?

>  #define ENVELOPE_RETRIES_DEFAULT 5
>  
>  static void envelope_queue_run(struct ofono_stk *stk);
> @@ -2102,6 +2107,135 @@ static gboolean handle_command_send_dtmf(const struct 
> stk_command *cmd,
>       return FALSE;
>  }
>  
> +static void play_tone_cb(enum stk_agent_result result, void *user_data)
> +{
> +     struct ofono_stk *stk = user_data;
> +
> +     stk->respond_on_exit = FALSE;
> +
> +     switch (result) {
> +     case STK_AGENT_RESULT_OK:
> +     case STK_AGENT_RESULT_TIMEOUT:
> +             send_simple_response(stk, STK_RESULT_TYPE_SUCCESS);
> +             break;
> +
> +     default:
> +             send_simple_response(stk, STK_RESULT_TYPE_USER_TERMINATED);
> +             break;
> +     }
> +}
> +
> +static gboolean handle_command_play_tone(const struct stk_command *cmd,
> +                                             struct stk_response *rsp,
> +                                             struct ofono_stk *stk)
> +{
> +     static int manufacturer_timeout = 10000; /* 10 seconds */
> +     /* Continuous true/false according to 02.40 */
> +     static const struct tone_info tone_infos[] = {
> +             /* Default */
> +             [0x00] = { "dial-tone", TRUE },
> +
> +             /* Standard */
> +             [0x01] = { "dial-tone", TRUE },
> +             [0x02] = { "busy", TRUE },
> +             [0x03] = { "congestion", TRUE },
> +             [0x04] = { "radio-path-acknowledge", FALSE },
> +             [0x05] = { "radio-path-not-available", FALSE },
> +             [0x06] = { "error", TRUE },
> +             [0x07] = { "call-waiting", FALSE },
> +             [0x08] = { "ringing-tone", TRUE },
> +
> +             /* Proprietary */
> +             [0x10] = { "general-beep", FALSE },
> +             [0x11] = { "positive-acknowledgement", FALSE },
> +             [0x12] = { "negative-acknowledgement", FALSE },
> +             [0x13] = { "user-ringing-tone", TRUE },
> +             [0x14] = { "user-sms-alert", FALSE },
> +             [0x15] = { "critical", FALSE },
> +             [0x20] = { "vibrate", TRUE },
> +
> +             /* Themed */
> +             [0x30] = { "happy", FALSE },
> +             [0x31] = { "sad", FALSE },
> +             [0x32] = { "urgent-action", FALSE },
> +             [0x33] = { "question", FALSE },
> +             [0x34] = { "message-received", FALSE },
> +
> +             /* Melody */
> +             [0x40] = { "melody-1", FALSE },
> +             [0x41] = { "melody-2", FALSE },
> +             [0x42] = { "melody-3", FALSE },
> +             [0x43] = { "melody-4", FALSE },
> +             [0x44] = { "melody-5", FALSE },
> +             [0x45] = { "melody-6", FALSE },
> +             [0x46] = { "melody-7", FALSE },
> +             [0x47] = { "melody-8", FALSE },
> +     };
> +
> +     const struct stk_command_play_tone *pt = &cmd->play_tone;
> +     uint8_t qualifier = stk->pending_cmd->qualifier;
> +     gboolean vibrate = (qualifier & (1 << 0)) != 0;
> +     char *text;
> +     int timeout;
> +     int err;
> +
> +     if (!tone_infos[pt->tone].name) {
> +             rsp->result.type = STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD;
> +
> +             return TRUE;
> +     }
> +
> +     text = dbus_apply_text_attributes(pt->alpha_id ? pt->alpha_id : "",
> +                                             &pt->text_attr);
> +     if (!text) {
> +             rsp->result.type = STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD;
> +
> +             return TRUE;
> +     }
> +
> +     if (pt->duration.interval) {
> +             timeout = pt->duration.interval;
> +             switch (pt->duration.unit) {
> +             case STK_DURATION_TYPE_MINUTES:
> +                     timeout *= 60;
> +             case STK_DURATION_TYPE_SECONDS:
> +                     timeout *= 10;
> +             case STK_DURATION_TYPE_SECOND_TENTHS:
> +                     timeout *= 100;
> +             }

This switch is repeated so many times throughout the code it should
really be turned into its own function.  Also, whenever you have
fall-throughs, they should be documented (e.g. with /* Fall through */)
otherwise me or Marcel are likely to go in and put in some break
statements in accidentally.

> +     } else
> +             timeout = manufacturer_timeout;
> +
> +     if (!tone_infos[pt->tone].continuous)

So this one makes me a bit worried.  Should we be using a search or at
least performing boundary checking?  Otherwise I'm afraid there is a
possibility of a crash if the SIM sends us something we do not expect.

> +             /* Duration ignored */
> +             err = stk_agent_play_tone(stk->current_agent, text,
> +                                             &pt->icon_id, vibrate,
> +                                             tone_infos[pt->tone].name,
> +                                             play_tone_cb, stk, NULL,
> +                                             stk->timeout * 1000);
> +     else
> +             err = stk_agent_loop_tone(stk->current_agent, text,
> +                                             &pt->icon_id, vibrate,
> +                                             tone_infos[pt->tone].name,
> +                                             play_tone_cb, stk, NULL,
> +                                             timeout);
> +     g_free(text);
> +
> +     if (err < 0) {
> +             /*
> +              * We most likely got an out of memory error, tell SIM
> +              * to retry
> +              */
> +             rsp->result.type = STK_RESULT_TYPE_TERMINAL_BUSY;
> +             return TRUE;
> +     }
> +
> +     stk->respond_on_exit = TRUE;
> +     stk->cancel_cmd = stk_request_cancel;
> +
> +     return FALSE;
> +}
> +
>  static void stk_proactive_command_cancel(struct ofono_stk *stk)
>  {
>       if (stk->immediate_response)
> @@ -2279,6 +2413,11 @@ void ofono_stk_proactive_command_notify(struct 
> ofono_stk *stk,
>                                                       &rsp, stk);
>               break;
>  
> +     case STK_COMMAND_TYPE_PLAY_TONE:
> +             respond = handle_command_play_tone(stk->pending_cmd,
> +                                                     &rsp, stk);
> +             break;
> +
>       default:
>               rsp.result.type = STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD;
>               break;

Regards,
-Denis
_______________________________________________
ofono mailing list
[email protected]
http://lists.ofono.org/listinfo/ofono

Reply via email to