static gboolean set_powered_timeout(gpointer user)
{
struct ofono_modem *modem = user;
DBG("modem: %p", modem);
modem->timeout = 0;
if (modem->powered_pending == FALSE) {
DBusConnection *conn = ofono_dbus_get_connection();
dbus_bool_t powered = FALSE;
set_online(modem, FALSE);
modem->powered = FALSE;
notify_powered_watches(modem);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
} else {
modem->powered_pending = modem->powered;
}
if (modem->pending != NULL) {
DBusMessage *reply;
reply = __ofono_error_timed_out(modem->pending);
__ofono_dbus_pending_reply(&modem->pending, reply);
if (modem->lockdown)
lockdown_remove(modem);
}
return FALSE;
}
void ofono_ussd_notify(struct ofono_ussd *ussd, int status, int dcs,
const unsigned char *data, int data_len)
{
DBusConnection *conn = ofono_dbus_get_connection();
const char *ussdstr = "USSD";
char *utf8_str = NULL;
const char *str;
const char sig[] = { DBUS_TYPE_STRING, 0 };
DBusMessage *reply;
DBusMessageIter iter;
DBusMessageIter variant;
DBG("status: %d %s, state: %d %s",
status, ussd_status_name(status),
ussd->state, ussd_state_name(ussd->state));
if (ussd->req &&
(status == OFONO_USSD_STATUS_NOTIFY ||
status == OFONO_USSD_STATUS_TERMINATED ||
status == OFONO_USSD_STATUS_TIMED_OUT ||
status == OFONO_USSD_STATUS_NOT_SUPPORTED)) {
ussd_request_finish(ussd, ussd_status_to_failure_code(status),
dcs, data, data_len);
ussd_change_state(ussd, USSD_STATE_IDLE);
return;
}
if (status == OFONO_USSD_STATUS_TERMINATED) {
ussd_change_state(ussd, USSD_STATE_IDLE);
if (ussd->pending == NULL)
return;
reply = __ofono_error_network_terminated(ussd->pending);
goto out;
}
if (status == OFONO_USSD_STATUS_NOT_SUPPORTED) {
ussd_change_state(ussd, USSD_STATE_IDLE);
if (ussd->pending == NULL)
return;
reply = __ofono_error_not_supported(ussd->pending);
goto out;
}
if (status == OFONO_USSD_STATUS_TIMED_OUT) {
ussd_change_state(ussd, USSD_STATE_IDLE);
if (ussd->pending == NULL)
return;
reply = __ofono_error_timed_out(ussd->pending);
goto out;
}
if (data && data_len > 0)
utf8_str = ussd_decode(dcs, data_len, data);
str = utf8_str;
/* TODO: Rework this in the Agent framework */
if (ussd->state == USSD_STATE_ACTIVE) {
reply = dbus_message_new_method_return(ussd->pending);
if (str == NULL)
str = "";
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
&ussdstr);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT, sig,
&variant);
dbus_message_iter_append_basic(&variant, DBUS_TYPE_STRING,
&str);
dbus_message_iter_close_container(&iter, &variant);
if (status == OFONO_USSD_STATUS_ACTION_REQUIRED)
ussd_change_state(ussd, USSD_STATE_USER_ACTION);
else
ussd_change_state(ussd, USSD_STATE_IDLE);
} else if (ussd->state == USSD_STATE_RESPONSE_SENT) {
reply = dbus_message_new_method_return(ussd->pending);
if (str == NULL)
str = "";
dbus_message_append_args(reply, DBUS_TYPE_STRING, &str,
DBUS_TYPE_INVALID);
if (status == OFONO_USSD_STATUS_ACTION_REQUIRED)
ussd_change_state(ussd, USSD_STATE_USER_ACTION);
else
ussd_change_state(ussd, USSD_STATE_IDLE);
} else if (ussd->state == USSD_STATE_IDLE) {
const char *signal_name;
const char *path = __ofono_atom_get_path(ussd->atom);
int new_state;
if (status == OFONO_USSD_STATUS_ACTION_REQUIRED) {
new_state = USSD_STATE_USER_ACTION;
signal_name = "RequestReceived";
} else {
new_state = USSD_STATE_IDLE;
signal_name = "NotificationReceived";
}
if (str == NULL)
str = "";
g_dbus_emit_signal(conn, path,
OFONO_SUPPLEMENTARY_SERVICES_INTERFACE, signal_name,
DBUS_TYPE_STRING, &str, DBUS_TYPE_INVALID);
ussd_change_state(ussd, new_state);
goto free;
} else {
ofono_error("Received an unsolicited USSD but can't handle.");
DBG("USSD is: status: %d, %s", status, str);
goto free;
}
out:
g_dbus_send_message(conn, reply);
dbus_message_unref(ussd->pending);
ussd->pending = NULL;
free:
g_free(utf8_str);
}
