daemon.c

linux蓝牙剖面实现

/*
 *
 *  Headset Profile support for Linux
 *
 *  Copyright (C) 2006  Fabien Chevalier
 *
 *  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
 *
 */

#include <sys/socket.h>
#include <sys/un.h>
#include <fcntl.h>
#include <unistd.h>
#include <signal.h>
#include <errno.h>
#include <syslog.h>
#include <assert.h>

#include <bluetooth/bluetooth.h>
#include <bluetooth/rfcomm.h>
#include <bluetooth/sdp.h>
#include <bluetooth/sdp_lib.h>

#include <config.h>
#include "daemon.h"
#include "sdp.h"
#include "volctl.h"

/* Local defines */
#define PCM_SERVER_SOCKET "\0bluez-headset-pcm"
#define CTL_SERVER_SOCKET "\0bluez-headset-ctl"

/* Local data */
volatile sig_atomic_t terminate = 0;
static   sdp_session_t *sdp_session;

/* Local functions declaration */
static void daemon_checkNewState  (struct Daemon *this);
static int  daemon_dispatchEvents (struct Daemon *this, const short revents[], int pollrvalue);

static void sig_term(int sig);

/* Functions definitions */

int createDaemon(struct Daemon* this)
{
	this->_cur_state     = &HeadsetIdleState;

	openlog("headsetd", LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_DAEMON);
	syslog(LOG_INFO, "Bluetooth headset daemon version " VERSION);

	/* Initialising Applicative PCM server socket */
	int _appl_srv_sockfd = socket(PF_LOCAL, SOCK_STREAM, 0);  
  	if(_appl_srv_sockfd < 0)
  	{
    		syslog(LOG_ERR, "socket(_appl_srv_sockfd): %s", strerror(errno));
    		return -1;
  	}

	struct sockaddr_un  pcm_srv_sock = {
		AF_UNIX, PCM_SERVER_SOCKET
	};
	if(bind(_appl_srv_sockfd, (struct sockaddr *)&pcm_srv_sock, sizeof(pcm_srv_sock)) != 0) {
    		syslog(LOG_ERR, "bind(_appl_srv_sockfd): %s", strerror(errno));
		goto error;	
	}
  
	/* Set socket as non blocking */
	if(fcntl(_appl_srv_sockfd, F_SETFL, O_NONBLOCK) < 0) {
    		syslog(LOG_ERR, "fcntl(_appl_srv_sockfd): %s", strerror(errno));
		goto error;	
	}
	listen(_appl_srv_sockfd, 1);

	/* Initialising Applicative CTL server socket */
	int _appl_ctlsrv_sockfd = socket(PF_LOCAL, SOCK_DGRAM, 0);  
  	if(_appl_ctlsrv_sockfd < 0)
  	{
    		syslog(LOG_ERR, "socket(_appl_ctlsrv_sockfd): %s", strerror(errno));
    		goto error;
  	}

	struct sockaddr_un  ctl_srv_sock = {
		AF_UNIX, CTL_SERVER_SOCKET
	};
	if(bind(_appl_ctlsrv_sockfd, (struct sockaddr *)&ctl_srv_sock, sizeof(ctl_srv_sock)) != 0) {
    		syslog(LOG_ERR, "bind(_appl_ctlsrv_sockfd): %s", strerror(errno));
		goto error2;	
	}
  
	/* Set socket as non blocking */
	if(fcntl(_appl_ctlsrv_sockfd, F_SETFL, O_NONBLOCK) < 0) {
    		syslog(LOG_ERR, "fcntl(_appl_srv_sockfd): %s", strerror(errno));
		goto error2;	
	}
	listen(_appl_ctlsrv_sockfd, 1);

	/* Initialising RFCOMM server socket */
	int _rfcomm_srv_sockfd = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
  	if(_rfcomm_srv_sockfd < 0)
  	{
    		syslog(LOG_ERR, "socket(_rfcomm_srv_sockfd): %s", strerror(errno));
		goto error2;	
  	}

	struct sockaddr_rc socka;
	socka.rc_family  = AF_BLUETOOTH;
	socka.rc_channel = 1;
	socka.rc_bdaddr  = *BDADDR_ANY;
	/* We loop until we find a free channel to bind to */
	int rfcomm_channel;
	for(rfcomm_channel = 0; (rfcomm_channel == 0) && (socka.rc_channel <= 31); socka.rc_channel += 2) {
		if(bind(_rfcomm_srv_sockfd, (struct sockaddr *)&socka, sizeof(socka)) == 0) {
			rfcomm_channel = socka.rc_channel;
		}
		else if(errno != EADDRINUSE) {
			syslog(LOG_ERR, "bind(_rfcomm_srv_sockfd): %s", strerror(errno));
			goto error3;	
		}
	}
  
	/* Set socket as non blocking */
	if(fcntl(_rfcomm_srv_sockfd, F_SETFL, O_NONBLOCK) < 0) {
    		syslog(LOG_ERR, "fcntl(_rfcomm_srv_sockfd): %s", strerror(errno));
		goto error3;	
	}
	listen(_rfcomm_srv_sockfd, 1);

	/* registering sdp record */
	if((sdp_session = sdp_headset_register(rfcomm_channel)) == 0) {
		goto error3;
	}

	/* FROM THIS POINT WE KNOW WE ARE GOOD */
	hspd_sockets[IDX_PCM_APPL_SRV_SOCK] = _appl_srv_sockfd;
	hspd_sockets[IDX_CTL_APPL_SRV_SOCK] = _appl_ctlsrv_sockfd;
	hspd_sockets[IDX_RFCOMM_SRV_SOCK] = _rfcomm_srv_sockfd;

	/* enter idle state */
	HeadsetIdleState.enter(&HeadsetIdleState);

	/* Initialising signal handlers */
	struct sigaction sa;
	/* setup sigterm handler. we must make sure to do a clean disconnect */
	memset(&sa, 0, sizeof(sa));
	sa.sa_flags = SA_NOCLDSTOP;
	sa.sa_handler = sig_term;
	sigaction(SIGTERM, &sa, NULL);
	sigaction(SIGINT, &sa, NULL);

	return 0;	

error3:
	close(_rfcomm_srv_sockfd);
error2:
	close(_appl_ctlsrv_sockfd);
error:
	close(_appl_srv_sockfd);
	return -1;
}

static int daemon_dispatchEvents (struct Daemon *this, const short revents_tbl[], int pollrvalue)
{
	short revents;
	const int USLEEP_VALUE = 100000;

	/* Checking if we have been interrupted */
	if(terminate) {
		/* exit from loop */
		return 1;
	}

	/* Checking if timeout */
	if (pollrvalue == 0) {
		struct State *s = this->_cur_state;
		if(s->timedout) {
			s->timedout(s);
			daemon_checkNewState(this);
		}
		else {
	    		syslog(LOG_ERR, "unexpected Timeout happened in state %s", s->name);
		}
		return 0;
	}

	revents = revents_tbl[IDX_CTL_APPL_SRV_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		s->readCtlAppl(s, revents);
		return 0;
	}
	revents = revents_tbl[IDX_PCM_APPL_SRV_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		if(s->handleApplConnReq) {
			s->handleApplConnReq(s);
			daemon_checkNewState(this);
		}
		else {
	    		syslog(LOG_ERR, "unexpected event handleApplConnReq received in state %s", s->name);
			/* Ending up here means there is a bug, and we have a very high chance
			to end up looping on this forever. So we sleep a bit to avoid eating
			100 % CPU */
			usleep(USLEEP_VALUE);
		}
		return 0;
	}
	revents = revents_tbl[IDX_RFCOMM_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		if(s->readRfcomm) {
			s->readRfcomm(s, revents);
			daemon_checkNewState(this);
		}
		else {
			syslog(LOG_ERR, "unexpected event readRfcomm received in state %s",
				s->name);
			/* Ending up here means there is a bug, and we have a very high chance
			to end up looping on this forever. So we sleep a bit to avoid eating
			100 % CPU */
			usleep(USLEEP_VALUE);
		}
		return 0;
	}
	revents = revents_tbl[IDX_PCM_APPL_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		if(s->readPcmAppl) {
			s->readPcmAppl(s, revents);
			daemon_checkNewState(this);
		}
		else {
			syslog(LOG_ERR, "unexpected event readPcmAppl received in state %s",
				s->name);
			/* Ending up here means there is a bug, and we have a very high chance
			to end up looping on this forever. So we sleep a bit to avoid eating
			100 % CPU */
			usleep(USLEEP_VALUE);
		}
		return 0;
	}
	revents = revents_tbl[IDX_SCO_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		if(s->readSco) {
			s->readSco(s, revents);
			daemon_checkNewState(this);
		}
		else {
			syslog(LOG_ERR, "unexpected event readSco received in state %s",
				s->name);
			/* Ending up here means there is a bug, and we have a very high chance
			to end up looping on this forever. So we sleep a bit to avoid eating
			100 % CPU */
			usleep(USLEEP_VALUE);
		}
		return 0;
	}
	revents = revents_tbl[IDX_RFCOMM_SRV_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		if(s->handleRfcommConnReq) {
			s->handleRfcommConnReq(s);
			daemon_checkNewState(this);
		}
		else {
			syslog(LOG_ERR, "unexpected event handleRfcommConnReq received in state %s",
				s->name);
			/* Ending up here means there is a bug, and we have a very high chance
			to end up looping on this forever. So we sleep a bit to avoid eating
			100 % CPU */
			usleep(USLEEP_VALUE);
		}
		return 0;
	}
	revents = revents_tbl[IDX_SDP_SOCK];
	if(revents) {
		struct State *s = this->_cur_state;
		if(s->readSdp) {
			s->readSdp(s, revents);
			daemon_checkNewState(this);
		}
		else {
			syslog(LOG_ERR, "unexpected event handleRfcommConnReq received in state %s",
				s->name);
			/* Ending up here means there is a bug, and we have a very high chance
			to end up looping on this forever. So we sleep a bit to avoid eating
			100 % CPU */
			usleep(USLEEP_VALUE);
		}
		return 0;
	}

	return 0;
}

void daemon_checkNewState  (struct Daemon *this)
{
	struct State *s = this->_cur_state;
	struct State *new = s->getNextState(s);
	this->_cur_state = new;
	if(new != s) {
		syslog(LOG_INFO, "Changing state: %s-->%s", s->name, new->name);
		if(new->enter) {
			new->enter(new);
			/* Transitionnal states may change their state in enter method,
			   so we have to check recursively */
			daemon_checkNewState(this);
		}
	}
}

void daemon_enterLoop(struct Daemon *this)
{
	int done;
	int timeout;
	int ret;
	int i;
	nfds_t poll_nfds;
	struct pollfd pollfds[DAEMON_NUM_SOCKS];
	short revents[DAEMON_NUM_SOCKS];
	do {
		struct State *s = this->_cur_state;
		/* Getting timeout */
		if(s->getTimeout) {
			timeout = s->getTimeout(s);
		}
		else {
			timeout = -1;
		}
		/* Getting file descriptors to poll on */
		poll_nfds = 0;
		for(i = 0; i < DAEMON_NUM_SOCKS; i++) {
		#ifndef NDEBUG	
			/* This may indicate an error, but not always - as such, we disable this
			   warning for release */
			if(hspd_sockets[i] == 0 && s->pollEvents[i] != 0) {
				fprintf(stderr, "WARNING: polling on non existent socket idx=%d\n", i);
			}
		#endif
			if(s->pollEvents[i] != 0) {
				pollfds[poll_nfds].fd     = hspd_sockets[i];
				pollfds[poll_nfds].events = s->pollEvents[i];
				poll_nfds++;
			}
		}

		ret  = poll(pollfds, poll_nfds, timeout);

		/* Putting return events in order */
		poll_nfds = 0;
		for(i = 0; i < DAEMON_NUM_SOCKS; i++) {
			if(s->pollEvents[i] == 0) {
				revents[i] = 0;
			}
			else {
				revents[i] = pollfds[poll_nfds].revents;
				poll_nfds++;
			}
		}

		done = daemon_dispatchEvents(this, revents, ret);
	} while (!done);
}

void daemon_destroy(struct Daemon *this)
{
	syslog(LOG_INFO, "exiting cleanly");
	if(hspd_sockets[IDX_PCM_APPL_SOCK] > 0 ) {
		close(hspd_sockets[IDX_PCM_APPL_SOCK]);
		hspd_sockets[IDX_PCM_APPL_SOCK] = 0;
	}
	if(hspd_sockets[IDX_SCO_SOCK] > 0 ) {
		close(hspd_sockets[IDX_SCO_SOCK]);
		hspd_sockets[IDX_SCO_SOCK] = 0;
	}
	if(hspd_sockets[IDX_RFCOMM_SOCK] > 0 ) {
		close(hspd_sockets[IDX_RFCOMM_SOCK]);
		hspd_sockets[IDX_RFCOMM_SOCK] = 0;
	}
	close(hspd_sockets[IDX_PCM_APPL_SRV_SOCK]);
	hspd_sockets[IDX_PCM_APPL_SRV_SOCK] = 0;
	close(hspd_sockets[IDX_CTL_APPL_SRV_SOCK]);
	hspd_sockets[IDX_CTL_APPL_SRV_SOCK] = 0;
	close(hspd_sockets[IDX_RFCOMM_SRV_SOCK]);
	hspd_sockets[IDX_RFCOMM_SRV_SOCK] = 0;
	sdp_close(sdp_session);
	sdp_session = 0;
	volctl_release();
}

static void sig_term(int sig)
{
	terminate = 1;
}