ServiceDiscoveryProtocol.c 28.4 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
31
32
33
/*
             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.
*/

#define  INCLUDE_FROM_SERVICEDISCOVERYPROTOCOL_C
#include "ServiceDiscoveryProtocol.h"

34
35
/** Base UUID value common to all standardized Bluetooth services */
const uint8_t BaseUUID[] PROGMEM = {BASE_96BIT_UUID, 0x00, 0x00, 0x00, 0x00};
36

37
38
39
/** Master service table, listing all supported services (and their attribute tables) of the device, including
 *  each service's UUID.
 */
40
const ServiceTable_t SDP_Services_Table[] PROGMEM =
41
	{
42
		{   // 128-bit UUID for the SDP service
43
			.UUID  = {BASE_96BIT_UUID, 0x01, 0x00, 0x00, 0x00},
44
			.AttributeTable = SDP_Attribute_Table,
45
		},
46
47
48
49
		{   // 128-bit UUID for the RFCOMM service
			.UUID  = {BASE_96BIT_UUID, 0x03, 0x00, 0x00, 0x00},
			.AttributeTable = RFCOMM_Attribute_Table,
		},
50
51
52
	};


53
54
55
56
57
58
59
/** 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
 */
60
void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel)
61
62
63
64
65
66
67
68
69
70
71
{
	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);

	switch (SDPHeader->PDU)
	{
		case SDP_PDU_SERVICESEARCHREQUEST:
72
			SDP_ProcessServiceSearch(SDPHeader, Channel);
73
74
			break;		
		case SDP_PDU_SERVICEATTRIBUTEREQUEST:
75
			SDP_ProcessServiceAttribute(SDPHeader, Channel);
76
77
			break;
		case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST:
78
			SDP_ProcessServiceSearchAttribute(SDPHeader, Channel);
79
80
81
82
			break;
	}
}

83
84
85
86
87
88
/** 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)
89
{
90
91
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));

92
	BT_SDP_DEBUG(1, "<< Service Search");
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

	/* 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 */
	uint16_t MaxServiceRecordCount = SwapEndian_16(*((uint16_t*)CurrentParameter));
	CurrentParameter += sizeof(uint16_t);
	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;

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

	/* Search through the list of UUIDs one at a time looking for matching search Attributes */
	for (uint8_t CurrUUIDItem = 0; CurrUUIDItem < TotalUUIDs; CurrUUIDItem++)
	{
		/* Retrieve the attribute table of the current search UUID from the global UUID table if it exists */
		ServiceAttributeTable_t* AttributeTable = SDP_GetAttributeTable(UUIDList[CurrUUIDItem]);
		
		/* If the UUID does not exist in the global UUID table, continue on to the next search UUID */
		if (AttributeTable == NULL)
		  continue;
		  
		BT_SDP_DEBUG(2, " -- Found UUID %d in table", CurrUUIDItem);

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

		/* Copy over the service record handle to the response list */
		uint8_t AttrHeaderSize;
		SDP_GetLocalAttributeContainerSize(AttributeValue, &AttrHeaderSize);
		memcpy_P(CurrResponsePos, AttributeValue + AttrHeaderSize, sizeof(uint32_t));
		CurrResponsePos += AttrHeaderSize + sizeof(uint32_t);
		
		/* Increment the total number of service records added to the list */
		AddedServiceHandles++;
	}

	/* Continuation state - always zero */
	*((uint8_t*)CurrResponsePos) = 0;

	/* 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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273

	/* Retrieve the service handle whose attributes are to be examined */
	uint32_t ServiceHandle = SwapEndian_32(*((uint16_t*)CurrentParameter));
	CurrentParameter += sizeof(uint32_t);
	BT_SDP_DEBUG(2, "-- Service Handle: 0x%08lX", ServiceHandle);
	
	/* Retrieve the maximum Attribute reponse size from the request */
	uint16_t MaxAttributeSize = SwapEndian_16(*((uint16_t*)CurrentParameter));
	CurrentParameter += sizeof(uint16_t);
	BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize);
	
	/* Retrieve the list of Attributes from the request */
	uint16_t AttributeList[15][2];
	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);

	/* Add the outer Data Element Sequence header for all of the retrieved Attributes */
	uint16_t* TotalResponseSize = SDP_AddDataElementHeader16(&CurrResponsePos, SDP_DATATYPE_Sequence);

	/* Search through the global UUID list an item at a time */
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(ServiceTable_t)); CurrTableItem++)
	{
		/* Read in a pointer to the current UUID table entry's Attribute table */
		ServiceAttributeTable_t* CurrAttributeTable = (ServiceAttributeTable_t*)pgm_read_word(&SDP_Services_Table[CurrTableItem].AttributeTable);
		
		/* Retrieve a PROGMEM pointer to the value of the Service Record Handle */
		const void* ServiceRecord = SDP_GetAttributeValue(CurrAttributeTable, SDP_ATTRIBUTE_ID_SERVICERECORDHANDLE);
		
		/* Check if the current service in the service table has the requested service handle */
		if (memcmp_P(ServiceRecord, &ServiceHandle, sizeof(uint32_t)) == 0)
		{
			/* 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];
			
				/* Look in the current Attribute Range for a matching Attribute ID in the service's Attribute table */
				for (uint32_t CurrAttributeID = AttributeIDRange[0]; CurrAttributeID <= AttributeIDRange[1]; CurrAttributeID++)
				{
					/* Retrieve a PROGMEM pointer to the value of the current Attribute ID, if it exists in the service's Attribute table */
					const void* AttributeValue = SDP_GetAttributeValue(CurrAttributeTable, CurrAttributeID);
					
					/* If the Attribute does not exist in the current service's Attribute table, continue to the next Attribute ID */
					if (AttributeValue == NULL)
					  continue;
					
					BT_SDP_DEBUG(2, " -- Add Attribute 0x%04X", CurrAttributeID);

					/* Increment the service's returned Attribute container size by the number of added bytes */
					*TotalResponseSize += SDP_AddAttributeToResponse(CurrAttributeID, AttributeValue, &CurrResponsePos);
				}
			}
			
			/* Requested service found, abort the search through the service table */
			break;
		}
	}

	/* Continuation state - always zero */
	*((uint8_t*)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));

	/* Fill in the response packet's header */
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICEATTRIBUTERESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
	ResponsePacket.SDPHeader.ParameterLength = SwapEndian_16(ParamLength);

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

	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);
274
275
}

276
277
278
279
280
281
/** 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)
282
{
283
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));
284
285
286
	
	BT_SDP_DEBUG(1, "<< Service Search Attribute");

287
	/* Retrieve the list of search UUIDs from the request */
288
	uint8_t UUIDList[12][UUID_SIZE_BYTES];
289
	uint8_t TotalUUIDs = SDP_GetUUIDList(UUIDList, &CurrentParameter);
290
	BT_SDP_DEBUG(2, "-- Total UUIDs: %d", TotalUUIDs);
291
	
292
	/* Retrieve the maximum Attribute reponse size from the request */
293
	uint16_t MaxAttributeSize = SwapEndian_16(*((uint16_t*)CurrentParameter));
294
	CurrentParameter += sizeof(uint16_t);
295
	BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize);
296
	
297
	/* Retrieve the list of Attributes from the request */
298
	uint16_t AttributeList[15][2];
299
	uint8_t  TotalAttributes = SDP_GetAttributeList(AttributeList, &CurrentParameter);
300
301
	BT_SDP_DEBUG(2, "-- Total Attributes: %d", TotalAttributes);
	
302
303
304
	struct
	{
		SDP_PDUHeader_t SDPHeader;
305
		uint16_t        AttributeListByteCount;
306
307
308
		uint8_t         ResponseData[100];
	} ResponsePacket;
	
309
	/* Create a pointer to the buffer to indicate the current location for response data to be added */
310
	void* CurrResponsePos = ResponsePacket.ResponseData;
311

312
	/* Clamp the maximum attribute size to the size of the allocated buffer */
313
314
	if (MaxAttributeSize > sizeof(ResponsePacket.ResponseData))
	  MaxAttributeSize = sizeof(ResponsePacket.ResponseData);
315

316
	/* Add the outer Data Element Sequence header for all of the retrieved Attributes */
317
318
319
	uint16_t* TotalResponseSize = SDP_AddDataElementHeader16(&CurrResponsePos, SDP_DATATYPE_Sequence);
	
	/* Search through the list of UUIDs one at a time looking for matching search Attributes */
320
321
	for (uint8_t CurrUUIDItem = 0; CurrUUIDItem < TotalUUIDs; CurrUUIDItem++)
	{
322
323
		/* Retrieve the attribute table of the current search UUID from the global UUID table if it exists */
		ServiceAttributeTable_t* AttributeTable = SDP_GetAttributeTable(UUIDList[CurrUUIDItem]);
324
		
325
		/* If the UUID does not exist in the global UUID table, continue on to the next search UUID */
326
327
328
		if (AttributeTable == NULL)
		  continue;
		  
329
330
		BT_SDP_DEBUG(2, " -- Found UUID %d in table", CurrUUIDItem);

331
332
333
334
		/* Add an inner Data Element Sequence header for the current UUID's found Attributes */
		uint16_t* CurrentUUIDResponseSize = SDP_AddDataElementHeader16(&CurrResponsePos, SDP_DATATYPE_Sequence);
		
		/* Search through the list of Attributes one at a time looking for values in the current UUID's Attribute table */
335
336
337
338
		for (uint8_t CurrAttribute = 0; CurrAttribute < TotalAttributes; CurrAttribute++)
		{
			uint16_t* AttributeIDRange = AttributeList[CurrAttribute];
		
339
			/* Look in the current Attribute Range for a matching Attribute ID in the UUID's Attribute table */
340
			for (uint32_t CurrAttributeID = AttributeIDRange[0]; CurrAttributeID <= AttributeIDRange[1]; CurrAttributeID++)
341
			{
342
343
				/* Retrieve a PROGMEM pointer to the value of the current Attribute ID, if it exists in the UUID's Attribute table */
				const void* AttributeValue = SDP_GetAttributeValue(AttributeTable, CurrAttributeID);
344
				
345
				/* If the Attribute does not exist in the current UUID's Attribute table, continue to the next Attribute ID */
346
347
				if (AttributeValue == NULL)
				  continue;
348
				
349
350
				BT_SDP_DEBUG(2, " -- Add Attribute 0x%04X", CurrAttributeID);

351
				/* Increment the current UUID's returned Attribute container size by the number of added bytes */
352
				*CurrentUUIDResponseSize += SDP_AddAttributeToResponse(CurrAttributeID, AttributeValue, &CurrResponsePos);
353
			}
354

355
			/* Increment the outer container size by the number of added bytes */
356
			*TotalResponseSize += 3 + *CurrentUUIDResponseSize;
357
		}
358
359
360

		/* Flip the endianness of the container's size */
		*CurrentUUIDResponseSize = SwapEndian_16(*CurrentUUIDResponseSize);
361
	}
362
363
364
	
	/* Continuation state - always zero */
	*((uint8_t*)CurrResponsePos) = 0;
365

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

369
370
371
372
373
374
	/* 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));

375
	/* Fill in the response packet's header */
376
377
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICESEARCHATTRIBUTERESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
378
	ResponsePacket.SDPHeader.ParameterLength = SwapEndian_16(ParamLength);
379
380
381

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

383
	BT_SDP_DEBUG(1, ">> Service Search Attribute Response");
384
	BT_SDP_DEBUG(2, "-- Param Len 0x%04X", ParamLength);
385

386
	/* Send the completed response packet to the sender */
387
	Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ParamLength), Channel);
388
389
}

390
391
392
393
394
395
396
397
398
399
400
/** 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 */
401
402
	uint8_t  AttributeHeaderLength;
	uint32_t AttributeValueLength = SDP_GetLocalAttributeContainerSize(AttributeValue, &AttributeHeaderLength);
403
	
404
405
406
407
408
	/* Add a Data Element header to the response for the Attribute ID */
	*((uint8_t*)*ResponseBuffer) = (SDP_DATATYPE_UnsignedInt | SDP_DATASIZE_16Bit);
	*ResponseBuffer += sizeof(uint8_t);
	
	/* Add the Attribute ID to the created Data Element */
409
	*((uint16_t*)*ResponseBuffer) = SwapEndian_16(AttributeID);
410
411
412
	*ResponseBuffer += sizeof(uint16_t);
	
	/* Copy over the Attribute value Data Element container to the response */
413
414
	memcpy_P(*ResponseBuffer, AttributeValue, AttributeHeaderLength + AttributeValueLength);
	*ResponseBuffer += AttributeHeaderLength + AttributeValueLength;
415
	
416
	return (sizeof(uint8_t) + sizeof(uint16_t) + AttributeHeaderLength + AttributeValueLength);
417
418
}

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

443
444
445
446
447
448
449
/** Retrieves the Attribute table for the given UUID if it exists.
 *
 *  \param[in] UUID  UUID to search for
 *
 *  \return Pointer to the UUID's associated Attribute table if found in the global UUID table, NULL otherwise
 */
static ServiceAttributeTable_t* SDP_GetAttributeTable(const uint8_t* const UUID)
450
{
451
	/* Search through the global UUID list an item at a time */
452
453
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(ServiceTable_t)); CurrTableItem++)
	{
454
455
456
		/* Read in a pointer to the current UUID table entry's Attribute table */
		ServiceAttributeTable_t* CurrAttributeTable = (ServiceAttributeTable_t*)pgm_read_word(&SDP_Services_Table[CurrTableItem].AttributeTable);
	
457
		/* If the current table item's UUID matches the search UUID, return a pointer the table item's Attribute table */
458
		if (!(memcmp_P(UUID, SDP_Services_Table[CurrTableItem].UUID, UUID_SIZE_BYTES)))
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
		  return CurrAttributeTable;
		
		/* Retrieve the list of the service's Class UUIDs from its Attribute table */
		void* ClassUUIDs = SDP_GetAttributeValue(CurrAttributeTable, SDP_ATTRIBUTE_ID_SERVICECLASSIDS);
		
		/* Go to the next UUID in the table if the current item does not have a list of Class UUIDs */
		if (ClassUUIDs == NULL)
		  continue;
		  
		/* Retrieve the size of the Class UUID list and skip past the header to the first Class UUID in the list */ 
		uint8_t  ClassUUIDListHeaderSize;
		uint32_t ClassUUIDListSize = SDP_GetLocalAttributeContainerSize(ClassUUIDs, &ClassUUIDListHeaderSize);
		ClassUUIDs += ClassUUIDListHeaderSize;
		
		/* Check each class UUID in turn for a match */
		while (ClassUUIDListSize)
		{
			/* Current Service UUID's Class UUID list has a matching entry, return the Attribute table */
477
			if (!(memcmp_P(UUID, &((ClassUUID_t*)ClassUUIDs)->UUID, UUID_SIZE_BYTES)))
478
479
			  return CurrAttributeTable;
		
480
481
			ClassUUIDListSize -= sizeof(ClassUUID_t);
			ClassUUIDs        += sizeof(ClassUUID_t);
482
		}	
483
484
485
486
487
	}
	
	return NULL;
}

488
489
490
491
492
493
494
495
496
/** 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)
497
{
498
499
	uint8_t ElementHeaderSize;
	uint8_t TotalAttributes = 0;
500

501
502
	/* Retrieve the total size of the Attribute container, and unwrap the outer Data Element Sequence container */
	uint16_t AttributeIDListLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
503
504
505
	BT_SDP_DEBUG(2, "-- Total Attribute Length: 0x%04X", AttributeIDListLength);
	while (AttributeIDListLength)
	{
506
507
508
		/* 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);
509
		
510
511
		/* Copy over the starting Attribute ID and (if it the current element is a range) the ending Attribute ID */
		memcpy(&CurrentAttributeRange[0], *CurrentParameter, AttributeLength);
512
		
513
		/* If the element is not an Attribute Range, copy over the starting ID to the ending ID to make a range of 1 */
514
		if (AttributeLength == 2)
515
516
517
518
519
		  CurrentAttributeRange[1] = CurrentAttributeRange[0];

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

521
		BT_SDP_DEBUG(2, "-- Attribute: 0x%04X-0x%04X", CurrentAttributeRange[0], CurrentAttributeRange[1]);
522
		
523
		AttributeIDListLength -= (AttributeLength + ElementHeaderSize);
524
		*CurrentParameter     += AttributeLength;
525
	}
526
	
527
	return TotalAttributes;
528
529
}

530
531
532
533
534
535
536
537
538
/** 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)
539
540
541
542
{
	uint8_t ElementHeaderSize;
	uint8_t TotalUUIDs = 0;

543
544
	/* Retrieve the total size of the UUID container, and unwrap the outer Data Element Sequence container */
	uint16_t ServicePatternLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
545
546
547
	BT_SDP_DEBUG(2, "-- Total UUID Length: 0x%04X", ServicePatternLength);
	while (ServicePatternLength)
	{
548
		/* Retrieve the size of the next UUID in the container and get a pointer to the next free UUID element in the list */
549
		uint8_t* CurrentUUID = UUIDList[TotalUUIDs++];
550
		uint8_t  UUIDLength  = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
551
		
552
		/* Copy over the base UUID value to the free UUID slot in the list */
553
		memcpy_P(CurrentUUID, BaseUUID, sizeof(BaseUUID));
554
555
556

		/* Copy over UUID from the container to the free slot - if a short UUID (<= 4 bytes) it replaces the lower
		   4 bytes of the base UUID, otherwise it replaces the UUID completely */
557
558
559
560
561
562
563
564
565
		if (UUIDLength <= 4)
		{
			memcpy(&CurrentUUID[UUID_SIZE_BYTES - 4], *CurrentParameter, UUIDLength);
			SwapEndian_n(&CurrentUUID[UUID_SIZE_BYTES - 4], UUIDLength);				
		}
		else
		{
			memcpy(&CurrentUUID[0], *CurrentParameter, UUIDLength);		
		}
566
		
567
		BT_SDP_DEBUG(2, "-- UUID (%d): %02X%02X%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X",
568
569
570
571
572
573
574
575
576
577
578
579
580
		                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;
}

581
582
583
584
585
586
/** Retrieves the total size of the given locally stored (in PROGMEM) attribute Data Element container.
 *
 *  \param[in] AttributeData  Pointer to the start of the Attribute container, located in PROGMEM
 *
 *  \return Size in bytes of the entire attribute container, including the header
 */
587
static uint32_t SDP_GetLocalAttributeContainerSize(const void* const AttributeData, uint8_t* const HeaderSize)
588
589
590
591
592
593
594
{
	/* Fetch the size of the Data Element structure from the header */
	uint8_t SizeIndex = (pgm_read_byte(AttributeData) & 0x07);
	
	/* Convert the Data Element size index into a size in bytes */
	switch (SizeIndex)
	{
595
		case SDP_DATASIZE_Variable8Bit:
596
597
			*HeaderSize = (1 + sizeof(uint8_t));
			return pgm_read_byte(AttributeData + 1);
598
		case SDP_DATASIZE_Variable16Bit:
599
			*HeaderSize = (1 + sizeof(uint16_t));
600
			return SwapEndian_16(pgm_read_word(AttributeData + 1));
601
		case SDP_DATASIZE_Variable32Bit:
602
			*HeaderSize = (1 + sizeof(uint32_t));
603
			return SwapEndian_32(pgm_read_dword(AttributeData + 1));
604
		default:
605
606
			*HeaderSize = 1;
			return (1 << SizeIndex);
607
608
609
610
611
	}

	return 0;
}

612
613
614
615
616
617
618
619
620
/** 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)
621
{
622
	/* Fetch the size of the Data Element structure from the header, increment the current buffer pos */
623
624
625
	uint8_t SizeIndex = (*((uint8_t*)*DataElementHeader) & 0x07);
	*DataElementHeader += sizeof(uint8_t);
	
626
	uint32_t ElementValueSize;
627
628

	/* Convert the Data Element size index into a size in bytes */
629
630
	switch (SizeIndex)
	{
631
		case SDP_DATASIZE_Variable8Bit:
632
			ElementValueSize    = *((uint8_t*)*DataElementHeader);
633
634
635
			*DataElementHeader += sizeof(uint8_t);
			*ElementHeaderSize  = (1 + sizeof(uint8_t));
			break;
636
		case SDP_DATASIZE_Variable16Bit:
637
			ElementValueSize    = SwapEndian_16(*((uint16_t*)*DataElementHeader));
638
639
640
			*DataElementHeader += sizeof(uint16_t);
			*ElementHeaderSize  = (1 + sizeof(uint16_t));
			break;
641
		case SDP_DATASIZE_Variable32Bit:
642
			ElementValueSize    = SwapEndian_32(*((uint32_t*)*DataElementHeader));
643
644
645
			*DataElementHeader += sizeof(uint32_t);
			*ElementHeaderSize  = (1 + sizeof(uint32_t));
			break;
646
		default:
647
648
			ElementValueSize    = (1 << SizeIndex);
			*ElementHeaderSize  = 1;
649
			break;
650
651
	}
	
652
	return ElementValueSize;
653
}