Setting Lockdown to TRUE means power down the modem and hold a lock that only permits the lock's owner power up the modem back. When released it restores the last state of the modem before holding the lock. --- doc/modem-api.txt | 9 ++++ src/modem.c | 129 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 138 insertions(+), 0 deletions(-) diff --git a/doc/modem-api.txt b/doc/modem-api.txt index b92e53c..45043b0 100644 --- a/doc/modem-api.txt +++ b/doc/modem-api.txt @@ -37,6 +37,15 @@ Properties boolean Powered [readwrite] Boolean representing the rf state of the modem. Online is false in flight mode. + boolean Lockdown [readwrite] + + Boolean representing the lock state of the modem. + Setting it to true, makes the calling application hold + the modem lock and power it down. Setting to false + makes the it release the modem lock. Only the + application that holds the lock can power up the modem. + If the the application exits Lockdown is set to false. + boolean Emergency [readonly, optional, experimental] Boolean representing the emergency mode of the diff --git a/src/modem.c b/src/modem.c index b334b58..a9a6e87 100644 --- a/src/modem.c +++ b/src/modem.c @@ -71,6 +71,9 @@ struct ofono_modem { ofono_bool_t powered; ofono_bool_t powered_pending; ofono_bool_t get_online; + ofono_bool_t lockdown; + char *lock_owner; + guint lock_watch; guint timeout; ofono_bool_t online; struct ofono_watchlist *online_watches; @@ -583,6 +586,9 @@ void __ofono_modem_append_properties(struct ofono_modem *modem, ofono_dbus_dict_append(dict, "Powered", DBUS_TYPE_BOOLEAN, &modem->powered); + ofono_dbus_dict_append(dict, "Lockdown", DBUS_TYPE_BOOLEAN, + &modem->lockdown); + devinfo_atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_DEVINFO); /* We cheat a little here and don't check the registered status */ @@ -686,6 +692,16 @@ static int set_powered(struct ofono_modem *modem, ofono_bool_t powered) return err; } +static void lockdown_remove(struct ofono_modem *modem) +{ + DBusConnection *conn =ofono_dbus_get_connection(); + + g_free(modem->lock_owner); + g_dbus_remove_watch(conn, modem->lock_watch); + modem->lock_watch = 0; + modem->lockdown = FALSE; +} + static gboolean set_powered_timeout(gpointer user) { struct ofono_modem *modem = user; @@ -712,11 +728,107 @@ static gboolean set_powered_timeout(gpointer user) reply = __ofono_error_timed_out(modem->pending); __ofono_dbus_pending_reply(&modem->pending, reply); + + if (modem->lockdown) + lockdown_remove(modem); } return FALSE; } +static void lockdown_disconnect(DBusConnection *conn, void *user_data) +{ + struct ofono_modem *modem = user_data; + + DBG(""); + + g_free(modem->lock_owner); + + modem->lockdown = FALSE; + + ofono_dbus_signal_property_changed(conn, modem->path, + OFONO_MODEM_INTERFACE, + "Lockdown", DBUS_TYPE_BOOLEAN, + &modem->lockdown); +} + +static DBusMessage *set_property_lockdown(struct ofono_modem *modem, + DBusMessage *msg, + DBusMessageIter *var) +{ + DBusConnection *conn = ofono_dbus_get_connection(); + ofono_bool_t lockdown; + 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); + + if (modem->lockdown == lockdown) + return dbus_message_new_method_return(msg); + + caller = dbus_message_get_sender(msg); + + if (lockdown) { + dbus_bool_t powered; + + modem->lock_owner = g_strdup(caller); + + modem->lock_watch = g_dbus_add_service_watch(conn, + modem->lock_owner, NULL, + lockdown_disconnect, modem, NULL); + + if (modem->lock_watch == 0) { + g_free(modem->lock_owner); + return __ofono_error_failed(msg); + } + + modem->lockdown = lockdown; + + if (!modem->powered) + 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; + } + + powered = FALSE; + ofono_dbus_signal_property_changed(conn, modem->path, + OFONO_MODEM_INTERFACE, + "Powered", DBUS_TYPE_BOOLEAN, + &powered); + } else { + if (g_strcmp0(caller, modem->lock_owner)) + return __ofono_error_access_denied(msg); + + lockdown_remove(modem); + } + +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 *modem_set_property(DBusConnection *conn, DBusMessage *msg, void *data) { @@ -759,6 +871,9 @@ static DBusMessage *modem_set_property(DBusConnection *conn, if (modem->powered == powered) return dbus_message_new_method_return(msg); + if (modem->lockdown) + return __ofono_error_access_denied(msg); + err = set_powered(modem, powered); if (err < 0) { if (err != -EINPROGRESS) @@ -790,6 +905,9 @@ static DBusMessage *modem_set_property(DBusConnection *conn, return NULL; } + if (g_str_equal(name, "Lockdown")) + return set_property_lockdown(modem, msg, &var); + return __ofono_error_invalid_args(msg); } @@ -834,6 +952,12 @@ void ofono_modem_set_powered(struct ofono_modem *modem, ofono_bool_t powered) modem->powered = powered; + if (modem->lockdown) + ofono_dbus_signal_property_changed(conn, modem->path, + OFONO_MODEM_INTERFACE, + "Lockdown", DBUS_TYPE_BOOLEAN, + &modem->lockdown); + if (modem->driver == NULL) { ofono_error("Calling ofono_modem_set_powered on a" "modem with no driver is not valid, " @@ -1593,6 +1717,11 @@ static void modem_unregister(struct ofono_modem *modem) modem->interface_update = 0; } + if (modem->lock_watch) { + g_dbus_remove_watch(conn, modem->lock_watch); + modem->lock_watch = 0; + } + g_dbus_unregister_interface(conn, modem->path, OFONO_MODEM_INTERFACE); if (modem->driver && modem->driver->remove) -- 1.7.3.2