X-Git-Url: http://git.linex4red.de/pub/lufa.git/blobdiff_plain/071e02c6b6b4837fa9cf0b6d4c749994e02638d7..141d94fa980b6056c1922cbfeb9f5535227331c5:/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c diff --git a/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c b/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c index f79bb4239..4eb262103 100644 --- a/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c +++ b/Demos/Host/Incomplete/BluetoothHost/Lib/ServiceDiscoveryProtocol.c @@ -31,28 +31,39 @@ #define INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C #include "ServiceDiscoveryProtocol.h" -SERVICE_ATTRIBUTE_TEXT(SDP_Attribute_Name, "SDP"); -SERVICE_ATTRIBUTE_TEXT(SDP_Attribute_Description, "BT Service Discovery"); -SERVICE_ATTRIBUTE_8BIT_LEN(SDP_Attribute_Availability, SDP_DATATYPE_UNSIGNED_INT, 1, {0xFF}); +/** Service Discovery Protocol attribute, indicationg the service's name. */ +SERVICE_ATTRIBUTE_TEXT(SDP_Attribute_Name, "SDP"); +/** Service Discovery Protocol attribute, indicationg the service's description. */ +SERVICE_ATTRIBUTE_TEXT(SDP_Attribute_Description, "BT Service Discovery"); +/** Service Discovery Protocol attribute, indicationg the service's availability. */ +SERVICE_ATTRIBUTE_LEN8(SDP_Attribute_Availability, SDP_DATATYPE_UnsignedInt, 1, {0xFF}); +/** Service Discovery Protocol attribute table, listing all supported attributes of the service. */ const ServiceAttributeTable_t SDP_Attribute_Table[] PROGMEM = { - {.AttributeID = SDP_ATTRIBUTE_NAME , .AttributeData = &SDP_Attribute_Name}, - {.AttributeID = SDP_ATTRIBUTE_DESCRIPTION , .AttributeData = &SDP_Attribute_Description}, - {.AttributeID = SDP_ATTRIBUTE_AVAILABILITY, .AttributeData = &SDP_Attribute_Availability}, + {.AttributeID = SDP_ATTRIBUTE_NAME , .Data = &SDP_Attribute_Name}, + {.AttributeID = SDP_ATTRIBUTE_DESCRIPTION , .Data = &SDP_Attribute_Description}, + {.AttributeID = SDP_ATTRIBUTE_AVAILABILITY, .Data = &SDP_Attribute_Availability}, SERVICE_ATTRIBUTE_TABLE_TERMINATOR }; -SERVICE_ATTRIBUTE_TEXT(RFCOMM_Attribute_Name, "RFCOMM"); -SERVICE_ATTRIBUTE_TEXT(RFCOMM_Attribute_Description, "Virtual Serial"); -SERVICE_ATTRIBUTE_8BIT_LEN(RFCOMM_Attribute_Availability, SDP_DATATYPE_UNSIGNED_INT, 1, {0xFF}); +/** RFCOMM Service attribute, indicationg the service's name. */ +SERVICE_ATTRIBUTE_TEXT(RFCOMM_Attribute_Name, "RFCOMM"); +/** RFCOMM Service attribute, indicationg the service's description. */ +SERVICE_ATTRIBUTE_TEXT(RFCOMM_Attribute_Description, "Virtual Serial"); +/** RFCOMM Service attribute, indicationg the service's availability. */ +SERVICE_ATTRIBUTE_LEN8(RFCOMM_Attribute_Availability, SDP_DATATYPE_UnsignedInt, 1, {0xFF}); +/** RFCOMM Service attribute table, listing all supported attributes of the service. */ const ServiceAttributeTable_t RFCOMM_Attribute_Table[] PROGMEM = { - {.AttributeID = SDP_ATTRIBUTE_NAME , .AttributeData = &RFCOMM_Attribute_Name}, - {.AttributeID = SDP_ATTRIBUTE_DESCRIPTION , .AttributeData = &RFCOMM_Attribute_Description}, - {.AttributeID = SDP_ATTRIBUTE_AVAILABILITY, .AttributeData = &RFCOMM_Attribute_Availability}, + {.AttributeID = SDP_ATTRIBUTE_NAME , .Data = &RFCOMM_Attribute_Name}, + {.AttributeID = SDP_ATTRIBUTE_DESCRIPTION , .Data = &RFCOMM_Attribute_Description}, + {.AttributeID = SDP_ATTRIBUTE_AVAILABILITY, .Data = &RFCOMM_Attribute_Availability}, SERVICE_ATTRIBUTE_TABLE_TERMINATOR }; - + +/** Master service table, listing all supported services (and their attribute tables) of the device, including + * each service's UUID. + */ const ServiceTable_t SDP_Services_Table[] = { { // 128-bit UUID for the SDP service @@ -65,6 +76,9 @@ const ServiceTable_t SDP_Services_Table[] = }, }; +/* Base UUID value common to all standardized Bluetooth services */ +const uint8_t BaseUUID[] = {BASE_96BIT_UUID, 0x00, 0x00, 0x00, 0x00}; + void ServiceDiscovery_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel) { @@ -78,102 +92,150 @@ void ServiceDiscovery_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel) switch (SDPHeader->PDU) { case SDP_PDU_SERVICESEARCHREQUEST: - ServiceDiscovery_ProcessServiceSearch(SDPHeader); + ServiceDiscovery_ProcessServiceSearch(SDPHeader, Channel); break; case SDP_PDU_SERVICEATTRIBUTEREQUEST: - ServiceDiscovery_ProcessServiceAttribute(SDPHeader); + ServiceDiscovery_ProcessServiceAttribute(SDPHeader, Channel); break; case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST: - ServiceDiscovery_ProcessServiceSearchAttribute(SDPHeader); + ServiceDiscovery_ProcessServiceSearchAttribute(SDPHeader, Channel); break; } } -static void ServiceDiscovery_ProcessServiceSearch(SDP_PDUHeader_t* SDPHeader) +static void ServiceDiscovery_ProcessServiceSearch(SDP_PDUHeader_t* SDPHeader, Bluetooth_Channel_t* Channel) { BT_SDP_DEBUG(1, "<< Service Search"); } -static void ServiceDiscovery_ProcessServiceAttribute(SDP_PDUHeader_t* SDPHeader) +static void ServiceDiscovery_ProcessServiceAttribute(SDP_PDUHeader_t* SDPHeader, Bluetooth_Channel_t* Channel) { BT_SDP_DEBUG(1, "<< Service Attribute"); } -static void ServiceDiscovery_ProcessServiceSearchAttribute(SDP_PDUHeader_t* SDPHeader) +static void ServiceDiscovery_ProcessServiceSearchAttribute(SDP_PDUHeader_t* SDPHeader, Bluetooth_Channel_t* Channel) { - void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t)); + const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t)); BT_SDP_DEBUG(1, "<< Service Search Attribute"); + + uint8_t UUIDList[12][UUID_SIZE_BYTES]; + uint8_t TotalUUIDs = ServiceDiscovery_GetUUIDList(UUIDList, &CurrentParameter); + BT_SDP_DEBUG(2, "-- Total UUIDs: %d", TotalUUIDs); - uint8_t ElementHeaderSize; + uint16_t MaxAttributeSize = ServiceDiscovery_Read16BitParameter(&CurrentParameter); + BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize); - uint16_t ServicePatternLength = ServiceDiscovery_GetDataElementSize(&CurrentParameter, &ElementHeaderSize); - BT_SDP_DEBUG(2, "-- Total UUID Length: 0x%04X", ServicePatternLength); - while (ServicePatternLength) + struct { - uint8_t UUIDLength = ServiceDiscovery_GetDataElementSize(&CurrentParameter, &ElementHeaderSize); - uint8_t UUID[16] = {BASE_96BIT_UUID, 0x00, 0x00, 0x00, 0x00}; + SDP_PDUHeader_t SDPHeader; + uint16_t AttributeListByteCount; + uint8_t ResponseData[100]; + } ResponsePacket; + + if (MaxAttributeSize > sizeof(ResponsePacket.ResponseData)) + MaxAttributeSize = sizeof(ResponsePacket.ResponseData); + + ResponsePacket.AttributeListByteCount = ServiceDiscovery_ProcessAttributes(UUIDList, TotalUUIDs, + ResponsePacket.ResponseData, + MaxAttributeSize, &CurrentParameter); + ResponsePacket.SDPHeader.PDU = SDP_PDU_SERVICESEARCHATTRIBUTERESPONSE; + ResponsePacket.SDPHeader.TransactionID = SDPHeader->TransactionID; + ResponsePacket.SDPHeader.ParameterLength = (ResponsePacket.AttributeListByteCount + sizeof(ResponsePacket.AttributeListByteCount)); + + Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ResponsePacket.SDPHeader.ParameterLength), + Channel); +} - if (UUIDLength <= 32) - memcpy(&UUID[sizeof(UUID) - sizeof(uint32_t)], CurrentParameter, UUIDLength); - else - memcpy(UUID, CurrentParameter, UUIDLength); +static uint8_t ServiceDiscovery_ProcessAttributes(uint8_t UUIDList[][UUID_SIZE_BYTES], const uint8_t TotalUUIDs, uint8_t* ResponseBuffer, + uint8_t MaxResponseSize, const void** CurrentParameter) +{ + uint16_t* AttributeResponseSize = ServiceDiscovery_AddDataElementHeader(&ResponseBuffer, SDP_DATATYPE_UnsignedInt); + uint8_t ElementHeaderSize; + + uint16_t AttributeIDListLength = ServiceDiscovery_GetDataElementSize(CurrentParameter, &ElementHeaderSize); + BT_SDP_DEBUG(2, "-- Total Attribute Length: 0x%04X", AttributeIDListLength); + while (AttributeIDListLength) + { + uint8_t AttributeLength = ServiceDiscovery_GetDataElementSize(CurrentParameter, &ElementHeaderSize); + uint32_t Attribute = 0; - CurrentParameter += UUIDLength; + memcpy(&((char*)&Attribute)[sizeof(uint32_t) - AttributeLength], *CurrentParameter, AttributeLength); + + BT_SDP_DEBUG(2, "-- Attribute(%d): 0x%08lX", AttributeLength, Attribute); - BT_SDP_DEBUG(2, "-- UUID (%d): 0x%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", - UUIDLength, - UUID[15], UUID[14], UUID[13], UUID[12], UUID[11], UUID[10], UUID[9], UUID[8], - UUID[7], UUID[6], UUID[5], UUID[4], UUID[3], UUID[2], UUID[1], UUID[0]); + *AttributeResponseSize += ServiceDiscovery_GetAttribute(UUIDList, TotalUUIDs, Attribute, &ResponseBuffer, + (MaxResponseSize - *AttributeResponseSize)); - ServicePatternLength -= (UUIDLength + ElementHeaderSize); + AttributeIDListLength -= (AttributeLength + ElementHeaderSize); + *CurrentParameter += AttributeLength; } - uint16_t MaxAttributeSize = ServiceDiscovery_Read16BitParameter(&CurrentParameter); - BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize); + return *AttributeResponseSize; +} - uint16_t AttributeIDListLength = ServiceDiscovery_GetDataElementSize(&CurrentParameter, &ElementHeaderSize); - BT_SDP_DEBUG(2, "-- Total Attribute Length: 0x%04X", AttributeIDListLength); - while (AttributeIDListLength) +static uint8_t ServiceDiscovery_GetAttribute(uint8_t UUIDList[][UUID_SIZE_BYTES], const uint8_t TotalUUIDs, const uint32_t Attribute, + uint8_t** DataBuffer, uint8_t BufferLen) +{ + for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(ServiceTable_t)); CurrTableItem++) + { + for (uint8_t CurrUUIDIndex = 0; CurrUUIDIndex < TotalUUIDs; CurrUUIDIndex++) + { + if (!(memcmp(SDP_Services_Table[CurrTableItem].UUID, UUIDList[CurrUUIDIndex], UUID_SIZE_BYTES))) + { + const ServiceAttributeTable_t* AttributeTable = SDP_Services_Table[CurrTableItem].AttributeTable; + + // TODO: Process attribute table + BT_SDP_DEBUG(2, "FOUND UUID IN TABLE"); + + break; + } + } + } + + return 0; +} + +static uint8_t ServiceDiscovery_GetUUIDList(uint8_t UUIDList[][UUID_SIZE_BYTES], const void** CurrentParameter) +{ + uint8_t ElementHeaderSize; + uint8_t TotalUUIDs = 0; + + uint16_t ServicePatternLength = ServiceDiscovery_GetDataElementSize(CurrentParameter, &ElementHeaderSize); + BT_SDP_DEBUG(2, "-- Total UUID Length: 0x%04X", ServicePatternLength); + while (ServicePatternLength) { - uint8_t AttributeLength = ServiceDiscovery_GetDataElementSize(&CurrentParameter, &ElementHeaderSize); - uint32_t Attribute = 0; + uint8_t* CurrentUUID = UUIDList[TotalUUIDs++]; + uint8_t UUIDLength = ServiceDiscovery_GetDataElementSize(CurrentParameter, &ElementHeaderSize); - memcpy(&Attribute, CurrentParameter, AttributeLength); - CurrentParameter += AttributeLength; + memcpy(CurrentUUID, BaseUUID, sizeof(BaseUUID)); + memcpy(&CurrentUUID[(UUIDLength <= 32) ? (sizeof(BaseUUID) - 32) : 0], *CurrentParameter, UUIDLength); - BT_SDP_DEBUG(2, "-- Attribute(%d): 0x%08lX", AttributeLength, Attribute); - - AttributeIDListLength -= (AttributeLength + ElementHeaderSize); + BT_SDP_DEBUG(2, "-- UUID (%d): 0x%02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X", + UUIDLength, + CurrentUUID[15], CurrentUUID[14], CurrentUUID[13], CurrentUUID[12], + CurrentUUID[11], CurrentUUID[10], CurrentUUID[9], CurrentUUID[8], + CurrentUUID[7], CurrentUUID[6], CurrentUUID[5], CurrentUUID[4], + CurrentUUID[3], CurrentUUID[2], CurrentUUID[1], CurrentUUID[0]); + + ServicePatternLength -= (UUIDLength + ElementHeaderSize); + *CurrentParameter += UUIDLength; } + + return TotalUUIDs; } -static uint32_t ServiceDiscovery_GetDataElementSize(void** DataElementHeader, uint8_t* ElementHeaderSize) +static uint32_t ServiceDiscovery_GetDataElementSize(const void** DataElementHeader, uint8_t* ElementHeaderSize) { + /* Fetch the size of the Data Element structure from the header, increment the current buffer pos */ uint8_t SizeIndex = (*((uint8_t*)*DataElementHeader) & 0x07); *DataElementHeader += sizeof(uint8_t); - *ElementHeaderSize = 1; - uint32_t ElementValue; - + + /* Convert the Data Element size index into a size in bytes */ switch (SizeIndex) { - case 0: - ElementValue = 1; - break; - case 1: - ElementValue = 2; - break; - case 2: - ElementValue = 4; - break; - case 3: - ElementValue = 8; - break; - case 4: - ElementValue = 16; - break; case 5: ElementValue = *((uint8_t*)*DataElementHeader); *DataElementHeader += sizeof(uint8_t); @@ -184,11 +246,15 @@ static uint32_t ServiceDiscovery_GetDataElementSize(void** DataElementHeader, ui *DataElementHeader += sizeof(uint16_t); *ElementHeaderSize = (1 + sizeof(uint16_t)); break; - default: + case 7: ElementValue = *((uint32_t*)*DataElementHeader); *DataElementHeader += sizeof(uint32_t); *ElementHeaderSize = (1 + sizeof(uint32_t)); break; + default: + ElementValue = (1 << SizeIndex); + *ElementHeaderSize = 1; + break; } return ElementValue;