def l2cap_conn(bd_addr, bd_addr_type, psm, mtu=0, num=1, ecfc=0, hold_credit=0): logging.debug("%s %r %r %r", l2cap_conn.__name__, bd_addr, bd_addr_type, psm) iutctl = get_iut() gap_wait_for_connection() if isinstance(psm, str): psm = int(psm, 16) bd_addr = pts_addr_get(bd_addr) bd_addr_type = pts_addr_type_get(bd_addr_type) bd_addr_ba = addr2btp_ba(bd_addr) data_ba = bytearray(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(struct.pack('H', psm)) data_ba.extend(struct.pack('H', mtu)) data_ba.extend(struct.pack('B', num)) opts = 0 if ecfc: opts |= defs.L2CAP_CONNECT_OPT_ECFC if hold_credit: opts |= defs.L2CAP_CONNECT_OPT_HOLD_CREDIT data_ba.extend(struct.pack('B', opts)) iutctl.btp_socket.send(*L2CAP['connect'], data=data_ba) chan_ids = l2cap_conn_rsp() logging.debug("id %r", chan_ids)
def set_filter_accept_list(address_list=None): """ Send tuples (address, address_type) to IUT and save them to the filter accept list. If address_list=None PTS's (address,type) will be sent. Arguments: address_list -- addrs and their types as tuples: address_list = [('DB:F5:72:56:C9:EF', 0), ('DB:F5:72:56:C9:EF', 0)] """ logging.debug("%s %s", set_filter_accept_list.__name__, address_list) iutctl = get_iut() data_ba = bytearray() if not address_list: address_list = [(pts_addr_get(None), pts_addr_type_get(None))] addr_cnt_ba = chr(len(address_list)).encode('utf-8') data_ba.extend(addr_cnt_ba) for addr, type in address_list: bd_addr_ba = addr2btp_ba(addr) bd_addr_type_ba = chr(type).encode('utf-8') data_ba.extend(bd_addr_type_ba) data_ba.extend(bd_addr_ba) iutctl.btp_socket.send(*GAP['set_filter_accept_list'], data=data_ba) gap_command_rsp_succ()
def gattc_cfg_indicate(bd_addr_type, bd_addr, enable, ccc_hdl): logging.debug("%s %r %r, %r, %r", gattc_cfg_indicate.__name__, bd_addr_type, bd_addr, enable, ccc_hdl) gap_wait_for_connection() if isinstance(ccc_hdl, str): ccc_hdl = int(ccc_hdl, 16) iutctl = get_iut() bd_addr_ba = addr2btp_ba(bd_addr) ccc_hdl_ba = struct.pack('H', ccc_hdl) data_ba = bytearray() data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(chr(enable).encode('utf-8')) data_ba.extend(ccc_hdl_ba) iutctl.btp_socket.send(*GATTC['cfg_indicate'], data=data_ba) tuple_hdr, tuple_data = iutctl.btp_socket.read() logging.debug("%s received %r %r", gattc_cfg_indicate.__name__, tuple_hdr, tuple_data) btp_hdr_check(tuple_hdr, defs.BTP_SERVICE_ID_GATT, defs.GATT_CFG_INDICATE)
def gattc_disc_all_desc(bd_addr_type, bd_addr, start_hdl, stop_hdl): logging.debug("%s %r %r %r %r", gattc_disc_all_desc.__name__, bd_addr_type, bd_addr, start_hdl, stop_hdl) iutctl = get_iut() gap_wait_for_connection() if isinstance(start_hdl, str): start_hdl = int(start_hdl, 16) if isinstance(stop_hdl, str): stop_hdl = int(stop_hdl, 16) data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) start_hdl_ba = struct.pack('H', start_hdl) stop_hdl_ba = struct.pack('H', stop_hdl) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(start_hdl_ba) data_ba.extend(stop_hdl_ba) iutctl.btp_socket.send(*GATTC['disc_all_desc'], data=data_ba)
def gap_direct_adv_on(addr, addr_type, high_duty=0, peer_rpa=0): logging.debug("%s %r %r", gap_direct_adv_on.__name__, addr, high_duty) stack = get_stack() if stack.gap.current_settings_get( gap_settings_btp2txt[defs.GAP_SETTINGS_ADVERTISING]): return iutctl = get_iut() data_ba = bytearray() bd_addr_ba = addr2btp_ba(addr) data_ba.extend(chr(addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) opts = 0 if high_duty: opts |= defs.GAP_START_DIRECT_ADV_HD if peer_rpa: opts |= defs.GAP_START_DIRECT_ADV_PEER_RPA data_ba.extend(struct.pack('H', opts)) iutctl.btp_socket.send(*GAP['start_direct_adv'], data=data_ba) tuple_data = gap_command_rsp_succ(defs.GAP_START_DIRECT_ADV) __gap_current_settings_update(tuple_data)
def gattc_write(bd_addr_type, bd_addr, hdl, val, val_mtp=None): logging.debug("%s %r %r %r %r %r", gattc_write.__name__, bd_addr_type, bd_addr, hdl, val, val_mtp) iutctl = get_iut() gap_wait_for_connection() if isinstance(hdl, str): hdl = int(hdl, 16) if val_mtp: val *= int(val_mtp) data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) hdl_ba = struct.pack('H', hdl) val_ba = binascii.unhexlify(val) val_len_ba = struct.pack('H', len(val_ba)) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(hdl_ba) data_ba.extend(val_len_ba) data_ba.extend(val_ba) iutctl.btp_socket.send(*GATTC['write'], data=data_ba)
def gattc_read_long(bd_addr_type, bd_addr, hdl, off, modif_off=None): logging.debug("%s %r %r %r %r %r", gattc_read_long.__name__, bd_addr_type, bd_addr, hdl, off, modif_off) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() if isinstance(off, str): off = int(off, 16) if modif_off: off += modif_off if isinstance(hdl, str): hdl = int(hdl, 16) bd_addr_ba = addr2btp_ba(bd_addr) hdl_ba = struct.pack('H', hdl) off_ba = struct.pack('H', off) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(hdl_ba) data_ba.extend(off_ba) iutctl.btp_socket.send(*GATTC['read_long'], data=data_ba)
def gatts_get_attr_val(bd_addr_type, bd_addr, handle): logging.debug("%s %r", gatts_get_attr_val.__name__, handle) iutctl = get_iut() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) if isinstance(handle, str): handle = int(handle, 16) hdl_ba = struct.pack('H', handle) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(hdl_ba) iutctl.btp_socket.send(*GATTS['get_attr_val'], data=data_ba) tuple_hdr, tuple_data = iutctl.btp_socket.read() logging.debug("received %r %r", tuple_hdr, tuple_data) btp_hdr_check(tuple_hdr, defs.BTP_SERVICE_ID_GATT, defs.GATT_GET_ATTRIBUTE_VALUE) hdr = '<BH' hdr_len = struct.calcsize(hdr) data_len = tuple_hdr.data_len - hdr_len return struct.unpack(hdr + '%ds' % data_len, tuple_data[0])
def gattc_read_uuid(bd_addr_type, bd_addr, start_hdl, end_hdl, uuid): logging.debug("%s %r %r %r %r %r", gattc_read_uuid.__name__, bd_addr_type, bd_addr, start_hdl, end_hdl, uuid) iutctl = get_iut() gap_wait_for_connection() if isinstance(start_hdl, str): start_hdl = int(start_hdl, 16) if isinstance(end_hdl, str): end_hdl = int(end_hdl, 16) data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) start_hdl_ba = struct.pack('H', start_hdl) end_hdl_ba = struct.pack('H', end_hdl) if "-" in uuid: uuid = uuid.replace("-", "") if uuid.startswith("0x"): uuid = uuid.replace("0x", "") uuid_ba = binascii.unhexlify(uuid)[::-1] data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(start_hdl_ba) data_ba.extend(end_hdl_ba) data_ba.extend(chr(len(uuid_ba)).encode('utf-8')) data_ba.extend(uuid_ba) iutctl.btp_socket.send(*GATTC['read_uuid'], data=data_ba)
def gattc_write_long(bd_addr_type, bd_addr, hdl, off, val, length=None): logging.debug("%s %r %r %r %r %r", gattc_write_long.__name__, bd_addr_type, hdl, off, val, length) gap_wait_for_connection() if isinstance(hdl, str): hdl = int(hdl, 16) # convert string in hex format to int if isinstance(off, str): off = int(off, 16) if length: val *= int(length) iutctl = get_iut() bd_addr_ba = addr2btp_ba(bd_addr) hdl_ba = struct.pack('H', hdl) off_ba = struct.pack('H', off) val_ba = bytes.fromhex(val) val_len_ba = struct.pack('H', len(val_ba)) data_ba = bytearray() data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(hdl_ba) data_ba.extend(off_ba) data_ba.extend(val_len_ba) data_ba.extend(val_ba) iutctl.btp_socket.send(*GATTC['write_long'], data=data_ba)
def gap_conn_param_update(bd_addr, bd_addr_type, conn_itvl_min, conn_itvl_max, conn_latency, supervision_timeout): logging.debug("%s %r %r", gap_conn_param_update.__name__, bd_addr, bd_addr_type) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr)) data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8')) data_ba.extend(bd_addr_ba) conn_itvl_min_ba = struct.pack('H', conn_itvl_min) conn_itvl_max_ba = struct.pack('H', conn_itvl_max) conn_latency_ba = struct.pack('H', conn_latency) supervision_timeout_ba = struct.pack('H', supervision_timeout) data_ba.extend(conn_itvl_min_ba) data_ba.extend(conn_itvl_max_ba) data_ba.extend(conn_latency_ba) data_ba.extend(supervision_timeout_ba) iutctl.btp_socket.send(*GAP['conn_param_update'], data=data_ba) # Expected result gap_command_rsp_succ()
def __bytes__(self): data_ba = bytearray() bd_addr_ba = addr2btp_ba(self.addr) data_ba.extend([self.addr_type]) data_ba.extend(bd_addr_ba) return data_ba
def gap_unpair(bd_addr=None, bd_addr_type=None): logging.debug("%s %r %r", gap_unpair.__name__, bd_addr, bd_addr_type) iutctl = get_iut() data_ba = bytearray() bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr)) data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8')) data_ba.extend(bd_addr_ba) iutctl.btp_socket.send(*GAP['unpair'], data=data_ba) # Expected result gap_command_rsp_succ(defs.GAP_UNPAIR)
def gattc_disc_all_prim(bd_addr_type, bd_addr): logging.debug("%s %r %r", gattc_disc_all_prim.__name__, bd_addr_type, bd_addr) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) iutctl.btp_socket.send(*GATTC['disc_all_prim'], data=data_ba)
def gap_conn(bd_addr=None, bd_addr_type=None, own_addr_type=OwnAddrType.le_identity_address): logging.debug("%s %r %r", gap_conn.__name__, bd_addr, bd_addr_type) iutctl = get_iut() data_ba = bytearray() bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr)) data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(chr(own_addr_type).encode('utf-8')) iutctl.btp_socket.send(*GAP['conn'], data=data_ba) gap_command_rsp_succ()
def gattc_exchange_mtu(bd_addr_type, bd_addr): logging.debug("%s %r %r", gattc_exchange_mtu.__name__, bd_addr_type, bd_addr) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) iutctl.btp_socket.send(*GATTC['exchange_mtu'], data=data_ba) gatt_command_rsp_succ()
def l2cap_disconn_eatt_chans(bd_addr, bd_addr_type, channel_count): logging.debug("%s %r", l2cap_disconn_eatt_chans.__name__, channel_count) iutctl = get_iut() bd_addr = pts_addr_get(bd_addr) bd_addr_type = pts_addr_type_get(bd_addr_type) bd_addr_ba = addr2btp_ba(bd_addr) data_ba = bytearray(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(bytearray(chr(channel_count).encode('utf-8'))) iutctl.btp_socket.send(*L2CAP['disconnect_eatt_chans'], data=data_ba) l2cap_command_rsp_succ(defs.L2CAP_DISCONNECT_EATT_CHANS)
def gap_disconn(bd_addr=None, bd_addr_type=None): logging.debug("%s %r %r", gap_disconn.__name__, bd_addr, bd_addr_type) iutctl = get_iut() stack = get_stack() if not stack.gap.is_connected(): return data_ba = bytearray() bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr)) data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8')) data_ba.extend(bd_addr_ba) iutctl.btp_socket.send(*GAP['disconn'], data=data_ba) gap_command_rsp_succ()
def gattc_disc_prim_uuid(bd_addr_type, bd_addr, uuid): logging.debug("%s %r %r %r", gattc_disc_prim_uuid.__name__, bd_addr_type, bd_addr, uuid) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) uuid_ba = bytes.fromhex(uuid.replace("-", "")) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(chr(len(uuid_ba)).encode('utf-8')) data_ba.extend(uuid_ba) iutctl.btp_socket.send(*GATTC['disc_prim_uuid'], data=data_ba)
def gattc_disc_all_chrc(bd_addr_type, bd_addr, start_hdl, stop_hdl, svc=None): logging.debug("%s %r %r %r %r %r", gattc_disc_all_chrc.__name__, bd_addr_type, bd_addr, start_hdl, stop_hdl, svc) iutctl = get_iut() gap_wait_for_connection() if svc: svc_nb = svc[1] for s in GATT_SVCS: if not ((svc[0][0] and svc[0][0] != s[0]) and (svc[0][1] and svc[0][1] != s[1]) and (svc[0][2] and svc[0][2] != s[2])): # To take n-th service svc_nb -= 1 if svc_nb != 0: continue start_hdl = s[0] stop_hdl = s[1] logging.debug("Got requested service!") break if isinstance(start_hdl, str): start_hdl = int(start_hdl, 16) if isinstance(stop_hdl, str): stop_hdl = int(stop_hdl, 16) data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) start_hdl_ba = struct.pack('H', start_hdl) stop_hdl_ba = struct.pack('H', stop_hdl) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(start_hdl_ba) data_ba.extend(stop_hdl_ba) iutctl.btp_socket.send(*GATTC['disc_all_chrc'], data=data_ba)
def gattc_read(bd_addr_type, bd_addr, hdl): logging.debug("%s %r %r %r", gattc_read.__name__, bd_addr_type, bd_addr, hdl) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) if isinstance(hdl, str): hdl = int(hdl, 16) hdl_ba = struct.pack('H', hdl) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(hdl_ba) iutctl.btp_socket.send(*GATTC['read'], data=data_ba)
def l2cap_reconfigure(bd_addr, bd_addr_type, mtu, channels): logging.debug("%s %r %r %r %r", l2cap_reconfigure.__name__, bd_addr, bd_addr_type, mtu, channels) iutctl = get_iut() bd_addr = pts_addr_get(bd_addr) bd_addr_type = pts_addr_type_get(bd_addr_type) bd_addr_ba = addr2btp_ba(bd_addr) data_ba = bytearray(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(struct.pack('H', mtu)) data_ba.extend(struct.pack('B', len(channels))) for chan in channels: data_ba.extend(struct.pack('B', chan)) iutctl.btp_socket.send(*L2CAP['reconfigure'], data=data_ba) l2cap_command_rsp_succ(defs.L2CAP_RECONFIGURE)
def gap_passkey_entry_rsp(bd_addr, bd_addr_type, passkey): logging.debug("%s %r %r", gap_passkey_entry_rsp.__name__, bd_addr, bd_addr_type) iutctl = get_iut() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) if isinstance(passkey, str): passkey = int(passkey, 32) passkey_ba = struct.pack('I', passkey) data_ba.extend(passkey_ba) iutctl.btp_socket.send(*GAP['passkey_entry_rsp'], data=data_ba) gap_command_rsp_succ()
def gattc_notification_ev(bd_addr, bd_addr_type, ev_type): logging.debug("%s %r %r %r", gattc_notification_ev.__name__, bd_addr, bd_addr_type, ev_type) iutctl = get_iut() tuple_hdr, tuple_data = iutctl.btp_socket.read() logging.debug("received %r %r", tuple_hdr, tuple_data) btp_hdr_check(tuple_hdr, defs.BTP_SERVICE_ID_GATT, defs.GATT_EV_NOTIFICATION) data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(chr(ev_type).encode('utf-8')) if tuple_data[0][0:len(data_ba)] != data_ba: raise BTPError("Error in notification event data")
def gap_passkey_confirm_rsp(bd_addr, bd_addr_type, passkey): logging.debug("%s %r %r", gap_passkey_confirm_rsp.__name__, bd_addr, bd_addr_type) iutctl = get_iut() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) if isinstance(passkey, str): passkey = int(passkey) match = int(passkey == int(get_stack().gap.get_passkey())) data_ba.extend(chr(match).encode('utf-8')) iutctl.btp_socket.send(*GAP['passkey_confirm_rsp'], data=data_ba) gap_command_rsp_succ()
def l2cap_conn(bd_addr, bd_addr_type, psm, mtu=0, num=1): logging.debug("%s %r %r %r", l2cap_conn.__name__, bd_addr, bd_addr_type, psm) iutctl = get_iut() gap_wait_for_connection() if isinstance(psm, str): psm = int(psm, 16) bd_addr = pts_addr_get(bd_addr) bd_addr_type = pts_addr_type_get(bd_addr_type) bd_addr_ba = addr2btp_ba(bd_addr) data_ba = bytearray(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(struct.pack('H', psm)) data_ba.extend(struct.pack('H', mtu)) data_ba.extend(struct.pack('B', num)) iutctl.btp_socket.send(*L2CAP['connect'], data=data_ba) chan_ids = l2cap_conn_rsp() logging.debug("id %r", chan_ids)
def _gattc_find_included_req(bd_addr_type, bd_addr, start_hdl, end_hdl): logging.debug("%s %r %r %r %r", _gattc_find_included_req.__name__, bd_addr_type, bd_addr, start_hdl, end_hdl) iutctl = get_iut() if isinstance(end_hdl, str): end_hdl = int(end_hdl, 16) if isinstance(start_hdl, str): start_hdl = int(start_hdl, 16) data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) start_hdl_ba = struct.pack('H', start_hdl) end_hdl_ba = struct.pack('H', end_hdl) data_ba.extend(chr(bd_addr_type).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(start_hdl_ba) data_ba.extend(end_hdl_ba) iutctl.btp_socket.send(*GATTC['find_included'], data=data_ba)
def gattc_read_multiple_var(bd_addr_type, bd_addr, *hdls): logging.debug("%s %r %r %r", gattc_read_multiple_var.__name__, bd_addr_type, bd_addr, hdls) iutctl = get_iut() gap_wait_for_connection() data_ba = bytearray() bd_addr_ba = addr2btp_ba(bd_addr) hdls_j = ''.join(hdl for hdl in hdls) hdls_byte_table = [hdls_j[i:i + 2] for i in range(0, len(hdls_j), 2)] hdls_swp = ''.join([ c[1] + c[0] for c in zip(hdls_byte_table[::2], hdls_byte_table[1::2]) ]) hdls_ba = binascii.unhexlify(bytearray(hdls_swp)) data_ba.extend(chr(bd_addr_type)) data_ba.extend(bd_addr_ba) data_ba.extend(chr(len(hdls))) data_ba.extend(hdls_ba) iutctl.btp_socket.send(*GATTC['read_multiple_var'], data=data_ba)
def gap_rpa_conn(description, own_addr_type=OwnAddrType.le_identity_address): """Initiate connection with PTS using RPA address provided in MMI description. Function returns True. Arguments: description -- description provided in PTS MMI. """ logging.debug("%s %s", gap_conn.__name__, description) iutctl = get_iut() bd_addr = re.search("[a-fA-F0-9]{12}", description).group(0) bd_addr_type = Addr.le_random data_ba = bytearray() bd_addr_ba = addr2btp_ba(pts_addr_get(bd_addr)) data_ba.extend(chr(pts_addr_type_get(bd_addr_type)).encode('utf-8')) data_ba.extend(bd_addr_ba) data_ba.extend(chr(own_addr_type).encode('utf-8')) iutctl.btp_socket.send(*GAP['conn'], data=data_ba) gap_command_rsp_succ() return True