/*
|
* BlueALSA - ctl.c
|
* Copyright (c) 2016-2018 Arkadiusz Bokowy
|
*
|
* This file is a part of bluez-alsa.
|
*
|
* This project is licensed under the terms of the MIT license.
|
*
|
*/
|
|
#define _GNU_SOURCE
|
#include "ctl.h"
|
|
#include <errno.h>
|
#include <poll.h>
|
#include <pthread.h>
|
#include <stdio.h>
|
#include <stdlib.h>
|
#include <string.h>
|
#include <unistd.h>
|
#include <sys/socket.h>
|
#include <sys/stat.h>
|
#include <sys/types.h>
|
#include <sys/un.h>
|
|
#include <glib.h>
|
|
#include "a2dp-codecs.h"
|
#include "bluealsa.h"
|
#include "bluez.h"
|
#include "hfp.h"
|
#include "transport.h"
|
#include "utils.h"
|
#include "shared/defs.h"
|
#include "shared/log.h"
|
|
|
/**
|
* Looks up a transport matching BT address and profile.
|
*
|
* This function is not thread-safe. It returns references to objects managed
|
* by the devices hash-table. If the devices hash-table is modified in some
|
* other thread, it may result in an undefined behavior.
|
*
|
* @param devices Address of the hash-table with connected devices.
|
* @param addr Address to the structure with the looked up BT address.
|
* @param type Looked up PCM type.
|
* @param stream Looked up PCM stream direction.
|
* @param t Address, where the transport structure pointer should be stored.
|
* @return If the lookup succeeded, this function returns 0. Otherwise, -1 or
|
* -2 is returned respectively for not found device and not found stream.
|
* Upon error value of the transport pointer is undefined. */
|
static int _transport_lookup(GHashTable *devices, const bdaddr_t *addr,
|
enum ba_pcm_type type, enum ba_pcm_stream stream, struct ba_transport **t) {
|
|
bool device_found = false;
|
GHashTableIter iter_d, iter_t;
|
struct ba_device *d;
|
|
for (g_hash_table_iter_init(&iter_d, devices);
|
g_hash_table_iter_next(&iter_d, NULL, (gpointer)&d); ) {
|
|
if (bacmp(&d->addr, addr) != 0)
|
continue;
|
|
device_found = true;
|
|
for (g_hash_table_iter_init(&iter_t, d->transports);
|
g_hash_table_iter_next(&iter_t, NULL, (gpointer)t); ) {
|
|
switch (type) {
|
case BA_PCM_TYPE_NULL:
|
continue;
|
case BA_PCM_TYPE_A2DP:
|
if ((*t)->type != TRANSPORT_TYPE_A2DP)
|
continue;
|
switch (stream) {
|
case BA_PCM_STREAM_PLAYBACK:
|
if ((*t)->profile != BLUETOOTH_PROFILE_A2DP_SOURCE)
|
continue;
|
break;
|
case BA_PCM_STREAM_CAPTURE:
|
if ((*t)->profile != BLUETOOTH_PROFILE_A2DP_SINK)
|
continue;
|
break;
|
case BA_PCM_STREAM_DUPLEX:
|
continue;
|
}
|
break;
|
case BA_PCM_TYPE_SCO:
|
if ((*t)->type != TRANSPORT_TYPE_SCO)
|
continue;
|
/* ignore SCO transport if codec is not selected yet */
|
if ((*t)->codec == HFP_CODEC_UNDEFINED)
|
continue;
|
break;
|
}
|
|
return 0;
|
}
|
|
}
|
|
return device_found ? -2 : -1;
|
}
|
|
static int _transport_lookup_rfcomm(GHashTable *devices, const bdaddr_t *addr,
|
struct ba_transport **t) {
|
|
GHashTableIter iter_d, iter_t;
|
struct ba_device *d;
|
|
for (g_hash_table_iter_init(&iter_d, devices);
|
g_hash_table_iter_next(&iter_d, NULL, (gpointer)&d); ) {
|
|
if (bacmp(&d->addr, addr) != 0)
|
continue;
|
|
for (g_hash_table_iter_init(&iter_t, d->transports);
|
g_hash_table_iter_next(&iter_t, NULL, (gpointer)t); ) {
|
|
if ((*t)->type != TRANSPORT_TYPE_RFCOMM)
|
continue;
|
|
return 0;
|
}
|
}
|
|
return -1;
|
}
|
|
/**
|
* Get transport PCM structure.
|
*
|
* @param t Pointer to the transport structure.
|
* @param stream Stream type.
|
* @return On success address of the PCM structure is returned. If the PCM
|
* structure can not be determined, NULL is returned. */
|
static struct ba_pcm *_transport_get_pcm(struct ba_transport *t, enum ba_pcm_stream stream) {
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
return &t->a2dp.pcm;
|
case TRANSPORT_TYPE_RFCOMM:
|
debug("Trying to get PCM for RFCOMM transport... that's nuts");
|
break;
|
case TRANSPORT_TYPE_SCO:
|
switch (stream) {
|
case BA_PCM_STREAM_PLAYBACK:
|
return &t->sco.spk_pcm;
|
case BA_PCM_STREAM_CAPTURE:
|
return &t->sco.mic_pcm;
|
case BA_PCM_STREAM_DUPLEX:
|
break;
|
}
|
}
|
return NULL;
|
}
|
|
/**
|
* Release transport resources acquired by the controller module. */
|
static void _transport_release_pcm(struct ba_transport *t, int client) {
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
transport_release_pcm(&t->a2dp.pcm);
|
t->a2dp.pcm.client = -1;
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
break;
|
case TRANSPORT_TYPE_SCO:
|
if (t->sco.spk_pcm.client == client) {
|
transport_release_pcm(&t->sco.spk_pcm);
|
t->sco.spk_pcm.client = -1;
|
}
|
if (t->sco.mic_pcm.client == client) {
|
transport_release_pcm(&t->sco.mic_pcm);
|
t->sco.mic_pcm.client = -1;
|
}
|
}
|
}
|
|
static void _ctl_transport(const struct ba_transport *t, struct ba_msg_transport *transport) {
|
|
bacpy(&transport->addr, &t->device->addr);
|
|
switch (t->type) {
|
case TRANSPORT_TYPE_A2DP:
|
transport->type = BA_PCM_TYPE_A2DP;
|
transport->stream = t->profile == BLUETOOTH_PROFILE_A2DP_SOURCE ?
|
BA_PCM_STREAM_PLAYBACK : BA_PCM_STREAM_CAPTURE;
|
transport->ch1_muted = t->a2dp.ch1_muted;
|
transport->ch1_volume = t->a2dp.ch1_volume;
|
transport->ch2_muted = t->a2dp.ch2_muted;
|
transport->ch2_volume = t->a2dp.ch2_volume;
|
transport->delay = t->a2dp.delay;
|
break;
|
case TRANSPORT_TYPE_RFCOMM:
|
transport->type = BA_PCM_TYPE_NULL;
|
break;
|
case TRANSPORT_TYPE_SCO:
|
transport->type = BA_PCM_TYPE_SCO;
|
transport->stream = BA_PCM_STREAM_DUPLEX;
|
transport->ch1_muted = t->sco.spk_muted;
|
transport->ch1_volume = t->sco.spk_gain;
|
transport->ch2_muted = t->sco.mic_muted;
|
transport->ch2_volume = t->sco.mic_gain;
|
transport->delay = 10;
|
break;
|
}
|
|
transport->codec = t->codec;
|
transport->channels = transport_get_channels(t);
|
transport->sampling = transport_get_sampling(t);
|
transport->delay += t->delay;
|
|
}
|
|
static void ctl_thread_cmd_ping(const struct ba_request *req, int fd) {
|
(void)req;
|
static const struct ba_msg_status status = { BA_STATUS_CODE_PONG };
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_subscribe(const struct ba_request *req, int fd) {
|
|
static const struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
size_t i;
|
|
for (i = __CTL_IDX_MAX; i < __CTL_IDX_MAX + BLUEALSA_MAX_CLIENTS; i++)
|
if (config.ctl.pfds[i].fd == fd)
|
config.ctl.subs[i - __CTL_IDX_MAX] = req->events;
|
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_list_devices(const struct ba_request *req, int fd) {
|
(void)req;
|
|
static const struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_msg_device device;
|
GHashTableIter iter_d;
|
struct ba_device *d;
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
for (g_hash_table_iter_init(&iter_d, config.devices);
|
g_hash_table_iter_next(&iter_d, NULL, (gpointer)&d); ) {
|
|
bacpy(&device.addr, &d->addr);
|
strncpy(device.name, d->name, sizeof(device.name) - 1);
|
device.name[sizeof(device.name) - 1] = '\0';
|
|
device.battery = d->battery.enabled;
|
device.battery_level = d->battery.level;
|
|
send(fd, &device, sizeof(device), MSG_NOSIGNAL);
|
}
|
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_list_transports(const struct ba_request *req, int fd) {
|
(void)req;
|
|
static const struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_msg_transport transport;
|
GHashTableIter iter_d, iter_t;
|
struct ba_device *d;
|
struct ba_transport *t;
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
for (g_hash_table_iter_init(&iter_d, config.devices);
|
g_hash_table_iter_next(&iter_d, NULL, (gpointer)&d); )
|
for (g_hash_table_iter_init(&iter_t, d->transports);
|
g_hash_table_iter_next(&iter_t, NULL, (gpointer)&t); ) {
|
/* ignore SCO transport if codec is not selected yet */
|
if (t->type == TRANSPORT_TYPE_SCO && t->codec == HFP_CODEC_UNDEFINED)
|
continue;
|
_ctl_transport(t, &transport);
|
send(fd, &transport, sizeof(transport), MSG_NOSIGNAL);
|
}
|
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_transport_get(const struct ba_request *req, int fd) {
|
|
struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_msg_transport transport;
|
struct ba_transport *t;
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
switch (_transport_lookup(config.devices, &req->addr, req->type, req->stream, &t)) {
|
case -1:
|
status.code = BA_STATUS_CODE_DEVICE_NOT_FOUND;
|
goto fail;
|
case -2:
|
status.code = BA_STATUS_CODE_STREAM_NOT_FOUND;
|
goto fail;
|
}
|
|
_ctl_transport(t, &transport);
|
send(fd, &transport, sizeof(transport), MSG_NOSIGNAL);
|
|
fail:
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_transport_set_volume(const struct ba_request *req, int fd) {
|
|
struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_transport *t;
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
switch (_transport_lookup(config.devices, &req->addr, req->type, req->stream, &t)) {
|
case -1:
|
status.code = BA_STATUS_CODE_DEVICE_NOT_FOUND;
|
goto fail;
|
case -2:
|
status.code = BA_STATUS_CODE_STREAM_NOT_FOUND;
|
goto fail;
|
}
|
|
transport_set_volume(t, req->ch1_muted, req->ch2_muted, req->ch1_volume, req->ch2_volume);
|
|
fail:
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_pcm_open(const struct ba_request *req, int fd) {
|
|
struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_transport *t;
|
struct ba_pcm *t_pcm;
|
int pipefd[2];
|
|
debug("PCM requested for %s type %d stream %d", batostr_(&req->addr), req->type, req->stream);
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
switch (_transport_lookup(config.devices, &req->addr, req->type, req->stream, &t)) {
|
case -1:
|
status.code = BA_STATUS_CODE_DEVICE_NOT_FOUND;
|
goto fail_lookup;
|
case -2:
|
status.code = BA_STATUS_CODE_STREAM_NOT_FOUND;
|
goto fail_lookup;
|
}
|
|
pthread_mutex_lock(&t->mutex);
|
|
if ((t_pcm = _transport_get_pcm(t, req->stream)) == NULL) {
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto final;
|
}
|
|
if (t_pcm->fd != -1) {
|
debug("PCM already requested: %d", t_pcm->fd);
|
status.code = BA_STATUS_CODE_DEVICE_BUSY;
|
goto final;
|
}
|
|
if (pipe(pipefd) == -1) {
|
error("Couldn't create FIFO: %s", strerror(errno));
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto final;
|
}
|
|
union {
|
char buf[CMSG_SPACE(sizeof(int))];
|
struct cmsghdr _align;
|
} control_un;
|
struct iovec io = { .iov_base = "", .iov_len = 1 };
|
struct msghdr msg = {
|
.msg_iov = &io,
|
.msg_iovlen = 1,
|
.msg_control = control_un.buf,
|
.msg_controllen = sizeof(control_un.buf),
|
};
|
|
struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg);
|
cmsg->cmsg_level = SOL_SOCKET;
|
cmsg->cmsg_type = SCM_RIGHTS;
|
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
|
int *fdptr = (int *)CMSG_DATA(cmsg);
|
|
switch (req->stream) {
|
case BA_PCM_STREAM_PLAYBACK:
|
t_pcm->fd = pipefd[0];
|
*fdptr = pipefd[1];
|
break;
|
case BA_PCM_STREAM_CAPTURE:
|
t_pcm->fd = pipefd[1];
|
*fdptr = pipefd[0];
|
break;
|
case BA_PCM_STREAM_DUPLEX:
|
debug("Invalid PCM stream type: %d", req->stream);
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto fail;
|
}
|
|
/* Notify our IO thread, that the FIFO has just been created - it may be
|
* used for poll() right away. */
|
transport_send_signal(t, TRANSPORT_PCM_OPEN);
|
|
/* A2DP source profile should be initialized (acquired) only if the audio
|
* is about to be transfered. It is most likely, that BT headset will not
|
* run voltage converter (power-on its circuit board) until the transport
|
* is acquired - in order to extend battery life. */
|
if (t->profile == BLUETOOTH_PROFILE_A2DP_SOURCE)
|
if (transport_acquire_bt_a2dp(t) == -1) {
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto fail;
|
}
|
|
if (sendmsg(fd, &msg, 0) == -1)
|
goto fail;
|
|
t_pcm->client = fd;
|
close(*fdptr);
|
goto final;
|
|
fail:
|
close(pipefd[0]);
|
close(pipefd[1]);
|
t_pcm->fd = -1;
|
|
final:
|
pthread_mutex_unlock(&t->mutex);
|
fail_lookup:
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_pcm_close(const struct ba_request *req, int fd) {
|
|
struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_transport *t;
|
struct ba_pcm *t_pcm;
|
|
debug("PCM close for %s type %d stream %d", batostr_(&req->addr), req->type, req->stream);
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
switch (_transport_lookup(config.devices, &req->addr, req->type, req->stream, &t)) {
|
case -1:
|
status.code = BA_STATUS_CODE_DEVICE_NOT_FOUND;
|
goto fail_lookup;
|
case -2:
|
status.code = BA_STATUS_CODE_STREAM_NOT_FOUND;
|
goto fail_lookup;
|
}
|
|
pthread_mutex_lock(&t->mutex);
|
|
if ((t_pcm = _transport_get_pcm(t, req->stream)) == NULL) {
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto fail;
|
}
|
|
if (t_pcm->client != fd) {
|
status.code = BA_STATUS_CODE_FORBIDDEN;
|
goto fail;
|
}
|
|
_transport_release_pcm(t, fd);
|
transport_send_signal(t, TRANSPORT_PCM_CLOSE);
|
|
fail:
|
pthread_mutex_unlock(&t->mutex);
|
fail_lookup:
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_pcm_control(const struct ba_request *req, int fd) {
|
|
struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_transport *t;
|
struct ba_pcm *t_pcm;
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
switch (_transport_lookup(config.devices, &req->addr, req->type, req->stream, &t)) {
|
case -1:
|
status.code = BA_STATUS_CODE_DEVICE_NOT_FOUND;
|
goto fail;
|
case -2:
|
status.code = BA_STATUS_CODE_STREAM_NOT_FOUND;
|
goto fail;
|
}
|
if ((t_pcm = _transport_get_pcm(t, req->stream)) == NULL) {
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto fail;
|
}
|
if (t_pcm->fd == -1 || t_pcm->client == -1) {
|
status.code = BA_STATUS_CODE_ERROR_UNKNOWN;
|
goto fail;
|
}
|
if (t_pcm->client != fd) {
|
status.code = BA_STATUS_CODE_FORBIDDEN;
|
goto fail;
|
}
|
|
switch (req->command) {
|
case BA_COMMAND_PCM_PAUSE:
|
transport_set_state(t, TRANSPORT_PAUSED);
|
transport_send_signal(t, TRANSPORT_PCM_PAUSE);
|
break;
|
case BA_COMMAND_PCM_RESUME:
|
transport_set_state(t, TRANSPORT_ACTIVE);
|
transport_send_signal(t, TRANSPORT_PCM_RESUME);
|
break;
|
case BA_COMMAND_PCM_DRAIN:
|
transport_drain_pcm(t);
|
break;
|
default:
|
warn("Invalid PCM control command: %d", req->command);
|
}
|
|
fail:
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void ctl_thread_cmd_rfcomm_send(const struct ba_request *req, int fd) {
|
|
struct ba_msg_status status = { BA_STATUS_CODE_SUCCESS };
|
struct ba_transport *t;
|
|
pthread_mutex_lock(&config.devices_mutex);
|
|
if (_transport_lookup_rfcomm(config.devices, &req->addr, &t) != 0) {
|
status.code = BA_STATUS_CODE_DEVICE_NOT_FOUND;
|
goto fail;
|
}
|
|
transport_send_rfcomm(t, req->rfcomm_command);
|
|
fail:
|
pthread_mutex_unlock(&config.devices_mutex);
|
send(fd, &status, sizeof(status), MSG_NOSIGNAL);
|
}
|
|
static void *ctl_thread(void *arg) {
|
(void)arg;
|
|
static void (*commands[__BA_COMMAND_MAX])(const struct ba_request *, int) = {
|
[BA_COMMAND_PING] = ctl_thread_cmd_ping,
|
[BA_COMMAND_SUBSCRIBE] = ctl_thread_cmd_subscribe,
|
[BA_COMMAND_LIST_DEVICES] = ctl_thread_cmd_list_devices,
|
[BA_COMMAND_LIST_TRANSPORTS] = ctl_thread_cmd_list_transports,
|
[BA_COMMAND_TRANSPORT_GET] = ctl_thread_cmd_transport_get,
|
[BA_COMMAND_TRANSPORT_SET_VOLUME] = ctl_thread_cmd_transport_set_volume,
|
[BA_COMMAND_PCM_OPEN] = ctl_thread_cmd_pcm_open,
|
[BA_COMMAND_PCM_CLOSE] = ctl_thread_cmd_pcm_close,
|
[BA_COMMAND_PCM_PAUSE] = ctl_thread_cmd_pcm_control,
|
[BA_COMMAND_PCM_RESUME] = ctl_thread_cmd_pcm_control,
|
[BA_COMMAND_PCM_DRAIN] = ctl_thread_cmd_pcm_control,
|
[BA_COMMAND_RFCOMM_SEND] = ctl_thread_cmd_rfcomm_send,
|
};
|
|
debug("Starting controller loop");
|
while (config.ctl.thread_created) {
|
|
if (poll(config.ctl.pfds, ARRAYSIZE(config.ctl.pfds), -1) == -1) {
|
if (errno == EINTR)
|
continue;
|
error("Controller poll error: %s", strerror(errno));
|
break;
|
}
|
|
/* Clients handling loop will update this variable to point to the
|
* first available client structure, which might be later used by
|
* the connection handling loop. */
|
struct pollfd *pfd = NULL;
|
size_t i;
|
|
/* handle data transmission with connected clients */
|
for (i = __CTL_IDX_MAX; i < __CTL_IDX_MAX + BLUEALSA_MAX_CLIENTS; i++) {
|
const int fd = config.ctl.pfds[i].fd;
|
|
if (fd == -1) {
|
pfd = &config.ctl.pfds[i];
|
continue;
|
}
|
|
if (config.ctl.pfds[i].revents & POLLIN) {
|
|
struct ba_request request;
|
ssize_t len;
|
|
if ((len = recv(fd, &request, sizeof(request), MSG_DONTWAIT)) != sizeof(request)) {
|
/* if the request cannot be retrieved, release resources */
|
|
if (len == 0)
|
debug("Client closed connection: %d", fd);
|
else
|
debug("Invalid request length: %zd != %zd", len, sizeof(request));
|
|
struct ba_transport *t;
|
if ((t = transport_lookup_pcm_client(config.devices, fd)) != NULL) {
|
_transport_release_pcm(t, fd);
|
transport_send_signal(t, TRANSPORT_PCM_CLOSE);
|
}
|
|
config.ctl.pfds[i].fd = -1;
|
config.ctl.subs[i - __CTL_IDX_MAX] = 0;
|
close(fd);
|
continue;
|
}
|
|
/* validate and execute requested command */
|
if (request.command < __BA_COMMAND_MAX && commands[request.command] != NULL)
|
commands[request.command](&request, fd);
|
else
|
warn("Invalid command: %u", request.command);
|
|
}
|
|
}
|
|
/* process new connections to our controller */
|
if (config.ctl.pfds[CTL_IDX_SRV].revents & POLLIN && pfd != NULL) {
|
|
struct pollfd fd = { -1, POLLIN, 0 };
|
uint16_t ver = 0;
|
|
fd.fd = accept(config.ctl.pfds[CTL_IDX_SRV].fd, NULL, NULL);
|
debug("Received new connection: %d", fd.fd);
|
|
errno = ETIMEDOUT;
|
if (poll(&fd, 1, 500) <= 0 ||
|
recv(fd.fd, &ver, sizeof(ver), MSG_DONTWAIT) != sizeof(ver)) {
|
warn("Couldn't receive protocol version: %s", strerror(errno));
|
close(fd.fd);
|
}
|
else if (ver != BLUEALSA_CRL_PROTO_VERSION) {
|
warn("Invalid protocol version: %#06x != %#06x", ver, BLUEALSA_CRL_PROTO_VERSION);
|
close(fd.fd);
|
}
|
else {
|
debug("New client accepted: %d", fd.fd);
|
pfd->fd = fd.fd;
|
}
|
|
}
|
|
/* generate notifications for subscribed clients */
|
if (config.ctl.pfds[CTL_IDX_EVT].revents & POLLIN) {
|
|
struct ba_msg_event event = { 0 };
|
size_t i;
|
|
if (read(config.ctl.pfds[CTL_IDX_EVT].fd, &event.mask, sizeof(event.mask)) == -1)
|
warn("Couldn't read controller event: %s", strerror(errno));
|
|
for (i = 0; i < BLUEALSA_MAX_CLIENTS; i++)
|
if (config.ctl.subs[i] & event.mask) {
|
const int client = config.ctl.pfds[i + __CTL_IDX_MAX].fd;
|
debug("Emitting notification: %B => %d", event.mask, client);
|
send(client, &event, sizeof(event), MSG_NOSIGNAL);
|
}
|
|
}
|
|
debug("+-+-");
|
}
|
|
debug("Exiting controller thread");
|
return NULL;
|
}
|
|
int bluealsa_ctl_thread_init(void) {
|
|
if (config.ctl.thread_created) {
|
/* thread is already created */
|
errno = EISCONN;
|
return -1;
|
}
|
|
{ /* initialize (mark as closed) all sockets */
|
size_t i;
|
for (i = 0; i < ARRAYSIZE(config.ctl.pfds); i++) {
|
config.ctl.pfds[i].events = POLLIN;
|
config.ctl.pfds[i].fd = -1;
|
}
|
}
|
|
struct sockaddr_un saddr = { .sun_family = AF_UNIX };
|
snprintf(saddr.sun_path, sizeof(saddr.sun_path) - 1,
|
BLUEALSA_RUN_STATE_DIR "/%s", config.hci_dev.name);
|
|
if (mkdir(BLUEALSA_RUN_STATE_DIR, 0755) == -1 && errno != EEXIST) {
|
error("Couldn't create run-state directory: %s", strerror(errno));
|
goto fail;
|
}
|
if ((config.ctl.pfds[CTL_IDX_SRV].fd = socket(PF_UNIX, SOCK_SEQPACKET, 0)) == -1) {
|
error("Couldn't create controller socket: %s", strerror(errno));
|
goto fail;
|
}
|
if (bind(config.ctl.pfds[CTL_IDX_SRV].fd, (struct sockaddr *)(&saddr), sizeof(saddr)) == -1) {
|
error("Couldn't bind controller socket: %s", strerror(errno));
|
goto fail;
|
}
|
config.ctl.socket_created = true;
|
if (chmod(saddr.sun_path, 0660) == -1 ||
|
chown(saddr.sun_path, -1, config.gid_audio) == -1) {
|
error("Couldn't set permission for controller socket: %s", strerror(errno));
|
goto fail;
|
}
|
if (listen(config.ctl.pfds[CTL_IDX_SRV].fd, 2) == -1) {
|
error("Couldn't listen on controller socket: %s", strerror(errno));
|
goto fail;
|
}
|
|
if (pipe(config.ctl.evt) == -1) {
|
error("Couldn't create controller event PIPE: %s", strerror(errno));
|
goto fail;
|
}
|
config.ctl.pfds[CTL_IDX_EVT].fd = config.ctl.evt[0];
|
|
config.ctl.thread_created = true;
|
if ((errno = pthread_create(&config.ctl.thread, NULL, ctl_thread, NULL)) != 0) {
|
error("Couldn't create controller thread: %s", strerror(errno));
|
config.ctl.thread_created = false;
|
goto fail;
|
}
|
|
/* name controller thread - for aesthetic purposes only */
|
pthread_setname_np(config.ctl.thread, "bactl");
|
|
return 0;
|
|
fail:
|
bluealsa_ctl_free();
|
return -1;
|
}
|
|
void bluealsa_ctl_free(void) {
|
|
int created = config.ctl.thread_created;
|
size_t i;
|
|
config.ctl.thread_created = false;
|
|
if (config.ctl.evt[0] != -1)
|
close(config.ctl.evt[0]);
|
if (config.ctl.evt[1] != -1)
|
close(config.ctl.evt[1]);
|
|
config.ctl.pfds[CTL_IDX_EVT].fd = -1;
|
for (i = 0; i < ARRAYSIZE(config.ctl.pfds); i++)
|
if (config.ctl.pfds[i].fd != -1)
|
close(config.ctl.pfds[i].fd);
|
|
if (created) {
|
pthread_cancel(config.ctl.thread);
|
if ((errno = pthread_join(config.ctl.thread, NULL)) != 0)
|
error("Couldn't join controller thread: %s", strerror(errno));
|
}
|
|
if (config.ctl.socket_created) {
|
char tmp[256] = BLUEALSA_RUN_STATE_DIR "/";
|
unlink(strcat(tmp, config.hci_dev.name));
|
config.ctl.socket_created = false;
|
}
|
|
}
|
|
int bluealsa_ctl_event(enum ba_event event) {
|
return write(config.ctl.evt[1], &event, sizeof(event));
|
}
|
