projects / pub / lufa.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
More SDP code improvements - responses to ServiceSearchAttribute service discovery...
[pub/lufa.git] / 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 f79bb42..4eb2621 100644 (file)
--- 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"
 
 #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 =
        {
 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_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 =
        {
 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
        };
                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
 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)
 {
 
 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:
        switch (SDPHeader->PDU)
        {
                case SDP_PDU_SERVICESEARCHREQUEST:
-                       ServiceDiscovery_ProcessServiceSearch(SDPHeader);
+                       ServiceDiscovery_ProcessServiceSearch(SDPHeader, Channel);
                        break;          
                case SDP_PDU_SERVICEATTRIBUTEREQUEST:
                        break;          
                case SDP_PDU_SERVICEATTRIBUTEREQUEST:
-                       ServiceDiscovery_ProcessServiceAttribute(SDPHeader);
+                       ServiceDiscovery_ProcessServiceAttribute(SDPHeader, Channel);
                        break;
                case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST:
                        break;
                case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST:
-                       ServiceDiscovery_ProcessServiceSearchAttribute(SDPHeader);
+                       ServiceDiscovery_ProcessServiceSearchAttribute(SDPHeader, Channel);
                        break;
        }
 }
 
                        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");
 }
 
 {
        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");
 }
 
 {
        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");
        
        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);
        
        uint8_t SizeIndex = (*((uint8_t*)*DataElementHeader) & 0x07);
        *DataElementHeader += sizeof(uint8_t);
        
-       *ElementHeaderSize = 1;
-       
        uint32_t ElementValue;
        uint32_t ElementValue;
-       
+
+       /* Convert the Data Element size index into a size in bytes */
        switch (SizeIndex)
        {
        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);
                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;
                        *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;
                        ElementValue = *((uint32_t*)*DataElementHeader);
                        *DataElementHeader += sizeof(uint32_t);
                        *ElementHeaderSize  = (1 + sizeof(uint32_t));
                        break;
+               default:
+                       ElementValue = (1 << SizeIndex);
+                       *ElementHeaderSize = 1;
+                       break;
        }
        
        return ElementValue;
        }
        
        return ElementValue;
Lightweight USB Framework for AVRs