static DBusMessage *connect_provider(DBusConnection *conn,
DBusMessage *msg, void *data)
{
int err;
DBG("conn %p", conn);
if (__connman_session_mode() == TRUE) {
connman_info("Session mode enabled: "
"direct provider connect disabled");
return __connman_error_failed(msg, -EINVAL);
}
err = __connman_provider_create_and_connect(msg);
if (err < 0) {
if (err == -EINPROGRESS) {
connman_error("Invalid return code from connect");
err = -EINVAL;
}
return __connman_error_failed(msg, -err);
}
return NULL;
}
static DBusMessage *unregister_peer_service(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const unsigned char *spec, *query;
DBusMessageIter iter, array;
int spec_len, query_len;
const char *owner;
int version;
int ret;
DBG("");
owner = dbus_message_get_sender(msg);
dbus_message_iter_init(msg, &iter);
dbus_message_iter_recurse(&iter, &array);
ret = parse_peers_service_specs(&array, &spec, &spec_len,
&query, &query_len, &version);
if (ret)
goto error;
ret = __connman_peer_service_unregister(owner, spec, spec_len,
query, query_len, version);
if (!ret)
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
error:
return __connman_error_failed(msg, -ret);
}
int __connman_technology_disable(enum connman_service_type type, DBusMessage *msg)
{
struct connman_technology *technology;
GSList *list;
int err = 0;
int ret = -ENODEV;
DBusMessage *reply;
DBG("type %d disable", type);
technology = technology_find(type);
if (technology == NULL) {
err = -ENXIO;
goto done;
}
if (technology->pending_reply != NULL) {
err = -EBUSY;
goto done;
}
if (technology->tethering == TRUE)
set_tethering(technology, FALSE);
if (msg != NULL) {
technology->enable_persistent = FALSE;
save_state(technology);
}
__connman_rfkill_block(technology->type, TRUE);
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
err = __connman_device_disable(device);
if (err == 0)
ret = 0;
}
done:
if (ret == 0) {
if (msg != NULL)
g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID);
return ret;
}
if (msg != NULL) {
if (err == -EINPROGRESS) {
technology->pending_reply = dbus_message_ref(msg);
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else {
reply = __connman_error_failed(msg, -err);
if (reply != NULL)
g_dbus_send_message(connection, reply);
}
}
return err;
}
static DBusMessage *connect_session(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_session *session = user_data;
DBG("session %p", session);
if (ecall_session) {
if (ecall_session->ecall && ecall_session != session)
return __connman_error_failed(msg, EBUSY);
session->ecall = true;
}
if (!session->active) {
session->active = true;
set_active_session(session, true);
}
session_activate(session);
__connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_SESSION);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
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 *connect_provider(DBusConnection *conn,
DBusMessage *msg, void *data)
{
int err;
DBG("conn %p", conn);
if (__connman_session_mode()) {
connman_info("Session mode enabled: "
"direct provider connect disabled");
return __connman_error_failed(msg, EINVAL);
}
err = __connman_provider_create_and_connect(msg);
if (err < 0)
return __connman_error_failed(msg, -err);
return NULL;
}
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 *remove_saved_service(DBusConnection *conn, DBusMessage *msg, void *data)
{
gchar *identifier;
int i;
struct connman_service *service;
dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &identifier, DBUS_TYPE_INVALID);
if (connman_service_remove(identifier) != TRUE)
return __connman_error_failed(msg, EINVAL);
return dbus_message_new_method_return(msg);
}
static DBusMessage *connect_provider(DBusConnection *conn,
DBusMessage *msg, void *data)
{
int err;
DBG("conn %p", conn);
err = __connman_provider_create_and_connect(msg);
if (err < 0)
return __connman_error_failed(msg, -err);
return NULL;
}
static DBusMessage *destroy_session(DBusConnection *conn,
DBusMessage *msg, void *data)
{
int err;
DBG("conn %p", conn);
err = __connman_session_destroy(msg);
if (err < 0)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *get_connections(DBusConnection *conn, DBusMessage *msg,
void *data)
{
DBusMessage *reply;
DBG("conn %p", conn);
reply = __vpn_provider_get_connections(msg);
if (!reply)
return __connman_error_failed(msg, EINVAL);
return reply;
}
static DBusMessage *provision_service(DBusConnection *conn, DBusMessage *msg,
void *data)
{
int err;
DBG("conn %p", conn);
err = __connman_service_provision(msg);
if (err < 0)
return __connman_error_failed(msg, -err);
return NULL;
}
static DBusMessage *destroy_session(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_session *session = user_data;
DBG("session %p", session);
if (ecall_session && ecall_session != session)
return __connman_error_failed(msg, EBUSY);
session_disconnect(session);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *disconnect_peer(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_peer *peer = user_data;
int err;
DBG("peer %p", peer);
err = peer_disconnect(peer);
if (err < 0 && err != -EINPROGRESS)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *do_disconnect(DBusConnection *conn, DBusMessage *msg,
void *data)
{
struct vpn_provider *provider = data;
int err;
DBG("conn %p provider %p", conn, provider);
err = __vpn_provider_disconnect(provider);
if (err < 0)
return __connman_error_failed(msg, -err);
else
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *remove(DBusConnection *conn, DBusMessage *msg, void *data)
{
const char *path;
int err;
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
DBG("conn %p path %s", conn, path);
err = __vpn_provider_remove(path);
if (err < 0)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *request_private_network(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *sender;
int err;
DBG("conn %p", conn);
sender = dbus_message_get_sender(msg);
err = __connman_private_network_request(msg, sender);
if (err < 0)
return __connman_error_failed(msg, -err);
return NULL;
}
static DBusMessage *create_session(DBusConnection *conn,
DBusMessage *msg, void *data)
{
int err;
DBG("conn %p", conn);
err = __connman_session_create(msg);
if (err < 0) {
if (err == -EINPROGRESS)
return NULL;
return __connman_error_failed(msg, -err);
}
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *release_private_network(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *path;
int err;
DBG("conn %p", conn);
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
err = __connman_private_network_release(path);
if (err < 0)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *connect_peer(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_peer *peer = user_data;
GList *list, *start;
int err;
DBG("peer %p", peer);
if (peer->pending)
return __connman_error_in_progress(msg);
list = g_hash_table_get_values(peers_table);
start = list;
for (; list; list = list->next) {
struct connman_peer *temp = list->data;
if (temp == peer || temp->device != peer->device)
continue;
if (is_connecting(temp) || is_connected(temp)) {
if (peer_disconnect(temp) == -EINPROGRESS) {
g_list_free(start);
return __connman_error_in_progress(msg);
}
}
}
g_list_free(start);
peer->pending = dbus_message_ref(msg);
err = peer_connect(peer);
if (err == -EINPROGRESS)
return NULL;
if (err < 0) {
dbus_message_unref(peer->pending);
peer->pending = NULL;
return __connman_error_failed(msg, -err);
}
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *disconnect_session(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_session *session = user_data;
DBG("session %p", session);
if (ecall_session != NULL) {
if (ecall_session->ecall == TRUE && ecall_session != session)
return __connman_error_failed(msg, EBUSY);
session->ecall = FALSE;
}
session_changed(session, CONNMAN_SESSION_TRIGGER_DISCONNECT);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *lookup_service(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *pattern, *path;
int err;
DBG("conn %p", conn);
dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern,
DBUS_TYPE_INVALID);
err = __connman_service_lookup(pattern, &path);
if (err < 0)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
}
static gboolean technology_pending_reply(gpointer user_data)
{
struct connman_technology *technology = user_data;
DBusMessage *reply;
/* Power request timedout, send ETIMEDOUT. */
if (technology->pending_reply != NULL) {
reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
if (reply != NULL)
g_dbus_send_message(connection, reply);
dbus_message_unref(technology->pending_reply);
technology->pending_reply = NULL;
technology->pending_timeout = 0;
}
return FALSE;
}
static DBusMessage *register_agent(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *sender, *path;
int err;
DBG("conn %p", conn);
sender = dbus_message_get_sender(msg);
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_INVALID);
err = connman_agent_register(sender, path);
if (err < 0)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *create(DBusConnection *conn, DBusMessage *msg, void *data)
{
int err;
DBG("conn %p", conn);
err = __vpn_provider_create(msg);
if (err < 0) {
if (err == -EINPROGRESS) {
connman_error("Invalid return code (%d) "
"from connect", err);
err = -EINVAL;
}
return __connman_error_failed(msg, -err);
}
return NULL;
}
static DBusMessage *set_powered(struct connman_technology *technology,
DBusMessage *msg, connman_bool_t powered)
{
DBusMessage *reply = NULL;
int err = 0;
if (technology->rfkill_driven && technology->hardblocked == TRUE) {
err = -EACCES;
goto make_reply;
}
if (powered == TRUE)
err = technology_enable(technology);
else
err = technology_disable(technology);
if (err != -EBUSY) {
technology->enable_persistent = powered;
technology_save(technology);
}
make_reply:
if (err == -EINPROGRESS) {
technology->pending_reply = dbus_message_ref(msg);
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else if (err == -EALREADY) {
if (powered == TRUE)
reply = __connman_error_already_enabled(msg);
else
reply = __connman_error_already_disabled(msg);
} else if (err < 0)
reply = __connman_error_failed(msg, -err);
else
reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
return reply;
}
static void reply_scan_pending(struct connman_technology *technology, int err)
{
DBusMessage *reply;
DBG("technology %p err %d", technology, err);
while (technology->scan_pending != NULL) {
DBusMessage *msg = technology->scan_pending->data;
DBG("reply to %s", dbus_message_get_sender(msg));
if (err == 0)
reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
else
reply = __connman_error_failed(msg, -err);
g_dbus_send_message(connection, reply);
dbus_message_unref(msg);
technology->scan_pending =
g_slist_delete_link(technology->scan_pending,
technology->scan_pending);
}
}
static DBusMessage *register_counter(DBusConnection *conn,
DBusMessage *msg, void *data)
{
const char *sender, *path;
unsigned int accuracy, period;
int err;
DBG("conn %p", conn);
sender = dbus_message_get_sender(msg);
dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
DBUS_TYPE_UINT32, &accuracy,
DBUS_TYPE_UINT32, &period,
DBUS_TYPE_INVALID);
/* FIXME: add handling of accuracy parameter */
err = __connman_counter_register(sender, path, period);
if (err < 0)
return __connman_error_failed(msg, -err);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static DBusMessage *disconnect_session(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct connman_session *session = user_data;
DBG("session %p", session);
if (ecall_session) {
if (ecall_session->ecall && ecall_session != session)
return __connman_error_failed(msg, EBUSY);
session->ecall = false;
}
if (session->active) {
session->active = false;
set_active_session(session, false);
}
session_deactivate(session);
update_session_state(session);
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static int session_policy_config_cb(struct connman_session *session,
struct connman_session_config *config,
void *user_data, int err)
{
struct creation_data *creation_data = user_data;
struct session_info *info, *info_last;
DBusMessage *reply;
DBG("session %p config %p", session, config);
if (err < 0)
goto err;
session->policy_config = config;
session->mark = session_mark++;
session->index = -1;
err = init_firewall_session(session);
if (err < 0)
goto err;
err = init_routing_table(session);
if (err < 0)
goto err;
info = session->info;
info_last = session->info_last;
if (session->policy_config->ecall)
ecall_session = session;
info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
info->config.type = apply_policy_on_type(
session->policy_config->type,
creation_data->type);
info->config.priority = session->policy_config->priority;
info->config.roaming_policy = session->policy_config->roaming_policy;
session->user_allowed_bearers = creation_data->allowed_bearers;
creation_data->allowed_bearers = NULL;
apply_policy_on_bearers(
session->policy_config->allowed_bearers,
session->user_allowed_bearers,
&info->config.allowed_bearers);
g_hash_table_replace(session_hash, session->session_path, session);
DBG("add %s", session->session_path);
if (!g_dbus_register_interface(connection, session->session_path,
CONNMAN_SESSION_INTERFACE,
session_methods, NULL, NULL,
session, NULL)) {
connman_error("Failed to register %s", session->session_path);
g_hash_table_remove(session_hash, session->session_path);
err = -EINVAL;
goto err;
}
reply = g_dbus_create_reply(creation_data->pending,
DBUS_TYPE_OBJECT_PATH, &session->session_path,
DBUS_TYPE_INVALID);
g_dbus_send_message(connection, reply);
creation_data->pending = NULL;
info_last->state = info->state;
info_last->config.priority = info->config.priority;
info_last->config.roaming_policy = info->config.roaming_policy;
info_last->config.allowed_bearers = info->config.allowed_bearers;
session->append_all = true;
cleanup_creation_data(creation_data);
session_activate(session);
return 0;
err:
reply = __connman_error_failed(creation_data->pending, -err);
g_dbus_send_message(connection, reply);
creation_data->pending = NULL;
cleanup_session(session);
cleanup_creation_data(creation_data);
return err;
}
