static DBusMessage *am_agent_register(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *sender, *path;
unsigned char *codecs;
DBusMessageIter iter, array;
int length, i;
gboolean has_cvsd = FALSE, has_msbc = FALSE;
if (agent)
return __ofono_error_in_use(msg);
sender = dbus_message_get_sender(msg);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &path);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &array);
dbus_message_iter_get_fixed_array(&array, &codecs, &length);
if (length == 0)
return __ofono_error_invalid_args(msg);
for (i = 0; i < length; i++) {
if (codecs[i] == HFP_CODEC_CVSD)
has_cvsd = TRUE;
else if (codecs[i] == HFP_CODEC_MSBC)
has_msbc = TRUE;
else
return __ofono_error_invalid_args(msg);
}
DBG("Agent %s registered with the CODECs:%s%s", sender,
has_cvsd ? " CVSD" : "", has_msbc ? " mSBC" : "");
if (has_msbc && transparent_sco)
has_wideband = TRUE;
else {
has_wideband = FALSE;
DBG("Wideband speech disabled: %s", has_msbc ?
"no Transparent SCO support" : "no mSBC support");
}
if (has_cvsd == FALSE) {
ofono_error("CVSD codec is mandatory");
return __ofono_error_invalid_args(msg);
}
agent = g_new0(struct agent, 1);
agent->owner = g_strdup(sender);
agent->path = g_strdup(path);
agent->watch = g_dbus_add_disconnect_watch(conn, sender,
agent_disconnect, NULL, NULL);
return dbus_message_new_method_return(msg);
}
static DBusMessage *handsfree_set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_handsfree *hf = data;
DBusMessageIter iter, var;
ofono_bool_t enabled;
const char *name;
if (hf->pending)
return __ofono_error_busy(msg);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &enabled);
if (g_str_equal(name, "VoiceRecognition") == TRUE) {
if (!hf->driver->voice_recognition)
return __ofono_error_not_implemented(msg);
if (hf->voice_recognition == enabled)
return dbus_message_new_method_return(msg);
hf->voice_recognition_pending = enabled;
hf->pending = dbus_message_ref(msg);
hf->driver->voice_recognition(hf, enabled, voicerec_set_cb, hf);
} else if (g_str_equal(name, "EchoCancelingNoiseReduction") == TRUE) {
if (!(hf->ag_features & HFP_AG_FEATURE_ECNR))
return __ofono_error_not_supported(msg);
if (!hf->driver->disable_nrec || enabled == TRUE)
return __ofono_error_not_implemented(msg);
if (hf->nrec == FALSE)
return dbus_message_new_method_return(msg);
hf->pending = dbus_message_ref(msg);
hf->driver->disable_nrec(hf, nrec_set_cb, hf);
} else
return __ofono_error_invalid_args(msg);
return NULL;
}
static DBusMessage *message_cancel(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct message *m = data;
int res;
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (m->state != MESSAGE_STATE_PENDING)
return __ofono_error_not_available(msg);
res = __ofono_sms_txq_cancel(__ofono_atom_get_data(m->atom), &m->uuid);
switch (res) {
case -ENOENT:
return __ofono_error_not_found(msg);
case -EPERM:
return __ofono_error_access_denied(msg);
case 0:
return dbus_message_new_method_return(msg);
default:
return __ofono_error_failed(msg);
}
}
static DBusMessage *gnss_register_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_gnss *gnss = data;
const char *agent_path;
if (gnss->pending)
return __ofono_error_busy(msg);
if (gnss->posr_agent)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH,
&agent_path, DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!__ofono_dbus_valid_object_path(agent_path))
return __ofono_error_invalid_format(msg);
gnss->posr_agent = gnss_agent_new(agent_path,
dbus_message_get_sender(msg));
if (gnss->posr_agent == NULL)
return __ofono_error_failed(msg);
gnss_agent_set_removed_notify(gnss->posr_agent,
gnss_agent_notify, gnss);
gnss->driver->set_position_reporting(gnss, TRUE, gnss_register_agent_cb,
gnss);
gnss->pending = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *cm_acm_reset(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_call_meter *cm = data;
const char *pin2;
if (cm->driver->acm_reset == NULL)
return __ofono_error_not_implemented(msg);
if (cm->pending)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pin2,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!__ofono_is_valid_sim_pin(pin2, OFONO_SIM_PASSWORD_SIM_PIN2))
return __ofono_error_invalid_format(msg);
cm->pending = dbus_message_ref(msg);
cm->driver->acm_reset(cm, pin2, acm_reset_callback, cm);
return NULL;
}
static DBusMessage *gnss_unregister_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_gnss *gnss = data;
const char *agent_path;
const char *agent_bus = dbus_message_get_sender(msg);
if (gnss->pending)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (gnss->posr_agent == NULL)
return __ofono_error_failed(msg);
if (!gnss_agent_matches(gnss->posr_agent, agent_path, agent_bus))
return __ofono_error_access_denied(msg);
gnss->pending = dbus_message_ref(msg);
gnss->enabled = FALSE;
gnss->driver->set_position_reporting(gnss, FALSE,
gnss_unregister_agent_cb,
gnss);
return NULL;
}
static DBusMessage *gnss_send_element(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *caller = dbus_message_get_sender(msg);
struct ofono_gnss *gnss = data;
const char *xml;
DBG("");
if (gnss->pending)
return __ofono_error_busy(msg);
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &xml,
DBUS_TYPE_INVALID))
return __ofono_error_invalid_args(msg);
if (gnss->posr_agent == NULL)
return __ofono_error_not_available(msg);
if (!gnss_agent_sender_matches(gnss->posr_agent, caller))
return __ofono_error_access_denied(msg);
gnss->pending = dbus_message_ref(msg);
gnss->driver->send_element(gnss, xml, gnss_send_element_cb, gnss);
return NULL;
}
static DBusMessage *stk_register_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_stk *stk = data;
const char *agent_path;
if (stk->default_agent)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!__ofono_dbus_valid_object_path(agent_path))
return __ofono_error_invalid_format(msg);
stk->default_agent = stk_agent_new(agent_path,
dbus_message_get_sender(msg),
FALSE);
if (!stk->default_agent)
return __ofono_error_failed(msg);
stk_agent_set_removed_notify(stk->default_agent,
default_agent_notify, stk);
if (!stk->session_agent)
stk->current_agent = stk->default_agent;
return dbus_message_new_method_return(msg);
}
static DBusMessage *am_agent_unregister(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
const char *sender, *path;
DBusMessageIter iter;
if (agent == NULL)
return __ofono_error_not_found(msg);
sender = dbus_message_get_sender(msg);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &path);
if (strcmp(sender, agent->owner) != 0)
return __ofono_error_not_allowed(msg);
if (strcmp(path, agent->path) != 0)
return __ofono_error_not_found(msg);
agent_free(agent);
agent = NULL;
has_wideband = FALSE;
DBG("Agent %s unregistered", sender);
return dbus_message_new_method_return(msg);
}
static DBusMessage *set_property_online(struct ofono_modem *modem,
DBusMessage *msg,
DBusMessageIter *var)
{
ofono_bool_t online;
const struct ofono_modem_driver *driver = modem->driver;
if (modem->powered == FALSE)
return __ofono_error_not_available(msg);
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(var, &online);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
if (modem->online == online)
return dbus_message_new_method_return(msg);
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
if (modem_is_always_online(modem) == TRUE)
return __ofono_error_not_implemented(msg);
modem->pending = dbus_message_ref(msg);
driver->set_online(modem, online,
online ? online_cb : offline_cb, modem);
return NULL;
}
static DBusMessage *ussd_respond(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_ussd *ussd = data;
const char *str;
int dcs = 0x0f;
unsigned char buf[160];
long num_packed;
if (ussd->pending)
return __ofono_error_busy(msg);
if (ussd->state != USSD_STATE_USER_ACTION)
return __ofono_error_not_active(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (strlen(str) == 0)
return __ofono_error_invalid_format(msg);
if (!ussd_encode(str, &num_packed, buf))
return __ofono_error_invalid_format(msg);
if (ussd->driver->request == NULL)
return __ofono_error_not_implemented(msg);
ussd->pending = dbus_message_ref(msg);
ussd->driver->request(ussd, dcs, buf, num_packed,
ussd_response_callback, ussd);
return NULL;
}
static DBusMessage *thermal_management_set_property(DBusConnection *conn,
DBusMessage *msg,
void *data)
{
struct ril_thermal_management *tm = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *name;
dbus_bool_t throttling;
DBG("");
if (!ofono_modem_get_online(tm->modem))
return __ofono_error_not_available(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
if (!strcmp(name, "TransmitPowerThrottling")) {
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &throttling);
if (tm->throttling == throttling)
/* Ignore set request if new state == current state */
return dbus_message_new_method_return(msg);
return set_rf_power_status(msg, throttling, tm);
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *control_add(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *driver = "phonesim";
struct ofono_modem *modem;
DBusMessageIter iter;
char *name;
char *address;
char *port;
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &address);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &port);
modem = ofono_modem_create(name, driver);
if (modem == NULL)
return NULL;
ofono_modem_set_string(modem, "Address", address);
ofono_modem_set_integer(modem, "Port", atoi(port));
if (ofono_modem_register(modem) != 0) {
ofono_modem_remove(modem);
return __ofono_error_invalid_args(msg);
}
modem_list = g_slist_prepend(modem_list, modem);
return dbus_message_new_method_return(msg);
}
static DBusMessage *ussd_initiate(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_ussd *ussd = data;
struct ofono_modem *modem = __ofono_atom_get_modem(ussd->atom);
struct ofono_voicecall *vc;
gboolean call_in_progress;
const char *str;
int dcs = 0x0f;
unsigned char buf[160];
long num_packed;
if (__ofono_ussd_is_busy(ussd))
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (strlen(str) == 0)
return __ofono_error_invalid_format(msg);
DBG("checking if this is a recognized control string");
if (recognized_control_string(ussd, str, msg))
return NULL;
vc = __ofono_atom_find(OFONO_ATOM_TYPE_VOICECALL, modem);
if (vc)
call_in_progress = __ofono_voicecall_is_busy(vc,
OFONO_VOICECALL_INTERACTION_NONE);
else
call_in_progress = FALSE;
DBG("No.., checking if this is a USSD string");
if (!valid_ussd_string(str, call_in_progress))
return __ofono_error_not_recognized(msg);
if (!ussd_encode(str, &num_packed, buf))
return __ofono_error_invalid_format(msg);
if (ussd->driver->request == NULL)
return __ofono_error_not_implemented(msg);
DBG("OK, running USSD request");
ussd->pending = dbus_message_ref(msg);
ussd->driver->request(ussd, dcs, buf, num_packed, ussd_callback, ussd);
return NULL;
}
/*
* Pre-process a SMS text message and deliver it [D-Bus SendMessage()]
*
* @conn: D-Bus connection
* @msg: message data (telephone number and text)
* @data: SMS object to use for transmision
*
* An alphabet is chosen for the text and it (might be) segmented in
* fragments by sms_text_prepare() into @msg_list. A queue list @entry
* is created by tx_queue_entry_new() and g_queue_push_tail()
* appends that entry to the SMS transmit queue. Then the tx_next()
* function is scheduled to run to process the queue.
*/
static DBusMessage *sms_send_message(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_sms *sms = data;
const char *to;
const char *text;
GSList *msg_list;
struct ofono_modem *modem;
unsigned int flags;
gboolean use_16bit_ref = FALSE;
int err;
struct ofono_uuid uuid;
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &to,
DBUS_TYPE_STRING, &text,
DBUS_TYPE_INVALID))
return __ofono_error_invalid_args(msg);
if (valid_phone_number_format(to) == FALSE)
return __ofono_error_invalid_format(msg);
msg_list = sms_text_prepare_with_alphabet(to, text, sms->ref,
use_16bit_ref,
sms->use_delivery_reports,
sms->alphabet);
if (msg_list == NULL)
return __ofono_error_invalid_format(msg);
flags = OFONO_SMS_SUBMIT_FLAG_RECORD_HISTORY;
flags |= OFONO_SMS_SUBMIT_FLAG_RETRY;
flags |= OFONO_SMS_SUBMIT_FLAG_EXPOSE_DBUS;
if (sms->use_delivery_reports)
flags |= OFONO_SMS_SUBMIT_FLAG_REQUEST_SR;
err = __ofono_sms_txq_submit(sms, msg_list, flags, &uuid,
message_queued, msg);
g_slist_foreach(msg_list, (GFunc) g_free, NULL);
g_slist_free(msg_list);
if (err < 0)
return __ofono_error_failed(msg);
modem = __ofono_atom_get_modem(sms->atom);
__ofono_history_sms_send_pending(modem, &uuid, to, time(NULL), text);
return NULL;
}
static DBusMessage *cm_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_call_meter *cm = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *name, *passwd = "";
struct call_meter_property *property;
if (cm->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (!dbus_message_iter_next(&iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &passwd);
if (!__ofono_is_valid_sim_pin(passwd, OFONO_SIM_PASSWORD_SIM_PIN2))
return __ofono_error_invalid_format(msg);
for (property = cm_properties; property->name; property++) {
if (strcmp(name, property->name))
continue;
if (dbus_message_iter_get_arg_type(&var) != property->type)
return __ofono_error_invalid_args(msg);
return property->set(msg, cm, &var, passwd);
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *oem_raw_make_request(DBusConnection *conn,
DBusMessage *msg, void *data)
{
char *array; /* Byte array containing client request*/
int array_len; /* Length of request byte array */
DBusMessageIter iter;
DBusMessageIter subiter;
struct ofono_oem_raw_request *req;
struct ofono_oem_raw *raw;
raw = data;
req = 0;
if (raw && raw->driver->request == NULL)
return __ofono_error_not_implemented(msg);
dbus_message_iter_init(msg, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
goto error_arg;
if (dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_BYTE) {
DBG("Ignoring request because dbus request element type=%c",
dbus_message_iter_get_element_type(&iter));
goto error_arg;
}
dbus_message_iter_recurse(&iter, &subiter);
dbus_message_iter_get_fixed_array(&subiter, &array, &array_len);
req = g_new0(struct ofono_oem_raw_request, 1);
req->data = array;
req->length = array_len;
/* Store msg to request struct to allow multiple parallel requests */
req->pending = dbus_message_ref(msg);
raw->driver->request(raw, req, ofono_oem_raw_query_cb, req);
return NULL;
error_arg:
DBG("DBus arg type=%c, msg signature: %s",
dbus_message_iter_get_arg_type(&iter),
dbus_message_get_signature(msg));
return __ofono_error_invalid_args(msg);
}
static DBusMessage *stk_select_item(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_stk *stk = data;
const char *agent_path;
unsigned char selection, i;
struct stk_envelope e;
struct stk_menu *menu = stk->main_menu;
if (stk->pending)
return __ofono_error_busy(msg);
if (stk->session_agent || !menu)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_BYTE, &selection,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!__ofono_dbus_valid_object_path(agent_path))
return __ofono_error_invalid_format(msg);
for (i = 0; i < selection && menu->items[i].text; i++);
if (i != selection)
return __ofono_error_invalid_format(msg);
memset(&e, 0, sizeof(e));
e.type = STK_ENVELOPE_TYPE_MENU_SELECTION;
e.src = STK_DEVICE_IDENTITY_TYPE_KEYPAD,
e.menu_selection.item_id = menu->items[selection].item_id;
e.menu_selection.help_request = FALSE;
if (stk_send_envelope(stk, &e, menu_selection_envelope_cb, 0))
return __ofono_error_failed(msg);
stk->pending = dbus_message_ref(msg);
return NULL;
}
static DBusMessage *stk_unregister_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_stk *stk = data;
const char *agent_path;
const char *agent_bus = dbus_message_get_sender(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!stk->default_agent)
return __ofono_error_failed(msg);
if (!stk_agent_matches(stk->default_agent, agent_path, agent_bus))
return __ofono_error_failed(msg);
stk_agent_free(stk->default_agent);
return dbus_message_new_method_return(msg);
}
static DBusMessage *push_notification_register_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct push_notification *pn = data;
const char *agent_path;
if (pn->agent)
return __ofono_error_busy(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!__ofono_dbus_valid_object_path(agent_path))
return __ofono_error_invalid_format(msg);
pn->agent = sms_agent_new(AGENT_INTERFACE,
dbus_message_get_sender(msg),
agent_path);
if (pn->agent == NULL)
return __ofono_error_failed(msg);
sms_agent_set_removed_notify(pn->agent, agent_exited, pn);
pn->push_watch[0] = __ofono_sms_datagram_watch_add(pn->sms,
push_received,
WAP_PUSH_DST_PORT,
WAP_PUSH_SRC_PORT,
pn, NULL);
pn->push_watch[1] = __ofono_sms_datagram_watch_add(pn->sms,
push_received,
WAP_PUSH_DST_PORT,
0, pn, NULL);
return dbus_message_new_method_return(msg);
}
static DBusMessage *push_notification_unregister_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct push_notification *pn = data;
const char *agent_path;
const char *agent_bus = dbus_message_get_sender(msg);
if (dbus_message_get_args(msg, NULL,
DBUS_TYPE_OBJECT_PATH, &agent_path,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (pn->agent == NULL)
return __ofono_error_failed(msg);
if (sms_agent_matches(pn->agent, agent_bus, agent_path) == FALSE)
return __ofono_error_failed(msg);
sms_agent_free(pn->agent);
pn->agent = NULL;
return dbus_message_new_method_return(msg);
}
static DBusMessage *hfp_agent_new_connection(DBusConnection *conn,
DBusMessage *msg, void *data)
{
int fd, err;
struct ofono_modem *modem = data;
struct hfp_data *hfp_data = ofono_modem_get_data(modem);
guint16 version;
if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_UINT16, &version, DBUS_TYPE_INVALID))
return __ofono_error_invalid_args(msg);
hfp_slc_info_init(&hfp_data->info, version);
err = service_level_connection(modem, fd);
if (err < 0 && err != -EINPROGRESS)
return __ofono_error_failed(msg);
hfp_data->slc_msg = msg;
dbus_message_ref(msg);
return NULL;
}
static DBusMessage *cf_disable_all(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_call_forwarding *cf = data;
const char *strtype;
int type;
if (cf->driver->erasure == NULL)
return __ofono_error_not_implemented(msg);
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,
DBUS_TYPE_INVALID) == FALSE)
return __ofono_error_invalid_args(msg);
if (!strcmp(strtype, "all") || !strcmp(strtype, ""))
type = CALL_FORWARDING_TYPE_ALL;
else if (!strcmp(strtype, "conditional"))
type = CALL_FORWARDING_TYPE_ALL_CONDITIONAL;
else
return __ofono_error_invalid_format(msg);
cf->pending = dbus_message_ref(msg);
if (type == CALL_FORWARDING_TYPE_ALL)
cf->driver->erasure(cf, type, BEARER_CLASS_DEFAULT,
disable_all_callback, cf);
else
cf->driver->erasure(cf, type, BEARER_CLASS_DEFAULT,
disable_conditional_callback, cf);
return NULL;
}
static DBusMessage *radio_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_radio_settings *rs = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (rs->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_strcmp0(property, "TechnologyPreference") == 0) {
const char *value;
enum ofono_radio_access_mode mode;
if (rs->driver->set_rat_mode == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (radio_access_mode_from_string(value, &mode) == FALSE)
return __ofono_error_invalid_args(msg);
if (rs->mode == mode)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->pending_mode = mode;
rs->driver->set_rat_mode(rs, mode, radio_mode_set_callback, rs);
return NULL;
} else if (g_strcmp0(property, "GsmBand") == 0) {
const char *value;
enum ofono_radio_band_gsm band;
if (rs->driver->set_band == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (radio_band_gsm_from_string(value, &band) == FALSE)
return __ofono_error_invalid_args(msg);
if (rs->band_gsm == band)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->pending_band_gsm = band;
rs->driver->set_band(rs, band, rs->band_umts,
radio_band_set_callback, rs);
return NULL;
} else if (g_strcmp0(property, "UmtsBand") == 0) {
const char *value;
enum ofono_radio_band_umts band;
if (rs->driver->set_band == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (radio_band_umts_from_string(value, &band) == FALSE)
return __ofono_error_invalid_args(msg);
if (rs->band_umts == band)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->pending_band_umts = band;
rs->driver->set_band(rs, rs->band_gsm, band,
radio_band_set_callback, rs);
return NULL;
} else if (g_strcmp0(property, "FastDormancy") == 0) {
dbus_bool_t value;
int target;
if (rs->driver->set_fast_dormancy == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
target = value;
if (rs->fast_dormancy_pending == target)
return dbus_message_new_method_return(msg);
rs->pending = dbus_message_ref(msg);
rs->fast_dormancy_pending = target;
rs->driver->set_fast_dormancy(rs, target,
radio_fast_dormancy_set_callback, rs);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *sms_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_sms *sms = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (sms->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (!strcmp(property, "ServiceCenterAddress")) {
const char *value;
struct ofono_phone_number sca;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (strlen(value) == 0 || !valid_phone_number_format(value))
return __ofono_error_invalid_format(msg);
if (sms->driver->sca_set == NULL ||
sms->driver->sca_query == NULL)
return __ofono_error_not_implemented(msg);
string_to_phone_number(value, &sca);
sms->pending = dbus_message_ref(msg);
sms->driver->sca_set(sms, &sca, sca_set_callback, sms);
return NULL;
}
if (!strcmp(property, "Bearer")) {
const char *value;
int bearer;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (sms_bearer_from_string(value, &bearer) != TRUE)
return __ofono_error_invalid_format(msg);
if (sms->driver->bearer_set == NULL ||
sms->driver->bearer_query == NULL)
return __ofono_error_not_implemented(msg);
sms->pending = dbus_message_ref(msg);
sms->driver->bearer_set(sms, bearer, bearer_set_callback, sms);
return NULL;
}
if (!strcmp(property, "UseDeliveryReports")) {
const char *path = __ofono_atom_get_path(sms->atom);
dbus_bool_t value;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
if (sms->use_delivery_reports != (ofono_bool_t) value) {
sms->use_delivery_reports = value;
ofono_dbus_signal_property_changed(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
"UseDeliveryReports",
DBUS_TYPE_BOOLEAN, &value);
}
return NULL;
}
if (!strcmp(property, "Alphabet")) {
const char *value;
enum sms_alphabet alphabet;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &value);
if (!sms_alphabet_from_string(value, &alphabet))
return __ofono_error_invalid_format(msg);
set_alphabet(sms, alphabet);
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *set_property_lockdown(struct ofono_modem *modem,
DBusMessage *msg,
DBusMessageIter *var)
{
DBusConnection *conn = ofono_dbus_get_connection();
ofono_bool_t lockdown;
dbus_bool_t powered;
const char *caller;
int err;
if (dbus_message_iter_get_arg_type(var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(var, &lockdown);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
caller = dbus_message_get_sender(msg);
if (modem->lockdown && g_strcmp0(caller, modem->lock_owner))
return __ofono_error_access_denied(msg);
if (modem->lockdown == lockdown)
return dbus_message_new_method_return(msg);
if (lockdown == FALSE) {
lockdown_remove(modem);
goto done;
}
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
modem->lock_owner = g_strdup(caller);
modem->lock_watch = g_dbus_add_disconnect_watch(conn,
modem->lock_owner, lockdown_disconnect,
modem, NULL);
if (modem->lock_watch == 0) {
g_free(modem->lock_owner);
modem->lock_owner = NULL;
return __ofono_error_failed(msg);
}
modem->lockdown = lockdown;
if (modem->powered == FALSE)
goto done;
err = set_powered(modem, FALSE);
if (err < 0) {
if (err != -EINPROGRESS) {
lockdown_remove(modem);
return __ofono_error_failed(msg);
}
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
set_online(modem, FALSE);
powered = FALSE;
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
done:
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Lockdown", DBUS_TYPE_BOOLEAN,
&lockdown);
return NULL;
}
static DBusMessage *cf_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_call_forwarding *cf = data;
struct ofono_modem *modem = __ofono_atom_get_modem(cf->atom);
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
int cls;
int type;
if (ofono_modem_get_online(modem) == FALSE)
return __ofono_error_not_available(msg);
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))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (cf_condition_timeout_property(property, &cls)) {
dbus_uint16_t timeout;
GSList *l;
struct ofono_call_forwarding_condition *c;
type = CALL_FORWARDING_TYPE_NO_REPLY;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_UINT16)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &timeout);
if (timeout < 1 || timeout > 30)
return __ofono_error_invalid_format(msg);
l = g_slist_find_custom(cf->cf_conditions[type],
GINT_TO_POINTER(cls),
cf_condition_find_with_cls);
if (l == NULL)
return __ofono_error_failed(msg);
c = l->data;
return set_property_request(cf, msg, type, cls,
&c->phone_number, timeout);
} else if (cf_condition_enabled_property(cf, property, &type, &cls)) {
struct ofono_phone_number ph;
const char *number;
int timeout;
ph.number[0] = '\0';
ph.type = 129;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &number);
if (strlen(number) > 0 && !valid_phone_number_format(number))
return __ofono_error_invalid_format(msg);
if (number[0] != '\0')
string_to_phone_number(number, &ph);
timeout = cf_find_timeout(cf->cf_conditions[type], cls);
return set_property_request(cf, msg, type, cls, &ph,
timeout);
}
return __ofono_error_invalid_args(msg);
}
static DBusMessage *modem_set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct ofono_modem *modem = data;
DBusMessageIter iter, var;
const char *name;
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
if (powering_down == TRUE)
return __ofono_error_failed(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(name, "Online"))
return set_property_online(modem, msg, &var);
if (g_str_equal(name, "Powered") == TRUE) {
ofono_bool_t powered;
int err;
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &powered);
if (modem->pending != NULL)
return __ofono_error_busy(msg);
if (modem->powered == powered)
return dbus_message_new_method_return(msg);
if (ofono_modem_get_emergency_mode(modem) == TRUE)
return __ofono_error_emergency_active(msg);
if (modem->lockdown)
return __ofono_error_access_denied(msg);
err = set_powered(modem, powered);
if (err < 0) {
if (err != -EINPROGRESS)
return __ofono_error_failed(msg);
modem->pending = dbus_message_ref(msg);
modem->timeout = g_timeout_add_seconds(20,
set_powered_timeout, modem);
return NULL;
}
g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID);
ofono_dbus_signal_property_changed(conn, modem->path,
OFONO_MODEM_INTERFACE,
"Powered", DBUS_TYPE_BOOLEAN,
&powered);
if (powered) {
modem_change_state(modem, MODEM_STATE_PRE_SIM);
/* Force SIM Ready for devies with no sim atom */
if (modem_has_sim(modem) == FALSE)
sim_state_watch(OFONO_SIM_STATE_READY, modem);
} else {
set_online(modem, FALSE);
modem_change_state(modem, MODEM_STATE_POWER_OFF);
}
return NULL;
}
if (g_str_equal(name, "Lockdown"))
return set_property_lockdown(modem, msg, &var);
return __ofono_error_invalid_args(msg);
}
static DBusMessage *cv_set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct ofono_call_volume *cv = data;
DBusMessageIter iter;
DBusMessageIter var;
const char *property;
if (cv->pending)
return __ofono_error_busy(msg);
if (!dbus_message_iter_init(msg, &iter))
return __ofono_error_invalid_args(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&iter, &property);
dbus_message_iter_next(&iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
return __ofono_error_invalid_args(msg);
dbus_message_iter_recurse(&iter, &var);
if (g_str_equal(property, "SpeakerVolume") == TRUE) {
unsigned char percent;
if (cv->driver->speaker_volume == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BYTE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &percent);
if (percent > 100)
return __ofono_error_invalid_format(msg);
if (percent == cv->speaker_volume)
return dbus_message_new_method_return(msg);
cv->pending_volume = percent;
cv->pending = dbus_message_ref(msg);
cv->driver->speaker_volume(cv, percent, sv_set_callback, cv);
return NULL;
} else if (g_str_equal(property, "MicrophoneVolume") == TRUE) {
unsigned char percent;
if (cv->driver->microphone_volume == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BYTE)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &percent);
if (percent > 100)
return __ofono_error_invalid_format(msg);
if (percent == cv->microphone_volume)
return dbus_message_new_method_return(msg);
cv->pending_volume = percent;
cv->pending = dbus_message_ref(msg);
cv->driver->microphone_volume(cv, percent, mv_set_callback, cv);
return NULL;
} else if (g_str_equal(property, "Muted") == TRUE) {
dbus_bool_t muted;
if (cv->driver->mute == NULL)
return __ofono_error_not_implemented(msg);
if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
return __ofono_error_invalid_args(msg);
dbus_message_iter_get_basic(&var, &muted);
if (muted == (dbus_bool_t) cv->muted)
return dbus_message_new_method_return(msg);
cv->muted_pending = muted;
cv->pending = dbus_message_ref(msg);
cv->driver->mute(cv, muted, muted_set_callback, cv);
return NULL;
}
return __ofono_error_invalid_args(msg);
}
