---
src/call-barring.c | 168 ++++++++++++++++++++++---------------
src/call-forwarding.c | 155 +++++++++++++++++++++-------------
src/call-settings.c | 220 +++++++++++++++++++++++++++----------------------
src/ofono.h | 15 +++-
src/stk.c | 98 ++++++++++++++++++++++
src/stkutil.c | 2 +
src/stkutil.h | 23 +++++
src/ussd.c | 78 ++++++++++++------
8 files changed, 504 insertions(+), 255 deletions(-)
diff --git a/src/call-barring.c b/src/call-barring.c
index d235211..f504d07 100644
--- a/src/call-barring.c
+++ b/src/call-barring.c
@@ -48,6 +48,7 @@ static void set_query_next_lock(struct ofono_call_barring
*cb);
struct ofono_call_barring {
int flags;
DBusMessage *pending;
+ ofono_bool_t stk_pending;
int cur_locks[NUM_OF_BARRINGS];
int new_locks[NUM_OF_BARRINGS];
int query_start;
@@ -58,10 +59,12 @@ struct ofono_call_barring {
int ss_req_lock;
struct ofono_ssn *ssn;
struct ofono_ussd *ussd;
+ struct ofono_stk *stk;
unsigned int incoming_bar_watch;
unsigned int outgoing_bar_watch;
unsigned int ssn_watch;
unsigned int ussd_watch;
+ unsigned int stk_watch;
const struct ofono_call_barring_driver *driver;
void *driver_data;
struct ofono_atom *atom;
@@ -95,6 +98,36 @@ static struct call_barring_lock cb_locks[] = {
#define CB_ALL_OUTGOING 6
#define CB_ALL_INCOMING 7
+gboolean __ofono_call_barring_is_busy(struct ofono_call_barring *cb)
+{
+ if (!cb)
+ return FALSE;
+
+ if (cb->pending || cb->stk_pending)
+ return TRUE;
+
+ return FALSE;
+}
+
+static void reply_error(struct ofono_call_barring *cb,
+ const struct ofono_error *error)
+{
+ if (cb->pending)
+ __ofono_dbus_pending_reply(&cb->pending,
+ __ofono_error_failed(cb->pending));
+ else
+ __ofono_stk_send_ss_response(cb->stk, &cb->stk_pending, error);
+}
+
+static void set_pending(struct ofono_call_barring *cb,
+ struct ofono_ss_req *osr)
+{
+ if (osr->msg)
+ cb->pending = dbus_message_ref(osr->msg);
+ else
+ cb->stk_pending = TRUE;
+}
+
static inline void emit_barring_changed(struct ofono_call_barring *cb,
int start, int end,
const char *type, int cls)
@@ -293,9 +326,8 @@ static void cb_ss_query_next_lock_callback(const struct
ofono_error *error,
"successful, but query was not");
cb->flags &= ~CALL_BARRING_FLAG_CACHED;
+ reply_error(cb, error);
- __ofono_dbus_pending_reply(&cb->pending,
- __ofono_error_failed(cb->pending));
return;
}
@@ -307,7 +339,11 @@ static void cb_ss_query_next_lock_callback(const struct
ofono_error *error,
return;
}
- generate_ss_query_reply(cb);
+ if (cb->pending)
+ generate_ss_query_reply(cb);
+ else
+ __ofono_stk_send_ss_response(cb->stk, &cb->stk_pending, error);
+
update_barrings(cb, BEARER_CLASS_VOICE);
}
@@ -328,8 +364,7 @@ static void cb_ss_set_lock_callback(const struct
ofono_error *error,
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("Enabling/disabling Call Barring via SS failed");
- __ofono_dbus_pending_reply(&cb->pending,
- __ofono_error_failed(cb->pending));
+ reply_error(cb, error);
return;
}
@@ -359,25 +394,19 @@ static const char *cb_ss_service_to_fac(const char *svc)
return NULL;
}
-static gboolean cb_ss_control(int type, const char *sc,
+static int cb_ss_control(int type, const char *sc,
const char *sia, const char *sib,
const char *sic, const char *dn,
- DBusMessage *msg, void *data)
+ struct ofono_ss_req *osr, void *data)
{
struct ofono_call_barring *cb = data;
- DBusConnection *conn = ofono_dbus_get_connection();
int cls = BEARER_CLASS_DEFAULT;
const char *fac;
- DBusMessage *reply;
void *operation = NULL;
int i;
- if (cb->pending) {
- reply = __ofono_error_busy(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (__ofono_call_barring_is_busy(cb))
+ return EBUSY;
DBG("Received call barring ss control request");
@@ -386,7 +415,7 @@ static gboolean cb_ss_control(int type, const char *sc,
fac = cb_ss_service_to_fac(sc);
if (!fac)
- return FALSE;
+ return -ENOENT;
cb_set_query_bounds(cb, fac, type == SS_CONTROL_TYPE_QUERY);
@@ -397,13 +426,13 @@ static gboolean cb_ss_control(int type, const char *sc,
cb->ss_req_lock = i;
if (strlen(sic) > 0)
- goto bad_format;
+ return EINVAL;
if (strlen(dn) > 0)
- goto bad_format;
+ return EINVAL;
if (type != SS_CONTROL_TYPE_QUERY && !is_valid_pin(sia, PIN_TYPE_NET))
- goto bad_format;
+ return EINVAL;
switch (type) {
case SS_CONTROL_TYPE_ACTIVATION:
@@ -419,12 +448,8 @@ static gboolean cb_ss_control(int type, const char *sc,
break;
}
- if (!operation) {
- reply = __ofono_error_not_implemented(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (!operation)
+ return ENOSYS;
/* According to 27.007, AG, AC and AB only work with mode = 0
* We support query by querying all relevant types, since we must
@@ -433,7 +458,7 @@ static gboolean cb_ss_control(int type, const char *sc,
if ((!strcmp(fac, "AG") || !strcmp(fac, "AC") || !strcmp(fac, "AB")) &&
(type == SS_CONTROL_TYPE_ACTIVATION ||
type == SS_CONTROL_TYPE_REGISTRATION))
- goto bad_format;
+ return EINVAL;
if (strlen(sib) > 0) {
long service_code;
@@ -442,16 +467,16 @@ static gboolean cb_ss_control(int type, const char *sc,
service_code = strtoul(sib, &end, 10);
if (end == sib || *end != '\0')
- goto bad_format;
+ return EINVAL;
cls = mmi_service_code_to_bearer_class(service_code);
if (cls == 0)
- goto bad_format;
+ return EINVAL;
}
cb->ss_req_cls = cls;
- cb->pending = dbus_message_ref(msg);
+ set_pending(cb, osr);
switch (type) {
case SS_CONTROL_TYPE_ACTIVATION:
@@ -472,44 +497,35 @@ static gboolean cb_ss_control(int type, const char *sc,
break;
}
- return TRUE;
-
-bad_format:
- reply = __ofono_error_invalid_format(msg);
- g_dbus_send_message(conn, reply);
- return TRUE;
+ return 0;
}
static void cb_set_passwd_callback(const struct ofono_error *error, void *data)
{
struct ofono_call_barring *cb = data;
- DBusMessage *reply;
- if (error->type == OFONO_ERROR_TYPE_NO_ERROR)
- reply = dbus_message_new_method_return(cb->pending);
- else {
- reply = __ofono_error_failed(cb->pending);
+ if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("Changing Call Barring password via SS failed");
+ reply_error(cb, error);
+ return;
}
- __ofono_dbus_pending_reply(&cb->pending, reply);
+ if (cb->pending)
+ __ofono_dbus_pending_reply(&cb->pending,
+ dbus_message_new_method_return(cb->pending));
+ else
+ __ofono_stk_send_ss_response(cb->stk, &cb->stk_pending, error);
}
-static gboolean cb_ss_passwd(const char *sc,
+static int cb_ss_passwd(const char *sc,
const char *old, const char *new,
- DBusMessage *msg, void *data)
+ struct ofono_ss_req *osr, void *data)
{
struct ofono_call_barring *cb = data;
- DBusConnection *conn = ofono_dbus_get_connection();
- DBusMessage *reply;
const char *fac;
- if (cb->pending) {
- reply = __ofono_error_busy(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (__ofono_call_barring_is_busy(cb))
+ return EBUSY;
DBG("Received call barring ss password change request");
@@ -521,19 +537,16 @@ static gboolean cb_ss_passwd(const char *sc,
fac = cb_ss_service_to_fac(sc);
if (!fac)
- return FALSE;
+ return -ENOENT;
if (!is_valid_pin(old, PIN_TYPE_NET) || !is_valid_pin(new,
PIN_TYPE_NET))
- goto bad_format;
+ return EINVAL;
+
+ set_pending(cb, osr);
- cb->pending = dbus_message_ref(msg);
cb->driver->set_passwd(cb, fac, old, new, cb_set_passwd_callback, cb);
- return TRUE;
-bad_format:
- reply = __ofono_error_invalid_format(msg);
- g_dbus_send_message(conn, reply);
- return TRUE;
+ return 0;
}
static void cb_register_ss_controls(struct ofono_call_barring *cb)
@@ -580,11 +593,6 @@ static void cb_unregister_ss_controls(struct
ofono_call_barring *cb)
__ofono_ussd_passwd_unregister(cb->ussd, "353");
}
-gboolean __ofono_call_barring_is_busy(struct ofono_call_barring *cb)
-{
- return cb->pending ? TRUE : FALSE;
-}
-
static inline void cb_append_property(struct ofono_call_barring *cb,
DBusMessageIter *dict, int start,
int end, int cls, const char *property)
@@ -674,7 +682,7 @@ static DBusMessage *cb_get_properties(DBusConnection *conn,
DBusMessage *msg,
{
struct ofono_call_barring *cb = data;
- if (cb->pending || __ofono_ussd_is_busy(cb->ussd))
+ if (__ofono_call_barring_is_busy(cb) || __ofono_ussd_is_busy(cb->ussd))
return __ofono_error_busy(msg);
if (!cb->driver->query)
@@ -827,7 +835,7 @@ static DBusMessage *cb_set_property(DBusConnection *conn,
DBusMessage *msg,
int cls;
int mode;
- if (cb->pending || __ofono_ussd_is_busy(cb->ussd))
+ if (__ofono_call_barring_is_busy(cb) || __ofono_ussd_is_busy(cb->ussd))
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
@@ -899,7 +907,7 @@ static DBusMessage *cb_disable_all(DBusConnection *conn,
DBusMessage *msg,
if (!cb->driver->set)
return __ofono_error_not_implemented(msg);
- if (cb->pending || __ofono_ussd_is_busy(cb->ussd))
+ if (__ofono_call_barring_is_busy(cb) || __ofono_ussd_is_busy(cb->ussd))
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &passwd,
@@ -946,7 +954,7 @@ static DBusMessage *cb_set_passwd(DBusConnection *conn,
DBusMessage *msg,
if (!cb->driver->set_passwd)
return __ofono_error_not_implemented(msg);
- if (cb->pending || __ofono_ussd_is_busy(cb->ussd))
+ if (__ofono_call_barring_is_busy(cb) || __ofono_ussd_is_busy(cb->ussd))
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &old_passwd,
@@ -1150,6 +1158,19 @@ static void ussd_watch(struct ofono_atom *atom,
cb_register_ss_controls(cb);
}
+static void stk_watch(struct ofono_atom *atom,
+ enum ofono_atom_watch_condition cond, void *data)
+{
+ struct ofono_call_barring *cb = data;
+
+ if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) {
+ cb->stk = NULL;
+ return;
+ }
+
+ cb->stk = __ofono_atom_get_data(atom);
+}
+
void ofono_call_barring_register(struct ofono_call_barring *cb)
{
DBusConnection *conn = ofono_dbus_get_connection();
@@ -1157,6 +1178,7 @@ void ofono_call_barring_register(struct
ofono_call_barring *cb)
struct ofono_modem *modem = __ofono_atom_get_modem(cb->atom);
struct ofono_atom *ssn_atom;
struct ofono_atom *ussd_atom;
+ struct ofono_atom *stk_atom;
if (!g_dbus_register_interface(conn, path,
OFONO_CALL_BARRING_INTERFACE,
@@ -1188,6 +1210,16 @@ void ofono_call_barring_register(struct
ofono_call_barring *cb)
ussd_watch(ussd_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED,
cb);
+ cb->stk_watch = __ofono_modem_add_atom_watch(modem,
+ OFONO_ATOM_TYPE_STK,
+ stk_watch, cb, NULL);
+
+ stk_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_STK);
+
+ if (stk_atom && __ofono_atom_get_registered(stk_atom))
+ stk_watch(stk_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED,
+ cb);
+
__ofono_atom_register(cb->atom, call_barring_unregister);
}
diff --git a/src/call-forwarding.c b/src/call-forwarding.c
index 5eae6cf..9161121 100644
--- a/src/call-forwarding.c
+++ b/src/call-forwarding.c
@@ -55,11 +55,14 @@ struct ofono_call_forwarding {
GSList *cf_conditions[4];
int flags;
DBusMessage *pending;
+ ofono_bool_t stk_pending;
int query_next;
int query_end;
struct cf_ss_request *ss_req;
struct ofono_ussd *ussd;
+ struct ofono_stk *stk;
unsigned int ussd_watch;
+ unsigned int stk_watch;
const struct ofono_call_forwarding_driver *driver;
void *driver_data;
struct ofono_atom *atom;
@@ -77,6 +80,36 @@ struct cf_ss_request {
GSList *cf_list[4];
};
+gboolean __ofono_call_forwarding_is_busy(struct ofono_call_forwarding *cf)
+{
+ if (!cf)
+ return FALSE;
+
+ if (cf->pending || cf->stk_pending)
+ return TRUE;
+
+ return FALSE;
+}
+
+static void reply_error(struct ofono_call_forwarding *cf,
+ const struct ofono_error *error)
+{
+ if (cf->pending)
+ __ofono_dbus_pending_reply(&cf->pending,
+ __ofono_error_failed(cf->pending));
+ else
+ __ofono_stk_send_ss_response(cf->stk, &cf->stk_pending, error);
+}
+
+static void set_pending(struct ofono_call_forwarding *cf,
+ struct ofono_ss_req *osr)
+{
+ if (osr->msg)
+ cf->pending = dbus_message_ref(osr->msg);
+ else
+ cf->stk_pending = TRUE;
+}
+
static gint cf_condition_compare(gconstpointer a, gconstpointer b)
{
const struct ofono_call_forwarding_condition *ca = a;
@@ -430,7 +463,8 @@ static DBusMessage *cf_get_properties(DBusConnection *conn,
DBusMessage *msg,
if (!cf->driver->query)
return __ofono_error_not_implemented(msg);
- if (cf->pending || __ofono_ussd_is_busy(cf->ussd))
+ if (__ofono_call_forwarding_is_busy(cf) ||
+ __ofono_ussd_is_busy(cf->ussd))
return __ofono_error_busy(msg);
cf->pending = dbus_message_ref(msg);
@@ -586,7 +620,8 @@ static DBusMessage *cf_set_property(DBusConnection *conn,
DBusMessage *msg,
int cls;
int type;
- if (cf->pending || __ofono_ussd_is_busy(cf->ussd))
+ if (__ofono_call_forwarding_is_busy(cf) ||
+ __ofono_ussd_is_busy(cf->ussd))
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
@@ -704,7 +739,8 @@ static DBusMessage *cf_disable_all(DBusConnection *conn,
DBusMessage *msg,
if (!cf->driver->erasure)
return __ofono_error_not_implemented(msg);
- if (cf->pending || __ofono_ussd_is_busy(cf->ussd))
+ if (__ofono_call_forwarding_is_busy(cf) ||
+ __ofono_ussd_is_busy(cf->ussd))
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &strtype,
@@ -823,13 +859,11 @@ static void ss_set_query_cf_callback(const struct
ofono_error *error, int total,
{
struct ofono_call_forwarding *cf = data;
GSList *l;
- DBusMessage *reply;
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
ofono_error("Setting succeeded, but query failed");
cf->flags &= ~CALL_FORWARDING_FLAG_CACHED;
- reply = __ofono_error_failed(cf->pending);
- __ofono_dbus_pending_reply(&cf->pending, reply);
+ reply_error(cf, error);
return;
}
@@ -840,8 +874,13 @@ static void ss_set_query_cf_callback(const struct
ofono_error *error, int total,
cf->ss_req->cf_list[cf->query_next] = l;
if (cf->query_next == cf->query_end) {
- reply = cf_ss_control_reply(cf, cf->ss_req);
- __ofono_dbus_pending_reply(&cf->pending, reply);
+ if (cf->pending)
+ __ofono_dbus_pending_reply(&cf->pending,
+ cf_ss_control_reply(cf, cf->ss_req));
+ else
+ __ofono_stk_send_ss_response(cf->stk, &cf->stk_pending,
+ error);
+
g_free(cf->ss_req);
cf->ss_req = NULL;
}
@@ -866,9 +905,7 @@ static void cf_ss_control_callback(const struct ofono_error
*error, void *data)
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("Error occurred during cf ss control set/erasure");
-
- __ofono_dbus_pending_reply(&cf->pending,
- __ofono_error_failed(cf->pending));
+ reply_error(cf, error);
g_free(cf->ss_req);
cf->ss_req = NULL;
return;
@@ -877,30 +914,24 @@ static void cf_ss_control_callback(const struct
ofono_error *error, void *data)
ss_set_query_next_cf_cond(cf);
}
-static gboolean cf_ss_control(int type, const char *sc,
+static int cf_ss_control(int type, const char *sc,
const char *sia, const char *sib,
const char *sic, const char *dn,
- DBusMessage *msg, void *data)
+ struct ofono_ss_req *osr, void *data)
{
struct ofono_call_forwarding *cf = data;
- DBusConnection *conn = ofono_dbus_get_connection();
int cls = BEARER_CLASS_SS_DEFAULT;
int timeout = DEFAULT_NO_REPLY_TIMEOUT;
int cf_type;
- DBusMessage *reply;
struct ofono_phone_number ph;
void *operation = NULL;
/* Before we do anything, make sure we're actually initialized */
if (!cf)
- return FALSE;
+ return -ENOENT;
- if (cf->pending) {
- reply = __ofono_error_busy(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (__ofono_call_forwarding_is_busy(cf))
+ return EBUSY;
DBG("Received call forwarding ss control request");
@@ -920,13 +951,13 @@ static gboolean cf_ss_control(int type, const char *sc,
else if (!strcmp(sc, "004"))
cf_type = CALL_FORWARDING_TYPE_ALL_CONDITIONAL;
else
- return FALSE;
+ return -ENOENT;
if (strlen(sia) &&
- (type == SS_CONTROL_TYPE_QUERY ||
- type == SS_CONTROL_TYPE_ERASURE ||
- type == SS_CONTROL_TYPE_DEACTIVATION))
- goto error;
+ (type == SS_CONTROL_TYPE_QUERY ||
+ type == SS_CONTROL_TYPE_ERASURE ||
+ type == SS_CONTROL_TYPE_DEACTIVATION))
+ return EINVAL;
/* Activation / Registration is figured context specific according to
* 22.030 Section 6.5.2 "The UE shall determine from the context
@@ -937,8 +968,8 @@ static gboolean cf_ss_control(int type, const char *sc,
type = SS_CONTROL_TYPE_REGISTRATION;
if (type == SS_CONTROL_TYPE_REGISTRATION &&
- !valid_phone_number_format(sia))
- goto error;
+ !valid_phone_number_format(sia))
+ return EINVAL;
if (strlen(sib) > 0) {
long service_code;
@@ -947,32 +978,32 @@ static gboolean cf_ss_control(int type, const char *sc,
service_code = strtoul(sib, &end, 10);
if (end == sib || *end != '\0')
- goto error;
+ return EINVAL;
cls = mmi_service_code_to_bearer_class(service_code);
if (cls == 0)
- goto error;
+ return EINVAL;
}
if (strlen(sic) > 0) {
char *end;
if (type != SS_CONTROL_TYPE_REGISTRATION)
- goto error;
+ return EINVAL;
if (cf_type != CALL_FORWARDING_TYPE_ALL &&
cf_type != CALL_FORWARDING_TYPE_ALL_CONDITIONAL &&
cf_type != CALL_FORWARDING_TYPE_NO_REPLY)
- goto error;
+ return EINVAL;
timeout = strtoul(sic, &end, 10);
if (end == sic || *end != '\0')
- goto error;
+ return EINVAL;
if (timeout < 1 || timeout > 30)
- goto error;
+ return EINVAL;
}
switch (type) {
@@ -993,27 +1024,19 @@ static gboolean cf_ss_control(int type, const char *sc,
break;
}
- if (!operation) {
- reply = __ofono_error_not_implemented(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (!operation)
+ return ENOSYS;
cf->ss_req = g_try_new0(struct cf_ss_request, 1);
- if (!cf->ss_req) {
- reply = __ofono_error_failed(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (!cf->ss_req)
+ return ENOMEM;
cf->ss_req->ss_type = type;
cf->ss_req->cf_type = cf_type;
cf->ss_req->cls = cls;
- cf->pending = dbus_message_ref(msg);
+ set_pending(cf, osr);
switch (cf->ss_req->cf_type) {
case CALL_FORWARDING_TYPE_ALL:
@@ -1062,12 +1085,7 @@ static gboolean cf_ss_control(int type, const char *sc,
break;
}
- return TRUE;
-
-error:
- reply = __ofono_error_invalid_format(msg);
- g_dbus_send_message(conn, reply);
- return TRUE;
+ return 0;
}
static void cf_register_ss_controls(struct ofono_call_forwarding *cf)
@@ -1092,11 +1110,6 @@ static void cf_unregister_ss_controls(struct
ofono_call_forwarding *cf)
__ofono_ussd_ssc_unregister(cf->ussd, "004");
}
-gboolean __ofono_call_forwarding_is_busy(struct ofono_call_forwarding *cf)
-{
- return cf->pending ? TRUE : FALSE;
-}
-
int ofono_call_forwarding_driver_register(const struct
ofono_call_forwarding_driver *d)
{
DBG("driver: %p, name: %s", d, d->name);
@@ -1200,12 +1213,26 @@ static void ussd_watch(struct ofono_atom *atom,
cf_register_ss_controls(cf);
}
+static void stk_watch(struct ofono_atom *atom,
+ enum ofono_atom_watch_condition cond, void *data)
+{
+ struct ofono_call_forwarding *cf = data;
+
+ if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) {
+ cf->stk = NULL;
+ return;
+ }
+
+ cf->stk = __ofono_atom_get_data(atom);
+}
+
void ofono_call_forwarding_register(struct ofono_call_forwarding *cf)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cf->atom);
struct ofono_modem *modem = __ofono_atom_get_modem(cf->atom);
struct ofono_atom *ussd_atom;
+ struct ofono_atom *stk_atom;
if (!g_dbus_register_interface(conn, path,
OFONO_CALL_FORWARDING_INTERFACE,
@@ -1229,6 +1256,16 @@ void ofono_call_forwarding_register(struct
ofono_call_forwarding *cf)
ussd_watch(ussd_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED,
cf);
+ cf->stk_watch = __ofono_modem_add_atom_watch(modem,
+ OFONO_ATOM_TYPE_STK,
+ stk_watch, cf, NULL);
+
+ stk_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_STK);
+
+ if (stk_atom && __ofono_atom_get_registered(stk_atom))
+ stk_watch(stk_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED,
+ cf);
+
__ofono_atom_register(cf->atom, call_forwarding_unregister);
}
diff --git a/src/call-settings.c b/src/call-settings.c
index 0c46a2a..4b8d71f 100644
--- a/src/call-settings.c
+++ b/src/call-settings.c
@@ -86,16 +86,49 @@ struct ofono_call_settings {
int cw;
int flags;
DBusMessage *pending;
+ ofono_bool_t stk_pending;
int ss_req_type;
int ss_req_cls;
enum call_setting_type ss_setting;
struct ofono_ussd *ussd;
+ struct ofono_stk *stk;
unsigned int ussd_watch;
+ unsigned int stk_watch;
const struct ofono_call_settings_driver *driver;
void *driver_data;
struct ofono_atom *atom;
};
+gboolean __ofono_call_settings_is_busy(struct ofono_call_settings *cs)
+{
+ if (!cs)
+ return FALSE;
+
+ if (cs->pending || cs->stk_pending)
+ return TRUE;
+
+ return FALSE;
+}
+
+static void reply_error(struct ofono_call_settings *cs,
+ const struct ofono_error *error)
+{
+ if (cs->pending)
+ __ofono_dbus_pending_reply(&cs->pending,
+ __ofono_error_failed(cs->pending));
+ else
+ __ofono_stk_send_ss_response(cs->stk, &cs->stk_pending, error);
+}
+
+static void set_pending(struct ofono_call_settings *cs,
+ struct ofono_ss_req *osr)
+{
+ if (osr->msg)
+ cs->pending = dbus_message_ref(osr->msg);
+ else
+ cs->stk_pending = TRUE;
+}
+
static const char *clip_status_to_string(int status)
{
switch (status) {
@@ -375,15 +408,17 @@ static void cw_ss_query_callback(const struct ofono_error
*error, int status,
DBG("setting CW via SS failed");
cs->flags &= ~CALL_SETTINGS_FLAG_CACHED;
- __ofono_dbus_pending_reply(&cs->pending,
- __ofono_error_failed(cs->pending));
+ reply_error(cs, error);
return;
}
set_cw(cs, status, BEARER_CLASS_VOICE);
- generate_cw_ss_query_reply(cs);
+ if (cs->pending)
+ generate_cw_ss_query_reply(cs);
+ else
+ __ofono_stk_send_ss_response(cs->stk, &cs->stk_pending, error);
}
static void cw_ss_set_callback(const struct ofono_error *error, void *data)
@@ -392,8 +427,7 @@ static void cw_ss_set_callback(const struct ofono_error
*error, void *data)
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("setting CW via SS failed");
- __ofono_dbus_pending_reply(&cs->pending,
- __ofono_error_failed(cs->pending));
+ reply_error(cs, error);
return;
}
@@ -402,35 +436,29 @@ static void cw_ss_set_callback(const struct ofono_error
*error, void *data)
cw_ss_query_callback, cs);
}
-static gboolean cw_ss_control(int type,
- const char *sc, const char *sia,
+static int cw_ss_control(int type, const char *sc, const char *sia,
const char *sib, const char *sic,
- const char *dn, DBusMessage *msg, void *data)
+ const char *dn, struct ofono_ss_req *osr,
+ void *data)
{
struct ofono_call_settings *cs = data;
- DBusConnection *conn = ofono_dbus_get_connection();
int cls = BEARER_CLASS_SS_DEFAULT;
- DBusMessage *reply;
if (!cs)
- return FALSE;
+ return -ENOENT;
if (strcmp(sc, "43"))
- return FALSE;
+ return -ENOENT;
- if (cs->pending) {
- reply = __ofono_error_busy(msg);
- goto error;
- }
+ if (__ofono_call_settings_is_busy(cs))
+ return EBUSY;
if (strlen(sib) || strlen(sib) || strlen(dn))
- goto bad_format;
+ return EINVAL;
if ((type == SS_CONTROL_TYPE_QUERY && !cs->driver->cw_query) ||
- (type != SS_CONTROL_TYPE_QUERY && !cs->driver->cw_set)) {
- reply = __ofono_error_not_implemented(msg);
- goto error;
- }
+ (type != SS_CONTROL_TYPE_QUERY && !cs->driver->cw_set))
+ return ENOSYS;
if (strlen(sia) > 0) {
long service_code;
@@ -439,15 +467,15 @@ static gboolean cw_ss_control(int type,
service_code = strtoul(sia, &end, 10);
if (end == sia || *end != '\0')
- goto bad_format;
+ return EINVAL;
cls = mmi_service_code_to_bearer_class(service_code);
if (cls == 0)
- goto bad_format;
+ return EINVAL;
}
cs->ss_req_cls = cls;
- cs->pending = dbus_message_ref(msg);
+ set_pending(cs, osr);
/* For the default case use the more readily accepted value */
if (cls == BEARER_CLASS_SS_DEFAULT)
@@ -477,13 +505,7 @@ static gboolean cw_ss_control(int type,
break;
}
- return TRUE;
-
-bad_format:
- reply = __ofono_error_invalid_format(msg);
-error:
- g_dbus_send_message(conn, reply);
- return TRUE;
+ return 0;
}
static void generate_ss_query_reply(struct ofono_call_settings *cs,
@@ -528,8 +550,7 @@ static void clip_colp_colr_ss_query_cb(const struct
ofono_error *error,
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("Error occurred during ss control query");
- __ofono_dbus_pending_reply(&cs->pending,
- __ofono_error_failed(cs->pending));
+ reply_error(cs, error);
return;
}
@@ -560,28 +581,26 @@ static void clip_colp_colr_ss_query_cb(const struct
ofono_error *error,
return;
};
- generate_ss_query_reply(cs, context, value);
+ if (cs->pending)
+ generate_ss_query_reply(cs, context, value);
+ else
+ __ofono_stk_send_ss_response(cs->stk, &cs->stk_pending, error);
}
-static gboolean clip_colp_colr_ss(int type,
- const char *sc, const char *sia,
+static int clip_colp_colr_ss(int type, const char *sc, const char *sia,
const char *sib, const char *sic,
- const char *dn, DBusMessage *msg, void *data)
+ const char *dn, struct ofono_ss_req *osr,
+ void *data)
{
struct ofono_call_settings *cs = data;
- DBusConnection *conn = ofono_dbus_get_connection();
void (*query_op)(struct ofono_call_settings *cs,
ofono_call_settings_status_cb_t cb, void *data);
if (!cs)
- return FALSE;
+ return -ENOENT;
- if (cs->pending) {
- DBusMessage *reply = __ofono_error_busy(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ if (__ofono_call_settings_is_busy(cs))
+ return EBUSY;
if (!strcmp(sc, "30")) {
cs->ss_setting = CALL_SETTING_TYPE_CLIP;
@@ -593,31 +612,23 @@ static gboolean clip_colp_colr_ss(int type,
cs->ss_setting = CALL_SETTING_TYPE_COLR;
query_op = cs->driver->colr_query;
} else {
- return FALSE;
+ return -ENOENT;
}
if (type != SS_CONTROL_TYPE_QUERY || strlen(sia) || strlen(sib) ||
- strlen(sic) || strlen(dn)) {
- DBusMessage *reply = __ofono_error_invalid_format(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
-
- if (!query_op) {
- DBusMessage *reply = __ofono_error_not_implemented(msg);
- g_dbus_send_message(conn, reply);
+ strlen(sic) || strlen(dn))
+ return EINVAL;
- return TRUE;
- }
+ if (!query_op)
+ return ENOSYS;
DBG("Received CLIP/COLR/COLP query ss control");
- cs->pending = dbus_message_ref(msg);
+ set_pending(cs, osr);
query_op(cs, clip_colp_colr_ss_query_cb, cs);
- return TRUE;
+ return 0;
}
static void clir_ss_query_callback(const struct ofono_error *error,
@@ -628,8 +639,7 @@ static void clir_ss_query_callback(const struct ofono_error
*error,
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("setting clir via SS failed");
- __ofono_dbus_pending_reply(&cs->pending,
- __ofono_error_failed(cs->pending));
+ reply_error(cs, error);
return;
}
@@ -664,7 +674,10 @@ static void clir_ss_query_callback(const struct
ofono_error *error,
value = "unknown";
};
- generate_ss_query_reply(cs, "CallingLineRestriction", value);
+ if (cs->pending)
+ generate_ss_query_reply(cs, "CallingLineRestriction", value);
+ else
+ __ofono_stk_send_ss_response(cs->stk, &cs->stk_pending, error);
set_clir_network(cs, network);
set_clir_override(cs, override);
@@ -676,8 +689,8 @@ static void clir_ss_set_callback(const struct ofono_error
*error, void *data)
if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
DBG("setting clir via SS failed");
- __ofono_dbus_pending_reply(&cs->pending,
- __ofono_error_failed(cs->pending));
+
+ reply_error(cs, error);
return;
}
@@ -685,49 +698,37 @@ static void clir_ss_set_callback(const struct ofono_error
*error, void *data)
cs->driver->clir_query(cs, clir_ss_query_callback, cs);
}
-static gboolean clir_ss_control(int type,
- const char *sc, const char *sia,
+static int clir_ss_control(int type, const char *sc, const char *sia,
const char *sib, const char *sic,
- const char *dn, DBusMessage *msg, void *data)
+ const char *dn, struct ofono_ss_req *osr,
+ void *data)
{
struct ofono_call_settings *cs = data;
- DBusConnection *conn = ofono_dbus_get_connection();
if (!cs)
- return FALSE;
+ return -ENOENT;
if (strcmp(sc, "31"))
- return FALSE;
-
- if (cs->pending) {
- DBusMessage *reply = __ofono_error_busy(msg);
- g_dbus_send_message(conn, reply);
+ return -ENOENT;
- return TRUE;
- }
+ if (__ofono_call_settings_is_busy(cs))
+ return EBUSY;
/* This is the temporary form of CLIR, handled in voicecalls */
if (!strlen(sia) && !strlen(sib) & !strlen(sic) &&
- strlen(dn) && type != SS_CONTROL_TYPE_QUERY)
- return FALSE;
-
- if (strlen(sia) || strlen(sib) || strlen(sic) || strlen(dn)) {
- DBusMessage *reply = __ofono_error_invalid_format(msg);
- g_dbus_send_message(conn, reply);
+ strlen(dn) && type != SS_CONTROL_TYPE_QUERY)
+ return -ENOENT;
- return TRUE;
- }
+ if (strlen(sia) || strlen(sib) || strlen(sic) || strlen(dn))
+ return EINVAL;
if ((type == SS_CONTROL_TYPE_QUERY && !cs->driver->clir_query) ||
- (type != SS_CONTROL_TYPE_QUERY && !cs->driver->clir_set)) {
- DBusMessage *reply = __ofono_error_not_implemented(msg);
- g_dbus_send_message(conn, reply);
-
- return TRUE;
- }
+ (type != SS_CONTROL_TYPE_QUERY &&
+ !cs->driver->clir_set))
+ return ENOSYS;
cs->ss_setting = CALL_SETTING_TYPE_CLIR;
- cs->pending = dbus_message_ref(msg);
+ set_pending(cs, osr);
switch (type) {
case SS_CONTROL_TYPE_REGISTRATION:
@@ -750,7 +751,7 @@ static gboolean clir_ss_control(int type,
break;
};
- return TRUE;
+ return 0;
}
static void cs_register_ss_controls(struct ofono_call_settings *cs)
@@ -778,11 +779,6 @@ static void cs_unregister_ss_controls(struct
ofono_call_settings *cs)
__ofono_ussd_ssc_unregister(cs->ussd, "77");
}
-gboolean __ofono_call_settings_is_busy(struct ofono_call_settings *cs)
-{
- return cs->pending ? TRUE : FALSE;
-}
-
static DBusMessage *generate_get_properties_reply(struct ofono_call_settings
*cs,
DBusMessage *msg)
{
@@ -955,7 +951,7 @@ static DBusMessage *cs_get_properties(DBusConnection *conn,
DBusMessage *msg,
{
struct ofono_call_settings *cs = data;
- if (cs->pending || __ofono_ussd_is_busy(cs->ussd))
+ if (__ofono_call_settings_is_busy(cs) || __ofono_ussd_is_busy(cs->ussd))
return __ofono_error_busy(msg);
if (cs->flags & CALL_SETTINGS_FLAG_CACHED)
@@ -1132,7 +1128,7 @@ static DBusMessage *cs_set_property(DBusConnection *conn,
DBusMessage *msg,
const char *property;
int cls;
- if (cs->pending || __ofono_ussd_is_busy(cs->ussd))
+ if (__ofono_call_settings_is_busy(cs) || __ofono_ussd_is_busy(cs->ussd))
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
@@ -1290,12 +1286,26 @@ static void ussd_watch(struct ofono_atom *atom,
cs_register_ss_controls(cs);
}
+static void stk_watch(struct ofono_atom *atom,
+ enum ofono_atom_watch_condition cond, void *data)
+{
+ struct ofono_call_settings *cs = data;
+
+ if (cond == OFONO_ATOM_WATCH_CONDITION_UNREGISTERED) {
+ cs->stk = NULL;
+ return;
+ }
+
+ cs->stk = __ofono_atom_get_data(atom);
+}
+
void ofono_call_settings_register(struct ofono_call_settings *cs)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *path = __ofono_atom_get_path(cs->atom);
struct ofono_modem *modem = __ofono_atom_get_modem(cs->atom);
struct ofono_atom *ussd_atom;
+ struct ofono_atom *stk_atom;
if (!g_dbus_register_interface(conn, path,
OFONO_CALL_SETTINGS_INTERFACE,
@@ -1319,6 +1329,16 @@ void ofono_call_settings_register(struct
ofono_call_settings *cs)
ussd_watch(ussd_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED,
cs);
+ cs->stk_watch = __ofono_modem_add_atom_watch(modem,
+ OFONO_ATOM_TYPE_STK,
+ stk_watch, cs, NULL);
+
+ stk_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_STK);
+
+ if (stk_atom && __ofono_atom_get_registered(stk_atom))
+ stk_watch(stk_atom, OFONO_ATOM_WATCH_CONDITION_REGISTERED,
+ cs);
+
__ofono_atom_register(cs->atom, call_settings_unregister);
}
diff --git a/src/ofono.h b/src/ofono.h
index f1c0973..50d4f96 100644
--- a/src/ofono.h
+++ b/src/ofono.h
@@ -166,6 +166,12 @@ gboolean __ofono_modem_remove_atom_watch(struct
ofono_modem *modem,
void __ofono_atom_free(struct ofono_atom *atom);
+#include <gdbus.h>
+struct ofono_ss_req {
+ DBusMessage *msg;
+ gboolean stk;
+};
+
#include <ofono/call-barring.h>
gboolean __ofono_call_barring_is_busy(struct ofono_call_barring *cb);
@@ -228,6 +234,8 @@ unsigned int __ofono_sms_txq_submit(struct ofono_sms *sms,
GSList *list,
struct cbs;
void __ofono_cbs_sim_download(struct ofono_stk *stk, const struct cbs *msg);
+void __ofono_stk_send_ss_response(struct ofono_stk *stk, gboolean *stk_pending,
+ const struct ofono_error *error);
#include <ofono/ssn.h>
@@ -252,11 +260,11 @@ typedef gboolean (*ofono_ussd_ssc_cb_t)(int type,
const char *sc,
const char *sia, const char *sib,
const char *sic, const char *dn,
- DBusMessage *msg, void *data);
+ struct ofono_ss_req *osr, void *data);
typedef gboolean (*ofono_ussd_passwd_cb_t)(const char *sc,
const char *old, const char *new,
- DBusMessage *msg, void *data);
+ struct ofono_ss_req *osr, void *data);
gboolean __ofono_ussd_ssc_register(struct ofono_ussd *ussd, const char *sc,
ofono_ussd_ssc_cb_t cb, void *data,
@@ -268,6 +276,9 @@ gboolean __ofono_ussd_passwd_register(struct ofono_ussd
*ussd, const char *sc,
ofono_destroy_func destroy);
void __ofono_ussd_passwd_unregister(struct ofono_ussd *ussd, const char *sc);
gboolean __ofono_ussd_is_busy(struct ofono_ussd *ussd);
+int __ofono_ussd_recognized_control_string(struct ofono_ussd *ussd,
+ const char *ss_str,
+ struct ofono_ss_req *osr);
#include <ofono/netreg.h>
diff --git a/src/stk.c b/src/stk.c
index 04bfc65..e273914 100644
--- a/src/stk.c
+++ b/src/stk.c
@@ -648,6 +648,13 @@ static GDBusSignalTable stk_signals[] = {
{ }
};
+static gboolean set_result_type(struct stk_response *rsp,
+ enum stk_result_type type)
+{
+ rsp->result.type = type;
+ return TRUE;
+}
+
static gboolean handle_command_more_time(const struct stk_command *cmd,
struct stk_response *rsp,
struct ofono_stk *stk)
@@ -731,6 +738,92 @@ static gboolean handle_command_send_sms(const struct
stk_command *cmd,
return FALSE;
}
+void __ofono_stk_send_ss_response(struct ofono_stk *stk, gboolean *stk_pending,
+ const struct ofono_error *error)
+{
+ static struct ofono_error oe = { .type = OFONO_ERROR_TYPE_FAILURE };
+ struct stk_response rsp;
+ unsigned char addnl[2];
+
+ *stk_pending = FALSE;
+
+ memset(&rsp, 0, sizeof(rsp));
+
+ switch (error->type) {
+ case OFONO_ERROR_TYPE_NO_ERROR:
+ rsp.result.type = STK_RESULT_TYPE_SUCCESS;
+ break;
+ default:
+ rsp.result.type = STK_RESULT_TYPE_SS_RETURN_ERROR;
+ addnl[0] = (unsigned char) error->error;
+ addnl[1] = STK_RESULT_ADDNL_SS_PB_NO_SPECIFIC_CAUSE;
+ rsp.result.additional = addnl;
+ rsp.result.additional_len = 2;
+ break;
+ }
+
+ if (stk->pending_cmd->send_ss.alpha_id &&
+ stk->pending_cmd->send_ss.alpha_id[0])
+ stk_alpha_id_unset(stk);
+
+ if (stk_respond(stk, &rsp, stk_command_cb))
+ stk_command_cb(&oe, stk);
+}
+
+static gboolean handle_command_send_ss(const struct stk_command *cmd,
+ struct stk_response *rsp,
+ struct ofono_stk *stk)
+{
+ struct ofono_modem *modem = __ofono_atom_get_modem(stk->atom);
+ char *str = cmd->send_ss.ss.ss;
+ struct ofono_atom *ussd_atom;
+ struct ofono_ussd *ussd;
+ int result;
+ struct ofono_ss_req *osr;
+
+ ussd_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_USSD);
+
+ if (!ussd_atom || !__ofono_atom_get_registered(ussd_atom))
+ return set_result_type(rsp, STK_RESULT_TYPE_NOT_CAPABLE);
+
+ ussd = __ofono_atom_get_data(ussd_atom);
+
+ if (__ofono_ussd_is_busy(ussd))
+ return set_result_type(rsp, STK_RESULT_TYPE_TERMINAL_BUSY);
+
+ if (strlen(str) == 0)
+ return set_result_type(rsp,
+ STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD);
+
+ osr = g_try_new0(struct ofono_ss_req, 1);
+ if (!osr)
+ return set_result_type(rsp, STK_RESULT_TYPE_NOT_CAPABLE);
+
+ osr->stk = TRUE;
+
+ result = __ofono_ussd_recognized_control_string(ussd, str, osr);
+ g_free(osr);
+
+ switch (result) {
+ case EBUSY:
+ return set_result_type(rsp, STK_RESULT_TYPE_TERMINAL_BUSY);
+ case ENOSYS:
+ case ENOMEM:
+ return set_result_type(rsp, STK_RESULT_TYPE_NOT_CAPABLE);
+ case 0:
+ break;
+ case EINVAL:
+ default:
+ return set_result_type(rsp,
+ STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD);
+ }
+
+ if (cmd->send_ss.alpha_id && cmd->send_ss.alpha_id[0])
+ stk_alpha_id_set(stk, cmd->send_ss.alpha_id);
+
+ return FALSE;
+}
+
static gboolean handle_command_set_idle_text(const struct stk_command *cmd,
struct stk_response *rsp,
struct ofono_stk *stk)
@@ -1696,6 +1789,11 @@ void ofono_stk_proactive_command_notify(struct ofono_stk
*stk,
&rsp, stk);
break;
+ case STK_COMMAND_TYPE_SEND_SS:
+ respond = handle_command_send_ss(stk->pending_cmd,
+ &rsp, stk);
+ break;
+
case STK_COMMAND_TYPE_SETUP_IDLE_MODE_TEXT:
respond = handle_command_set_idle_text(stk->pending_cmd,
&rsp, stk);
diff --git a/src/stkutil.c b/src/stkutil.c
index 3cfe06a..e21698b 100644
--- a/src/stkutil.c
+++ b/src/stkutil.c
@@ -5441,6 +5441,8 @@ const unsigned char *stk_pdu_from_response(const struct
stk_response *response,
&response->select_item.item_id,
NULL);
break;
+ case STK_COMMAND_TYPE_SEND_SS:
+ break;
case STK_COMMAND_TYPE_SETUP_CALL:
ok = build_setup_call(&builder, response);
break;
diff --git a/src/stkutil.h b/src/stkutil.h
index c432df8..2b8f53a 100644
--- a/src/stkutil.h
+++ b/src/stkutil.h
@@ -254,6 +254,8 @@ enum stk_result_type {
STK_RESULT_TYPE_COMMAND_NOT_UNDERSTOOD = 0x31,
STK_RESULT_TYPE_DATA_NOT_UNDERSTOOD = 0x32,
STK_RESULT_TYPE_COMMAND_ID_UNKNOWN = 0x33,
+ STK_RESULT_TYPE_SS_RETURN_ERROR = 0x34,
+ STK_RESULT_TYPE_SMS_RP_ERROR = 0x35,
STK_RESULT_TYPE_MINIMUM_NOT_MET = 0x36,
STK_RESULT_TYPE_USSD_RETURN_ERROR = 0x37,
STK_RESULT_TYPE_CALL_CONTROL_PERMANENT = 0x39,
@@ -263,6 +265,27 @@ enum stk_result_type {
STK_RESULT_TYPE_MMS_ERROR = 0x3D,
};
+enum stk_result_addnl_me_pb_fb {
+ STK_RESULT_ADDNL_ME_PB_NO_SPECIFIC_CAUSE = 0x00,
+ STK_RESULT_ADDNL_ME_PB_SCREEN_BUSY = 0x01,
+ STK_RESULT_ADDNL_ME_PB_BUSY_ON_CALL = 0x02,
+ STK_RESULT_ADDNL_ME_PB_NO_SERVICE = 0x04,
+ STK_RESULT_ADDNL_ME_PB_NO_ACCESS = 0x05,
+ STK_RESULT_ADDNL_ME_PB_NO_RADIO_RESOURCE = 0x06,
+ STK_RESULT_ADDNL_ME_PB_NOT_IN_SPEECH_CALL = 0x07,
+ STK_RESULT_ADDNL_ME_PB_BUSY_ON_SEND_DTMF = 0x09,
+ STK_RESULT_ADDNL_ME_PB_NO_NAA_ACTIVE = 0x0A
+};
+
+enum stk_result_addnl_me_pb_ob {
+ STK_RESULT_ADDNL_ME_PB_SS_BUSY = 0x03,
+ STK_RESULT_ADDNL_ME_PB_USSD_BUSY = 0x08
+};
+
+enum stk_result_addnl_ss_pb_ob {
+ STK_RESULT_ADDNL_SS_PB_NO_SPECIFIC_CAUSE = 0x00
+};
+
enum stk_tone_type {
STK_TONE_TYPE_DIAL_TONE = 0x01,
STK_TONE_TYPE_BUSY_TONE = 0x02,
diff --git a/src/ussd.c b/src/ussd.c
index fbb07d2..7e8d1c8 100644
--- a/src/ussd.c
+++ b/src/ussd.c
@@ -182,11 +182,10 @@ void __ofono_ussd_passwd_unregister(struct ofono_ussd
*ussd, const char *sc)
ussd->ss_passwd_list = g_slist_remove(ussd->ss_passwd_list, l->data);
}
-static gboolean recognized_passwd_change_string(struct ofono_ussd *ussd,
- int type, char *sc,
- char *sia, char *sib,
- char *sic, char *sid,
- char *dn, DBusMessage *msg)
+static int recognized_passwd_change_string(struct ofono_ussd *ussd, int type,
+ char *sc, char *sia, char *sib,
+ char *sic, char *sid, char *dn,
+ struct ofono_ss_req *osr)
{
GSList *l = ussd->ss_passwd_list;
@@ -196,42 +195,40 @@ static gboolean recognized_passwd_change_string(struct
ofono_ussd *ussd,
break;
default:
- return FALSE;
+ return -ENOENT;
}
if (strcmp(sc, "03") || strlen(dn))
- return FALSE;
+ return -ENOENT;
/* If SIC & SID don't match, then we just bail out here */
- if (strcmp(sic, sid)) {
- DBusConnection *conn = ofono_dbus_get_connection();
- DBusMessage *reply = __ofono_error_invalid_format(msg);
- g_dbus_send_message(conn, reply);
- return TRUE;
- }
+ if (strcmp(sic, sid))
+ return EINVAL;
while ((l = g_slist_find_custom(l, sia,
ssc_entry_find_by_service)) != NULL) {
struct ssc_entry *entry = l->data;
ofono_ussd_passwd_cb_t cb = entry->cb;
+ int result = cb(sia, sib, sic, osr, entry->user);
- if (cb(sia, sib, sic, msg, entry->user))
- return TRUE;
+ if (result >= 0)
+ return result;
l = l->next;
}
- return FALSE;
+ return -ENOENT;
}
-static gboolean recognized_control_string(struct ofono_ussd *ussd,
+int __ofono_ussd_recognized_control_string(struct ofono_ussd *ussd,
const char *ss_str,
- DBusMessage *msg)
+ struct ofono_ss_req *osr)
{
char *str = g_strdup(ss_str);
char *sc, *sia, *sib, *sic, *sid, *dn;
int type;
- gboolean ret = FALSE;
+ int ret = -ENOENT;
+ int result;
DBG("parsing control string");
@@ -245,9 +242,11 @@ static gboolean recognized_control_string(struct
ofono_ussd *ussd,
/* A password change string needs to be treated separately
* because it uses a fourth SI and is thus not a valid
* control string. */
- if (recognized_passwd_change_string(ussd, type, sc,
- sia, sib, sic, sid, dn, msg)) {
- ret = TRUE;
+ result = recognized_passwd_change_string(ussd, type, sc,
+ sia, sib, sic, sid, dn, osr);
+
+ if (result >= 0) {
+ ret = result;
goto out;
}
@@ -259,8 +258,11 @@ static gboolean recognized_control_string(struct
ofono_ussd *ussd,
struct ssc_entry *entry = l->data;
ofono_ussd_ssc_cb_t cb = entry->cb;
- if (cb(type, sc, sia, sib, sic, dn, msg, entry->user)) {
- ret = TRUE;
+ result = cb(type, sc, sia, sib, sic, dn, osr,
+ entry->user);
+
+ if (result >= 0) {
+ ret = result;
goto out;
}
@@ -447,6 +449,8 @@ static DBusMessage *ussd_initiate(DBusConnection *conn,
DBusMessage *msg,
{
struct ofono_ussd *ussd = data;
const char *str;
+ int result;
+ struct ofono_ss_req *osr;
if (ussd->pending)
return __ofono_error_busy(msg);
@@ -462,8 +466,30 @@ static DBusMessage *ussd_initiate(DBusConnection *conn,
DBusMessage *msg,
return __ofono_error_invalid_format(msg);
DBG("checking if this is a recognized control string");
- if (recognized_control_string(ussd, str, msg))
- return NULL;
+
+ osr = g_try_new0(struct ofono_ss_req, 1);
+ if (!osr)
+ return __ofono_error_failed(msg);
+
+ osr->msg = msg;
+
+ result = __ofono_ussd_recognized_control_string(ussd, str, osr);
+ g_free(osr);
+
+ if (result >= 0) {
+ switch (result) {
+ case EBUSY:
+ return __ofono_error_busy(msg);
+ case EINVAL:
+ return __ofono_error_invalid_format(msg);
+ case ENOSYS:
+ return __ofono_error_not_implemented(msg);
+ case ENOMEM:
+ return __ofono_error_failed(msg);
+ default:
+ return NULL;
+ }
+ }
DBG("No.., checking if this is a USSD string");
if (!valid_ussd_string(str))
--
1.7.0.4
_______________________________________________
ofono mailing list
[email protected]
http://lists.ofono.org/listinfo/ofono
