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);
}
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 *get_properties(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct connman_network *network = data;
DBusMessage *reply;
DBusMessageIter array, dict;
_DBG_NETWORK("conn %p", conn);
if (__connman_security_check_privilege(msg,
CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0)
return __connman_error_permission_denied(msg);
reply = dbus_message_new_method_return(msg);
if (reply == NULL)
return NULL;
dbus_message_iter_init_append(reply, &array);
dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY,
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
if (network->device) {
const char *path = connman_device_get_path(network->device);
if (path != NULL)
connman_dbus_dict_append_variant(&dict, "Device",
DBUS_TYPE_OBJECT_PATH, &path);
}
if (network->address != NULL)
connman_dbus_dict_append_variant(&dict, "Address",
DBUS_TYPE_STRING, &network->address);
if (network->name != NULL)
connman_dbus_dict_append_variant(&dict, "Name",
DBUS_TYPE_STRING, &network->name);
connman_dbus_dict_append_variant(&dict, "Connected",
DBUS_TYPE_BOOLEAN, &network->connected);
if (network->strength > 0)
connman_dbus_dict_append_variant(&dict, "Strength",
DBUS_TYPE_BYTE, &network->strength);
if (network->frequency > 0)
connman_dbus_dict_append_variant(&dict, "Frequency",
DBUS_TYPE_UINT16, &network->frequency);
if (network->wifi.ssid != NULL && network->wifi.ssid_len > 0)
connman_dbus_dict_append_array(&dict, "WiFi.SSID",
DBUS_TYPE_BYTE, &network->wifi.ssid,
network->wifi.ssid_len);
if (network->wifi.mode != NULL)
connman_dbus_dict_append_variant(&dict, "WiFi.Mode",
DBUS_TYPE_STRING, &network->wifi.mode);
if (network->wifi.channel > 0)
connman_dbus_dict_append_variant(&dict, "WiFi.Channel",
DBUS_TYPE_UINT16, &network->wifi.channel);
if (network->wifi.security != NULL)
connman_dbus_dict_append_variant(&dict, "WiFi.Security",
DBUS_TYPE_STRING, &network->wifi.security);
if (network->wifi.passphrase != NULL &&
__connman_security_check_privilege(msg,
CONNMAN_SECURITY_PRIVILEGE_SECRET) == 0)
connman_dbus_dict_append_variant(&dict, "WiFi.Passphrase",
DBUS_TYPE_STRING, &network->wifi.passphrase);
dbus_message_iter_close_container(&array, &dict);
return reply;
}
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
