static void state_changed(connman_bool_t connected)
{
unsigned int count = __connman_notifier_count_connected();
char *state = "offline";
DBusMessage *signal;
if (count > 1)
return;
if (count == 1) {
if (connected == FALSE)
return;
state = "online";
}
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "State",
DBUS_TYPE_STRING, &state);
signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "StateChanged");
if (signal == NULL)
return;
dbus_message_append_args(signal, DBUS_TYPE_STRING, &state,
DBUS_TYPE_INVALID);
g_dbus_send_message(connection, signal);
}
static void offlinemode_changed(dbus_bool_t enabled)
{
DBG("enabled %d", enabled);
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "OfflineMode",
DBUS_TYPE_BOOLEAN, &enabled);
}
static void tethering_changed(struct connman_technology *technology)
{
connman_bool_t tethering = technology->tethering;
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "Tethering",
DBUS_TYPE_BOOLEAN, &tethering);
}
static void state_changed(struct connman_technology *technology)
{
const char *str;
str = state2string(technology->state);
if (str == NULL)
return;
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "State",
DBUS_TYPE_STRING, &str);
}
static void state_changed(struct connman_peer *peer)
{
const char *state;
state = state2string(peer->state);
if (!state || !allow_property_changed(peer))
return;
connman_dbus_property_changed_basic(peer->path,
CONNMAN_PEER_INTERFACE, "State",
DBUS_TYPE_STRING, &state);
}
static void technology_default(enum connman_service_type type)
{
const char *str;
str = __connman_service_type2string(type);
if (str == NULL)
str = "";
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "DefaultTechnology",
DBUS_TYPE_STRING, &str);
}
static void state_changed(void)
{
const char *state;
state = evaluate_notifier_state();
if (g_strcmp0(state, notifier_state) == 0)
return;
notifier_state = state;
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "State",
DBUS_TYPE_STRING, ¬ifier_state);
}
void __connman_session_set_mode(connman_bool_t enable)
{
DBG("enable %d", enable);
if (sessionmode != enable) {
sessionmode = enable;
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "SessionMode",
DBUS_TYPE_BOOLEAN, &sessionmode);
}
if (sessionmode == TRUE)
__connman_service_disconnect_all();
}
void __connman_technology_set_connected(enum connman_service_type type,
connman_bool_t connected)
{
struct connman_technology *technology;
technology = technology_find(type);
if (technology == NULL)
return;
DBG("technology %p connected %d", technology, connected);
technology->connected = connected;
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "Connected",
DBUS_TYPE_BOOLEAN, &connected);
}
static void powered_changed(struct connman_technology *technology)
{
if (technology->dbus_registered == FALSE)
return;
if (technology->pending_reply != NULL) {
g_dbus_send_reply(connection,
technology->pending_reply, DBUS_TYPE_INVALID);
dbus_message_unref(technology->pending_reply);
technology->pending_reply = NULL;
g_source_remove(technology->pending_timeout);
technology->pending_timeout = 0;
}
__sync_synchronize();
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
DBUS_TYPE_BOOLEAN, &technology->enabled);
}
static DBusMessage *set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
DBusMessageIter iter, value;
const char *name;
int type;
DBG("conn %p", conn);
if (!dbus_message_iter_init(msg, &iter))
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);
if (g_str_equal(name, "Time")) {
struct timeval tv;
dbus_uint64_t newval;
if (type != DBUS_TYPE_UINT64)
return __connman_error_invalid_arguments(msg);
if (time_updates_config != TIME_UPDATES_MANUAL)
return __connman_error_permission_denied(msg);
dbus_message_iter_get_basic(&value, &newval);
tv.tv_sec = newval;
tv.tv_usec = 0;
if (settimeofday(&tv, NULL) < 0)
return __connman_error_invalid_arguments(msg);
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_CLOCK_INTERFACE, "Time",
DBUS_TYPE_UINT64, &newval);
} else if (g_str_equal(name, "TimeUpdates")) {
const char *strval;
enum time_updates newval;
if (type != DBUS_TYPE_STRING)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &strval);
newval = string2time_updates(strval);
if (newval == TIME_UPDATES_UNKNOWN)
return __connman_error_invalid_arguments(msg);
if (newval == time_updates_config)
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
time_updates_config = newval;
clock_properties_save();
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_CLOCK_INTERFACE, "TimeUpdates",
DBUS_TYPE_STRING, &strval);
} else if (g_str_equal(name, "Timezone")) {
const char *strval;
if (type != DBUS_TYPE_STRING)
return __connman_error_invalid_arguments(msg);
if (timezone_updates_config != TIMEZONE_UPDATES_MANUAL)
return __connman_error_permission_denied(msg);
dbus_message_iter_get_basic(&value, &strval);
if (__connman_timezone_change(strval) < 0)
return __connman_error_invalid_arguments(msg);
} else if (g_str_equal(name, "TimezoneUpdates")) {
const char *strval;
enum timezone_updates newval;
if (type != DBUS_TYPE_STRING)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &strval);
newval = string2timezone_updates(strval);
if (newval == TIMEZONE_UPDATES_UNKNOWN)
return __connman_error_invalid_arguments(msg);
if (newval == timezone_updates_config)
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
timezone_updates_config = newval;
clock_properties_save();
connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
CONNMAN_CLOCK_INTERFACE, "TimezoneUpdates",
DBUS_TYPE_STRING, &strval);
} else if (g_str_equal(name, "Timeservers")) {
DBusMessageIter entry;
char **str = NULL;
GSList *list = NULL;
int count = 0;
if (type != DBUS_TYPE_ARRAY)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_recurse(&value, &entry);
while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
const char *val;
GSList *new_head;
dbus_message_iter_get_basic(&entry, &val);
new_head = __connman_timeserver_add_list(list, val);
if (list != new_head) {
count++;
list = new_head;
}
dbus_message_iter_next(&entry);
}
if (list) {
str = g_new0(char *, count+1);
while (list) {
count--;
str[count] = list->data;
list = g_slist_delete_link(list, list);
};
}
__connman_timeserver_system_set(str);
if (str)
g_strfreev(str);
connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
CONNMAN_CLOCK_INTERFACE, "Timeservers",
DBUS_TYPE_STRING, append_timeservers, NULL);
} else
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);
}
