static int find_adapter(struct bluetooth_session *session, const char *source)
{
if (source == NULL) {
bacpy(&session->src, BDADDR_ANY);
return send_method_call(session, BT_PATH, BT_MANAGER_IFACE,
"DefaultAdapter", manager_reply,
DBUS_TYPE_INVALID);
}
str2ba(source, &session->src);
return send_method_call(session, BT_PATH, BT_MANAGER_IFACE,
"FindAdapter", manager_reply,
DBUS_TYPE_STRING, &source,
DBUS_TYPE_INVALID);
}
static int request_session(struct bluetooth_session *session, const char *adapter)
{
session->adapter = g_strdup(adapter);
return send_method_call(session, adapter, BT_ADAPTER_IFACE,
"RequestSession", adapter_reply,
DBUS_TYPE_INVALID);
}
int dbus_set_property_array(DBusConnection *connection,
const char *path, const char *interface,
connman_dbus_method_return_func_t cb, void *user_data,
const char *property, int type,
connman_dbus_append_func_t append_fn,
struct json_object *append_json_object)
{
DBusMessage *message;
DBusMessageIter iter;
if (type != DBUS_TYPE_STRING)
return -EOPNOTSUPP;
message = dbus_message_new_method_call("net.connman", path,
interface, "SetProperty");
if (!message)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
append_variant_array(&iter, property, append_fn, append_json_object);
return send_method_call(connection, message, cb, user_data);
}
int main(int argc, char** argv)
{
init_bus_interface();
//send_signal( 12.00f, argv[2]);
send_method_call( argv[1]);
return 0;
}
static void manager_reply(DBusPendingCall *call, void *user_data)
{
DBusError err;
DBusMessage *reply;
char *adapter;
struct callback_data *callback = user_data;
struct obc_session *session = callback->session;
struct pending_req *req = find_session_request(session, call);
reply = dbus_pending_call_steal_reply(call);
session->pending_calls = g_slist_remove(session->pending_calls, req);
pending_req_finalize(req);
dbus_error_init(&err);
if (dbus_set_error_from_message(&err, reply)) {
error("manager replied with an error: %s, %s",
err.name, err.message);
dbus_error_free(&err);
goto failed;
}
if (dbus_message_get_args(reply, NULL,
DBUS_TYPE_OBJECT_PATH, &adapter,
DBUS_TYPE_INVALID)) {
DBG("adapter path %s", adapter);
session->adapter = g_strdup(adapter);
req = send_method_call(session->conn_system,
BT_BUS_NAME, adapter,
BT_ADAPTER_IFACE, "RequestSession",
adapter_reply, callback,
DBUS_TYPE_INVALID);
if (!req)
goto failed;
session->pending_calls = g_slist_prepend(session->pending_calls,
req);
} else
goto failed;
goto proceed;
failed:
obc_session_unref(session);
g_free(callback);
proceed:
dbus_message_unref(reply);
}
void obc_session_unref(struct obc_session *session)
{
gboolean ret;
ret = g_atomic_int_dec_and_test(&session->refcount);
DBG("%p: ref=%d", session, session->refcount);
if (ret == FALSE)
return;
send_method_call(session->conn_system,
BT_BUS_NAME, session->adapter,
BT_ADAPTER_IFACE, "ReleaseSession",
NULL, NULL,
DBUS_TYPE_INVALID);
session_free(session);
}
int dbus_set_property_dict(DBusConnection *connection,
const char *path, const char *interface,
connman_dbus_method_return_func_t cb, void *user_data,
const char *property, int type,
connman_dbus_append_func_t append_fn,
struct json_object *append_json_object)
{
DBusMessage *message;
DBusMessageIter iter, variant, dict;
message = dbus_message_new_method_call("net.connman", path,
interface, "SetProperty");
if (!message)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property);
dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
DBUS_TYPE_ARRAY_AS_STRING
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
DBUS_TYPE_STRING_AS_STRING
DBUS_TYPE_VARIANT_AS_STRING
DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
&variant);
dbus_message_iter_open_container(&variant, 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);
append_fn(&dict, append_json_object);
dbus_message_iter_close_container(&variant, &dict);
dbus_message_iter_close_container(&iter, &variant);
return send_method_call(connection, message, cb, user_data);
}
int dbus_method_call(DBusConnection *connection,
const char *service, const char *path, const char *interface,
const char *method, connman_dbus_method_return_func_t cb,
void *user_data, connman_dbus_append_func_t append_func,
struct json_object *append_json_object)
{
DBusMessage *message;
DBusMessageIter iter;
message = dbus_message_new_method_call(service, path, interface,
method);
if (!message)
return -ENOMEM;
if (append_func) {
dbus_message_iter_init_append(message, &iter);
append_func(&iter, append_json_object);
}
return send_method_call(connection, message, cb, user_data);
}
static void session_destroy(struct bluetooth_session *session)
{
GSList *l;
DBG("%p", session);
if (g_slist_find(sessions, session) == NULL)
return;
sessions = g_slist_remove(sessions, session);
if (session->adapter)
send_method_call(session, session->adapter, BT_ADAPTER_IFACE,
"ReleaseSession", NULL,
DBUS_TYPE_INVALID);
l = session->pending_calls;
while (l) {
DBusPendingCall *call = l->data;
l = l->next;
session->pending_calls = g_slist_remove(session->pending_calls, call);
finalize_call(call);
}
if (session->io != NULL) {
g_io_channel_shutdown(session->io, TRUE, NULL);
g_io_channel_unref(session->io);
}
if (session->conn)
dbus_connection_unref(session->conn);
g_free(session->service);
g_free(session->adapter);
g_free(session);
}
int dbus_set_property(DBusConnection *connection,
const char *path, const char *interface,
connman_dbus_method_return_func_t cb, void * user_data,
const char *property, int type, const void *value)
{
DBusMessage *message;
DBusMessageIter iter;
message = dbus_message_new_method_call("net.connman", path,
interface, "SetProperty");
if (!message)
return -ENOMEM;
dbus_message_iter_init_append(message, &iter);
if (append_variant(&iter, property, type, value) < 0) {
dbus_message_unref(message);
return -EINVAL;
}
return send_method_call(connection, message, cb, user_data);
}
struct obc_session *obc_session_create(const char *source,
const char *destination,
const char *service,
uint8_t channel,
const char *owner,
session_callback_t function,
void *user_data)
{
struct obc_session *session;
struct callback_data *callback;
struct pending_req *req;
struct obc_driver *driver;
if (destination == NULL)
return NULL;
session = session_find(source, destination, service, channel, owner);
if (session) {
obc_session_ref(session);
goto proceed;
}
driver = obc_driver_find(service);
if (!driver)
return NULL;
session = g_try_malloc0(sizeof(*session));
if (session == NULL)
return NULL;
session->refcount = 1;
session->channel = channel;
session->conn = dbus_bus_get(DBUS_BUS_SESSION, NULL);
if (session->conn == NULL) {
session_free(session);
return NULL;
}
session->conn_system = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, NULL);
if (session->conn_system == NULL) {
session_free(session);
return NULL;
}
if (source == NULL)
bacpy(&session->src, BDADDR_ANY);
else
str2ba(source, &session->src);
str2ba(destination, &session->dst);
session->driver = driver;
DBG("driver %s", driver->service);
proceed:
callback = g_try_malloc0(sizeof(*callback));
if (callback == NULL) {
obc_session_unref(session);
return NULL;
}
callback->session = obc_session_ref(session);
callback->func = function;
callback->data = user_data;
if (source) {
req = send_method_call(session->conn_system,
BT_BUS_NAME, BT_PATH,
BT_MANAGER_IFACE, "FindAdapter",
manager_reply, callback,
DBUS_TYPE_STRING, &source,
DBUS_TYPE_INVALID);
} else {
req = send_method_call(session->conn_system,
BT_BUS_NAME, BT_PATH,
BT_MANAGER_IFACE, "DefaultAdapter",
manager_reply, callback,
DBUS_TYPE_INVALID);
}
if (!req) {
obc_session_unref(session);
g_free(callback);
return NULL;
}
session->pending_calls = g_slist_prepend(session->pending_calls, req);
if (owner)
obc_session_set_owner(session, owner, owner_disconnected);
return session;
}
