+ /* Create a pointer to the buffer to indicate the current location for response data to be added */
+ void* CurrResponsePos = ResponsePacket.ResponseData;
+
+ /* Clamp the maximum attribute size to the size of the allocated buffer */
+ if (MaxAttributeSize > sizeof(ResponsePacket.ResponseData))
+ MaxAttributeSize = sizeof(ResponsePacket.ResponseData);
+
+ /* Add the outer Data Element Sequence header for all of the retrieved Attributes */
+ uint16_t* TotalResponseSize = SDP_AddSequence16(&CurrResponsePos);
+
+ /* Search through the global service list an item at a time */
+ for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(void*)); CurrTableItem++)
+ {
+ /* Read in a pointer to the current UUID table entry's Attribute table */
+ ServiceAttributeTable_t* CurrAttributeTable = pgm_read_ptr(&SDP_Services_Table[CurrTableItem]);
+
+ if (!(SDP_SearchServiceTable(UUIDList, TotalUUIDs, CurrAttributeTable)))
+ continue;
+
+ BT_SDP_DEBUG(2, " -- Found search match in table");
+
+ /* Add the listed attributes for the found UUID to the response */
+ *TotalResponseSize += SDP_AddListedAttributesToResponse(CurrAttributeTable, AttributeList, TotalAttributes,
+ &CurrResponsePos);
+ }
+
+ /* Continuation state - always zero */
+ SDP_WriteData8(&CurrResponsePos, 0);
+
+ /* Set the total response list size to the size of the outer container plus its header size and continuation state */
+ ResponsePacket.AttributeListByteCount = SwapEndian_16(3 + *TotalResponseSize);
+
+ /* Calculate the total parameter length that is to be sent, including the fixed return parameters, the created attribute
+ value list and the SDP continuation state */
+ uint16_t ParamLength = (sizeof(ResponsePacket.AttributeListByteCount) +
+ (3 + *TotalResponseSize) +
+ sizeof(uint8_t));
+
+ /* Flip the endianness of the container's size */
+ *TotalResponseSize = SwapEndian_16(*TotalResponseSize);
+
+ /* Fill in the response packet's header */
+ ResponsePacket.SDPHeader.PDU = SDP_PDU_SERVICESEARCHATTRIBUTERESPONSE;
+ ResponsePacket.SDPHeader.TransactionID = SDPHeader->TransactionID;
+ ResponsePacket.SDPHeader.ParameterLength = SwapEndian_16(ParamLength);
+
+ BT_SDP_DEBUG(1, ">> Service Search Attribute Response");
+ BT_SDP_DEBUG(2, "-- Param Len 0x%04X", ParamLength);
+
+ /* Send the completed response packet to the sender */
+ Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ParamLength), Channel);
+}
+
+/** Adds all the Attributes in the given service table to the response that appear in the Attribute table.
+ *
+ * \param[in] AttributeTable Pointer to an Attribute table for the service to examine
+ * \param[in] AttributeList Pointer to a list of Attribute ranges
+ * \param[in] TotalAttributes Number of Attributes stored in the Attribute list
+ * \param[out] BufferPos Pointer to the output buffer position where the retrieved attributes are to be stored
+ *
+ * \return Number of bytes added to the output buffer
+ */
+static uint16_t SDP_AddListedAttributesToResponse(const ServiceAttributeTable_t* AttributeTable, uint16_t AttributeList[][2],
+ const uint8_t TotalAttributes, void** const BufferPos)
+{
+ uint16_t TotalResponseSize;
+
+ /* Add an inner Data Element Sequence header for the current services's found Attributes */
+ uint16_t* AttributeListSize = SDP_AddSequence16(BufferPos);
+
+ /* Search through the list of Attributes one at a time looking for values in the current UUID's Attribute table */
+ for (uint8_t CurrAttribute = 0; CurrAttribute < TotalAttributes; CurrAttribute++)
+ {
+ uint16_t* AttributeIDRange = AttributeList[CurrAttribute];
+ void* AttributeValue;
+
+ /* Look through the current service's attribute list, examining all the attributes */
+ while ((AttributeValue = pgm_read_ptr(&AttributeTable->Data)) != NULL)
+ {
+ /* Get the current Attribute's ID from the current attribute table entry */
+ uint16_t CurrAttributeID = pgm_read_word(&AttributeTable->AttributeID);
+
+ /* Check if the current Attribute's ID is within the current Attribute range */
+ if ((CurrAttributeID >= AttributeIDRange[0]) && (CurrAttributeID <= AttributeIDRange[1]))
+ {
+ /* Increment the current UUID's returned Attribute container size by the number of added bytes */
+ *AttributeListSize += SDP_AddAttributeToResponse(CurrAttributeID, AttributeValue, BufferPos);
+ }
+
+ AttributeTable++;
+ }
+ }
+
+ /* Record the total number of added bytes to the buffer */
+ TotalResponseSize = 3 + *AttributeListSize;
+
+ /* Fix endianness of the added attribute data element sequence */
+ *AttributeListSize = SwapEndian_16(*AttributeListSize);
+
+ return TotalResponseSize;
+}
+
+/** Adds the given attribute ID and value to the reponse buffer, and advances the response buffer pointer past the added data.
+ *
+ * \param[in] AttributeID Attribute ID to add to the response buffer
+ * \param[in] AttributeValue Pointer to the start of the Attribute's value, located in PROGMEM
+ * \param[in, out] ResponseBuffer Pointer to a buffer where the Attribute and Attribute Value is to be added
+ *
+ * \return Number of bytes added to the response buffer
+ */
+static uint16_t SDP_AddAttributeToResponse(const uint16_t AttributeID, const void* AttributeValue, void** ResponseBuffer)
+{
+ /* Retrieve the size of the attribute value from its container header */
+ uint8_t AttributeHeaderLength;
+ uint16_t AttributeValueLength = SDP_GetLocalAttributeContainerSize(AttributeValue, &AttributeHeaderLength);
+
+ BT_SDP_DEBUG(2, " -- Add Attribute (0x%04X) 0x%04X", (AttributeHeaderLength + AttributeValueLength), AttributeID);
+
+ /* Add a Data Element header to the response for the Attribute ID */
+ SDP_WriteData8(ResponseBuffer, (SDP_DATATYPE_UnsignedInt | SDP_DATASIZE_16Bit));
+
+ /* Add the Attribute ID to the created Data Element */
+ SDP_WriteData16(ResponseBuffer, AttributeID);
+
+ /* Copy over the Attribute value Data Element container to the response */
+ memcpy_P(*ResponseBuffer, AttributeValue, AttributeHeaderLength + AttributeValueLength);
+ *ResponseBuffer += AttributeHeaderLength + AttributeValueLength;
+
+ return (sizeof(uint8_t) + sizeof(uint16_t) + AttributeHeaderLength + AttributeValueLength);
+}
+
+/** Retrieves a pointer to the value of the given Attribute ID from the given Attribute table.
+ *
+ * \param[in] AttributeTable Pointer to the Attribute table to search in
+ * \param[in] AttributeID Attribute ID to search for within the table
+ *
+ * \return Pointer to the start of the Attribute's value if found within the table, NULL otherwise
+ */
+static void* SDP_GetAttributeValue(const ServiceAttributeTable_t* AttributeTable, const uint16_t AttributeID)
+{
+ void* CurrTableItemData;
+
+ /* Search through the current Attribute table, abort when the terminator item has been reached */
+ while ((CurrTableItemData = pgm_read_ptr(&AttributeTable->Data)) != NULL)
+ {
+ /* Check if the current Attribute ID matches the search ID - if so return a pointer to it */
+ if (pgm_read_word(&AttributeTable->AttributeID) == AttributeID)
+ return CurrTableItemData;
+
+ AttributeTable++;
+ }
+
+ return NULL;
+}
+
+/** Retrieves the Attribute table for the given UUID list if it exists.
+ *
+ * \param[in] UUIDList List of UUIDs which must be matched within the service attribute table
+ * \param[in] TotalUUIDs Total number of UUIDs stored in the UUID list
+ * \param[in] CurrAttributeTable Pointer to the service attribute table to search through
+ *
+ * \return True if all the UUIDs given in the UUID list appear in the given attribute table, false otherwise
+ */
+static bool SDP_SearchServiceTable(uint8_t UUIDList[][UUID_SIZE_BYTES], const uint8_t TotalUUIDs,
+ const ServiceAttributeTable_t* CurrAttributeTable)
+{
+ bool UUIDMatch[TotalUUIDs];
+
+ /* Set all the match flags to false (not matched) before starting the search */
+ memset(UUIDMatch, false, sizeof(UUIDMatch));
+
+ const void* CurrAttribute;
projects / pub / lufa.git / blobdiff