def __init__(self, bdaddress=None):
self.cport = 0x11 # HID's control PSM
self.iport = 0x13 # HID' interrupt PSM
self.backlog = 1
self.address = ""
if bdaddress:
self.address = bdaddress
# create the HID control socket
self.csock = BluetoothSocket(L2CAP)
self.csock.bind((self.address, self.cport))
set_l2cap_mtu(self.csock, 64)
self.csock.settimeout(2)
self.csock.listen(self.backlog)
# create the HID interrupt socket
self.isock = BluetoothSocket(L2CAP)
self.isock.bind((self.address, self.iport))
set_l2cap_mtu(self.isock, 64)
self.isock.settimeout(2)
self.isock.listen(self.backlog)
self.connected = False
self.client_csock = None
self.caddress = None
self.client_isock = None
self.iaddress = None
def connect(self, target):
"""Connect to target MAC (the keyboard must already be known to the
target)"""
print("[*] Connecting to {}".format(target))
self.scontrol = BluetoothSocket(L2CAP)
self.sinterrupt = BluetoothSocket(L2CAP)
self.scontrol.connect((target, self.P_CTRL))
self.sinterrupt.connect((target, self.P_INTR))
self.ccontrol = self.scontrol
self.cinterrupt = self.sinterrupt
def _connect_to_server(self):
''' Establishes a connection with the Tremium Hub Bluetooth server '''
bluetooth_port = self.config_manager.config_data["bluetooth-port"]
try:
# creating a new socket
self.server_s = BluetoothSocket()
self.server_s.bind(
(self.config_manager.
config_data["bluetooth-adapter-mac-client"], bluetooth_port))
# connecting to the hub
time.sleep(0.25)
self.server_s.connect(
(self.config_manager.
config_data["bluetooth-adapter-mac-server"], bluetooth_port))
self.server_s.settimeout(
self.config_manager.config_data["bluetooth-comm-timeout"])
time.sleep(0.25)
# handling server connection failure
except Exception as e:
self.server_s.close()
time_str = datetime.datetime.fromtimestamp(
time.time()).strftime('%Y-%m-%d_%H-%M-%S')
logging.error(
"{0} - NodeBluetoothClient failed to connect to server : {1}".
format(time_str, e))
raise
def get_local_address():
hci = BluetoothSocket(HCI)
fd = hci.fileno()
buf = array.array('B', [0] * 96)
ioctl(fd, _bluetooth.HCIGETDEVINFO, buf, 1)
data = struct.unpack_from("H8s6B", buf.tostring())
return data[2:8][::-1]
def connect(self, protocol=None, device: str = None, port: int = None, service_uuid: str = None,
service_name: str = None):
"""
Connect to a bluetooth device.
You can query the advertised services through ``find_service``.
:param protocol: Supported values: either 'RFCOMM'/'L2CAP' (str) or bluetooth.RFCOMM/bluetooth.L2CAP
int constants (int)
:param device: Device address or name
:param port: Port number
:param service_uuid: Service UUID
:param service_name: Service name
"""
from bluetooth import BluetoothSocket
addr, port, protocol = self._get_addr_port_protocol(protocol=protocol, device=device, port=port,
service_uuid=service_uuid, service_name=service_name)
sock = self._get_sock(protocol=protocol, device=addr, port=port)
if sock:
self.close(device=addr, port=port)
sock = BluetoothSocket(protocol)
self.logger.info('Opening connection to device {} on port {}'.format(addr, port))
sock.connect((addr, port))
self.logger.info('Connected to device {} on port {}'.format(addr, port))
self._socks[(addr, port)] = sock
def listen_for_rfcomm_connection(self):
"""
Starts bluetooth interfaces
"""
# prepare bluetooth server
self.server_sock = BluetoothSocket(RFCOMM)
self.server_sock.bind(("", PORT_ANY))
self.server_sock.listen(1)
self.rfcomm_channel = self.server_sock.getsockname()[1]
# start listening for incoming connections
advertise_service(
self.server_sock,
self.service_name,
service_id=self.service_uuid,
service_classes=[self.service_uuid, SERIAL_PORT_CLASS],
profiles=[SERIAL_PORT_PROFILE])
LOGGER.info('waiting for connection on RFCOMM channel %d' %
self.rfcomm_channel)
# accept received connection
self.client_sock, self.client_info = self.server_sock.accept()
self.state = self.__states__.STATE_CONNECTED
LOGGER.info('accepted connection from %r', self.client_info)
# start listening for data
self.consume_bus()
def allocate_code(self):
"""Acquires and returns a string suitable for finding the key via Bluetooth.
Returns None if no powered on adapter could be found."""
# TODO: when we have magic-wormhole we should perform this operation in async
# and show the loading spinning wheel
bt_data = None
try:
code = get_local_bt_address().upper()
except NoBluezDbus as e:
log.debug("Bluetooth service seems to be unavailable: %s", e)
except NoAdapter as e:
log.debug("Bluetooth adapter is not available: %s", e)
except UnpoweredAdapter as e:
log.debug("Bluetooth adapter is turned off: %s", e)
else:
if self.server_socket is None:
self.server_socket = BluetoothSocket(RFCOMM)
# We create a bind with the Bluetooth address we have in the system
self.server_socket.bind((code, PORT_ANY))
# Number of unaccepted connections that the system will allow before refusing new connections
backlog = 1
self.server_socket.listen(backlog)
log.info("sockname: %r", self.server_socket.getsockname())
port = self.server_socket.getsockname()[1]
log.info("BT Code: %s %s", code, port)
bt_data = "BT={0};PT={1}".format(code, port)
return bt_data
def allocate_code(self):
try:
code = get_local_bt_address().upper()
except dbus.exceptions.DBusException as e:
if e.get_dbus_name() == "org.freedesktop.systemd1.NoSuchUnit":
log.info("No Bluetooth devices found, probably the bluetooth service is not running")
elif e.get_dbus_name() == "org.freedesktop.DBus.Error.UnknownObject":
log.info("No Bluetooth devices available")
else:
log.error("An unexpected error occurred %s", e.get_dbus_name())
self.code = None
return None
if self.server_socket is None:
self.server_socket = BluetoothSocket(RFCOMM)
# We can also bind only the mac found with get_local_bt_address(), anyway
# even with multiple bt in a single system BDADDR_ANY is not a problem
self.server_socket.bind((socket.BDADDR_ANY, PORT_ANY))
# Number of unaccepted connections that the system will allow before refusing new connections
backlog = 1
self.server_socket.listen(backlog)
log.info("sockname: %r", self.server_socket.getsockname())
port = self.server_socket.getsockname()[1]
log.info("BT Code: %s %s", code, port)
bt_data = "BT={0};PT={1}".format(code, port)
return bt_data
def client_init(server_name):
"""
initialize client socket
"""
logging.debug("client initialization")
server_address = None
devices = discover_devices()
for device_address in devices:
device_name = lookup_name(device_address)
logging.debug("found device : %s", device_name)
if device_name == server_name:
server_address = device_address
break
if server_address is None:
logging.error("could not connect to %s", server_name)
sys.exit(0)
client_socket = BluetoothSocket(RFCOMM)
client_socket.connect((server_address, PORT))
# handle callback function
if connected_callback is not None:
connected_callback()
return client_socket
def __init__(self, establish_bt=True):
self.folder = path.dirname(path.abspath(__file__))
try:
with open(path.join(self.folder,
'settings.yaml')) as settings_file:
self.settings = yaml.safe_load(settings_file)
except FileNotFoundError:
print(
"Create a settings.yaml file by copying settings-example.yaml")
raise
self.server_sock = None
self.client_sock = None
if establish_bt:
self.server_sock = BluetoothSocket(RFCOMM)
self.server_sock.bind(("", PORT_ANY))
self.server_sock.listen(1)
uuid = "28ccf815-245e-436f-a002-8e72a67422a8"
# doesn't appear to do anything on RasPi...
advertise_service(self.server_sock,
"LightNet",
service_id=uuid,
service_classes=[uuid, SERIAL_PORT_CLASS],
profiles=[SERIAL_PORT_PROFILE])
self.broadcast_socket = socket.socket(socket.AF_INET,
socket.SOCK_DGRAM)
self.broadcast_socket.setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self.broadcast_socket.setsockopt(socket.SOL_SOCKET,
socket.SO_BROADCAST, 1)
def connect(self):
try:
self.conn = BluetoothSocket(
bluetooth.RFCOMM) # use RFCOMM protocol
self.conn.bind(
(self.address,
self.port)) # empty address; use any available adapter
self.address, self.port = self.conn.getsockname()
self.conn.listen(1)
uuid = self.config.get('BT_UUID')
bluetooth.advertise_service(
sock=self.conn,
name='MDP-Group-15-Bluetooth-Server',
service_id=uuid,
service_classes=[uuid, bluetooth.SERIAL_PORT_CLASS],
profiles=[bluetooth.SERIAL_PORT_PROFILE],
)
print(
f'Listening for Bluetooth connection on {self.address} port {self.port}'
)
self.client, client_info = self.conn.accept()
print(f'Connected to {client_info}')
self._connected = True
except Exception as e:
print(f'Error with {self.get_name()}: {e}')
self.disconnect()
raise ConnectionError
def waitForConnection(self):
# enable visibility
if not self.sys_bus:
self.sys_bus = dbus.SystemBus()
# do only once (since we turn off the timeout)
# alternatively set DiscoverableTimeout = 0 in /etc/bluetooth/main.conf
# and run hciconfig hci0 piscan, from robertalab initscript
hci0 = self.sys_bus.get_object('org.bluez', '/org/bluez/hci0')
props = dbus.Interface(hci0, 'org.freedesktop.DBus.Properties')
props.Set('org.bluez.Adapter1', 'DiscoverableTimeout', dbus.UInt32(0))
props.Set('org.bluez.Adapter1', 'Discoverable', True)
if not self.bt_server:
self.bt_server = BluetoothSocket(bluetooth.RFCOMM)
self.bt_server.settimeout(
0.5) # half second to make IO interruptible
self.bt_server.bind(("", bluetooth.PORT_ANY))
self.bt_server.listen(1)
while True:
try:
(con, info) = self.bt_server.accept()
con.settimeout(0.5) # half second to make IO interruptible
self.bt_connections.append(con)
return len(self.bt_connections) - 1
except bluetooth.btcommon.BluetoothError as e:
if not self._isTimeOut(e):
logger.error("unhandled Bluetooth error: %s", repr(e))
break
return -1
def _create_client(self):
assert self.uuid is not None
logger.info("searching service %s (UUID: %s) @ %s" %
(self.name, self.uuid, self.upstream_addr or 'anywhere'))
service_matches = []
while len(service_matches) == 0:
try:
service_matches = bt.find_service(uuid=self.uuid,
address=self.upstream_addr)
if len(service_matches) == 0:
sleep(1)
except KeyboardInterrupt:
break
first_match = service_matches[0]
port = first_match["port"]
name = first_match["name"]
host = first_match["host"]
logger.info("connecting to App \"%s\" on %s" % (name, host))
# Create the client socket
sock = BluetoothSocket(bt.RFCOMM)
sock.connect((host, port))
return sock
def main():
# Setup logging
setup_logging()
# We need to wait until Bluetooth init is done
time.sleep(10)
# Make device visible
os.system("hciconfig hci0 piscan")
# Create a new server socket using RFCOMM protocol
server_sock = BluetoothSocket(RFCOMM)
# Bind to any port
server_sock.bind(("", PORT_ANY))
# Start listening
server_sock.listen(1)
# Get the port the server socket is listening
port = server_sock.getsockname()[1]
# The service UUID to advertise
uuid = "7be1fcb3-5776-42fb-91fd-2ee7b5bbb86d"
# Start advertising the service
advertise_service(server_sock,
"RaspiBtSrv",
service_id=uuid,
service_classes=[uuid, SERIAL_PORT_CLASS],
profiles=[SERIAL_PORT_PROFILE])
# These are the operations the service supports
# Feel free to add more
operations = ["ping", "example"]
# Main Bluetooth server loop
while True:
print("Waiting for connection on RFCOMM channel %d" % port)
client_sock = None
try:
# This will block until we get a new connection
client_sock, client_info = server_sock.accept()
print("Accepted connection from ", client_info)
# Read the data sent by the client
data = client_sock.recv(1024)
if len(data) == 0:
break
print("Received [%s]" % data)
# Handle the request
if data == "getop":
response = "op:%s" % ",".join(operations)
elif data == "ping":
response = "msg:Pong"
elif data == "example":
response = "msg:This is an example"
# Insert more here
else:
response = "msg:Not supported"
client_sock.send(response)
print("Sent back [%s]" % response)
except IOError:
pass
except KeyboardInterrupt:
if client_sock is not None:
client_sock.close()
server_sock.close()
print("Server going down")
break
def __init__(self, is_server: bool = True):
self.is_server = is_server
self._threads = {}
self._connections = {}
self.socket = BluetoothSocket(RFCOMM)
self.socket_is_ready = False
self.socket_thread = self.spawn_thread("Accepting", self._accept,
True).start()
def createClient(self, address, port=3):
if address == "first":
address = self.searchDevices()[0]
self.client_socket = BluetoothSocket(RFCOMM)
print "Trying to connect.."
self.client_socket.connect((address, port))
print "Connected!"
self.connected = True
def connect(self, host=None, port=4):
"""Open a connection to the TimeBox."""
# Create the client socket
if host is None:
host = self.DEFAULTHOST
#print("connecting to %s at %s" % (self.host, self.port))
self.socket = BluetoothSocket(RFCOMM)
self.socket.connect((host, port))
self.socket.setblocking(0)
def server_init():
"""
initialize server socket
"""
logging.debug("server initialization")
server_socket = BluetoothSocket(RFCOMM)
server_socket.bind(("", PORT))
server_socket.listen(1)
return server_socket
def task(self):
# Waiting until Bluetooth init is done
time.sleep(self.wakeup_time)
# Make device visible
self.scm.set_bluetooth_visible()
# Create a new server socket using RFCOMM protocol
server_sock = BluetoothSocket(RFCOMM)
# Bind to any port
server_sock.bind(("", PORT_ANY))
# Start listening
server_sock.listen(self.max_simultaneous_connections)
# Get the port the server socket is listening
port = server_sock.getsockname()[1]
# Main bluetooth server loop
while True:
logger.info(
'Waiting for bluetooth connection on channel {}'.format(port))
client_sock = None
try:
# Block until we get a new connection
client_sock, client_info = server_sock.accept()
logger.info('Accepted connection from {}'.format(client_info))
# Read the data sent by the client
command = client_sock.recv(1024)
if len(command) == 0:
continue
logger.info('Received [{}]'.format(command))
# Handle the request
response = self.handle_request(command)
client_sock.send(response)
logger.info('Sent back [{}]'.format(response))
except IOError:
pass
except KeyboardInterrupt:
if client_sock is not None:
client_sock.close()
server_sock.close()
logger.info('Bluetooth server going down')
break
def createServer(self, port=3):
self.server_socket = BluetoothSocket(RFCOMM)
self.server_socket.bind(("", port))
self.server_socket.listen(1)
print "Trying to connect.."
self.client_socket, _ = self.server_socket.accept()
print "Connected!"
self.connected = True
def get_port():
while True:
for port in range(1, 9): # limit 8 devices
s = BluetoothSocket(RFCOMM)
try:
s.bind(("", port))
s.close()
return port
except Exception as ex:
s.close()
sleep(1)
def run_bt_server(account):
"""Adapted from: https://github.com/EnableTech/raspberry-bluetooth-demo"""
import pdb
pdb.set_trace()
server_sock = BluetoothSocket(RFCOMM)
server_sock.bind(("", PORT_ANY))
server_sock.listen(1)
port = server_sock.getsockname()[1]
print ("listening on port %d" % port)
uuid = "1e0ca4ea-299d-4335-93eb-27fcfe7fa848"
advertise_service(
server_sock,
"Mock Detector",
service_id=uuid,
service_classes=[uuid, SERIAL_PORT_CLASS],
profiles=[SERIAL_PORT_PROFILE],
# protocols=[OBEX_UUID],
)
print("Waiting for connection on RFCOMM channel %d" % port)
client_sock, client_info = server_sock.accept()
print("Accepted connection from ", client_info)
try:
while True:
data = client_sock.recv(1024)
if len(data) == 0:
break
print("received [%s]" % data)
if data == b'ETH_ADDRESS\r\n':
client_sock.send(
"ETH_ADDRESS::0x{}\r\nEND\r\n".format(account.address())
)
elif data.startswith('SIGNED_MESSAGE::'):
start = len('SIGNED_MESSAGE::')
user_address = data[start:start+42]
message = account.create_signed_message(
user_address,
int(time.time())
)
client_sock.send(message)
except IOError:
pass
print("disconnected")
client_sock.close()
server_sock.close()
print("all done")
def connect_device(self):
if not self.scanservices():
self.logging.error('Not found valid service.')
return False
self.logging.info("Service found. Connecting to \"%s\" on %s..." %
(self.service["name"], self.service["host"]))
self.sock = BluetoothSocket(RFCOMM)
self.sock.connect((self.service["host"], self.service["port"]))
self.sock.settimeout(60)
self.logging.info("Device connected.")
return True
def start_service(self, port, name, uuid, service_classes,
service_profiles, provider, description, protocols):
socket = BluetoothSocket(RFCOMM)
socket.bind((self.address, port))
socket.listen(1)
advertise_service(socket, name, uuid, service_classes,
service_profiles, provider, description, protocols)
print("Starting server for %s on port %i" % socket.getsockname())
#self.serve(socket)
return socket
def _create_server(self):
server_sock = BluetoothSocket(bt.RFCOMM)
server_sock.bind(("", bt.PORT_ANY))
server_sock.listen(1)
self.channel = server_sock.getsockname()[1]
bt.advertise_service(server_sock,
self.name,
service_classes=[self.uuid],
profiles=[])
return server_sock
def connect(addr):
socket = BluetoothSocket(RFCOMM)
while True:
try:
socket.connect((addr, 1))
break
except Exception as e:
print("Failed to connect trying, again in 1 sec.")
time.sleep(1)
print("Connected to {} on channel {}".format(addr, 1))
return socket
def listen(self):
"""Listen for incoming client connections"""
print("[*] Waiting for connections")
self.scontrol = BluetoothSocket(L2CAP)
self.sinterrupt = BluetoothSocket(L2CAP)
# bind these sockets to a port - port zero to select next available
self.scontrol.bind((self.bdaddr, self.P_CTRL))
self.sinterrupt.bind((self.bdaddr, self.P_INTR))
# start listening on the server sockets (only allow 1 connection)
self.scontrol.listen(1)
self.sinterrupt.listen(1)
self.ccontrol, cinfo = self.scontrol.accept()
print("[*] Connection on the control channel from {}".format(cinfo[0]))
self.cinterrupt, cinfo = self.sinterrupt.accept()
print("[*] Connection on the interrupt channel from {}".format(
cinfo[0]))
def __init__(self, server_address, RequestHandlerClass):
self.server_address = server_address
self.RequestHandlerClass = RequestHandlerClass
self.socket = BluetoothSocket(RFCOMM)
try:
self.socket.bind((server_address[0], server_address[1]))
# self.server_address = self.socket.getsockname()
self.socket.listen(self.request_queue_size)
except Exception:
self.server_close()
raise
def connect(self):
if self.address is None and not self.scandevices():
return False
if not self.scanservices():
return False
logging.info('Service found: connecting to %s on %s...' %
(self.service['name'], self.service['host']))
self.sock = BluetoothSocket()
self.sock.connect((self.service['host'], self.service['port']))
self.sock.settimeout(60)
logging.info('Connected.')
self.registerCrcKeyToBt()
return True
def connect(self):
if self.address is None and not self.scandevices():
return False
if not self.scanservices():
return False
logging.info("Service found. Connecting to \"%s\" on %s..." %
(self.service["name"], self.service["host"]))
self.sock = BluetoothSocket(RFCOMM)
self.sock.connect((self.service["host"], self.service["port"]))
self.sock.settimeout(60)
logging.info("Connected.")
self.registerCrcKeyToBt()
return True
