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); }