case TYPE_HEADSET:		headset_discovery_complete(dev, client);		break;	default:		error("No known services for device");		goto failed;	}	client->dev = dev;	return;failed:	unix_ipc_error(client, BT_GETCAPABILITIES_RSP, err ? : EIO);}static void start_config(struct device *dev, struct unix_client *client){	struct a2dp_data *a2dp;	unsigned int id;	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;		}		id = a2dp_source_config(a2dp->session, a2dp_config_complete,					client->caps, client);		client->cancel = a2dp_source_cancel;		break;	case TYPE_HEADSET:		id = headset_request_stream(dev, headset_setup_complete, client);		client->cancel = headset_cancel_stream;		break;	default:		error("No known services for device");		goto failed;	}	if (id == 0) {		error("config failed");		goto failed;	}	client->req_id = id;	client->dev = dev;	return;failed:	unix_ipc_error(client, BT_SETCONFIGURATION_RSP, EIO);}static void start_resume(struct device *dev, struct unix_client *client){	struct a2dp_data *a2dp;	unsigned int id;	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;		}		if (!a2dp->sep) {			error("Unable to get a sep");			goto failed;		}		id = a2dp_source_resume(a2dp->session, a2dp->sep,					a2dp_resume_complete, client);		client->cancel = a2dp_source_cancel;		if (id == 0) {			error("resume failed");			goto failed;		}		break;	case TYPE_HEADSET:		headset_resume_complete(dev, client);		break;	default:		error("No known services for device");		goto failed;	}	return;failed:	unix_ipc_error(client, BT_STREAMSTART_RSP, EIO);}static void start_suspend(struct device *dev, struct unix_client *client){	struct a2dp_data *a2dp;	unsigned int id;	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;		}		if (!a2dp->sep) {			error("Unable to get a sep");			goto failed;		}		id = a2dp_source_suspend(a2dp->session, a2dp->sep,					a2dp_suspend_complete, client);		client->cancel = a2dp_source_cancel;		break;	case TYPE_HEADSET:		id = headset_request_stream(dev, headset_setup_complete, client);		client->cancel = headset_cancel_stream;		break;	default:		error("No known services for device");		goto failed;	}	if (id == 0) {		error("suspend failed");		goto failed;	}	return;failed:	unix_ipc_error(client, BT_STREAMSTOP_RSP, EIO);}static void create_cb(struct device *dev, void *user_data){	struct unix_client *client = user_data;	if (!dev)		unix_ipc_error(client, BT_GETCAPABILITIES_RSP, EIO);	else		start_discovery(dev, client);}static void handle_getcapabilities_req(struct unix_client *client,					struct bt_getcapabilities_req *req){	struct device *dev;	bdaddr_t bdaddr;	str2ba(req->device, &bdaddr);	if (client->interface) {		g_free(client->interface);		client->interface = NULL;	}	if (req->transport == BT_CAPABILITIES_TRANSPORT_SCO)		client->interface = g_strdup(AUDIO_HEADSET_INTERFACE);	else if (req->transport == BT_CAPABILITIES_TRANSPORT_A2DP)		client->interface = g_strdup(AUDIO_SINK_INTERFACE);	if (!manager_find_device(&bdaddr, NULL, FALSE)) {		if (!(req->flags & BT_FLAG_AUTOCONNECT))			goto failed;		if (!bacmp(&bdaddr, BDADDR_ANY))			goto failed;		if (!manager_create_device(&bdaddr, create_cb, client))			goto failed;		return;	}	dev = manager_find_device(&bdaddr, client->interface, TRUE);	if (!dev) {		if (req->flags & BT_FLAG_AUTOCONNECT)			dev = manager_find_device(&bdaddr, client->interface, FALSE);		else			goto failed;	}	if (!dev)		goto failed;	start_discovery(dev, client);	return;failed:	unix_ipc_error(client, BT_GETCAPABILITIES_RSP, EIO);}static int handle_sco_transport(struct unix_client *client,				struct bt_setconfiguration_req *req){	client->interface = g_strdup(AUDIO_HEADSET_INTERFACE);	info("config sco - device = %s access_mode = %u", req->device,			req->access_mode);	return 0;}static int handle_a2dp_transport(struct unix_client *client,				struct bt_setconfiguration_req *req){	struct avdtp_service_capability *media_transport, *media_codec;	struct sbc_codec_cap sbc_cap;	struct mpeg_codec_cap mpeg_cap;	client->interface = g_strdup(AUDIO_SINK_INTERFACE);	if (client->caps) {		g_slist_foreach(client->caps, (GFunc) g_free, NULL);		g_slist_free(client->caps);	}	media_transport = avdtp_service_cap_new(AVDTP_MEDIA_TRANSPORT,						NULL, 0);	client->caps = g_slist_append(client->caps, media_transport);	info("config a2dp - device = %s access_mode = %u", req->device,			req->access_mode);	if (req->mpeg_capabilities.frequency) {		memset(&mpeg_cap, 0, sizeof(mpeg_cap));		mpeg_cap.cap.media_type = AVDTP_MEDIA_TYPE_AUDIO;		mpeg_cap.cap.media_codec_type = A2DP_CODEC_MPEG12;		mpeg_cap.channel_mode = req->mpeg_capabilities.channel_mode;		mpeg_cap.crc = req->mpeg_capabilities.crc;		mpeg_cap.layer = req->mpeg_capabilities.layer;		mpeg_cap.frequency = req->mpeg_capabilities.frequency;		mpeg_cap.mpf = req->mpeg_capabilities.mpf;		mpeg_cap.bitrate = req->mpeg_capabilities.bitrate;		media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &mpeg_cap,							sizeof(mpeg_cap));		info("codec mpeg12 - frequency = %u channel_mode = %u "			"layer = %u crc = %u mpf = %u bitrate = %u",			mpeg_cap.frequency, mpeg_cap.channel_mode,			mpeg_cap.layer, mpeg_cap.crc, mpeg_cap.mpf,			mpeg_cap.bitrate);	} else if (req->sbc_capabilities.frequency) {		memset(&sbc_cap, 0, sizeof(sbc_cap));		sbc_cap.cap.media_type = AVDTP_MEDIA_TYPE_AUDIO;		sbc_cap.cap.media_codec_type = A2DP_CODEC_SBC;		sbc_cap.channel_mode = req->sbc_capabilities.channel_mode;		sbc_cap.frequency = req->sbc_capabilities.frequency;		sbc_cap.allocation_method = req->sbc_capabilities.allocation_method;		sbc_cap.subbands = req->sbc_capabilities.subbands;		sbc_cap.block_length = req->sbc_capabilities.block_length;		sbc_cap.min_bitpool = req->sbc_capabilities.min_bitpool;		sbc_cap.max_bitpool = req->sbc_capabilities.max_bitpool;		media_codec = avdtp_service_cap_new(AVDTP_MEDIA_CODEC, &sbc_cap,							sizeof(sbc_cap));		info("codec sbc - frequency = %u channel_mode = %u "			"allocation = %u subbands = %u blocks = %u "			"bitpool = %u", sbc_cap.frequency,			sbc_cap.channel_mode, sbc_cap.allocation_method,			sbc_cap.subbands, sbc_cap.block_length,			sbc_cap.max_bitpool);	} else		return -EINVAL;	client->caps = g_slist_append(client->caps, media_codec);	return 0;}static void handle_setconfiguration_req(struct unix_client *client,					struct bt_setconfiguration_req *req){	struct device *dev;	bdaddr_t bdaddr;	int err = 0;	if (!req->access_mode) {		err = EINVAL;		goto failed;	}	str2ba(req->device, &bdaddr);	if (client->interface) {		g_free(client->interface);		client->interface = NULL;	}	if (req->transport == BT_CAPABILITIES_TRANSPORT_SCO) {		err = handle_sco_transport(client, req);		if (err < 0) {			err = -err;			goto failed;		}	} else if (req->transport == BT_CAPABILITIES_TRANSPORT_A2DP) {		err = handle_a2dp_transport(client, req);		if (err < 0) {			err = -err;			goto failed;		}	}	if (!manager_find_device(&bdaddr, NULL, FALSE)) {		if (!bacmp(&bdaddr, BDADDR_ANY))			goto failed;		if (!manager_create_device(&bdaddr, create_cb, client))			goto failed;		return;	}	dev = manager_find_device(&bdaddr, client->interface, TRUE);	if (!dev)		dev = manager_find_device(&bdaddr, client->interface, FALSE);	if (!dev)		goto failed;	client->access_mode = req->access_mode;	start_config(dev, client);	return;failed:	unix_ipc_error(client, BT_SETCONFIGURATION_RSP, err ? : EIO);}static void handle_streamstart_req(struct unix_client *client,					struct bt_streamstart_req *req){	if (!client->dev)		goto failed;	start_resume(client->dev, client);	return;failed:	unix_ipc_error(client, BT_STREAMSTART_REQ, EIO);}static void handle_streamstop_req(struct unix_client *client,					struct bt_streamstop_req *req){	if (!client->dev)		goto failed;	start_suspend(client->dev, client);	return;failed:	unix_ipc_error(client, BT_STREAMSTOP_REQ, EIO);}static void handle_control_req(struct unix_client *client,					struct bt_control_req *req){	/* FIXME: really implement that */	char buf[BT_AUDIO_IPC_PACKET_SIZE];	struct bt_setconfiguration_rsp *rsp = (void *) buf;	memset(buf, 0, sizeof(buf));	rsp->rsp_h.msg_h.msg_type = BT_CONTROL_RSP;	rsp->rsp_h.posix_errno = 0;	unix_ipc_sendmsg(client, &rsp->rsp_h.msg_h);}static gboolean client_cb(GIOChannel *chan, GIOCondition cond, gpointer data){	char buf[BT_AUDIO_IPC_PACKET_SIZE];	bt_audio_msg_header_t *msghdr = (void *) buf;	struct unix_client *client = data;	int len;	struct a2dp_data *a2dp = &client->d.a2dp;	struct headset_data *hs = &client->d.hs;	const char *type;	if (cond & G_IO_NVAL)		return FALSE;	if (cond & (G_IO_HUP | G_IO_ERR)) {		debug("Unix client disconnected (fd=%d)", client->sock);		switch (client->type) {		case TYPE_HEADSET:			if (client->dev)				headset_unlock(client->dev, hs->lock);			break;		case TYPE_SOURCE:		case TYPE_SINK:			if (a2dp->sep) {				a2dp_sep_unlock(a2dp->sep, a2dp->session);				a2dp->sep = NULL;			}			break;		default:			break;		}		if (client->cancel && client->req_id > 0)			client->cancel(client->dev, client->req_id);		goto failed;	}	memset(buf, 0, sizeof(buf));	len = recv(client->sock, buf, sizeof(buf), MSG_WAITALL);	if (len < 0) {		error("recv: %s (%d)", strerror(errno), errno);		goto failed;	}	if ((type = bt_audio_strmsg(msghdr->msg_type)))		info("Audio API: received %s", type);	switch (msghdr->msg_type) {	case BT_GETCAPABILITIES_REQ:		handle_getcapabilities_req(client,				(struct bt_getcapabilities_req *) msghdr);		break;	case BT_SETCONFIGURATION_REQ:		handle_setconfiguration_req(client,				(struct bt_setconfiguration_req *) msghdr);		break;	case BT_STREAMSTART_REQ:		handle_streamstart_req(client,				(struct bt_streamstart_req *) msghdr);		break;	case BT_STREAMSTOP_REQ:		handle_streamstop_req(client,				(struct bt_streamstop_req *) msghdr);		break;	case BT_CONTROL_REQ:		handle_control_req(client,				(struct bt_control_req *) msghdr);		break;	default:		error("Audio API: received unexpected packet type %d",				msghdr->msg_type);	}	return TRUE;failed:	clients = g_slist_remove(clients, client);	client_free(client);	return FALSE;}static gboolean server_cb(GIOChannel *chan, GIOCondition cond, gpointer data){	struct sockaddr_un addr;	socklen_t addrlen;	int sk, cli_sk;	struct unix_client *client;	GIOChannel *io;	if (cond & G_IO_NVAL)		return FALSE;	if (cond & (G_IO_HUP | G_IO_ERR)) {		g_io_channel_close(chan);		return FALSE;	}	sk = g_io_channel_unix_get_fd(chan);	memset(&addr, 0, sizeof(addr));	addrlen = sizeof(addr);	cli_sk = accept(sk, (struct sockaddr *) &addr, &addrlen);	if (cli_sk < 0) {		error("accept: %s (%d)", strerror(errno), errno);		return TRUE;	}	debug("Accepted new client connection on unix socket (fd=%d)", cli_sk);	client = g_new0(struct unix_client, 1);	client->sock = cli_sk;	clients = g_slist_append(clients, client);	io = g_io_channel_unix_new(cli_sk);	g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,							client_cb, client);	g_io_channel_unref(io);	return TRUE;}int unix_init(void){	GIOChannel *io;	struct sockaddr_un addr = {		AF_UNIX, BT_IPC_SOCKET_NAME	};	int sk, err;	sk = socket(PF_LOCAL, SOCK_STREAM, 0);	if (sk < 0) {		err = errno;		error("Can't create unix socket: %s (%d)", strerror(err), err);		return -err;	}	if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {		error("Can't bind unix socket: %s (%d)", strerror(errno),				errno);		close(sk);		return -1;	}	set_nonblocking(sk);	unix_sock = sk;	listen(sk, 1);	io = g_io_channel_unix_new(sk);	g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,							server_cb, NULL);	g_io_channel_unref(io);	info("Unix socket created: %d", sk);	return 0;}void unix_exit(void){	g_slist_foreach(clients, (GFunc) client_free, NULL);	g_slist_free(clients);	close(unix_sock);	unix_sock = -1;}