//----
internal List <ServiceRecord> DoSdpQueryWithConnect(
BluetoothAddress addr, Guid svcClass, bool rfcommOnly)
{
var svcUuid = new Structs.uuid_t(svcClass);
//:TestUuids();
// Connect
byte[] target = BluezUtils.FromBluetoothAddress(addr);
Console.WriteLine("Gonna sdp_connect (SafeHandle)...");
NativeMethods.SdpSessionSafeHandle session = NativeMethods.sdp_connect(StackConsts.BDADDR_ANY,
target, StackConsts.SdpConnectFlags.SDP_RETRY_IF_BUSY);
if (session.IsInvalid)
{
//BluezUtils.Throw((BluezError)(-1), "sdp_connect");
const int WSASERVICE_NOT_FOUND = 10108;
throw new SocketException(WSASERVICE_NOT_FOUND);
}
try {
// Query
return(DoSdpQuery(session, svcUuid, rfcommOnly));
} finally {
session.Close();
}
}
void InitRadios()
{
if (_radioPrimary != null)
{
return;
}
//
int idPrimary = NativeMethods.hci_get_route(IntPtr.Zero);
/////////////////////////////// BluezUtils.CheckAndThrow((BluezError)idPrimary, "hci_get_route");
var dd = NativeMethods.hci_open_dev(idPrimary);
Console.WriteLine("InitRadios idPrimary: {0}, dd: {1}", idPrimary, dd);
_radioPrimary = new BluezRadio(this, dd);
//
int maxToTry = 10;
var list = new List <IBluetoothRadio>();
for (int curId = 0; curId < maxToTry; ++curId)
{
var curDd = NativeMethods.hci_open_dev(curId);
var ret = (BluezError)curDd;
if (BluezUtils.IsSuccess(ret))
{
Console.WriteLine("InitRadios curDd: {0}", curDd);
var curR = new BluezRadio(this, curDd);
list.Add(curR);
}
}
_radioList = list;
Debug.Assert(_radioList.Count >= 1);
}
IBluetoothDeviceInfo[] DoDiscoverDevices(
int maxDevices, bool authenticated, bool remembered, bool unknown, bool discoverableOnly,
BluetoothClient.LiveDiscoveryCallback liveDiscoHandler, object liveDiscoState)
{
Console.WriteLine("DoDiscoverDevices");
var discoTime = DateTime.UtcNow;
List <IBluetoothDeviceInfo> known = new List <IBluetoothDeviceInfo>(); // hack often GC fodder
var bus = _fcty.BluezDbus;
known = bus.GetDeviceList_OnDefaultAdapter();
//
List <IBluetoothDeviceInfo> inquired = null;
if (discoverableOnly || unknown)
{
inquired = new List <IBluetoothDeviceInfo>();
double td = InquiryLength.TotalSeconds;
const double Multiplier = 1.25d;
td /= Multiplier;
int t = (int)td;
StackConsts.IREQ_int flags = StackConsts.IREQ_int.IREQ_CACHE_FLUSH;
//
var TypeofItem = typeof(Structs.inquiry_info);
var SizeofItem = Marshal.SizeOf(TypeofItem);
IntPtr pii = BluezUtils.malloc(maxDevices * SizeofItem);
try {
Console.WriteLine("Gonna hci_inquiry num_rsp: {0}, t: {1} ({2} was {3}) ", maxDevices, t, td, InquiryLength);
// TO-DO LAP/IAC: var lap = InquiryAccessCode;
//var stackTrace = new StackTrace();
//var msg = "Gonna hci_inquiry at: " + stackTrace;
//Debug.WriteLine(msg);
//Console.WriteLine(msg);
int num = NativeMethods.hci_inquiry(_fcty.DevId, t, maxDevices, IntPtr.Zero, ref pii, flags);
Console.WriteLine("inquiry num=" + num);
//BluezUtils.CheckAndThrow((BluezError)num, "hci_inquiry");
BluezUtils.Assert((BluezError)num, "hci_inquiry");
//
IntPtr pCur = pii;
for (int i = 0; i < num; i++)
{
var cur = (Structs.inquiry_info)Marshal.PtrToStructure(pCur, TypeofItem);
var bdi = BluezDeviceInfo.CreateFromInquiry(_fcty, cur);
inquired.Add(bdi);
pCur = PointerAdd(pCur, SizeofItem);
}//for
} finally {
BluezUtils.free(pii);
}
}
//
var merged = BluetoothClient.DiscoverDevicesMerge(
authenticated, remembered, unknown,
known, inquired, discoverableOnly, discoTime);
return(merged.ToArray());
}
void CloseStack()
{
lock (_lock) {
var hDevD = _hDevDescr;
if (hDevD != null)
{
BluezUtils.close(hDevD.Value);
}
}
}
internal static BluezDeviceInfo CreateFromInquiry(BluezFactory fcty, Structs.inquiry_info cur)
{
var addr = BluezUtils.ToBluetoothAddress(cur.bdaddr);
var bdi = new BluezDeviceInfo(fcty, addr);
bdi._cod = BluezUtils.ToClassOfDevice(cur.dev_class);
// Note the devices here aren't 'created' by BlueZ so no ObjectPath.
// We'll lookup/create the device later if required.
//
return(bdi);
}
void adapter_DeviceFound(string address, IDictionary <string, object> properties)
{
Console.WriteLine("xAdapter_DeviceFound addr: {0}, prop.Count: {1}",
address, properties.Count);
if (!_livePropDumped)
{
_livePropDumped = true;
BluezUtils.DumpKeys(properties);
// "keys: Address, Class, Icon, RSSI, Name, Alias, LegacyPairing, Paired"
}
var bdi = BluezDeviceInfo.CreateFromInquiryLive(_fcty, properties);
LiveDisco(bdi);
}
internal static NativeMethods.SdpSessionSafeHandle AddRecord(IntPtr rec)
{
//Console.Write("Hit return to AddRecord> ");
//Console.ReadLine();
//
BluezError ret;
var session = NativeMethods.sdp_connect(
StackConsts.BDADDR_ANY, StackConsts.BDADDR_LOCAL,
StackConsts.SdpConnectFlags.SDP_RETRY_IF_BUSY);
//
ret = NativeMethods.sdp_record_register(session, rec, 0);
BluezUtils.CheckAndThrow(ret, "sdp_record_register");
return(session);
}
internal static BluezDeviceInfo CreateFromStored(BluezFactory fcty,
ObjectPath objectPath,
BluetoothAddress address,
IDictionary <string, object> dbusDeviceDict)
{
var bdi = new BluezDeviceInfo(fcty, address);
if (!_propDumped)
{
_propDumped = true;
BluezUtils.DumpKeys(dbusDeviceDict);
// "keys: Address, Name, Alias, Class, Icon, Paired, Trusted, Connected, UUIDs, Adapter"
}
SetProperties(objectPath, bdi, dbusDeviceDict);
return(bdi);
}
internal static IntPtr Malloc <T>(ref T val, List <IntPtr> listAllocs) where T : struct
{
int size = Marshal.SizeOf(val);
IntPtr p = BluezUtils.malloc(size);
//Console.WriteLine("Malloc size: {0}, p: {1}", size, p);
if (p == IntPtr.Zero)
{
throw new InvalidOperationException("malloc");
}
listAllocs.Add(p);
Marshal.StructureToPtr(val, p, false);
var data = Marshal.ReadInt64(p);
//Console.WriteLine("Malloc data as u64: {0:X}", data);
return(p);
}
List <ServiceRecord> DoSdpQuery(NativeMethods.SdpSessionSafeHandle session,
Structs.uuid_t svcUuid, bool rfcommOnly)
{
var listAllocs = new List <IntPtr>();
IntPtr searchList = BluezUtils.sdp_list_append(IntPtr.Zero, svcUuid, listAllocs);
// Attribute pattern
IntPtr attridList;
StackConsts.sdp_attrreq_type_t reqType;
Console.WriteLine("rfcommOnly: " + rfcommOnly);
if (rfcommOnly)
{
const UInt16 ClassListId = (ushort)UniversalAttributeId.ServiceClassIdList; //=1
const UInt16 ProtoDListId = (ushort)UniversalAttributeId.ProtocolDescriptorList; //=4
reqType = StackConsts.sdp_attrreq_type_t.SDP_ATTR_REQ_INDIVIDUAL;
attridList = BluezUtils.sdp_list_append(IntPtr.Zero, ClassListId, listAllocs);
attridList = BluezUtils.sdp_list_append(attridList, ProtoDListId, listAllocs);
}
else
{
const UInt32 allAttributes = 0x0000ffff;
reqType = StackConsts.sdp_attrreq_type_t.SDP_ATTR_REQ_RANGE;
attridList = BluezUtils.sdp_list_append(IntPtr.Zero, allAttributes, listAllocs);
}
// Query
Console.WriteLine("sdp_service_search_attr_req in:"
+ " {0}, attrid_list: {1}",
searchList, attridList);
IntPtr pResponseList;
BluezError ret = NativeMethods.sdp_service_search_attr_req(session,
searchList,
reqType, attridList,
out pResponseList);
Console.WriteLine("sdp_service_search_attr_req ret: {0}, result: {1}",
ret, pResponseList);
BluezUtils.CheckAndThrow(ret, "sdp_service_search_attr_req");
//
var rList = BuildRecordList(pResponseList);
return(rList);
}
//----
internal BluezRadio(BluezFactory fcty, int dd)
{
_dd = dd;
Debug.Assert(fcty != null, "ArgNull");
_fcty = fcty;
BluezError ret;
var bdaddr = BluezUtils.FromBluetoothAddress(BluetoothAddress.None);
ret = NativeMethods.hci_read_bd_addr(_dd, bdaddr, _fcty.StackTimeout);
//TODO BluezUtils.CheckAndThrow(ret, "hci_read_bd_addr");
BluezUtils.Assert(ret, "hci_read_bd_addr");
if (BluezUtils.IsSuccess(ret))
{
_addr = BluezUtils.ToBluetoothAddress(bdaddr);
Console.WriteLine("Radio SUCCESS, addr: " + _addr);
}
else
{
// NEVER used EXCEPT in the debugger if we skip the CheckandThrow above.
_addr = BluetoothAddress.None;
Console.WriteLine("Radio FAIL, addr: " + _addr);
}
_nameTmp = new byte[250];
//
// First find _objectPath. In the future we'll be passed this.
var ax = _fcty.BluezDbus.FindAdapter(_addr, out _objectPath);
Debug.Assert(_objectPath != null, "BluezRadio..ctor NOT _objectPath!=null");
//--
// Set Adapter.
_adapter = GetAdapter(_objectPath);
Console.WriteLine("Got adapter at .ctor.3.");
//
var prop = GetProperties();
string addrDt = (string)prop[PropertyName.Address];
var addrD = BluetoothAddress.Parse(addrDt);
Utils.MiscUtils.AssertEquals(addrD, _addr);
Console.WriteLine("Check DONE Radio..ctor. " + addrD + " vs " + _addr);
}
private void OpenStack()
{
lock (_lock) {
if (_hDevDescr == null)
{
BluezError ret;
int hDevId = NativeMethods.hci_get_route(IntPtr.Zero); // TODO (BlueZ: open specific interface)
ret = (BluezError)hDevId;
BluezUtils.CheckAndThrow(ret, "hci_get_route");
int hDevDescr = NativeMethods.hci_open_dev(hDevId);
ret = (BluezError)hDevDescr;
BluezUtils.CheckAndThrow(ret, "hci_open_dev");
if (hDevId < 0 || hDevDescr < 0)
{
Debug.Fail("should have been detected above");
BluezUtils.Throw(ret, "opening socket");
}
_hDevId = hDevId;
_hDevDescr = hDevDescr;
Console.WriteLine("Id: {0}, DD: {1}", DevId, DevDescr);
}
}
}
private static void EnsureHasObjectPath(BluezDeviceInfo bdi)
{
// A device from discovery (D-Bus or HCI) isn't 'created' by BlueZ
// so no ObjectPath. So we have to lookup/create the device now.
if (bdi._dbusPath != null)
{
return;
}
var pd = bdi._fcty.BluezDbus.FindDeviceProperties_OnDefaultAdapter(bdi._addr, out bdi._dbusPath);
Debug.Assert((pd == null) == (bdi._dbusPath == null), "Xor! "
+ Utils.MiscUtils.ToStringQuotedOrNull(pd) + " vs "
+ Utils.MiscUtils.ToStringQuotedOrNull(bdi._dbusPath));
if (pd == null)
{
// Doesn't exist, so have to create the device now.
var a = bdi._fcty.BluezDbus.GetDefaultAdapter();
bdi._dbusPath = a.CreateDevice(BluezUtils.FromBluetoothAddressToDbus(bdi._addr));
}
Debug.Assert(bdi._dbusPath != null, "NOT _dbusPath!=null after EnsureHasObjectPath.");
Console.WriteLine("EnsureHasObjectPath after: "
+ Utils.MiscUtils.ToStringQuotedOrNull(bdi._dbusPath));
}
//--
void ReadVersions()
{
if (_doneVersions)
{
return;
}
var vers = new Structs.hci_version(HciVersion.Unknown);
var ret = NativeMethods.hci_read_local_version(_dd, ref vers, _fcty.StackTimeout);
BluezUtils.Assert(ret, "hci_read_local_version");
if (BluezUtils.IsSuccess(ret))
{
_versions = vers;
}
_doneVersions = true; // Always set, as unlikely to work second time if failed first time.
//
var arr = new byte[8];
ret = NativeMethods.hci_read_local_features(_dd, arr, _fcty.StackTimeout);
if (BluezUtils.IsSuccess(ret))
{
_lmpFeatures = (LmpFeatures)BitConverter.ToInt64(arr, 0);
}
}
private static void SetProperties(ObjectPath objectPath,
BluezDeviceInfo bdi, IDictionary <string, object> dbusDeviceDict)
{
// Stored:
// "keys: Address, Name, Alias, Class, Icon, Paired, Trusted, Connected, UUIDs, Adapter"
// D-Bus Inquiry event:
// "keys: Address, Name, Alias, Class, Icon, Paired; RSSI, LegacyPairing"
// ("keys: Address, Class, Icon, RSSI, Name, Alias, LegacyPairing, Paired")
#if DEBUG
var checkAddr = BluetoothAddress.Parse((string)dbusDeviceDict["Address"]);
Debug.Assert(bdi._addr == checkAddr, "NOT EQUAL address: " + bdi._addr + " checkAddr: " + checkAddr);
#endif
bdi._rmbd = true;
bdi._dbusPath = objectPath;
BluezUtils.DebugKeyExists(dbusDeviceDict, "Paired");
bdi._authd = (bool)dbusDeviceDict["Paired"];
BluezUtils.DebugKeyExists(dbusDeviceDict, "Connected");
object value;
if (dbusDeviceDict.TryGetValue("Connected", out value))
{
bdi._connd = (bool)value;
}
BluezUtils.DebugKeyExists(dbusDeviceDict, "Alias");
bdi._name = (string)dbusDeviceDict["Alias"];
// Seen not present when callled from CreateFromGivenAddress from BtCli.GetRemoteMachineName.
BluezUtils.DebugKeyExists(dbusDeviceDict, "Class");
if (dbusDeviceDict.ContainsKey("Class"))
{
bdi._cod = new ClassOfDevice((UInt32)dbusDeviceDict["Class"]);
}
else
{
bdi._cod = new ClassOfDevice(0);
}
Console.WriteLine("After SetProperties, _name: " + bdi._name);
}
//--------
static string FromBluetoothAddress(BluetoothAddress address)
{
return(BluezUtils.FromBluetoothAddressToDbus(address));
}
