/* * *  BlueZ - Bluetooth protocol stack for Linux * *  Copyright (C) 2006-2007  Nokia Corporation *  Copyright (C) 2004-2008  Marcel Holtmann <marcel@holtmann.org> * * *  This program is free software; you can redistribute it and/or modify *  it under the terms of the GNU General Public License as published by *  the Free Software Foundation; either version 2 of the License, or *  (at your option) any later version. * *  This program is distributed in the hope that it will be useful, *  but WITHOUT ANY WARRANTY; without even the implied warranty of *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the *  GNU General Public License for more details. * *  You should have received a copy of the GNU General Public License *  along with this program; if not, write to the Free Software *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA * */#ifdef HAVE_CONFIG_H#include <config.h>#endif#include <stdio.h>#include <sys/socket.h>#include <sys/un.h>#include <stdlib.h>#include <errno.h>#include <unistd.h>#include <stdint.h>#include <bluetooth/bluetooth.h>#include <bluetooth/sdp.h>#include <dbus/dbus.h>#include <glib.h>#include "logging.h"#include "dbus.h"#include "ipc.h"#include "device.h"#include "manager.h"#include "avdtp.h"#include "a2dp.h"#include "headset.h"#include "sink.h"#include "unix.h"typedef enum {	TYPE_NONE,	TYPE_HEADSET,	TYPE_SINK,	TYPE_SOURCE} service_type_t;typedef void (*notify_cb_t) (struct device *dev, void *data);struct a2dp_data {	struct avdtp *session;	struct avdtp_stream *stream;	struct a2dp_sep *sep;};struct headset_data {	headset_lock_t lock;};struct unix_client {	struct device *dev;	GSList *caps;	service_type_t type;	char *interface;	union {		struct a2dp_data a2dp;		struct headset_data hs;	} d;	int sock;	int access_mode;	int data_fd; /* To be deleted once two phase configuration is fully implemented */	unsigned int req_id;	unsigned int cb_id;	gboolean (*cancel) (struct device *dev, unsigned int id);};static GSList *clients = NULL;static int unix_sock = -1;static void client_free(struct unix_client *client){	struct a2dp_data *a2dp;	switch (client->type) {	case TYPE_SINK:	case TYPE_SOURCE:		a2dp = &client->d.a2dp;		if (client->cb_id > 0)			avdtp_stream_remove_cb(a2dp->session, a2dp->stream,								client->cb_id);		if (a2dp->sep)			a2dp_sep_unlock(a2dp->sep, a2dp->session);		if (a2dp->session)			avdtp_unref(a2dp->session);		break;	default:		break;	}	if (client->sock >= 0)		close(client->sock);	if (client->caps) {		g_slist_foreach(client->caps, (GFunc) g_free, NULL);		g_slist_free(client->caps);	}	g_free(client->interface);	g_free(client);}/* Pass file descriptor through local domain sockets (AF_LOCAL, formerly * AF_UNIX) and the sendmsg() system call with the cmsg_type field of a "struct * cmsghdr" set to SCM_RIGHTS and the data being an integer value equal to the * handle of the file descriptor to be passed. */static int unix_sendmsg_fd(int sock, int fd){	char cmsg_b[CMSG_SPACE(sizeof(int))], m = 'm';	struct cmsghdr *cmsg;	struct iovec iov = { &m, sizeof(m) };	struct msghdr msgh;	memset(&msgh, 0, sizeof(msgh));	msgh.msg_iov = &iov;	msgh.msg_iovlen = 1;	msgh.msg_control = &cmsg_b;	msgh.msg_controllen = CMSG_LEN(sizeof(int));	cmsg = CMSG_FIRSTHDR(&msgh);	cmsg->cmsg_level = SOL_SOCKET;	cmsg->cmsg_type = SCM_RIGHTS;	cmsg->cmsg_len = CMSG_LEN(sizeof(int));	/* Initialize the payload */	(*(int *) CMSG_DATA(cmsg)) = fd;	return sendmsg(sock, &msgh, MSG_NOSIGNAL);}static void unix_ipc_sendmsg(struct unix_client *client,					const bt_audio_msg_header_t *msg){	info("Audio API: sending %s", bt_audio_strmsg(msg->msg_type));	if (send(client->sock, msg, BT_AUDIO_IPC_PACKET_SIZE, 0) < 0)		error("Error %s(%d)", strerror(errno), errno);}static void unix_ipc_error(struct unix_client *client, int type, int err){	char buf[BT_AUDIO_IPC_PACKET_SIZE];	bt_audio_rsp_msg_header_t *rsp_hdr = (void *) buf;	memset(buf, 0, sizeof(buf));	rsp_hdr->msg_h.msg_type = type;	rsp_hdr->posix_errno = err;	unix_ipc_sendmsg(client, &rsp_hdr->msg_h);}static service_type_t select_service(struct device *dev, const char *interface){	if (!interface) {		if (dev->sink && avdtp_is_connected(&dev->src, &dev->dst))			return TYPE_SINK;		else if (dev->headset && headset_is_active(dev))			return TYPE_HEADSET;		else if (dev->sink)			return TYPE_SINK;		else if (dev->headset)			return TYPE_HEADSET;	} else if (!strcmp(interface, AUDIO_SINK_INTERFACE) && dev->sink)		return TYPE_SINK;	else if (!strcmp(interface, AUDIO_HEADSET_INTERFACE) && dev->headset)		return TYPE_HEADSET;	return TYPE_NONE;}static void stream_state_changed(struct avdtp_stream *stream,					avdtp_state_t old_state,					avdtp_state_t new_state,					struct avdtp_error *err,					void *user_data){	struct unix_client *client = user_data;	struct a2dp_data *a2dp = &client->d.a2dp;	switch (new_state) {	case AVDTP_STATE_IDLE:		if (a2dp->sep) {			a2dp_sep_unlock(a2dp->sep, a2dp->session);			a2dp->sep = NULL;		}		client->dev = NULL;		if (a2dp->session) {			avdtp_unref(a2dp->session);			a2dp->session = NULL;		}		a2dp->stream = NULL;		client->cb_id = 0;		break;	default:		break;	}}static void headset_discovery_complete(struct device *dev, void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_getcapabilities_rsp *rsp = (void *) buf;	client->req_id = 0;	if (!dev)		goto failed;	memset(buf, 0, sizeof(buf));	rsp->rsp_h.msg_h.msg_type = BT_GETCAPABILITIES_RSP;	rsp->transport  = BT_CAPABILITIES_TRANSPORT_SCO;	rsp->sampling_rate = 8000;	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	return;failed:	error("discovery failed");	unix_ipc_error(client, BT_SETCONFIGURATION_RSP, EIO);	client->dev = NULL;}static void headset_setup_complete(struct device *dev, void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_setconfiguration_rsp *rsp = (void *) buf;	struct headset_data *hs = &client->d.hs;	client->req_id = 0;	if (!dev)		goto failed;	switch (client->access_mode) {	case BT_CAPABILITIES_ACCESS_MODE_READ:		hs->lock = HEADSET_LOCK_READ;		break;	case BT_CAPABILITIES_ACCESS_MODE_WRITE:		hs->lock = HEADSET_LOCK_WRITE;		break;	case BT_CAPABILITIES_ACCESS_MODE_READWRITE:		hs->lock = HEADSET_LOCK_READ | HEADSET_LOCK_WRITE;		break;	default:		hs->lock = 0;		break;	}	if (!headset_lock(dev, hs->lock)) {		error("Unable to lock headset");		goto failed;	}	memset(buf, 0, sizeof(buf));	rsp->rsp_h.msg_h.msg_type = BT_SETCONFIGURATION_RSP;	rsp->transport  = BT_CAPABILITIES_TRANSPORT_SCO;	rsp->access_mode = client->access_mode;	rsp->link_mtu = 48;	client->data_fd = headset_get_sco_fd(dev);	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	return;failed:	error("config failed");	unix_ipc_error(client, BT_SETCONFIGURATION_RSP, EIO);	client->dev = NULL;}static void headset_resume_complete(struct device *dev, void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_streamstart_rsp *rsp = (void *) buf;	struct bt_streamfd_ind *ind = (void *) buf;	client->req_id = 0;	if (!dev)		goto failed;	memset(buf, 0, sizeof(buf));	rsp->rsp_h.msg_h.msg_type = BT_STREAMSTART_RSP;	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	memset(buf, 0, sizeof(buf));	ind->h.msg_type = BT_STREAMFD_IND;	unix_ipc_sendmsg(client, &ind->h);	client->data_fd = headset_get_sco_fd(dev);	if (unix_sendmsg_fd(client->sock, client->data_fd) < 0) {		error("unix_sendmsg_fd: %s(%d)", strerror(errno), errno);		goto failed;	}	return;failed:	error("resume failed");	unix_ipc_error(client, BT_STREAMSTART_RSP, EIO);	client->dev = NULL;}static void a2dp_discovery_complete(struct avdtp *session, GSList *seps,					struct avdtp_error *err,					void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_getcapabilities_rsp *rsp = (void *) buf;	struct a2dp_data *a2dp = &client->d.a2dp;	struct sbc_codec_cap *sbc_cap = NULL;	struct mpeg_codec_cap *mpeg_cap = NULL;	GSList *l;	if (!g_slist_find(clients, client)) {		debug("Client disconnected during discovery");		return;	}	if (err)		goto failed;	memset(buf, 0, sizeof(buf));	client->req_id = 0;	rsp->rsp_h.msg_h.msg_type = BT_GETCAPABILITIES_RSP;	rsp->transport = BT_CAPABILITIES_TRANSPORT_A2DP;	for (l = seps; l; l = g_slist_next(l)) {		struct avdtp_remote_sep *rsep = l->data;		struct avdtp_service_capability *cap;		struct avdtp_media_codec_capability *codec_cap;		cap = avdtp_get_codec(rsep);		if (cap->category != AVDTP_MEDIA_CODEC)			continue;		codec_cap = (void *) cap->data;		if (codec_cap->media_codec_type == A2DP_CODEC_SBC && !sbc_cap)			sbc_cap = (void *) codec_cap;		if (codec_cap->media_codec_type == A2DP_CODEC_MPEG12 && !mpeg_cap)			mpeg_cap = (void *) codec_cap;	}	/* endianess prevent direct cast */	if (sbc_cap) {		rsp->sbc_capabilities.channel_mode = sbc_cap->channel_mode;		rsp->sbc_capabilities.frequency = sbc_cap->frequency;		rsp->sbc_capabilities.allocation_method = sbc_cap->allocation_method;		rsp->sbc_capabilities.subbands = sbc_cap->subbands;		rsp->sbc_capabilities.block_length = sbc_cap->block_length;		rsp->sbc_capabilities.min_bitpool = sbc_cap->min_bitpool;		rsp->sbc_capabilities.max_bitpool = sbc_cap->max_bitpool;	}	if (mpeg_cap) {		rsp->mpeg_capabilities.channel_mode = mpeg_cap->channel_mode;		rsp->mpeg_capabilities.crc = mpeg_cap->crc;		rsp->mpeg_capabilities.layer = mpeg_cap->layer;		rsp->mpeg_capabilities.frequency = mpeg_cap->frequency;		rsp->mpeg_capabilities.mpf = mpeg_cap->mpf;		rsp->mpeg_capabilities.bitrate = mpeg_cap->bitrate;	}	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	return;failed:	error("discovery failed");	unix_ipc_error(client, BT_GETCAPABILITIES_RSP, EIO);	avdtp_unref(a2dp->session);	a2dp->session = NULL;	a2dp->stream = NULL;}static void a2dp_config_complete(struct avdtp *session, struct a2dp_sep *sep,					struct avdtp_stream *stream,					struct avdtp_error *err,					void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_setconfiguration_rsp *rsp = (void *) buf;	struct a2dp_data *a2dp = &client->d.a2dp;	uint16_t imtu, omtu;	GSList *caps;	if (err)		goto failed;	memset(buf, 0, sizeof(buf));	client->req_id = 0;	if (!stream)		goto failed;	if (!a2dp_sep_lock(sep, session)) {		error("Unable to lock A2DP source SEP");		goto failed;	}	a2dp->sep = sep;	a2dp->stream = stream;	if (!avdtp_stream_get_transport(stream, &client->data_fd, &imtu, &omtu,					&caps)) {		error("Unable to get stream transport");		goto failed;	}	rsp->rsp_h.msg_h.msg_type = BT_SETCONFIGURATION_RSP;	rsp->transport = BT_CAPABILITIES_TRANSPORT_A2DP;	client->access_mode = BT_CAPABILITIES_ACCESS_MODE_WRITE;	rsp->access_mode = client->access_mode;	/* FIXME: Use imtu when fd_opt is CFG_FD_OPT_READ */	rsp->link_mtu = omtu;	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	client->cb_id = avdtp_stream_add_cb(session, stream,						stream_state_changed, client);	return;failed:	error("config failed");	if (a2dp->sep) {		a2dp_sep_unlock(a2dp->sep, a2dp->session);		a2dp->sep = NULL;	}	unix_ipc_error(client, BT_SETCONFIGURATION_RSP, EIO);	avdtp_unref(a2dp->session);	a2dp->session = NULL;	a2dp->stream = NULL;}static void a2dp_resume_complete(struct avdtp *session,				struct avdtp_error *err, void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_streamstart_rsp *rsp = (void *) buf;	struct bt_streamfd_ind *ind = (void *) buf;	struct a2dp_data *a2dp = &client->d.a2dp;	if (err)		goto failed;	memset(buf, 0, sizeof(buf));	rsp->rsp_h.msg_h.msg_type = BT_STREAMSTART_RSP;	rsp->rsp_h.posix_errno = 0;	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	memset(buf, 0, sizeof(buf));	ind->h.msg_type = BT_STREAMFD_IND;	unix_ipc_sendmsg(client, &ind->h);	if (unix_sendmsg_fd(client->sock, client->data_fd) < 0) {		error("unix_sendmsg_fd: %s(%d)", strerror(errno), errno);		goto failed;	}	return;failed:	error("resume failed");	if (a2dp->sep) {		a2dp_sep_unlock(a2dp->sep, a2dp->session);		a2dp->sep = NULL;	}	unix_ipc_error(client, BT_STREAMSTART_RSP, EIO);	avdtp_unref(a2dp->session);	a2dp->session = NULL;	a2dp->stream = NULL;}static void a2dp_suspend_complete(struct avdtp *session,				struct avdtp_error *err, void *user_data){	struct unix_client *client = user_data;	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_streamstart_rsp *rsp = (void *) buf;	struct a2dp_data *a2dp = &client->d.a2dp;	if (err)		goto failed;	memset(buf, 0, sizeof(buf));	rsp->rsp_h.msg_h.msg_type = BT_STREAMSTOP_RSP;	rsp->rsp_h.posix_errno = 0;	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);	return;failed:	error("suspend failed");	if (a2dp->sep) {		a2dp_sep_unlock(a2dp->sep, a2dp->session);		a2dp->sep = NULL;	}	unix_ipc_error(client, BT_STREAMSTOP_RSP, EIO);	avdtp_unref(a2dp->session);	a2dp->session = NULL;	a2dp->stream = NULL;}static void start_discovery(struct device *dev, struct unix_client *client){	struct a2dp_data *a2dp;	int err = 0;	client->type = select_service(dev, client->interface);	switch (client->type) {	case TYPE_SINK:		a2dp = &client->d.a2dp;		if (!a2dp->session)			a2dp->session = avdtp_get(&dev->src, &dev->dst);		if (!a2dp->session) {			error("Unable to get a session");			goto failed;		}		err = avdtp_discover(a2dp->session, a2dp_discovery_complete,					client);		if (err)			goto failed;		break;