More robust handling of socket opening and closing (#2)

Fix for #1 

* Change how socket is created from: socket.fromfd to using   socket.socket

* Output from btmgmt_socket.open() is a single socket object rather than two references to the same object

Author: ukBaz

btsocket/btmgmt_callback.py

@@ -15,7 +15,7 @@ class Mgmt:
 
     def __init__(self):
         # Setup read and write sockets
-        self.rsock, self.wsock = btmgmt_socket.btmgmt_socket()
+        self.sock = btmgmt_socket.open()
         self.loop = asyncio.get_event_loop()
         # Store for event callbacks
         self._event_callbacks = dict()
@@ -42,7 +42,7 @@ def reader(self):
         to events.
         """
         logger.debug('Reader callback')
-        data = self.rsock.recv(100)
+        data = self.sock.recv(100)
         pkt = btmgmt_protocol.reader(data)
         logger.info('pkt: [%s]', pkt)
         if pkt.header.event_code in self._event_callbacks:
@@ -59,7 +59,7 @@ def writer(self):
         if len(self.cmd_queue) > 0:
             this_cmd = self.cmd_queue.popleft()
             logger.info('sending pkt [%s]', tools.format_pkt(this_cmd))
-            self.wsock.send(this_cmd)
+            self.sock.send(this_cmd)
         if not self.running and len(self.cmd_queue) == 0:
             self.loop.stop()
             # Do one more read to get the response from the last command
@@ -95,24 +95,23 @@ def stop(self):
         """
         self.running = False
 
-        self.loop.remove_writer(self.wsock)
-        self.loop.remove_reader(self.rsock)
+        self.loop.remove_writer(self.sock)
+        self.loop.remove_reader(self.sock)
         self.loop.stop()
 
     def close(self):
         """
         Stop the event loop and close sockets etc.
         """
-        self.rsock.close()
-        # self.wsock.close()
+        btmgmt_socket.close(self.sock)
         # Stop the event loop
         self.loop.close()
 
     def start(self):
         self.running = True
         # Setup reader and writer for socket streams
-        self.loop.add_reader(self.rsock, self.reader)
-        self.loop.add_writer(self.wsock, self.writer)
+        self.loop.add_reader(self.sock, self.reader)
+        self.loop.add_writer(self.sock, self.writer)
         logger.debug('Starting event loop...')
         try:
             # Run the event loop

btsocket/btmgmt_socket.py

@@ -29,7 +29,7 @@ class SocketAddr(ctypes.Structure):
     ]
 
 
-def btmgmt_socket():
+def open():
     """
     Because of the following issue with Python the Bluetooth User socket
     on linux needs to be done with lower level calls.
@@ -53,6 +53,7 @@ def btmgmt_socket():
     # fd = libc_socket(PF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC | SOCK_NONBLOCK,
     #               BTPROTO_HCI)
     fd = libc_socket(PF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)
+
     if fd < 0:
         raise BluetoothSocketError("Unable to open PF_BLUETOOTH socket")
 
@@ -64,40 +65,45 @@ def btmgmt_socket():
     if r < 0:
         raise BluetoothSocketError("Unable to bind %s", r)
 
-    ins = outs = socket.fromfd(fd, AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI)
-    return ins, outs
+    sock_fd = socket.socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI, fileno=fd)
+    return sock_fd
+
+
+def close(bt_socket):
+    """Close the open socket"""
+    fd = bt_socket.detach()
+    socket.close(fd)
 
 
 def test_asyncio_usage():
-    rsock, wsock = btmgmt_socket()
+    sock = open()
 
     loop = asyncio.get_event_loop()
 
     def reader():
-        data = rsock.recv(100)
+        data = sock.recv(100)
         print("Received:", data)
 
         # We are done: unregister the file descriptor
-        loop.remove_reader(rsock)
+        loop.remove_reader(sock)
 
         # Stop the event loop
         loop.stop()
 
     # Register the file descriptor for read event
-    loop.add_reader(rsock, reader)
+    loop.add_reader(sock, reader)
 
     # Write a command to the socket
     # Read Management Version Information Command
     # b'\x01\x00\xff\xff\x00\x00'
-    loop.call_soon(wsock.send, b'\x01\x00\xff\xff\x00\x00')
+    loop.call_soon(sock.send, b'\x01\x00\xff\xff\x00\x00')
 
     try:
         # Run the event loop
         loop.run_forever()
     finally:
         # We are done. Close sockets and the event loop.
-        rsock.close()
-        wsock.close()
+        close(sock)
         loop.close()
 
 

btsocket/btmgmt_sync.py

@@ -19,18 +19,18 @@ def send(*args):
     logger.debug('Sending btmgmt frames %s', pkt_objs)
     cmd_pkt = _as_packet(pkt_objs)
     # print('cmd pkt', [f'{octets:x}' for octets in cmd_pkt])
-    rsock, wsock = btmgmt_socket.btmgmt_socket()
+    sock = btmgmt_socket.open()
     logger.debug('Sending bytes: %s', cmd_pkt)
-    wsock.send(cmd_pkt)
+    sock.send(cmd_pkt)
     while not response_recvd:
-        raw_data = rsock.recv(100)
+        raw_data = sock.recv(100)
         logger.debug('Received: %s', raw_data)
         data = btmgmt_protocol.reader(raw_data)
         logger.debug('Received btmgmt frames: %s', data)
         if data.cmd_response_frame:
             response_recvd = True
-    rsock.close()
-    wsock.close()
+
+    btmgmt_socket.close(sock)
     if data.event_frame.status != btmgmt_protocol.ErrorCodes.Success:
         raise NameError(f'btmgmt Error: '
                         f'{data.event_frame.command_opcode} '