int bluesnarfer(struct opt options) {
FILE *fd;
signal(SIGINT, (void *)bt_rfcomm_rel);
signal(SIGSEGV, (void *)bt_rfcomm_rel);
if ((device = hci_for_each_dev(HCI_UP, 0x00, 0)) < 0 )
fprintf(stderr, "bluesnarfer: hci_for_each_dev , %s\n", strerror(errno));
if ( bt_get_remote_name(options.bd_addr) < 0 )
fprintf(stderr, "bluesnarfer: unable to get device name\n");
if ((ctl = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_RFCOMM)) < 0 )
fprintf(stderr, "bluesnarfer: Can't open RFCOMM control socket");
if (!(fd = bt_rfcomm(ctl, options.bd_addr, options.channel)))
fprintf(stderr,"bluesnarfer: unable to create rfcomm connection\n");
if ( switch_cmd(fd, options) < 0 )
fprintf(stderr, "bluesnarfer: send_cmd failed\n");
bt_rfcomm_rel();
return 0;
}
DBusHandlerResult cancel_authorize_request(DBusConnection *conn,
DBusMessage *msg,
struct service *service,
const char *address,
const char *path)
{
char adapter_path[PATH_MAX];
int adapter_id;
bdaddr_t bdaddr;
if (!default_auth_agent)
return error_auth_agent_does_not_exist(conn, msg);
str2ba(address, &bdaddr);
adapter_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
if (adapter_id < 0)
return error_not_connected(conn, msg);
snprintf(adapter_path, sizeof(adapter_path), "/org/bluez/hci%d",
adapter_id);
return auth_agent_send_cancel(msg, default_auth_agent, adapter_path,
service, address, path);
}
DBusHandlerResult handle_authorize_request(DBusConnection *conn,
DBusMessage *msg,
struct service *service,
const char *address,
const char *uuid)
{
struct auth_agent_req *req;
char adapter_path[PATH_MAX];
bdaddr_t bdaddr;
int adapter_id;
debug("handle_authorize_request");
if (!default_auth_agent) {
debug("no default agent");
return error_auth_agent_does_not_exist(conn, msg);
}
str2ba(address, &bdaddr);
adapter_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
if (adapter_id < 0)
return error_not_connected(conn, msg);
debug("Found %s connected to hci%d", address, adapter_id);
snprintf(adapter_path, sizeof(adapter_path), "/org/bluez/hci%d",
adapter_id);
req = auth_agent_req_new(msg, default_auth_agent, adapter_path,
address, service->object_path, uuid);
req->call = auth_agent_call_authorize(default_auth_agent, adapter_path,
service->object_path, address,
uuid);
if (!req->call) {
auth_agent_req_free(req);
return DBUS_HANDLER_RESULT_NEED_MEMORY;
}
dbus_pending_call_set_notify(req->call, auth_agent_req_reply, req,
NULL);
default_auth_agent->pending_requests =
g_slist_append(default_auth_agent->pending_requests, req);
debug("authorize request was forwarded");
return DBUS_HANDLER_RESULT_HANDLED;
}
int connection_init(int dev_id, char *addr, struct conn_info_handles *ci)
{
struct hci_conn_info_req *cr = NULL;
bdaddr_t bdaddr;
int dd;
int ret = 1;
str2ba(addr, &bdaddr);
if (dev_id < 0) {
dev_id = hci_for_each_dev(HCI_UP, find_conn, (long) &bdaddr);
if (dev_id < 0) {
ret = ERR_NOT_CONNECTED;
goto out;
}
}
dd = hci_open_dev(dev_id);
if (dd < 0) {
ret = ERR_HCI_DEV_OPEN_FAILED;
goto out;
}
cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
if (!cr) {
ret = ERR_CANNOT_ALLOCATE;
goto out;
}
bacpy(&cr->bdaddr, &bdaddr);
cr->type = ACL_LINK;
if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
ret = ERR_GET_CONN_INFO_FAILED;
goto out;
}
ci->dd = dd;
ci->handle = cr->conn_info->handle;
out:
if (cr)
free(cr);
return ret;
}
char *
psmove_port_get_host_bluetooth_address()
{
PSMove_Data_BTAddr btaddr;
PSMove_Data_BTAddr blank;
memset(blank, 0, sizeof(PSMove_Data_BTAddr));
memset(btaddr, 0, sizeof(PSMove_Data_BTAddr));
hci_for_each_dev(HCI_UP, _psmove_linux_bt_dev_info, (long)btaddr);
if(memcmp(btaddr, blank, sizeof(PSMove_Data_BTAddr))==0) {
fprintf(stderr, "WARNING: Can't determine Bluetooth address.\n"
"Make sure Bluetooth is turned on.\n");
return NULL;
}
return _psmove_btaddr_to_string(btaddr);
}
int read_rssi(char *pAddress, int *pRSSI )
{
int cc = 0;
int dd;
int dev_id;
uint16_t handle;
struct hci_conn_info_req *cr;
struct hci_request rq;
read_rssi_rp rp;
bdaddr_t bdaddr;
str2ba( pAddress, &bdaddr);
dev_id = hci_for_each_dev( HCI_UP, find_conn, (long)&bdaddr );
if (dev_id < 0) {
dev_id = hci_get_route( &bdaddr );
cc = 1;
}
if (dev_id < 0) {
printf("Device not available\n");
return -1;
}
dd = hci_open_dev(dev_id);
if (dd < 0) {
printf("Cannot open device\n");
return -2;
}
if (cc) {
if (hci_create_connection( dd,
&bdaddr,
0x0008 | 0x0010,
0,
0,
&handle,
25000 ) < 0) {
printf("Cannot create connection\n");
close(dd);
return -3;
}
}
cr = malloc(sizeof(*cr) + sizeof(struct hci_conn_info));
if (!cr) {
printf("Could not allocate memory\n");
return -4;
}
bacpy(&cr->bdaddr, &bdaddr);
cr->type = ACL_LINK;
if (ioctl(dd, HCIGETCONNINFO, (unsigned long) cr) < 0) {
printf("Get connection info failed\n");
return -5;
}
memset(&rq, 0, sizeof(rq));
rq.ogf = OGF_STATUS_PARAM;
rq.ocf = OCF_READ_RSSI;
rq.cparam = &cr->conn_info->handle;
rq.clen = 2;
rq.rparam = &rp;
rq.rlen = READ_RSSI_RP_SIZE;
if ( hci_send_req( dd, &rq, 100 ) < 0 ) {
printf("Read RSSI failed\n");
return -6;
}
if (rp.status) {
printf("Read RSSI returned (error) status 0x%2.2X\n", rp.status);
return -7;
}
if (cc) {
hci_disconnect(dd, handle, 0x13, 10000);
}
close(dd);
free(cr);
*pRSSI = rp.rssi;
return 0;
}
static int process_frames(bdaddr_t address, unsigned long flags)
{
struct cmsghdr *cmsg;
struct msghdr msg;
struct iovec iv;
struct hcidump_hdr *dh;
struct btsnoop_pkt *dp;
struct frame frm;
struct pollfd fds[2];
int nfds = 0;
char *buf, *ctrl;
int len, hdr_size = HCIDUMP_HDR_SIZE;
int polltimeout = -1;
int sock = -1;
int device = -1;
if (snap_len < SNAP_LEN)
snap_len = SNAP_LEN;
if (flags & DUMP_BTSNOOP)
hdr_size = BTSNOOP_PKT_SIZE;
buf = malloc(snap_len + hdr_size);
if (!buf) {
perror("Can't allocate data buffer");
return -1;
}
dh = (void *) buf;
dp = (void *) buf;
frm.data = buf + hdr_size;
ctrl = malloc(100);
if (!ctrl) {
free(buf);
perror("Can't allocate control buffer");
return -1;
}
printf("snap_len: %d filter: 0x%lx\n", snap_len, parser.filter);
memset(&msg, 0, sizeof(msg));
while (1)
{
nfds = 0;
if (sock == -1)
{
device = hci_for_each_dev(0, find_device_by_address_callback, (long)&address);
if (device != -1)
{
sock = open_socket(device, flags);
if (sock != -1)
{
printf("hci%d Connected\n", device);
(void)fflush(stdout);
onBtConnect();
}
}
}
if (sock != -1)
{
fds[nfds].fd = sock;
fds[nfds].events = POLLIN;
fds[nfds].revents = 0;
nfds++;
}
/* ------------------------------------------------------------- */
/* Remote sme */
/* ------------------------------------------------------------- */
#ifdef IPC_IP
// If we are not connected attempt to connect
if (!smeConnection)
{
//printf("Sme Connect :: tcp:localhost:10101\n");
//(void)fflush(stdout);
smeConnection = ipc_ip_connect("tcp:localhost:10101", NULL, NULL, NULL, NULL);
if (smeConnection)
{
printf("Sme Connected\n");
(void)fflush(stdout);
onIpcConnect();
}
}
if (smeConnection)
{
fds[nfds].fd = ipc_getFd(smeConnection);
fds[nfds].events = POLLIN;
fds[nfds].revents = 0;
nfds++;
}
polltimeout = sock==-1?500:smeConnection?-1:500;
#endif
/* ------------------------------------------------------------- */
(void)fflush(stdout);
int i, n = poll(fds, nfds, polltimeout);
(void)fflush(stdout);
if (n <= 0)
continue;
for (i = 0; i < nfds; i++) {
if (fds[i].revents & (POLLHUP | POLLERR | POLLNVAL)) {
if (fds[i].fd == sock)
{
printf("device: disconnected\n");
sock = -1;
onBtDisconnect();
continue;
}
#ifdef IPC_IP
else if (smeConnection && fds[i].fd == ipc_getFd(smeConnection))
{
printf("Sme Disconnected\n");
(void)fflush(stdout);
ipc_disconnect(smeConnection);
smeConnection = NULL;
continue;
}
#endif
else
{
printf("client: disconnect\n");
}
}
}
for (i = 0; i < nfds; i++)
{
#ifdef IPC_IP
if (smeConnection && fds[i].fd == ipc_getFd(smeConnection) && fds[i].revents & (POLLIN | POLLPRI))
{
CsrUint8* smeRxBuffer;
CsrUint32 smeRxLength = 0;
printf("Sme fd Triggered\n");
(void)fflush(stdout);
if (ipc_message_recv(smeConnection, 0, &smeRxBuffer, &smeRxLength))
{
if (smeRxLength != 0)
{
if (!remote_bt_signal_receive(NULL, smeRxBuffer, (CsrUint16)smeRxLength))
{
printf("Sme unhandled ipc message\n");
(void)fflush(stdout);
}
ipc_message_free(smeConnection, smeRxBuffer);
}
continue;
}
/* Opps Disconnected */
printf("Sme Disconnected\n");
(void)fflush(stdout);
ipc_disconnect(smeConnection);
smeConnection = NULL;
nfds--;
onIpcDisconnect();
continue;
}
#endif
if (sock != -1 && fds[i].fd == sock && fds[i].revents & (POLLIN | POLLPRI))
{
iv.iov_base = frm.data;
iv.iov_len = snap_len;
msg.msg_iov = &iv;
msg.msg_iovlen = 1;
msg.msg_control = ctrl;
msg.msg_controllen = 100;
len = recvmsg(sock, &msg, MSG_DONTWAIT);
if (len < 0) {
if (errno == EAGAIN || errno == EINTR)
continue;
perror("Receive failed");
return -1;
}
/* Process control message */
frm.data_len = len;
frm.dev_id = device;
frm.in = 0;
frm.pppdump_fd = parser.pppdump_fd;
frm.audio_fd = parser.audio_fd;
cmsg = CMSG_FIRSTHDR(&msg);
while (cmsg) {
switch (cmsg->cmsg_type) {
case HCI_CMSG_DIR:
frm.in = *((int *) CMSG_DATA(cmsg));
break;
case HCI_CMSG_TSTAMP:
frm.ts = *((struct timeval *) CMSG_DATA(cmsg));
break;
}
cmsg = CMSG_NXTHDR(&msg, cmsg);
}
frm.ptr = frm.data;
frm.len = frm.data_len;
/* Parse and print */
parse(&frm);
}
}
}
return 0;
}
