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;
}
