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) == 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);
if (g_str_equal(name, "OfflineMode") == TRUE) {
connman_bool_t offlinemode;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &offlinemode);
__connman_technology_set_offlinemode(offlinemode);
} else if (g_str_equal(name, "SessionMode") == TRUE) {
connman_bool_t sessionmode;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &sessionmode);
if (session_mode_pending != NULL)
return __connman_error_in_progress(msg);
__connman_session_set_mode(sessionmode);
if (sessionmode == TRUE && connman_state_idle == FALSE) {
session_mode_pending = dbus_message_ref(msg);
return NULL;
}
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct connman_network *network = data;
DBusMessageIter iter, value;
const char *name;
int type;
_DBG_NETWORK("conn %p", conn);
if (dbus_message_iter_init(msg, &iter) == FALSE)
return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
dbus_message_iter_recurse(&iter, &value);
if (__connman_security_check_privilege(msg,
CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0)
return __connman_error_permission_denied(msg);
type = dbus_message_iter_get_arg_type(&value);
if (g_str_equal(name, "WiFi.Passphrase") == TRUE) {
const char *passphrase;
if (type != DBUS_TYPE_STRING)
return __connman_error_invalid_arguments(msg);
if (__connman_security_check_privilege(msg,
CONNMAN_SECURITY_PRIVILEGE_SECRET) < 0)
return __connman_error_permission_denied(msg);
dbus_message_iter_get_basic(&value, &passphrase);
g_free(network->wifi.passphrase);
network->wifi.passphrase = g_strdup(passphrase);
} else if (g_str_has_prefix(name, "IPv4.") == TRUE) {
int err;
if (network->ipconfig == NULL)
return __connman_error_invalid_property(msg);
err = __connman_ipconfig_set_ipv4(network->ipconfig,
name + 5, &value);
if (err < 0)
return __connman_error_failed(msg, -err);
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *disable_technology(DBusConnection *conn,
DBusMessage *msg, void *data)
{
enum connman_service_type type;
const char *str;
DBG("conn %p", conn);
dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
DBUS_TYPE_INVALID);
if (g_strcmp0(str, "ethernet") == 0)
type = CONNMAN_SERVICE_TYPE_ETHERNET;
else if (g_strcmp0(str, "wifi") == 0)
type = CONNMAN_SERVICE_TYPE_WIFI;
else if (g_strcmp0(str, "wimax") == 0)
type = CONNMAN_SERVICE_TYPE_WIMAX;
else if (g_strcmp0(str, "bluetooth") == 0)
type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
else if (g_strcmp0(str, "cellular") == 0)
type = CONNMAN_SERVICE_TYPE_CELLULAR;
else
return __connman_error_invalid_arguments(msg);
if (__connman_notifier_is_registered(type) == FALSE)
return __connman_error_not_registered(msg);
if (__connman_notifier_is_enabled(type) == FALSE)
return __connman_error_already_disabled(msg);
__connman_technology_disable(type, msg);
return NULL;
}
static DBusMessage *request_scan(DBusConnection *conn,
DBusMessage *msg, void *data)
{
enum connman_service_type type;
const char *str;
int err;
DBG("conn %p", conn);
dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &str,
DBUS_TYPE_INVALID);
if (g_strcmp0(str, "") == 0)
type = CONNMAN_SERVICE_TYPE_UNKNOWN;
else if (g_strcmp0(str, "wifi") == 0)
type = CONNMAN_SERVICE_TYPE_WIFI;
else if (g_strcmp0(str, "wimax") == 0)
type = CONNMAN_SERVICE_TYPE_WIMAX;
else
return __connman_error_invalid_arguments(msg);
err = __connman_device_request_scan(type);
if (err < 0) {
if (err == -EINPROGRESS) {
connman_error("Invalid return code from scan");
err = -EINVAL;
}
return __connman_error_failed(msg, -err);
}
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *set_property(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct vpn_provider *provider = 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);
if (g_str_equal(name, "UserRoutes") == TRUE) {
GSList *networks;
if (type != DBUS_TYPE_ARRAY)
return __connman_error_invalid_arguments(msg);
networks = get_user_networks(&value);
if (networks != NULL) {
del_routes(provider);
provider->user_networks = networks;
set_user_networks(provider, provider->user_networks);
if (handle_routes == FALSE)
provider_schedule_changed(provider,
USER_ROUTES_CHANGED);
}
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
DBusMessage *__connman_error_failed(DBusMessage *msg, int errnum)
{
const char *str = strerror(errnum);
switch (errnum) {
case ESRCH:
return __connman_error_not_registered(msg);
case ENXIO:
return __connman_error_not_found(msg);
case EACCES:
return __connman_error_permission_denied(msg);
case EEXIST:
return __connman_error_already_exists(msg);
case EINVAL:
return __connman_error_invalid_arguments(msg);
case ENOSYS:
return __connman_error_not_implemented(msg);
case ENOLINK:
return __connman_error_no_carrier(msg);
case ENOTUNIQ:
return __connman_error_not_unique(msg);
case EOPNOTSUPP:
return __connman_error_not_supported(msg);
case ECONNABORTED:
return __connman_error_operation_aborted(msg);
case EISCONN:
return __connman_error_already_connected(msg);
case ENOTCONN:
return __connman_error_not_connected(msg);
case ETIMEDOUT:
return __connman_error_operation_timeout(msg);
case EALREADY:
case EINPROGRESS:
return __connman_error_in_progress(msg);
case ENOKEY:
return __connman_error_passphrase_required(msg);
}
return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
".Failed", "%s", str);
}
static DBusMessage *change_session(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_session *session = user_data;
struct session_info *info = session->info;
DBusMessageIter iter, value;
const char *name;
const char *val;
GSList *allowed_bearers;
int err;
DBG("session %p", session);
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);
switch (dbus_message_iter_get_arg_type(&value)) {
case DBUS_TYPE_ARRAY:
if (g_str_equal(name, "AllowedBearers")) {
err = parse_bearers(&value, &allowed_bearers);
if (err < 0)
return __connman_error_failed(msg, -err);
if (session->active)
set_active_session(session, false);
session->active = false;
session_deactivate(session);
g_slist_free(info->config.allowed_bearers);
session->user_allowed_bearers = allowed_bearers;
apply_policy_on_bearers(
session->policy_config->allowed_bearers,
session->user_allowed_bearers,
&info->config.allowed_bearers);
session_activate(session);
} else {
goto err;
}
break;
case DBUS_TYPE_STRING:
if (g_str_equal(name, "ConnectionType")) {
dbus_message_iter_get_basic(&value, &val);
info->config.type = apply_policy_on_type(
session->policy_config->type,
connman_session_parse_connection_type(val));
} else {
goto err;
}
break;
default:
goto err;
}
session_notify(session);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
err:
return __connman_error_invalid_arguments(msg);
}
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);
dbus_message_iter_get_basic(&iter, &name);
dbus_message_iter_next(&iter);
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);
dbus_message_iter_get_basic(&value, &tethering);
if (technology->tethering == tethering)
return __connman_error_in_progress(msg);
err = set_tethering(technology, tethering);
if (err < 0)
return __connman_error_failed(msg, -err);
} 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);
technology->tethering_ident = g_strdup(str);
} 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)
return __connman_error_invalid_arguments(msg);
technology->tethering_passphrase = g_strdup(str);
} else
return __connman_error_invalid_property(msg);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *notify_update(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct test_session *session = user_data;
struct test_session_info *info = session->info;
DBusMessageIter iter, array;
GSList *allowed_bearers;
LOG("session %p notify %s", session, session->notify_path);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array);
while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
DBusMessageIter entry, value;
const char *key;
dbus_message_iter_recurse(&array, &entry);
dbus_message_iter_get_basic(&entry, &key);
dbus_message_iter_next(&entry);
dbus_message_iter_recurse(&entry, &value);
switch (dbus_message_iter_get_arg_type(&value)) {
case DBUS_TYPE_ARRAY:
if (g_str_equal(key, "AllowedBearers") == TRUE) {
allowed_bearers = session_parse_allowed_bearers(&value);
g_slist_foreach(info->allowed_bearers,
bearer_info_cleanup, NULL);
g_slist_free(info->allowed_bearers);
info->allowed_bearers = allowed_bearers;
} else if (g_str_equal(key, "IPv4") == TRUE) {
/* XXX */
} else if (g_str_equal(key, "IPv6") == TRUE) {
/* XXX */
} else {
g_assert(FALSE);
return __connman_error_invalid_arguments(msg);
}
break;
case DBUS_TYPE_BOOLEAN:
if (g_str_equal(key, "Priority") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->priority);
} else if (g_str_equal(key, "AvoidHandover") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->avoid_handover);
} else if (g_str_equal(key, "StayConnected") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->stay_connected);
} else if (g_str_equal(key, "EmergencyCall") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->ecall);
} else {
g_assert(FALSE);
return __connman_error_invalid_arguments(msg);
}
break;
case DBUS_TYPE_UINT32:
if (g_str_equal(key, "PeriodicConnect") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->periodic_connect);
} else if (g_str_equal(key, "IdleTimeout") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->idle_timeout);
} else if (g_str_equal(key, "SessionMarker") == TRUE) {
dbus_message_iter_get_basic(&value,
&info->marker);
} else {
g_assert(FALSE);
return __connman_error_invalid_arguments(msg);
}
break;
case DBUS_TYPE_STRING:
if (g_str_equal(key, "State") == TRUE) {
const char *val;
dbus_message_iter_get_basic(&value, &val);
info->state = string2state(val);
} else if (g_str_equal(key, "Bearer") == TRUE) {
const char *val;
dbus_message_iter_get_basic(&value, &val);
if (info->bearer != NULL)
g_free(info->bearer);
info->bearer = g_strdup(val);
} else if (g_str_equal(key, "Name") == TRUE) {
const char *val;
dbus_message_iter_get_basic(&value, &val);
if (info->name != NULL)
g_free(info->name);
info->name = g_strdup(val);
} else if (g_str_equal(key, "RoamingPolicy") == TRUE) {
const char *val;
dbus_message_iter_get_basic(&value, &val);
info->roaming_policy =
string2roamingpolicy(val);
} else if (g_str_equal(key, "Interface") == TRUE) {
const char *val;
dbus_message_iter_get_basic(&value, &val);
if (info->interface != NULL)
g_free(info->interface);
info->interface = g_strdup(val);
} else if (g_str_equal(key, "ConnectionType")
== TRUE) {
const char *val;
dbus_message_iter_get_basic(&value, &val);
info->type = string2type(val);
} else {
g_assert(FALSE);
return __connman_error_invalid_arguments(msg);
}
break;
default:
g_assert(FALSE);
return __connman_error_invalid_arguments(msg);
}
dbus_message_iter_next(&array);
}
if (session->notify != NULL)
session->notify(session);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
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);
}
