int32_t vchi_service_create(VCHI_INSTANCE_T instance_handle,
SERVICE_CREATION_T *setup,
VCHI_SERVICE_HANDLE_T *handle)
{
VCHIQ_INSTANCE_T instance = (VCHIQ_INSTANCE_T)instance_handle;
struct shim_service *service = service_alloc(instance, setup);
*handle = (VCHI_SERVICE_HANDLE_T)service;
if (service) {
VCHIQ_SERVICE_PARAMS_T params;
VCHIQ_STATUS_T status;
memset(¶ms, 0, sizeof(params));
params.fourcc = setup->service_id;
params.callback = shim_callback;
params.userdata = service;
params.version = setup->version.version;
params.version_min = setup->version.version_min;
status = vchiq_add_service(instance, ¶ms, &service->handle);
if (status != VCHIQ_SUCCESS) {
service_free(service);
service = NULL;
*handle = NULL;
}
}
return (service != NULL) ? 0 : -1;
}
static struct service *service_create(struct gatt_db_attribute *attr,
struct btd_gatt_client *client)
{
struct service *service;
const char *device_path = device_get_path(client->device);
bt_uuid_t uuid;
service = new0(struct service, 1);
if (!service)
return NULL;
service->chrcs = queue_new();
if (!service->chrcs) {
free(service);
return NULL;
}
service->pending_ext_props = queue_new();
if (!service->pending_ext_props) {
queue_destroy(service->chrcs, NULL);
free(service);
return NULL;
}
service->client = client;
gatt_db_attribute_get_service_data(attr, &service->start_handle,
&service->end_handle,
&service->primary,
&uuid);
bt_uuid_to_uuid128(&uuid, &service->uuid);
service->path = g_strdup_printf("%s/service%04x", device_path,
service->start_handle);
if (!g_dbus_register_interface(btd_get_dbus_connection(), service->path,
GATT_SERVICE_IFACE,
NULL, NULL,
service_properties,
service, service_free)) {
error("Unable to register GATT service with handle 0x%04x for "
"device %s",
service->start_handle,
client->devaddr);
service_free(service);
return NULL;
}
DBG("Exported GATT service: %s", service->path);
/* Set service active so we can skip discovering next time */
gatt_db_service_set_active(attr, true);
/* Mark the service as claimed since it going to be exported */
gatt_db_service_set_claimed(attr, true);
return service;
}
static pa_hook_result_t device_unlink_cb(pa_core *c, pa_object *o, struct userdata *u) {
struct service *s;
pa_assert(c);
pa_object_assert_ref(o);
if ((s = pa_hashmap_get(u->services, o)))
service_free(s);
return PA_HOOK_OK;
}
void test_conf_parse_row(void) {
service_t* srv = conf_parse_row("a:b:c");
CU_ASSERT_PTR_NOT_NULL_FATAL(srv);
CU_ASSERT_STRING_EQUAL(srv->serv, "a");
CU_ASSERT_STRING_EQUAL(srv->warn, "b");
CU_ASSERT_STRING_EQUAL(srv->crit, "c");
service_free(srv);
srv = conf_parse_row("abc");
CU_ASSERT_PTR_NULL(srv);
}
static void unpublish_all_services(struct userdata *u) {
void *state = NULL;
struct service *s;
pa_assert(u);
pa_log_debug("Unpublishing services in Bonjour");
while ((s = pa_hashmap_iterate(u->services, &state, NULL)))
service_free(s);
if (u->main_service)
DNSServiceRefDeallocate(u->main_service);
}
void connman_service_deselect(void)
{
struct connman_service *service, *service_in_ht;
if (service_if == NULL || service_if->selected_service == NULL)
return;
service = service_if->selected_service;
service_if->selected_service = NULL;
service_in_ht = get_service(service->path);
if (service_in_ht == NULL)
service_free(service);
}
int32_t vchi_service_close(const VCHI_SERVICE_HANDLE_T handle)
{
int32_t ret = -1;
struct shim_service *service = (struct shim_service *)handle;
if (service) {
VCHIQ_STATUS_T status = vchiq_close_service(service->handle);
if (status == VCHIQ_SUCCESS) {
service_free(service);
service = NULL;
}
ret = vchiq_status_to_vchi(status);
}
return ret;
}
service_t* service_set(hashtable_t *table, char *name, service_mothod method, uint16_t num_all_nodes, service_node_t *node_arr[])
{
hashtable_data_t *data = hashtable_get(table, name);
if(data != NULL)
return NULL;
service_t *service = calloc(sizeof(service_t), 1);
if(service == NULL)
return NULL;
service->name = name;
service->len = strlen(name);
service->method = method;
service->num_all_nodes = num_all_nodes;
int i;
service_node_t *snode, *sprev;
for(i = 0; i < num_all_nodes; i++)
{
snode = node_arr[i];
if(service->all_next == NULL)
{
service->all_next = snode;
}else
{
sprev->all_next = snode;
}
sprev = snode;
}
data = hashtable_data_init(name, (void *) service);
if(data == NULL)
{
service_free(service);
return NULL;
}
hashtable_set(table, data);
return service;
}
static void
script_destroy(gpointer user_data)
{
script_t *obj = user_data;
g_assert(obj);
g_assert(obj->loop);
message("SCRIPT", "EVENT --------- [ DISCONNECTED ]");
service_free(obj->service);
g_main_loop_quit(obj->loop);
g_main_loop_unref(obj->loop);
g_free(obj);
}
void pa__done(pa_module*m) {
struct userdata*u;
pa_assert(m);
if (!(u = m->userdata))
return;
if (u->services) {
struct service *s;
while ((s = pa_hashmap_first(u->services)))
service_free(s);
pa_hashmap_free(u->services, NULL, NULL);
}
if (u->sink_new_slot)
pa_hook_slot_free(u->sink_new_slot);
if (u->source_new_slot)
pa_hook_slot_free(u->source_new_slot);
if (u->sink_changed_slot)
pa_hook_slot_free(u->sink_changed_slot);
if (u->source_changed_slot)
pa_hook_slot_free(u->source_changed_slot);
if (u->sink_unlink_slot)
pa_hook_slot_free(u->sink_unlink_slot);
if (u->source_unlink_slot)
pa_hook_slot_free(u->source_unlink_slot);
if (u->main_entry_group)
avahi_entry_group_free(u->main_entry_group);
if (u->client)
avahi_client_free(u->client);
if (u->avahi_poll)
pa_avahi_poll_free(u->avahi_poll);
if (u->native)
pa_native_protocol_unref(u->native);
pa_xfree(u->service_name);
pa_xfree(u);
}
static void dns_service_register_reply(DNSServiceRef sdRef,
DNSServiceFlags flags,
DNSServiceErrorType errorCode,
const char *name,
const char *regtype,
const char *domain,
void *context) {
struct service *s = context;
pa_assert(s);
switch (errorCode) {
case kDNSServiceErr_NameConflict:
pa_log("DNS service reported kDNSServiceErr_NameConflict\n");
service_free(s);
break;
case kDNSServiceErr_NoError:
default:
break;
}
}
int
service_start(const char *name, int sock, service_limit_func_t *limitfunc,
service_command_func_t *commandfunc, int argc, char *argv[])
{
struct service *service;
struct service_connection *sconn, *sconntmp;
fd_set fds;
int maxfd, nfds, serrno;
assert(argc == 2);
pjdlog_init(PJDLOG_MODE_STD);
pjdlog_debug_set(atoi(argv[1]));
service = service_alloc(name, limitfunc, commandfunc);
if (service == NULL)
return (errno);
if (service_connection_add(service, sock, NULL) == NULL) {
serrno = errno;
service_free(service);
return (serrno);
}
for (;;) {
FD_ZERO(&fds);
maxfd = -1;
for (sconn = service_connection_first(service); sconn != NULL;
sconn = service_connection_next(sconn)) {
maxfd = fd_add(&fds, maxfd,
service_connection_get_sock(sconn));
}
PJDLOG_ASSERT(maxfd >= 0);
PJDLOG_ASSERT(maxfd + 1 <= (int)FD_SETSIZE);
nfds = select(maxfd + 1, &fds, NULL, NULL, NULL);
if (nfds < 0) {
if (errno != EINTR)
pjdlog_errno(LOG_ERR, "select() failed");
continue;
} else if (nfds == 0) {
/* Timeout. */
PJDLOG_ABORT("select() timeout");
continue;
}
for (sconn = service_connection_first(service); sconn != NULL;
sconn = sconntmp) {
/*
* Prepare for connection to be removed from the list
* on failure.
*/
sconntmp = service_connection_next(sconn);
if (FD_ISSET(service_connection_get_sock(sconn), &fds))
service_message(service, sconn);
}
if (service_connection_first(service) == NULL) {
/*
* No connections left, exiting.
*/
break;
}
}
return (0);
}
static int publish_service(struct service *s) {
int r = -1;
TXTRecordRef txt;
DNSServiceErrorType err;
const char *name = NULL, *t;
pa_proplist *proplist = NULL;
pa_sample_spec ss;
pa_channel_map map;
char cm[PA_CHANNEL_MAP_SNPRINT_MAX], tmp[64];
enum service_subtype subtype;
const char * const subtype_text[] = {
[SUBTYPE_HARDWARE] = "hardware",
[SUBTYPE_VIRTUAL] = "virtual",
[SUBTYPE_MONITOR] = "monitor"
};
pa_assert(s);
if (s->service) {
DNSServiceRefDeallocate(s->service);
s->service = NULL;
}
TXTRecordCreate(&txt, 0, NULL);
txt_record_server_data(s->userdata->core, &txt);
get_service_data(s, &ss, &map, &name, &proplist, &subtype);
TXTRecordSetValue(&txt, "device", strlen(name), name);
snprintf(tmp, sizeof(tmp), "%u", ss.rate);
TXTRecordSetValue(&txt, "rate", strlen(tmp), tmp);
snprintf(tmp, sizeof(tmp), "%u", ss.channels);
TXTRecordSetValue(&txt, "channels", strlen(tmp), tmp);
t = pa_sample_format_to_string(ss.format);
TXTRecordSetValue(&txt, "format", strlen(t), t);
t = pa_channel_map_snprint(cm, sizeof(cm), &map);
TXTRecordSetValue(&txt, "channel_map", strlen(t), t);
t = subtype_text[subtype];
TXTRecordSetValue(&txt, "subtype", strlen(t), t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_DESCRIPTION)))
TXTRecordSetValue(&txt, "description", strlen(t), t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_ICON_NAME)))
TXTRecordSetValue(&txt, "icon-name", strlen(t), t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_VENDOR_NAME)))
TXTRecordSetValue(&txt, "vendor-name", strlen(t), t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_PRODUCT_NAME)))
TXTRecordSetValue(&txt, "product-name", strlen(t), t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_CLASS)))
TXTRecordSetValue(&txt, "class", strlen(t), t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_FORM_FACTOR)))
TXTRecordSetValue(&txt, "form-factor", strlen(t), t);
err = DNSServiceRegister(&s->service,
0, /* flags */
kDNSServiceInterfaceIndexAny,
s->service_name,
pa_sink_isinstance(s->device) ? SERVICE_TYPE_SINK : SERVICE_TYPE_SOURCE,
NULL, /* domain */
NULL, /* host */
compute_port(s->userdata),
TXTRecordGetLength(&txt),
TXTRecordGetBytesPtr(&txt),
dns_service_register_reply, s);
if (err != kDNSServiceErr_NoError) {
pa_log("DNSServiceRegister() returned err %d", err);
goto finish;
}
pa_log_debug("Successfully registered Bonjour services for >%s<.", s->service_name);
return 0;
finish:
/* Remove this service */
if (r < 0)
service_free(s);
TXTRecordDeallocate(&txt);
return r;
}
static int publish_service(struct service *s) {
int r = -1;
AvahiStringList *txt = NULL;
const char *name = NULL, *t;
pa_proplist *proplist = NULL;
pa_sample_spec ss;
pa_channel_map map;
char cm[PA_CHANNEL_MAP_SNPRINT_MAX];
enum service_subtype subtype;
const char * const subtype_text[] = {
[SUBTYPE_HARDWARE] = "hardware",
[SUBTYPE_VIRTUAL] = "virtual",
[SUBTYPE_MONITOR] = "monitor"
};
pa_assert(s);
if (!s->userdata->client || avahi_client_get_state(s->userdata->client) != AVAHI_CLIENT_S_RUNNING)
return 0;
if (!s->entry_group) {
if (!(s->entry_group = avahi_entry_group_new(s->userdata->client, service_entry_group_callback, s))) {
pa_log("avahi_entry_group_new(): %s", avahi_strerror(avahi_client_errno(s->userdata->client)));
goto finish;
}
} else
avahi_entry_group_reset(s->entry_group);
txt = txt_record_server_data(s->userdata->core, txt);
get_service_data(s, &ss, &map, &name, &proplist, &subtype);
txt = avahi_string_list_add_pair(txt, "device", name);
txt = avahi_string_list_add_printf(txt, "rate=%u", ss.rate);
txt = avahi_string_list_add_printf(txt, "channels=%u", ss.channels);
txt = avahi_string_list_add_pair(txt, "format", pa_sample_format_to_string(ss.format));
txt = avahi_string_list_add_pair(txt, "channel_map", pa_channel_map_snprint(cm, sizeof(cm), &map));
txt = avahi_string_list_add_pair(txt, "subtype", subtype_text[subtype]);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_DESCRIPTION)))
txt = avahi_string_list_add_pair(txt, "description", t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_ICON_NAME)))
txt = avahi_string_list_add_pair(txt, "icon-name", t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_VENDOR_NAME)))
txt = avahi_string_list_add_pair(txt, "vendor-name", t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_PRODUCT_NAME)))
txt = avahi_string_list_add_pair(txt, "product-name", t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_CLASS)))
txt = avahi_string_list_add_pair(txt, "class", t);
if ((t = pa_proplist_gets(proplist, PA_PROP_DEVICE_FORM_FACTOR)))
txt = avahi_string_list_add_pair(txt, "form-factor", t);
if (avahi_entry_group_add_service_strlst(
s->entry_group,
AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
0,
s->service_name,
pa_sink_isinstance(s->device) ? SERVICE_TYPE_SINK : SERVICE_TYPE_SOURCE,
NULL,
NULL,
compute_port(s->userdata),
txt) < 0) {
pa_log("avahi_entry_group_add_service_strlst(): %s", avahi_strerror(avahi_client_errno(s->userdata->client)));
goto finish;
}
if (avahi_entry_group_add_service_subtype(
s->entry_group,
AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
0,
s->service_name,
pa_sink_isinstance(s->device) ? SERVICE_TYPE_SINK : SERVICE_TYPE_SOURCE,
NULL,
pa_sink_isinstance(s->device) ? (subtype == SUBTYPE_HARDWARE ? SERVICE_SUBTYPE_SINK_HARDWARE : SERVICE_SUBTYPE_SINK_VIRTUAL) :
(subtype == SUBTYPE_HARDWARE ? SERVICE_SUBTYPE_SOURCE_HARDWARE : (subtype == SUBTYPE_VIRTUAL ? SERVICE_SUBTYPE_SOURCE_VIRTUAL : SERVICE_SUBTYPE_SOURCE_MONITOR))) < 0) {
pa_log("avahi_entry_group_add_service_subtype(): %s", avahi_strerror(avahi_client_errno(s->userdata->client)));
goto finish;
}
if (pa_source_isinstance(s->device) && subtype != SUBTYPE_MONITOR) {
if (avahi_entry_group_add_service_subtype(
s->entry_group,
AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC,
0,
s->service_name,
SERVICE_TYPE_SOURCE,
NULL,
SERVICE_SUBTYPE_SOURCE_NON_MONITOR) < 0) {
pa_log("avahi_entry_group_add_service_subtype(): %s", avahi_strerror(avahi_client_errno(s->userdata->client)));
goto finish;
}
}
if (avahi_entry_group_commit(s->entry_group) < 0) {
pa_log("avahi_entry_group_commit(): %s", avahi_strerror(avahi_client_errno(s->userdata->client)));
goto finish;
}
r = 0;
pa_log_debug("Successfully created entry group for %s.", s->service_name);
finish:
/* Remove this service */
if (r < 0)
service_free(s);
avahi_string_list_free(txt);
return r;
}