static void set_offlinemode(struct connman_device *device, connman_bool_t offlinemode) { connman_bool_t powered; DBG("device %p name %s", device, device->name); if (device == NULL) return; device->offlinemode = offlinemode; if (device->blocked == TRUE) return; powered = (offlinemode == TRUE) ? FALSE : TRUE; if (device->powered == powered) return; if (device->powered_persistent == FALSE) powered = FALSE; set_powered(device, powered); }
void manager_cleanup(struct manager *mgr) { DBusConnection *conn = get_dbus_connection(); if (mgr->state == ONLINE) set_powered(conn, mgr, FALSE); g_dbus_unregister_interface(conn, SAMSUNG_MODEM_MANAGER_PATH, SAMSUNG_MODEM_MANAGER_INTERFACE); ipc_client_free(mgr->client); rfs_manager_free(mgr->rfs); g_free(mgr); }
static DBusMessage *manager_set_property(DBusConnection *conn, DBusMessage *msg, void *data) { DBusMessageIter iter; DBusMessageIter var; const char *property; struct manager *mgr = data; if (!dbus_message_iter_init(msg, &iter)) return __dbus_error_invalid_args(msg); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return __dbus_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 __dbus_error_invalid_args(msg); dbus_message_iter_recurse(&iter, &var); if (g_str_equal(property, "Powered") == TRUE) { gboolean powered = FALSE; int err; if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN) return __dbus_error_invalid_args(msg); dbus_message_iter_get_basic(&var, &powered); if (mgr->state == INITIALIZING) return __dbus_error_busy(msg); if (mgr->powered == powered) return dbus_message_new_method_return(msg); g_dbus_send_reply(conn, msg, DBUS_TYPE_INVALID); err = set_powered(conn, mgr, powered); if (err < 0) return NULL; return NULL; } return __dbus_error_invalid_args(msg); }
static void property_set_powered(const GDBusPropertyTable *property, DBusMessageIter *value, GDBusPendingPropertySet id, void *data) { dbus_bool_t powered; if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN) { g_dbus_pending_property_error(id, NFC_ERROR_INTERFACE ".InvalidArguments", "Invalid arguments in method call"); return; } dbus_message_iter_get_basic(value, &powered); set_powered(id, powered, data); }
int __connman_device_set_blocked(struct connman_device *device, connman_bool_t blocked) { connman_bool_t powered; DBG("device %p blocked %d", device, blocked); device->blocked = blocked; if (device->offlinemode == TRUE) return 0; connman_info("%s {rfkill} blocked %d", device->interface, blocked); if (blocked == FALSE) powered = device->powered_persistent; else powered = FALSE; return set_powered(device, powered); }
void ofono_modem_reset(struct ofono_modem *modem) { int err; DBG("%p", modem); if (modem->pending) { DBusMessage *reply = __ofono_error_failed(modem->pending); __ofono_dbus_pending_reply(&modem->pending, reply); } if (modem->modem_state == MODEM_STATE_ONLINE) modem->get_online = TRUE; ofono_modem_set_powered(modem, FALSE); err = set_powered(modem, TRUE); if (err == -EINPROGRESS) return; modem_change_state(modem, MODEM_STATE_PRE_SIM); }
void __ofono_modem_shutdown(void) { struct ofono_modem *modem; GSList *l; powering_down = TRUE; for (l = g_modem_list; l; l = l->next) { modem = l->data; if (modem->driver == NULL) continue; if (modem->powered == FALSE && modem->powered_pending == FALSE) continue; if (set_powered(modem, FALSE) == -EINPROGRESS) modems_remaining += 1; } if (modems_remaining == 0) __ofono_exit(); }
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 void modem_unregister(struct ofono_modem *modem) { DBusConnection *conn = ofono_dbus_get_connection(); DBG("%p", modem); if (modem->powered == TRUE) set_powered(modem, FALSE); __ofono_watchlist_free(modem->atom_watches); modem->atom_watches = NULL; __ofono_watchlist_free(modem->online_watches); modem->online_watches = NULL; __ofono_watchlist_free(modem->powered_watches); modem->powered_watches = NULL; modem->sim_watch = 0; modem->sim_ready_watch = 0; g_slist_foreach(modem->interface_list, (GFunc) g_free, NULL); g_slist_free(modem->interface_list); modem->interface_list = NULL; g_slist_foreach(modem->feature_list, (GFunc) g_free, NULL); g_slist_free(modem->feature_list); modem->feature_list = NULL; if (modem->timeout) { g_source_remove(modem->timeout); modem->timeout = 0; } if (modem->pending) { dbus_message_unref(modem->pending); modem->pending = NULL; } if (modem->interface_update) { g_source_remove(modem->interface_update); modem->interface_update = 0; } if (modem->lock_watch) { lockdown_remove(modem); ofono_dbus_signal_property_changed(conn, modem->path, OFONO_MODEM_INTERFACE, "Lockdown", DBUS_TYPE_BOOLEAN, &modem->lockdown); } g_dbus_unregister_interface(conn, modem->path, OFONO_MODEM_INTERFACE); if (modem->driver && modem->driver->remove) modem->driver->remove(modem); g_hash_table_destroy(modem->properties); modem->properties = NULL; modem->driver = NULL; emit_modem_removed(modem); call_modemwatches(modem, FALSE); }
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 *set_property(DBusConnection *conn, DBusMessage *msg, void *data) { struct connman_technology *technology = data; DBusMessageIter iter, value; const char *name; int type; DBG("conn %p", conn); if (dbus_message_iter_init(msg, &iter) == FALSE) return __connman_error_invalid_arguments(msg); if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING) return __connman_error_invalid_arguments(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 __connman_error_invalid_arguments(msg); dbus_message_iter_recurse(&iter, &value); type = dbus_message_iter_get_arg_type(&value); DBG("property %s", name); if (g_str_equal(name, "Tethering") == TRUE) { int err; connman_bool_t tethering; if (type != DBUS_TYPE_BOOLEAN) return __connman_error_invalid_arguments(msg); if (connman_technology_is_tethering_allowed(technology->type) == FALSE) { DBG("%s tethering not allowed by config file", __connman_service_type2string(technology->type)); return __connman_error_not_supported(msg); } dbus_message_iter_get_basic(&value, &tethering); if (technology->tethering == tethering) { if (tethering == FALSE) return __connman_error_already_disabled(msg); else return __connman_error_already_enabled(msg); } err = set_tethering(technology, tethering); if (err < 0) return __connman_error_failed(msg, -err); technology->tethering_persistent = tethering; technology_save(technology); } else if (g_str_equal(name, "TetheringIdentifier") == TRUE) { const char *str; dbus_message_iter_get_basic(&value, &str); if (technology->type != CONNMAN_SERVICE_TYPE_WIFI) return __connman_error_not_supported(msg); if (strlen(str) < 1 || strlen(str) > 32) return __connman_error_invalid_arguments(msg); if (g_strcmp0(technology->tethering_ident, str) != 0) { g_free(technology->tethering_ident); technology->tethering_ident = g_strdup(str); technology_save(technology); connman_dbus_property_changed_basic(technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "TetheringIdentifier", DBUS_TYPE_STRING, &technology->tethering_ident); } } else if (g_str_equal(name, "TetheringPassphrase") == TRUE) { const char *str; dbus_message_iter_get_basic(&value, &str); if (technology->type != CONNMAN_SERVICE_TYPE_WIFI) return __connman_error_not_supported(msg); if (strlen(str) < 8 || strlen(str) > 63) return __connman_error_passphrase_required(msg); if (g_strcmp0(technology->tethering_passphrase, str) != 0) { g_free(technology->tethering_passphrase); technology->tethering_passphrase = g_strdup(str); technology_save(technology); connman_dbus_property_changed_basic(technology->path, CONNMAN_TECHNOLOGY_INTERFACE, "TetheringPassphrase", DBUS_TYPE_STRING, &technology->tethering_passphrase); } } else if (g_str_equal(name, "Powered") == TRUE) { connman_bool_t enable; if (type != DBUS_TYPE_BOOLEAN) return __connman_error_invalid_arguments(msg); dbus_message_iter_get_basic(&value, &enable); return set_powered(technology, msg, enable); } else return __connman_error_invalid_property(msg); return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); }