static DBusMessage *register_watcher(DBusConnection *conn, DBusMessage *msg, void *data) { const char *sender = dbus_message_get_sender(msg); struct gatt_service *gatt = data; struct watcher *watcher; char *path; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); watcher = g_new0(struct watcher, 1); watcher->name = g_strdup(sender); watcher->gatt = gatt; watcher->path = g_strdup(path); watcher->id = g_dbus_add_disconnect_watch(conn, sender, watcher_exit, watcher, watcher_free); INFO("registering watcher on %s",watcher->path); if (gatt->attioid == 0) { gatt->attioid = btd_device_add_attio_callback(gatt->dev, attio_connected, attio_disconnected, gatt); } gatt->watchers = g_slist_append(gatt->watchers, watcher); return dbus_message_new_method_return(msg); }
static DBusMessage *register_server(DBusConnection *conn, DBusMessage *msg, void *data) { struct network_server *ns = data; DBusMessage *reply; const char *uuid, *bridge; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &uuid, DBUS_TYPE_STRING, &bridge, DBUS_TYPE_INVALID)) return NULL; if (g_strcmp0(uuid, "nap")) return btd_error_failed(msg, "Invalid UUID"); if (ns->record_id) return btd_error_already_exists(msg); reply = dbus_message_new_method_return(msg); if (!reply) return NULL; ns->record_id = register_server_record(ns); if (!ns->record_id) return btd_error_failed(msg, "SDP record registration failed"); g_free(ns->bridge); ns->bridge = g_strdup(bridge); ns->watch_id = g_dbus_add_disconnect_watch(conn, dbus_message_get_sender(msg), server_disconnect, ns, NULL); return reply; }
static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg, void *data) { const char *path, *sender; if (agent) return agent_already_exists(msg); if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return invalid_args(msg); sender = dbus_message_get_sender(msg); agent = g_new0(struct agent, 1); agent->bus_name = g_strdup(sender); agent->path = g_strdup(path); agent->watch_id = g_dbus_add_disconnect_watch(conn, sender, agent_disconnected, NULL, NULL); DBG("Agent registered"); return dbus_message_new_method_return(msg); }
static DBusMessage *register_watcher(DBusConnection *conn, DBusMessage *msg, void *data) { struct heartrate_adapter *hradapter = data; struct watcher *watcher; const char *sender = dbus_message_get_sender(msg); char *path; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); watcher = find_watcher(hradapter->watchers, sender, path); if (watcher != NULL) return btd_error_already_exists(msg); watcher = g_new0(struct watcher, 1); watcher->hradapter = hradapter; watcher->id = g_dbus_add_disconnect_watch(conn, sender, watcher_exit_cb, watcher, destroy_watcher); watcher->srv = g_strdup(sender); watcher->path = g_strdup(path); if (g_slist_length(hradapter->watchers) == 0) g_slist_foreach(hradapter->devices, enable_measurement, 0); hradapter->watchers = g_slist_prepend(hradapter->watchers, watcher); DBG("heartrate watcher [%s] registered", path); return dbus_message_new_method_return(msg); }
static struct proxy_config *create_config(DBusConnection *conn, const char *sender, const char *interface) { struct proxy_config *config; config = g_try_new0(struct proxy_config, 1); if (!config) return NULL; config->proxy = pacrunner_proxy_create(interface); if (!config->proxy) { g_free(config); return NULL; } config->path = g_strdup_printf("%s/configuration%d", PACRUNNER_PATH, next_config_number++); config->sender = g_strdup(sender); DBG("path %s", config->path); config->conn = conn; config->watch = g_dbus_add_disconnect_watch(conn, sender, disconnect_callback, config, NULL); return config; }
static struct notify_client *notify_client_create(struct characteristic *chrc, const char *owner) { struct notify_client *client; client = new0(struct notify_client, 1); if (!client) return NULL; client->chrc = chrc; client->owner = strdup(owner); if (!client->owner) { free(client); return NULL; } client->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(), owner, notify_client_disconnect, client, NULL); if (!client->watch) { free(client->owner); free(client); return NULL; } return notify_client_ref(client); }
static void location_reporting_enable_cb(const struct ofono_error *error, int fd, void *data) { struct ofono_location_reporting *lr = data; DBusConnection *conn = ofono_dbus_get_connection(); DBusMessage *reply; if (error->type != OFONO_ERROR_TYPE_NO_ERROR) { ofono_error("Enabling location-reporting failed"); reply = __ofono_error_failed(lr->pending); __ofono_dbus_pending_reply(&lr->pending, reply); return; } lr->enabled = TRUE; lr->client_owner = g_strdup(dbus_message_get_sender(lr->pending)); lr->disconnect_watch = g_dbus_add_disconnect_watch(conn, lr->client_owner, client_exited, lr, NULL); reply = dbus_message_new_method_return(lr->pending); dbus_message_append_args(reply, DBUS_TYPE_UNIX_FD, &fd, DBUS_TYPE_INVALID); __ofono_dbus_pending_reply(&lr->pending, reply); signal_enabled(lr); }
static int create_handover_agent(const char *sender, const char *path, enum ho_agent_carrier carrier) { struct near_handover_agent *agent; agent = g_try_malloc0(sizeof(struct near_handover_agent)); if (!agent) return -ENOMEM; agent->sender = g_strdup(sender); agent->path = g_strdup(path); agent->carrier = carrier; agent->watch = g_dbus_add_disconnect_watch(connection, sender, handover_agent_disconnect, agent, NULL); g_hash_table_insert(ho_agent_hash, GINT_TO_POINTER(carrier), agent); DBG("handover agent registered"); switch (agent->carrier) { case HO_AGENT_BT: /* stop watching for legacy bluez */ __near_bluetooth_legacy_stop(); break; case HO_AGENT_WIFI: case HO_AGENT_UNKNOWN: break; } return 0; }
static int ndef_register(const char *sender, const char *path, const char *record_type) { struct near_ndef_agent *agent; DBG("%s registers path %s for %s", sender, path, record_type); if (g_hash_table_lookup(ndef_app_hash, record_type)) return -EEXIST; agent = g_try_malloc0(sizeof(struct near_ndef_agent)); if (!agent) return -ENOMEM; agent->sender = g_strdup(sender); agent->path = g_strdup(path); agent->record_type = g_strdup(record_type); if (!agent->sender || !agent->path || !agent->record_type) { g_free(agent); return -ENOMEM; } agent->watch = g_dbus_add_disconnect_watch(connection, sender, ndef_agent_disconnect, agent, NULL); g_hash_table_insert(ndef_app_hash, agent->record_type, agent); return 0; }
static DBusMessage *register_agent(DBusConnection *conn, DBusMessage *msg, void *data) { struct audio_device *device = data; struct gateway *gw = device->gateway; struct hf_agent *agent; const char *path, *name; if (gw->agent) return btd_error_already_exists(msg); if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); name = dbus_message_get_sender(msg); agent = g_new0(struct hf_agent, 1); agent->name = g_strdup(name); agent->path = g_strdup(path); agent->watch = g_dbus_add_disconnect_watch(conn, name, agent_exited, gw, NULL); gw->agent = agent; return dbus_message_new_method_return(msg); }
static DBusMessage *am_agent_register(DBusConnection *conn, DBusMessage *msg, void *user_data) { const char *sender, *path; unsigned char *codecs; DBusMessageIter iter, array; int length, i; gboolean has_cvsd = FALSE, has_msbc = FALSE; if (agent) return __ofono_error_in_use(msg); sender = dbus_message_get_sender(msg); if (dbus_message_iter_init(msg, &iter) == FALSE) return __ofono_error_invalid_args(msg); dbus_message_iter_get_basic(&iter, &path); dbus_message_iter_next(&iter); dbus_message_iter_recurse(&iter, &array); dbus_message_iter_get_fixed_array(&array, &codecs, &length); if (length == 0) return __ofono_error_invalid_args(msg); for (i = 0; i < length; i++) { if (codecs[i] == HFP_CODEC_CVSD) has_cvsd = TRUE; else if (codecs[i] == HFP_CODEC_MSBC) has_msbc = TRUE; else return __ofono_error_invalid_args(msg); } DBG("Agent %s registered with the CODECs:%s%s", sender, has_cvsd ? " CVSD" : "", has_msbc ? " mSBC" : ""); if (has_msbc && transparent_sco) has_wideband = TRUE; else { has_wideband = FALSE; DBG("Wideband speech disabled: %s", has_msbc ? "no Transparent SCO support" : "no mSBC support"); } if (has_cvsd == FALSE) { ofono_error("CVSD codec is mandatory"); return __ofono_error_invalid_args(msg); } agent = g_new0(struct agent, 1); agent->owner = g_strdup(sender); agent->path = g_strdup(path); agent->watch = g_dbus_add_disconnect_watch(conn, sender, agent_disconnect, NULL, NULL); return dbus_message_new_method_return(msg); }
static void pid_query_result(DBusPendingCall *pend, void *user_data) { char path[32]; struct access_check *check = user_data; DBusMessage *reply = NULL; DBusMessageIter iter; dbus_uint32_t pid; struct stat st; guint name_watch; DBG("query for busname %s", check->busname); reply = dbus_pending_call_steal_reply(pend); if (!reply) goto done; if (!gid_hash) goto done; if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) goto done; if (g_strcmp0(dbus_message_get_signature(reply), "u")) goto done; dbus_message_iter_init(reply, &iter); dbus_message_iter_get_basic(&iter, &pid); snprintf(path, sizeof(path), "/proc/%u", pid); if (stat(path, &st) < 0) goto done; DBG("query done, pid %d has gid %d", pid, st.st_gid); name_watch = g_dbus_add_disconnect_watch(check->connection, check->busname, busname_exit_callback, g_strdup(check->busname), g_free); g_hash_table_replace(watch_hash, g_strdup(check->busname), GUINT_TO_POINTER(name_watch)); g_hash_table_replace(gid_hash, g_strdup(check->busname), GINT_TO_POINTER(st.st_gid)); if (gid_is_authorized(st.st_gid)) { DBG("allowing access for pid %d, pending %u", pid, check->pending); g_dbus_pending_success(check->connection, check->pending); check->pending_unanswered = FALSE; } done: if (reply) dbus_message_unref(reply); dbus_pending_call_unref(pend); }
static void media_transport_add(struct media_transport *transport, struct media_owner *owner) { DBG("Transport %s Owner %s", transport->path, owner->name); transport->owners = g_slist_append(transport->owners, owner); owner->transport = transport; owner->watch = g_dbus_add_disconnect_watch(transport->conn, owner->name, media_owner_exit, owner, NULL); }
static void media_transport_set_owner(struct media_transport *transport, struct media_owner *owner) { DBG("Transport %s Owner %s", transport->path, owner->name); transport->owner = owner; owner->transport = transport; owner->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(), owner->name, media_owner_exit, owner, NULL); }
int connman_agent_register(const char *sender, const char *path) { DBG("sender %s path %s", sender, path); if (agent_path != NULL) return -EEXIST; agent_sender = g_strdup(sender); agent_path = g_strdup(path); agent_watch = g_dbus_add_disconnect_watch(connection, sender, agent_disconnect, NULL, NULL); return 0; }
static struct connman_agent *agent_create(const char *name, const char *path) { struct connman_agent *agent; agent = g_new0(struct connman_agent, 1); agent->owner = g_strdup(name); agent->path = g_strdup(path); agent->watch = g_dbus_add_disconnect_watch(connection, name, agent_disconnect, agent, NULL); return agent_ref(agent); }
static DBusMessage *port_connect(DBusConnection *conn, DBusMessage *msg, void *user_data) { struct serial_device *device = user_data; struct serial_port *port; const char *pattern; int err; if (dbus_message_has_member(msg, "ConnectFD") && DBUS_TYPE_UNIX_FD < 0) return btd_error_not_supported(msg); if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, DBUS_TYPE_INVALID) == FALSE) return NULL; port = find_port(device->ports, pattern); if (!port) { char *endptr = NULL; int channel; channel = strtol(pattern, &endptr, 10); if ((endptr && *endptr != '\0') || channel < 1 || channel > 30) return btd_error_does_not_exist(msg); port = create_port(device, NULL, channel); } if (port->listener_id) return btd_error_failed(msg, "Port already in use"); port->listener_id = g_dbus_add_disconnect_watch(conn, dbus_message_get_sender(msg), port_owner_exited, port, NULL); port->msg = dbus_message_ref(msg); err = connect_port(port); if (err < 0) { error("%s", strerror(-err)); g_dbus_remove_watch(conn, port->listener_id); port->listener_id = 0; return btd_error_failed(msg, strerror(-err)); } return NULL; }
/* Connect and initiate BNEP session */ static DBusMessage *connection_connect(DBusConnection *conn, DBusMessage *msg, void *data) { struct network_peer *peer = data; struct network_conn *nc; const char *svc; uint16_t id; GError *err = NULL; if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &svc, DBUS_TYPE_INVALID) == FALSE) return NULL; id = bnep_service_id(svc); nc = find_connection(peer->connections, id); if (!nc) return btd_error_not_supported(msg); if (nc->state != DISCONNECTED) return btd_error_already_connected(msg); nc->io = bt_io_connect(BT_IO_L2CAP, connect_cb, nc, NULL, &err, BT_IO_OPT_SOURCE_BDADDR, &peer->src, BT_IO_OPT_DEST_BDADDR, &peer->dst, BT_IO_OPT_PSM, BNEP_PSM, BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM, BT_IO_OPT_OMTU, BNEP_MTU, BT_IO_OPT_IMTU, BNEP_MTU, BT_IO_OPT_INVALID); if (!nc->io) { DBusMessage *reply; error("%s", err->message); reply = btd_error_failed(msg, err->message); g_error_free(err); return reply; } nc->state = CONNECTING; nc->msg = dbus_message_ref(msg); nc->watch = g_dbus_add_disconnect_watch(conn, dbus_message_get_sender(msg), connection_destroy, nc, NULL); return NULL; }
static struct agent *agent_create( const char *name, const char *path, uint8_t capability) { struct agent *agent; agent = g_new0(struct agent, 1); agent->owner = g_strdup(name); agent->path = g_strdup(path); agent->capability = capability; agent->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(), name, agent_disconnect, agent, NULL); return agent_ref(agent); }
static DBusMessage *register_alert(DBusConnection *conn, DBusMessage *msg, void *data) { const char *sender = dbus_message_get_sender(msg); char *path; const char *category; const char *c; struct alert_data *alert; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &c, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID)) return btd_error_invalid_args(msg); category = valid_category(c); if (!category) { DBG("Invalid category: %s", c); return btd_error_invalid_args(msg); } if (registered_category(category)) { DBG("Category %s already registered", category); return dbus_message_new_method_return(msg); } alert = g_new0(struct alert_data, 1); alert->srv = g_strdup(sender); alert->path = g_strdup(path); alert->category = category; alert->watcher = g_dbus_add_disconnect_watch(conn, alert->srv, watcher_disconnect, alert, NULL); if (alert->watcher == 0) { alert_data_destroy(alert); DBG("Could not register disconnect watcher"); return btd_error_failed(msg, "Could not register disconnect watcher"); } registered_alerts = g_slist_append(registered_alerts, alert); g_slist_foreach(alert_adapters, update_supported_categories, NULL); DBG("RegisterAlert(\"%s\", \"%s\")", alert->category, alert->path); return dbus_message_new_method_return(msg); }
static struct media_player *media_player_create(struct media_adapter *adapter, const char *sender, const char *path, int *err) { DBusConnection *conn = btd_get_dbus_connection(); struct media_player *mp; mp = g_new0(struct media_player, 1); mp->adapter = adapter; mp->sender = g_strdup(sender); mp->path = g_strdup(path); mp->timer = g_timer_new(); mp->watch = g_dbus_add_disconnect_watch(conn, sender, media_player_exit, mp, NULL); mp->properties_watch = g_dbus_add_properties_watch(conn, sender, path, MEDIA_PLAYER_INTERFACE, properties_changed, mp, NULL); mp->seek_watch = g_dbus_add_signal_watch(conn, sender, path, MEDIA_PLAYER_INTERFACE, "Seeked", position_changed, mp, NULL); mp->player = avrcp_register_player(adapter->btd_adapter, &player_cb, mp, media_player_free); if (!mp->player) { if (err) *err = -EPROTONOSUPPORT; media_player_destroy(mp); return NULL; } mp->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free); adapter->players = g_slist_append(adapter->players, mp); info("Player registered: sender=%s path=%s", sender, path); if (err) *err = 0; return mp; }
struct gnss_agent *gnss_agent_new(const char *path, const char *sender) { struct gnss_agent *agent = g_try_new0(struct gnss_agent, 1); DBusConnection *conn = ofono_dbus_get_connection(); if (agent == NULL) return NULL; agent->path = g_strdup(path); agent->bus = g_strdup(sender); agent->disconnect_watch = g_dbus_add_disconnect_watch(conn, sender, gnss_agent_disconnect_cb, agent, NULL); return agent; }
int obc_session_set_owner(struct obc_session *session, const char *name, GDBusWatchFunction func) { if (session == NULL) return -EINVAL; if (session->watch) g_dbus_remove_watch(session->conn, session->watch); session->watch = g_dbus_add_disconnect_watch(session->conn, name, func, session, NULL); if (session->watch == 0) return -EINVAL; session->owner = g_strdup(name); return 0; }
static struct media_owner *media_owner_create(DBusConnection *conn, DBusMessage *msg, const char *accesstype) { struct media_owner *owner; owner = g_new0(struct media_owner, 1); owner->name = g_strdup(dbus_message_get_sender(msg)); owner->accesstype = g_strdup(accesstype); owner->watch = g_dbus_add_disconnect_watch(conn, owner->name, media_owner_exit, owner, NULL); DBG("Owner created: sender=%s accesstype=%s", owner->name, accesstype); return owner; }
static int add_xml_record(DBusConnection *conn, const char *sender, struct service_adapter *serv_adapter, const char *record, dbus_uint32_t *handle) { struct record_data *user_record; sdp_record_t *sdp_record; bdaddr_t src; sdp_record = sdp_xml_parse_record(record, strlen(record)); if (!sdp_record) { error("Parsing of XML service record failed"); return -EIO; } if (serv_adapter->adapter) adapter_get_address(serv_adapter->adapter, &src); else bacpy(&src, BDADDR_ANY); if (add_record_to_server(&src, sdp_record) < 0) { error("Failed to register service record"); sdp_record_free(sdp_record); return -EIO; } user_record = g_new0(struct record_data, 1); user_record->handle = sdp_record->handle; user_record->sender = g_strdup(sender); user_record->serv_adapter = serv_adapter; user_record->listener_id = g_dbus_add_disconnect_watch(conn, sender, exit_callback, user_record, NULL); serv_adapter->records = g_slist_append(serv_adapter->records, user_record); DBG("listener_id %d", user_record->listener_id); *handle = user_record->handle; return 0; }
struct agent *agent_create(struct btd_adapter *adapter, const char *name, const char *path, uint8_t capability, agent_remove_cb cb, void *remove_cb_data) { struct agent *agent; agent = g_new0(struct agent, 1); agent->adapter = adapter; agent->name = g_strdup(name); agent->path = g_strdup(path); agent->capability = capability; agent->remove_cb = cb; agent->remove_cb_data = remove_cb_data; agent->listener_id = g_dbus_add_disconnect_watch(connection, name, agent_exited, agent, NULL); return agent; }
static struct agent *agent_create( const char *name, const char *path, uint8_t capability) { struct agent *agent; agent = g_new0(struct agent, 1); agent->owner = g_strdup(name); agent->path = g_strdup(path); agent->capability = capability; agent->watch = g_dbus_add_disconnect_watch(btd_get_dbus_connection(), name, agent_disconnect, agent, NULL); if (queue_isempty(default_agents)) add_default_agent(agent); else queue_push_tail(default_agents, agent); return agent_ref(agent); }
void port_add_listener(DBusConnection *conn, int16_t id, bdaddr_t *dst, int fd, const char *dev, const char *owner) { struct rfcomm_node *node; node = g_new0(struct rfcomm_node, 1); bacpy(&node->dst, dst); node->id = id; node->device = g_strdup(dev); node->conn = dbus_connection_ref(conn); node->owner = g_strdup(owner); node->io = g_io_channel_unix_new(fd); node->io_id = g_io_add_watch(node->io, G_IO_ERR | G_IO_NVAL | G_IO_HUP, (GIOFunc) rfcomm_disconnect_cb, node); connected_nodes = g_slist_append(connected_nodes, node); /* Service connection listener */ node->listener_id = g_dbus_add_disconnect_watch(conn, owner, connection_owner_exited, node, NULL); }
static DBusMessage *create_proxy(DBusConnection *conn, DBusMessage *msg, void *data) { struct serial_adapter *adapter = data; struct serial_proxy *proxy; const char *pattern, *address; char *uuid_str; int err; if (!dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &pattern, DBUS_TYPE_STRING, &address, DBUS_TYPE_INVALID)) return NULL; uuid_str = bt_name2string(pattern); if (!uuid_str) return invalid_arguments(msg, "Invalid UUID"); err = register_proxy(adapter, uuid_str, address, &proxy); g_free(uuid_str); if (err == -EINVAL) return invalid_arguments(msg, "Invalid address"); else if (err == -EALREADY) return g_dbus_create_error(msg, ERROR_INTERFACE ".AlreadyExist", "Proxy already exists"); else if (err < 0) return g_dbus_create_error(msg, ERROR_INTERFACE "Failed", "Proxy creation failed (%s)", strerror(-err)); proxy->owner = g_strdup(dbus_message_get_sender(msg)); proxy->watch = g_dbus_add_disconnect_watch(conn, proxy->owner, watch_proxy, proxy, NULL); return g_dbus_create_reply(msg, DBUS_TYPE_STRING, &proxy->path, DBUS_TYPE_INVALID); }
int __connman_counter_register(const char *owner, const char *path, unsigned int interval) { struct connman_counter *counter; int err; DBG("owner %s path %s interval %u", owner, path, interval); counter = g_hash_table_lookup(counter_table, path); if (counter) return -EEXIST; counter = g_try_new0(struct connman_counter, 1); if (!counter) return -ENOMEM; counter->owner = g_strdup(owner); counter->path = g_strdup(path); err = __connman_service_counter_register(counter->path); if (err < 0) { g_free(counter->owner); g_free(counter->path); g_free(counter); return err; } g_hash_table_replace(counter_table, counter->path, counter); g_hash_table_replace(owner_mapping, counter->owner, counter); counter->interval = interval; __connman_rtnl_update_interval_add(counter->interval); counter->watch = g_dbus_add_disconnect_watch(connection, owner, owner_disconnect, counter, NULL); __connman_service_counter_send_initial(counter->path); return 0; }