SDP.c 29.7 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/*
             LUFA Library
     Copyright (C) Dean Camera, 2010.
              
  dean [at] fourwalledcubicle [dot] com
      www.fourwalledcubicle.com
*/

/*
  Copyright 2010  Dean Camera (dean [at] fourwalledcubicle [dot] com)

  Permission to use, copy, modify, distribute, and sell this 
  software and its documentation for any purpose is hereby granted
  without fee, provided that the above copyright notice appear in 
  all copies and that both that the copyright notice and this
  permission notice and warranty disclaimer appear in supporting 
  documentation, and that the name of the author not be used in 
  advertising or publicity pertaining to distribution of the 
  software without specific, written prior permission.

  The author disclaim all warranties with regard to this
  software, including all implied warranties of merchantability
  and fitness.  In no event shall the author be liable for any
  special, indirect or consequential damages or any damages
  whatsoever resulting from loss of use, data or profits, whether
  in an action of contract, negligence or other tortious action,
  arising out of or in connection with the use or performance of
  this software.
*/

31
32
33
34
35
36
37
38
/** \file
 *
 *  SDP layer module. This module implements a simple Service Discovery
 *  Protocol server, which can broadcast the device's supported services
 *  to other Bluetooth devices upon request, so that they can determine
 *  what services are available.
 */

39
40
41
42
/*
	TODO: Honor remote device's buffer size constraints via continuation state
 */

43
#define  INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C
44
#include "SDP.h"
45

46
47
/** Service attribute table list, containing a pointer to each service attribute table the device contains */
const ServiceAttributeTable_t* SDP_Services_Table[] PROGMEM =
48
	{
49
		SerialPort_Attribute_Table,
50
51
	};

52
/** Base UUID value common to all standardized Bluetooth services */
53
const UUID_t BaseUUID PROGMEM = {0x00000000, BASE_80BIT_UUID};
54

55
56
57
58
59
60
61
/** Main Service Discovery Protocol packet processing routine. This function processes incomming SDP packets from
 *  a connected Bluetooth device, and sends back appropriate responses to allow other devices to determine the
 *  services the local device exposes.
 *
 *  \param[in]  Data     Incomming packet data containing the SDP request
 *  \param[in]  Channel  Channel the request was issued to by the remote device
 */
62
void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* const Channel)
63
64
65
66
67
68
69
70
{
	SDP_PDUHeader_t* SDPHeader = (SDP_PDUHeader_t*)Data;
	SDPHeader->ParameterLength = SwapEndian_16(SDPHeader->ParameterLength);

	BT_SDP_DEBUG(1, "SDP Packet Received");
	BT_SDP_DEBUG(2, "-- PDU ID: 0x%02X", SDPHeader->PDU);
	BT_SDP_DEBUG(2, "-- Param Length: 0x%04X", SDPHeader->ParameterLength);

71
	/* Dispatch to the correct processing routine for the given SDP packet type */
72
73
74
	switch (SDPHeader->PDU)
	{
		case SDP_PDU_SERVICESEARCHREQUEST:
75
			SDP_ProcessServiceSearch(SDPHeader, Channel);
76
77
			break;		
		case SDP_PDU_SERVICEATTRIBUTEREQUEST:
78
			SDP_ProcessServiceAttribute(SDPHeader, Channel);
79
80
			break;
		case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST:
81
			SDP_ProcessServiceSearchAttribute(SDPHeader, Channel);
82
83
84
85
			break;
	}
}

86
87
88
89
90
91
/** Internal processing routine for SDP Service Search Requests.
 *
 *  \param[in] SDPHeader  Pointer to the start of the issued SDP request
 *  \param[in] Channel    Pointer to the Bluetooth channel structure the request was issued to
 */
static void SDP_ProcessServiceSearch(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel)
92
{
93
94
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));

95
	BT_SDP_DEBUG(1, "<< Service Search");
96
97
98
99
100
101
102

	/* Retrieve the list of search UUIDs from the request */
	uint8_t UUIDList[12][UUID_SIZE_BYTES];
	uint8_t TotalUUIDs = SDP_GetUUIDList(UUIDList, &CurrentParameter);
	BT_SDP_DEBUG(2, "-- Total UUIDs: %d", TotalUUIDs);
	
	/* Retrieve the maximum service record reponse count from the request */
103
	uint16_t MaxServiceRecordCount = SDP_ReadData16(&CurrentParameter);
104
105
106
107
108
109
110
111
112
	BT_SDP_DEBUG(2, "-- Max Return Service Count: 0x%04X", MaxServiceRecordCount);
	
	struct
	{
		SDP_PDUHeader_t SDPHeader;
		uint16_t        TotalServiceRecordCount;
		uint16_t        CurrentServiceRecordCount;
		uint8_t         ResponseData[100];
	} ResponsePacket;
113
114
	
	uint8_t AddedServiceHandles = 0;
115
116
117
118

	/* Create a pointer to the buffer to indicate the current location for response data to be added */
	void* CurrResponsePos = ResponsePacket.ResponseData;

119
120
	/* Search through the global service list an item at a time */
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(void*)); CurrTableItem++)
121
	{
122
123
		/* Read in a pointer to the current UUID table entry's Attribute table */
		ServiceAttributeTable_t* CurrAttributeTable = pgm_read_ptr(&SDP_Services_Table[CurrTableItem]);
124

125
		if (!(SDP_SearchServiceTable(UUIDList, TotalUUIDs, CurrAttributeTable)))
126
		  continue;
127
128

		BT_SDP_DEBUG(2, " -- Found search match in table");
129
130

		/* Retrieve a PROGMEM pointer to the value of the service's record handle */
131
		const void* AttributeValue = SDP_GetAttributeValue(CurrAttributeTable, SDP_ATTRIBUTE_ID_SERVICERECORDHANDLE);
132
133
134

		/* Copy over the service record handle to the response list */
		uint8_t AttrHeaderSize;
135
136
137
		uint8_t AttrSize = SDP_GetLocalAttributeContainerSize(AttributeValue, &AttrHeaderSize);
		memcpy_P(CurrResponsePos, AttributeValue + AttrHeaderSize, AttrSize);
		CurrResponsePos += AttrHeaderSize + AttrSize;
138
139
140
141
142
		
		AddedServiceHandles++;
	}

	/* Continuation state - always zero */
143
	SDP_WriteData8(&CurrResponsePos, 0);
144
145
146
147
148

	/* Fill out the service record count values in the returned packet */
	ResponsePacket.TotalServiceRecordCount   = SwapEndian_16(AddedServiceHandles);
	ResponsePacket.CurrentServiceRecordCount = ResponsePacket.TotalServiceRecordCount;

149
150
151
152
153
154
155
	/* Calculate the total parameter length that is to be sent, including the fixed return parameters, the created service
	   handle list and the SDP continuation state */
	uint16_t ParamLength = (ResponsePacket.CurrentServiceRecordCount << 2) +
	                        sizeof(ResponsePacket.CurrentServiceRecordCount) +
	                        sizeof(ResponsePacket.TotalServiceRecordCount) +
	                        sizeof(uint8_t);

156
157
158
	/* Fill in the response packet's header */
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICESEARCHRESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
159
	ResponsePacket.SDPHeader.ParameterLength = SwapEndian_16(ParamLength);
160
161
162
163

	BT_SDP_DEBUG(1, ">> Service Search Response");

	/* Send the completed response packet to the sender */
164
	Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ParamLength), Channel);
165
166
}

167
168
169
170
171
172
/** Internal processing routine for SDP Service Attribute Requests.
 *
 *  \param[in] SDPHeader  Pointer to the start of the issued SDP request
 *  \param[in] Channel    Pointer to the Bluetooth channel structure the request was issued to
 */
static void SDP_ProcessServiceAttribute(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel)
173
{
174
175
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));

176
	BT_SDP_DEBUG(1, "<< Service Attribute");
177
178

	/* Retrieve the service handle whose attributes are to be examined */
179
	uint32_t ServiceHandle = SDP_ReadData32(&CurrentParameter);
180
181
182
	BT_SDP_DEBUG(2, "-- Service Handle: 0x%08lX", ServiceHandle);
	
	/* Retrieve the maximum Attribute reponse size from the request */
183
	uint16_t MaxAttributeSize = SDP_ReadData16(&CurrentParameter);
184
185
186
	BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize);
	
	/* Retrieve the list of Attributes from the request */
187
	uint16_t AttributeList[8][2];
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
	uint8_t  TotalAttributes = SDP_GetAttributeList(AttributeList, &CurrentParameter);
	BT_SDP_DEBUG(2, "-- Total Attributes: %d", TotalAttributes);

	struct
	{
		SDP_PDUHeader_t SDPHeader;
		uint16_t        AttributeListByteCount;
		uint8_t         ResponseData[100];
	} ResponsePacket;

	/* 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);

205
	uint16_t TotalResponseSize = 0;
206
207

	/* Search through the global UUID list an item at a time */
208
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(void*)); CurrTableItem++)
209
210
	{
		/* Read in a pointer to the current UUID table entry's Attribute table */
211
		ServiceAttributeTable_t* CurrAttributeTable = pgm_read_ptr(&SDP_Services_Table[CurrTableItem]);
212
213
214
215
		
		/* Retrieve a PROGMEM pointer to the value of the Service Record Handle */
		const void* ServiceRecord = SDP_GetAttributeValue(CurrAttributeTable, SDP_ATTRIBUTE_ID_SERVICERECORDHANDLE);
		
216
217
218
		/* Get the size of the header for the Service Record Handle */
		uint8_t AttrHeaderSize;
		SDP_GetLocalAttributeContainerSize(ServiceRecord, &AttrHeaderSize);
219
220
221
222
		
		/* Retrieve the endian-swapped service handle of the current service being examined */
		uint32_t CurrServiceHandle = SwapEndian_32(pgm_read_dword(ServiceRecord + AttrHeaderSize));
		
223
		/* Check if the current service in the service table has the requested service handle */
224
		if (ServiceHandle == CurrServiceHandle)
225
		{
226
			/* Add the listed attributes for the found UUID to the response */
227
228
			TotalResponseSize = SDP_AddListedAttributesToResponse(CurrAttributeTable, AttributeList, TotalAttributes,
		                                                          &CurrResponsePos);
229
230
231
232
233
234
235
			
			/* Requested service found, abort the search through the service table */
			break;
		}
	}

	/* Continuation state - always zero */
236
	SDP_WriteData8(&CurrResponsePos, 0);
237
238

	/* Set the total response list size to the size of the outer container plus its header size and continuation state */
239
	ResponsePacket.AttributeListByteCount    = SwapEndian_16(TotalResponseSize);
240
241
242

	/* 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 */
243
244
	uint16_t ParamLength = (sizeof(ResponsePacket.AttributeListByteCount) + TotalResponseSize + sizeof(uint8_t));
	
245
246
247
248
249
250
251
252
253
254
	/* Fill in the response packet's header */
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICEATTRIBUTERESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
	ResponsePacket.SDPHeader.ParameterLength = SwapEndian_16(ParamLength);

	BT_SDP_DEBUG(1, ">> Service 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);
255
256
}

257
258
259
260
261
262
/** Internal processing routine for SDP Service Search Attribute Requests.
 *
 *  \param[in] SDPHeader  Pointer to the start of the issued SDP request
 *  \param[in] Channel    Pointer to the Bluetooth channel structure the request was issued to
 */
static void SDP_ProcessServiceSearchAttribute(const SDP_PDUHeader_t* const SDPHeader, Bluetooth_Channel_t* const Channel)
263
{
264
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));
265
266
267
	
	BT_SDP_DEBUG(1, "<< Service Search Attribute");

268
	/* Retrieve the list of search UUIDs from the request */
269
	uint8_t UUIDList[12][UUID_SIZE_BYTES];
270
	uint8_t TotalUUIDs = SDP_GetUUIDList(UUIDList, &CurrentParameter);
271
	BT_SDP_DEBUG(2, "-- Total UUIDs: %d", TotalUUIDs);
272
	
273
	/* Retrieve the maximum Attribute reponse size from the request */
274
	uint16_t MaxAttributeSize = SDP_ReadData16(&CurrentParameter);
275
	BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize);
276
	
277
	/* Retrieve the list of Attributes from the request */
278
	uint16_t AttributeList[8][2];
279
	uint8_t  TotalAttributes = SDP_GetAttributeList(AttributeList, &CurrentParameter);
280
281
	BT_SDP_DEBUG(2, "-- Total Attributes: %d", TotalAttributes);
	
282
283
284
	struct
	{
		SDP_PDUHeader_t SDPHeader;
285
		uint16_t        AttributeListByteCount;
286
287
288
		uint8_t         ResponseData[100];
	} ResponsePacket;
	
289
	/* Create a pointer to the buffer to indicate the current location for response data to be added */
290
	void* CurrResponsePos = ResponsePacket.ResponseData;
291

292
	/* Clamp the maximum attribute size to the size of the allocated buffer */
293
294
	if (MaxAttributeSize > sizeof(ResponsePacket.ResponseData))
	  MaxAttributeSize = sizeof(ResponsePacket.ResponseData);
295

296
	/* Add the outer Data Element Sequence header for all of the retrieved Attributes */
297
	uint16_t* TotalResponseSize = SDP_AddSequence16(&CurrResponsePos);
298
	
299
300
	/* Search through the global service list an item at a time */
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(void*)); CurrTableItem++)
301
	{
302
303
		/* Read in a pointer to the current UUID table entry's Attribute table */
		ServiceAttributeTable_t* CurrAttributeTable = pgm_read_ptr(&SDP_Services_Table[CurrTableItem]);
304

305
		if (!(SDP_SearchServiceTable(UUIDList, TotalUUIDs, CurrAttributeTable)))
306
307
		  continue;
		  
308
		BT_SDP_DEBUG(2, " -- Found search match in table");
309

310
		/* Add the listed attributes for the found UUID to the response */
311
		*TotalResponseSize += SDP_AddListedAttributesToResponse(CurrAttributeTable, AttributeList, TotalAttributes, 
312
		                                                        &CurrResponsePos);
313
	}
314
315
	
	/* Continuation state - always zero */
316
	SDP_WriteData8(&CurrResponsePos, 0);
317

318
	/* Set the total response list size to the size of the outer container plus its header size and continuation state */
319
	ResponsePacket.AttributeListByteCount    = SwapEndian_16(3 + *TotalResponseSize);
320

321
322
323
324
325
326
	/* 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));

327
328
329
	/* Flip the endianness of the container's size */
	*TotalResponseSize = SwapEndian_16(*TotalResponseSize);

330
	/* Fill in the response packet's header */
331
332
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICESEARCHATTRIBUTERESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
333
	ResponsePacket.SDPHeader.ParameterLength = SwapEndian_16(ParamLength);
334

335
	BT_SDP_DEBUG(1, ">> Service Search Attribute Response");
336
	BT_SDP_DEBUG(2, "-- Param Len 0x%04X", ParamLength);
337

338
	/* Send the completed response packet to the sender */
339
	Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ParamLength), Channel);
340
341
}

342
343
344
345
346
347
348
349
350
/** 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
 */
351
352
static uint16_t SDP_AddListedAttributesToResponse(const ServiceAttributeTable_t* AttributeTable, uint16_t AttributeList[][2],
                                                  const uint8_t TotalAttributes, void** const BufferPos)
353
{
354
	uint16_t TotalResponseSize;
355
356

	/* Add an inner Data Element Sequence header for the current services's found Attributes */
357
	uint16_t* AttributeListSize = SDP_AddSequence16(BufferPos);
358
359
360
361
362

	/* 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];
363
364
365
		void*     AttributeValue;
		
		/* Look through the current service's attribute list, examining all the attributes */
366
		while ((AttributeValue = pgm_read_ptr(&AttributeTable->Data)) != NULL)
367
		{
368
369
370
371
372
373
374
375
376
377
378
			/* 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++;
379
380
381
		}
	}

382
383
384
	/* Record the total number of added bytes to the buffer */
	TotalResponseSize = 3 + *AttributeListSize;

385
386
387
388
389
390
	/* Fix endianness of the added attribute data element sequence */
	*AttributeListSize = SwapEndian_16(*AttributeListSize);

	return TotalResponseSize;
}

391
392
393
394
395
396
397
398
399
400
401
/** 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 */
402
	uint8_t  AttributeHeaderLength;
403
	uint16_t AttributeValueLength = SDP_GetLocalAttributeContainerSize(AttributeValue, &AttributeHeaderLength);
404
	
405
406
	BT_SDP_DEBUG(2, " -- Add Attribute (0x%04X) 0x%04X", (AttributeHeaderLength + AttributeValueLength), AttributeID);

407
	/* Add a Data Element header to the response for the Attribute ID */
408
	SDP_WriteData8(ResponseBuffer, (SDP_DATATYPE_UnsignedInt | SDP_DATASIZE_16Bit));
409
410
	
	/* Add the Attribute ID to the created Data Element */
411
	SDP_WriteData16(ResponseBuffer, AttributeID);
412
413
	
	/* Copy over the Attribute value Data Element container to the response */
414
415
	memcpy_P(*ResponseBuffer, AttributeValue, AttributeHeaderLength + AttributeValueLength);
	*ResponseBuffer += AttributeHeaderLength + AttributeValueLength;
416
	
417
	return (sizeof(uint8_t) + sizeof(uint16_t) + AttributeHeaderLength + AttributeValueLength);
418
419
}

420
421
422
423
424
425
426
427
/** 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)
428
{
429
	void* CurrTableItemData;
430
431
	
	/* Search through the current Attribute table, abort when the terminator item has been reached */
432
	while ((CurrTableItemData = pgm_read_ptr(&AttributeTable->Data)) != NULL)
433
	{
434
		/* Check if the current Attribute ID matches the search ID - if so return a pointer to it */
435
		if (pgm_read_word(&AttributeTable->AttributeID) == AttributeID)
436
		  return CurrTableItemData;
437
438
439
440
441
442
443
		
		AttributeTable++;
	}
			
	return NULL;
}

444
/** Retrieves the Attribute table for the given UUID list if it exists.
445
 *
446
447
448
 *  \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
449
 *
450
 *  \return True if all the UUIDs given in the UUID list appear in the given attribute table, false otherwise
451
 */
452
453
static bool SDP_SearchServiceTable(uint8_t UUIDList[][UUID_SIZE_BYTES], const uint8_t TotalUUIDs,
			                       const ServiceAttributeTable_t* CurrAttributeTable)
454
{
455
	const void* CurrAttribute;
456
	uint16_t    UUIDMatchFlags = 0;
457
458
459
	
	/* Search through the current attribute table, checking each attribute value for UUID matches */
	while ((CurrAttribute = pgm_read_ptr(&CurrAttributeTable->Data)) != NULL)
460
	{
461
		SDP_CheckUUIDMatch(UUIDList, TotalUUIDs, &UUIDMatchFlags, CurrAttribute);
462
463
464
465
		CurrAttributeTable++;
	}

	/* Determine how many UUID matches in the list we have found */
466
467
468
	uint8_t UUIDMatches;
	for (UUIDMatches = 0; UUIDMatchFlags; UUIDMatches++)
	  UUIDMatchFlags &= (UUIDMatchFlags - 1);
469
	
470
471
472
473
474
475
476
477
478
479
480
481
482
483
	/* If all UUIDs have been matched to the current service, return true */
	return (UUIDMatches == TotalUUIDs);
}

/** Recursively upwraps the given locally stored attribute (in PROGMEM space), searching for UUIDs to match against
 *  the given UUID list. As matches are found, they are indicated in the UUIDMatch flag list.
 *
 *  \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, out] UUIDMatch      Array of flags indicating which UUIDs in the list have already been matched
 *  \param[in]      CurrAttribute  Pointer to the current attribute to search through
 *
 *  \return True if all the UUIDs given in the UUID list appear in the given attribute table, false otherwise
 */
484
485
static void SDP_CheckUUIDMatch(uint8_t UUIDList[][UUID_SIZE_BYTES], const uint8_t TotalUUIDs,
                               uint16_t* const UUIDMatchFlags, const void* CurrAttribute)
486
487
488
489
490
491
{
	uint8_t CurrAttributeType = (pgm_read_byte(CurrAttribute) & ~0x07);

	/* Check the data type of the current attribute value - if UUID, compare, if Sequence, unwrap and recurse */
	if (CurrAttributeType == SDP_DATATYPE_UUID)
	{
492
493
		uint16_t CurrUUIDMatchMask = (1 << 0);
	
494
495
496
		/* Look for matches in the UUID list against the current attribute UUID value */
		for (uint8_t i = 0; i < TotalUUIDs; i++)
		{
497
			/* Check if the current unmatched UUID is identical to the search UUID */
498
			if (!(*UUIDMatchFlags & CurrUUIDMatchMask) && !(memcmp_P(UUIDList[i], (CurrAttribute + 1), UUID_SIZE_BYTES)))
499
500
			{
				/* Indicate match found for the current attribute UUID and early-abort */
501
				*UUIDMatchFlags |= CurrUUIDMatchMask;
502
503
				break;
			}
504
505
			
			CurrUUIDMatchMask <<= 1;
506
507
508
509
510
511
		}
	}
	else if (CurrAttributeType == SDP_DATATYPE_Sequence)
	{
		uint8_t  SequenceHeaderSize;
		uint16_t SequenceSize = SDP_GetLocalAttributeContainerSize(CurrAttribute, &SequenceHeaderSize);
512
		
513
		CurrAttribute += SequenceHeaderSize;
514
		
515
516
		/* Recursively unwrap the sequence container, and re-search its contents for UUIDs */
		while (SequenceSize)
517
		{
518
519
520
			uint8_t  InnerHeaderSize;
			uint16_t InnerSize = SDP_GetLocalAttributeContainerSize(CurrAttribute, &InnerHeaderSize);
			
521
522
523
524
			/* Recursively search of the next element in the sequence, trying to match UUIDs with the UUID list */
			SDP_CheckUUIDMatch(UUIDList, TotalUUIDs, UUIDMatchFlags, CurrAttribute);

			/* Skip to the next element in the sequence */
525
526
527
528
			SequenceSize  -= InnerHeaderSize + InnerSize;
			CurrAttribute += InnerHeaderSize + InnerSize;
		}
	}	
529
530
}

531
532
533
534
535
536
537
538
539
/** Reads in the collection of Attribute ranges from the input buffer's Data Element Sequence container, into the given 
 *  Attribute list for later use. Once complete, the input buffer pointer is advanced to the end of the Attribute container.
 *
 *  \param[out] AttributeList     Pointer to a buffer where the list of Attribute ranges are to be stored
 *  \param[in]  CurrentParameter  Pointer to a Buffer containing a Data Element Sequence of Attribute and Attribute Range elements
 *
 *  \return Total number of Attribute ranges stored in the Data Element Sequence
 */
static uint8_t SDP_GetAttributeList(uint16_t AttributeList[][2], const void** const CurrentParameter)
540
{
541
542
	uint8_t ElementHeaderSize;
	uint8_t TotalAttributes = 0;
543

544
545
	/* Retrieve the total size of the Attribute container, and unwrap the outer Data Element Sequence container */
	uint16_t AttributeIDListLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
546
547
548
	BT_SDP_DEBUG(2, "-- Total Attribute Length: 0x%04X", AttributeIDListLength);
	while (AttributeIDListLength)
	{
549
550
551
		/* Retrieve the size of the next Attribute in the container and get a pointer to the next free Attribute element in the list */
		uint16_t* CurrentAttributeRange = AttributeList[TotalAttributes++];
		uint8_t   AttributeLength       = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
552
		
553
554
		/* Copy over the starting Attribute ID and (if it the current element is a range) the ending Attribute ID */
		memcpy(&CurrentAttributeRange[0], *CurrentParameter, AttributeLength);
555
		
556
		/* If the element is not an Attribute Range, copy over the starting ID to the ending ID to make a range of 1 */
557
		if (AttributeLength == 2)
558
559
560
561
562
		  CurrentAttributeRange[1] = CurrentAttributeRange[0];

		/* Swap the endianness of the attribute range values */
		CurrentAttributeRange[0] = SwapEndian_16(CurrentAttributeRange[0]);
		CurrentAttributeRange[1] = SwapEndian_16(CurrentAttributeRange[1]);
563

564
		BT_SDP_DEBUG(2, "-- Attribute: 0x%04X-0x%04X", CurrentAttributeRange[0], CurrentAttributeRange[1]);
565
		
566
		AttributeIDListLength -= (AttributeLength + ElementHeaderSize);
567
		*CurrentParameter     += AttributeLength;
568
	}
569
	
570
	return TotalAttributes;
571
572
}

573
574
575
576
577
578
579
580
581
/** Reads in the collection of UUIDs from the input buffer's Data Element Sequence container, into the given 
 *  UUID list for later use. Once complete, the input buffer pointer is advanced to the end of the UUID container.
 *
 *  \param[out] UUIDList          Pointer to a buffer where the list of UUIDs are to be stored
 *  \param[in]  CurrentParameter  Pointer to a Buffer containing a Data Element Sequence of UUID elements
 *
 *  \return Total number of UUIDs stored in the Data Element Sequence
 */
static uint8_t SDP_GetUUIDList(uint8_t UUIDList[][UUID_SIZE_BYTES], const void** const CurrentParameter)
582
583
584
585
{
	uint8_t ElementHeaderSize;
	uint8_t TotalUUIDs = 0;

586
587
	/* Retrieve the total size of the UUID container, and unwrap the outer Data Element Sequence container */
	uint16_t ServicePatternLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
588
589
590
	BT_SDP_DEBUG(2, "-- Total UUID Length: 0x%04X", ServicePatternLength);
	while (ServicePatternLength)
	{
591
		/* Retrieve the size of the next UUID in the container and get a pointer to the next free UUID element in the list */
592
		uint8_t* CurrentUUID = UUIDList[TotalUUIDs++];
593
		uint8_t  UUIDLength  = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
594
		
595
		/* Copy over UUID from the container to the free slot */
596
597
598
599
600
601
602
603
604
605
606
607
608
		if (UUIDLength <= 4)
		{
			/* Copy over the base UUID value to the free UUID slot in the list */
			memcpy_P(CurrentUUID, &BaseUUID, sizeof(BaseUUID));

			/* Copy over short UUID */
			memcpy(CurrentUUID + (4 - UUIDLength), *CurrentParameter, UUIDLength);
		}
		else
		{
			/* Copy over full UUID */
			memcpy(CurrentUUID, *CurrentParameter, UUIDLength);		
		}
609
		
610
		BT_SDP_DEBUG(2, "-- UUID (%d): %02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
611
		                UUIDLength,
612
613
		                CurrentUUID[0], CurrentUUID[1], CurrentUUID[2], CurrentUUID[3],
		                CurrentUUID[4], CurrentUUID[5],
614
615
616
						CurrentUUID[6], CurrentUUID[7],
		                CurrentUUID[8], CurrentUUID[9],
						CurrentUUID[10], CurrentUUID[11], CurrentUUID[12],  CurrentUUID[13],  CurrentUUID[14],  CurrentUUID[15]);
617
618
619
620
621
622
623
624

		ServicePatternLength -= (UUIDLength + ElementHeaderSize);
		*CurrentParameter    += UUIDLength;
	}
	
	return TotalUUIDs;
}

625
626
/** Retrieves the total size of the given locally stored (in PROGMEM) attribute Data Element container.
 *
627
628
 *  \param[in]  AttributeData  Pointer to the start of the Attribute container, located in PROGMEM
 *  \param[out] HeaderSize     Pointer to a location where the header size of the data element is to be stored
629
630
631
 *
 *  \return Size in bytes of the entire attribute container, including the header
 */
632
static uint32_t SDP_GetLocalAttributeContainerSize(const void* const AttributeData, uint8_t* const HeaderSize)
633
634
635
636
{
	/* Fetch the size of the Data Element structure from the header */
	uint8_t SizeIndex = (pgm_read_byte(AttributeData) & 0x07);
	
637
638
	uint32_t ElementValueSize;

639
640
641
	/* Convert the Data Element size index into a size in bytes */
	switch (SizeIndex)
	{
642
		case SDP_DATASIZE_Variable8Bit:
643
			*HeaderSize = (1 + sizeof(uint8_t));
644
645
			ElementValueSize = pgm_read_byte(AttributeData + 1);
			break;
646
		case SDP_DATASIZE_Variable16Bit:
647
			*HeaderSize = (1 + sizeof(uint16_t));
648
649
			ElementValueSize = SwapEndian_16(pgm_read_word(AttributeData + 1));
			break;
650
		case SDP_DATASIZE_Variable32Bit:
651
			*HeaderSize = (1 + sizeof(uint32_t));
652
653
			ElementValueSize = SwapEndian_32(pgm_read_dword(AttributeData + 1));
			break;
654
		default:
655
			*HeaderSize = 1;
656
657
			ElementValueSize = (1 << SizeIndex);
			break;
658
659
	}

660
	return ElementValueSize;
661
662
}

663
664
665
666
667
668
669
670
671
/** Retrieves the size of a Data Element container from the current input buffer, and advances the input buffer
 *  pointer to the start of the Data Element's contents.
 *
 *  \param[in, out] DataElementHeader  Pointer to the start of a Data Element header
 *  \param[out]     ElementHeaderSize  Size in bytes of the header that was skipped
 *
 *  \return Size in bytes of the Data Element container's contents, minus the header
 */
static uint32_t SDP_GetDataElementSize(const void** const DataElementHeader, uint8_t* const ElementHeaderSize)
672
{
673
	/* Fetch the size of the Data Element structure from the header, increment the current buffer pos */
674
675
	uint8_t  SizeIndex = (SDP_ReadData8(DataElementHeader) & 0x07);	

676
	uint32_t ElementValueSize;
677
678

	/* Convert the Data Element size index into a size in bytes */
679
680
	switch (SizeIndex)
	{
681
		case SDP_DATASIZE_Variable8Bit:
682
			*ElementHeaderSize  = (1 + sizeof(uint8_t));
683
			ElementValueSize    = SDP_ReadData8(DataElementHeader);
684
			break;
685
		case SDP_DATASIZE_Variable16Bit:
686
			*ElementHeaderSize  = (1 + sizeof(uint16_t));
687
			ElementValueSize    = SDP_ReadData16(DataElementHeader);
688
			break;
689
		case SDP_DATASIZE_Variable32Bit:
690
			*ElementHeaderSize  = (1 + sizeof(uint32_t));
691
			ElementValueSize    = SDP_ReadData32(DataElementHeader);
692
			break;
693
		default:
694
			*ElementHeaderSize  = 1;
695
			ElementValueSize    = (1 << SizeIndex);
696
			break;
697
698
	}
	
699
	return ElementValueSize;
700
}