ServiceDiscoveryProtocol.c 19.2 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
/** Service Discovery Protocol attribute, indicationg the service's name. */
35
36
37
38
39
40
41
const struct
{
	uint8_t Header;
	uint8_t Length;
	uint8_t Data[];
} PROGMEM SDP_Attribute_Name = {(SDP_DATATYPE_String | 5), sizeof("SDP"), "SDP"};

42
/** Service Discovery Protocol attribute, indicationg the service's description. */
43
44
45
46
47
48
49
const struct
{
	uint8_t Header;
	uint8_t Length;
	uint8_t Data[];
} PROGMEM SDP_Attribute_Description = {(SDP_DATATYPE_String | 5), sizeof("BT Service Discovery"), "BT Service Discovery"};

50
/** Service Discovery Protocol attribute, indicationg the service's availability. */
51
52
53
54
55
56
57
58
59
60
const struct
{
	uint8_t Header;
	uint8_t Data;
} PROGMEM SDP_Attribute_Availability = {(SDP_DATATYPE_UnsignedInt | 0), 0xFF};

const struct
{
	uint8_t  Header;
	uint16_t Data;
61
} PROGMEM SDP_Attribute_LanguageOffset = {(SDP_DATATYPE_UnsignedInt | 1), SDP_ATTRIBUTE_LANGOFFSET};
62
63
64
65
66
67
68
69
70
71
72
73
74

const struct
{
	uint8_t  Header;
	uint16_t Data;
} PROGMEM SDP_Attribute_ServiceHandle = {(SDP_DATATYPE_UnsignedInt | 1), 0x0001};

const struct
{
	uint8_t     Header;
	uint8_t     Size;
	ClassUUID_t UUIDList[];
} PROGMEM SDP_Attribute_ServiceClassIDs =
75
	{
76
77
78
79
		(SDP_DATATYPE_Sequence | 5), (sizeof(ClassUUID_t) * 1),
		{
			{.Header = (SDP_DATATYPE_UUID | 5), .Size = UUID_SIZE_BYTES, .UUID = {BASE_96BIT_UUID, 0x01, 0x00, 0x00, 0x00}}
		}
80
81
	};

82
83
/** Service Discovery Protocol attribute table, listing all supported attributes of the service. */
const ServiceAttributeTable_t SDP_Attribute_Table[] PROGMEM =
84
	{
85
86
87
88
89
		{.AttributeID = SDP_ATTRIBUTE_ID_SERVICERECORDHANDLE, .Data = &SDP_Attribute_ServiceHandle    },
		{.AttributeID = SDP_ATTRIBUTE_ID_SERVICECLASSIDS,     .Data = &SDP_Attribute_ServiceClassIDs  },
		{.AttributeID = SDP_ATTRIBUTE_ID_LANGIDOFFSET,        .Data = &SDP_Attribute_LanguageOffset   },
		{.AttributeID = SDP_ATTRIBUTE_ID_NAME,                .Data = &SDP_Attribute_Name             },
		{.AttributeID = SDP_ATTRIBUTE_ID_DESCRIPTION,         .Data = &SDP_Attribute_Description      },
90

91
92
		SERVICE_ATTRIBUTE_TABLE_TERMINATOR
	};
93

94
95
96
/** Master service table, listing all supported services (and their attribute tables) of the device, including
 *  each service's UUID.
 */
97
const ServiceTable_t SDP_Services_Table[] PROGMEM =
98
99
100
	{
		{   // 128-bit UUID for the SDP service
			.UUID  = {BASE_96BIT_UUID, 0x01, 0x00, 0x00, 0x00},
101
			.AttributeTable = SDP_Attribute_Table,
102
		},
103
#if 0
104
105
		{   // 128-bit UUID for the RFCOMM service
			.UUID  = {BASE_96BIT_UUID, 0x03, 0x00, 0x00, 0x00},
106
			.AttributeTable = RFCOMM_Attribute_Table,
107
		},
108
#endif
109
110
	};

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

114

115
116
117
118
119
120
121
/** 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
 */
122
void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel)
123
124
125
126
127
128
129
130
131
132
133
{
	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:
134
			SDP_ProcessServiceSearch(SDPHeader, Channel);
135
136
			break;		
		case SDP_PDU_SERVICEATTRIBUTEREQUEST:
137
			SDP_ProcessServiceAttribute(SDPHeader, Channel);
138
139
			break;
		case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST:
140
			SDP_ProcessServiceSearchAttribute(SDPHeader, Channel);
141
142
143
144
			break;
	}
}

145
146
147
148
149
150
/** 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)
151
152
153
154
{
	BT_SDP_DEBUG(1, "<< Service Search");
}

155
156
157
158
159
160
/** 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)
161
162
163
164
{
	BT_SDP_DEBUG(1, "<< Service Attribute");
}

165
166
167
168
169
170
/** 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)
171
{
172
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));
173
174
175
	
	BT_SDP_DEBUG(1, "<< Service Search Attribute");

176
	/* Retrieve the list of search UUIDs from the request */
177
	uint8_t UUIDList[12][UUID_SIZE_BYTES];
178
	uint8_t TotalUUIDs = SDP_GetUUIDList(UUIDList, &CurrentParameter);
179
	BT_SDP_DEBUG(2, "-- Total UUIDs: %d", TotalUUIDs);
180
	
181
182
183
	/* Retrieve the maximum Attribute reponse size from the request */
	uint16_t MaxAttributeSize = *((uint16_t*)CurrentParameter);
	CurrentParameter += sizeof(uint16_t);
184
	BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize);
185
	
186
	/* Retrieve the list of Attributes from the request */
187
	uint16_t AttributeList[15][2];
188
	uint8_t  TotalAttributes = SDP_GetAttributeList(AttributeList, &CurrentParameter);
189
190
	BT_SDP_DEBUG(2, "-- Total Attributes: %d", TotalAttributes);
	
191
192
193
	struct
	{
		SDP_PDUHeader_t SDPHeader;
194
		uint16_t        AttributeListByteCount;
195
196
197
		uint8_t         ResponseData[100];
	} ResponsePacket;
	
198
	/* Create a pointer to the buffer to indicate the current location for response data to be added */
199
200
	uint8_t* CurrResponsePos = ResponsePacket.ResponseData;

201
	/* Clamp the maximum attribute size to the size of the allocated buffer */
202
203
	if (MaxAttributeSize > sizeof(ResponsePacket.ResponseData))
	  MaxAttributeSize = sizeof(ResponsePacket.ResponseData);
204
205
206
207
208

	/* Add the outer Data Element Sequence header for the retrieved Attributes */
	uint16_t* TotalResponseSize = SDP_AddDataElementHeader16(&CurrResponsePos, SDP_DATATYPE_Sequence);
	
	/* Search through the list of UUIDs one at a time looking for matching search Attributes */
209
210
	for (uint8_t CurrUUIDItem = 0; CurrUUIDItem < TotalUUIDs; CurrUUIDItem++)
	{
211
212
		/* Retrieve the attribute table of the current search UUID from the global UUID table if it exists */
		ServiceAttributeTable_t* AttributeTable = SDP_GetAttributeTable(UUIDList[CurrUUIDItem]);
213
		
214
		/* If the UUID does not exist in the global UUID table, continue on to the next search UUID */
215
216
217
		if (AttributeTable == NULL)
		  continue;
		  
218
219
220
221
		/* 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 */
222
223
224
225
		for (uint8_t CurrAttribute = 0; CurrAttribute < TotalAttributes; CurrAttribute++)
		{
			uint16_t* AttributeIDRange = AttributeList[CurrAttribute];
		
226
			/* Look in the current Attribute Range for a matching Attribute ID in the UUID's Attribute table */
227
			for (uint32_t CurrAttributeID = AttributeIDRange[0]; CurrAttributeID <= AttributeIDRange[1]; CurrAttributeID++)
228
			{
229
230
				/* 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);
231
				
232
				/* If the Attribute does not exist in the current UUID's Attribute table, continue to the next Attribute ID */
233
234
235
				if (AttributeValue == NULL)
				  continue;

236
237
				/* Retrieve the size of the attribute value from its container header */
				uint32_t AttributeValueLength = SDP_GetLocalAttributeContainerSize(AttributeValue);				
238
239
				BT_SDP_DEBUG(2, " -- Add Attribute 0x%04X", CurrAttributeID);

240
				/* Add a Data Element header to the response for the Attribute ID */
241
242
				*((uint8_t*)CurrResponsePos) = (1 | SDP_DATATYPE_UnsignedInt);
				CurrResponsePos += sizeof(uint8_t);
243
244
				
				/* Add the Attribute ID to the created Data Element */
245
				*((uint16_t*)CurrResponsePos) = CurrAttributeID;
246
247
248
				CurrResponsePos += sizeof(uint16_t);
				
				/* Copy over the Attribute value Data Element container to the response */
249
250
				memcpy_P(CurrResponsePos, AttributeValue, AttributeValueLength);
				CurrResponsePos += AttributeValueLength;
251
252
				
				/* Increment the current UUID's returned Attribute container size by the number of added bytes */
253
				*CurrentUUIDResponseSize += sizeof(uint8_t) + sizeof(uint16_t) + AttributeValueLength;
254
			}
255

256
			/* Increment the outer container size by the number of added bytes */
257
			*TotalResponseSize += 3 + *CurrentUUIDResponseSize;
258
259
260
		}
	}

261
262
263
264
	/* Set the total response list size to the size of the outer container plus its header size */
	ResponsePacket.AttributeListByteCount    = 3 + *TotalResponseSize;

	/* Fill in the response packet's header */
265
266
267
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICESEARCHATTRIBUTERESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
	ResponsePacket.SDPHeader.ParameterLength = (ResponsePacket.AttributeListByteCount + sizeof(ResponsePacket.AttributeListByteCount));
268

269
270
271
	BT_SDP_DEBUG(1, ">> Service Search Attribute Response");
	BT_SDP_DEBUG(2, "-- Total Parameter Length: 0x%04X", ResponsePacket.SDPHeader.ParameterLength);

272
	/* Send the completed response packet to the sender */
273
274
275
276
	Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ResponsePacket.SDPHeader.ParameterLength),
	                     Channel);
}

277
278
279
280
281
282
283
284
/** 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)
285
{
286
	void* CurrTableItemData;
287
288
	
	/* Search through the current Attribute table, abort when the terminator item has been reached */
289
	while ((CurrTableItemData = (void*)pgm_read_word(&AttributeTable->Data)) != NULL)
290
	{
291
		/* Check if the current Attribute ID matches the search ID - if so return a pointer to it */
292
		if (pgm_read_word(&AttributeTable->AttributeID) == AttributeID)
293
		  return CurrTableItemData;
294
295
296
297
298
299
300
		
		AttributeTable++;
	}
			
	return NULL;
}

301
302
303
304
305
306
307
/** 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)
308
{
309
	/* Search through the global UUID list an item at a time */
310
311
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(ServiceTable_t)); CurrTableItem++)
	{
312
		/* If the current table item's UUID matches the search UUID, return a pointer the table item's Attribute table */
313
314
315
316
317
318
319
		if (!(memcmp_P(UUID, SDP_Services_Table[CurrTableItem].UUID, UUID_SIZE_BYTES)))
		  return (ServiceAttributeTable_t*)pgm_read_word(&SDP_Services_Table[CurrTableItem].AttributeTable);
	}
	
	return NULL;
}

320
321
322
323
324
325
326
327
328
/** 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)
329
{
330
331
	uint8_t ElementHeaderSize;
	uint8_t TotalAttributes = 0;
332

333
334
	/* Retrieve the total size of the Attribute container, and unwrap the outer Data Element Sequence container */
	uint16_t AttributeIDListLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
335
336
337
	BT_SDP_DEBUG(2, "-- Total Attribute Length: 0x%04X", AttributeIDListLength);
	while (AttributeIDListLength)
	{
338
339
340
		/* 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);
341
		
342
343
		/* Copy over the starting Attribute ID and (if it the current element is a range) the ending Attribute ID */
		memcpy(&CurrentAttributeRange[0], *CurrentParameter, AttributeLength);
344
		
345
		/* If the element is not an Attribute Range, copy over the starting ID to the ending ID to make a range of 1 */
346
		if (AttributeLength == 2)
347
		  memcpy(&CurrentAttributeRange[1], *CurrentParameter, 2);
348

349
		BT_SDP_DEBUG(2, "-- Attribute: 0x%04X-0x%04X", CurrentAttributeRange[0], CurrentAttributeRange[1]);
350
		
351
		AttributeIDListLength -= (AttributeLength + ElementHeaderSize);
352
		*CurrentParameter     += AttributeLength;
353
	}
354
	
355
	return TotalAttributes;
356
357
}

358
359
360
361
362
363
364
365
366
/** 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)
367
368
369
370
{
	uint8_t ElementHeaderSize;
	uint8_t TotalUUIDs = 0;

371
372
	/* Retrieve the total size of the UUID container, and unwrap the outer Data Element Sequence container */
	uint16_t ServicePatternLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
373
374
375
	BT_SDP_DEBUG(2, "-- Total UUID Length: 0x%04X", ServicePatternLength);
	while (ServicePatternLength)
	{
376
		/* Retrieve the size of the next UUID in the container and get a pointer to the next free UUID element in the list */
377
		uint8_t* CurrentUUID = UUIDList[TotalUUIDs++];
378
		uint8_t  UUIDLength  = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
379
		
380
		/* Copy over the base UUID value to the free UUID slot in the list */
381
		memcpy_P(CurrentUUID, BaseUUID, sizeof(BaseUUID));
382
383
384

		/* 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 */
385
		memcpy(&CurrentUUID[(UUIDLength <= 4) ? (UUID_SIZE_BYTES - 4) : 0], *CurrentParameter, UUIDLength);
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
		
		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;
}

401
402
403
404
405
406
407
/** 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
 */
static uint32_t SDP_GetLocalAttributeContainerSize(const void* const AttributeData)
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
{
	/* 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)
	{
		case 5:
			return (1 + sizeof(uint8_t)) + pgm_read_byte(AttributeData + 1);
		case 6:
			return (1 + sizeof(uint16_t)) + pgm_read_word(AttributeData + 1);
		case 7:
			return (1 + sizeof(uint32_t)) + pgm_read_dword(AttributeData + 1);
		default:
			return (1 + (1 << SizeIndex));
	}

	return 0;
}

428
429
430
431
432
433
434
435
436
/** 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)
437
{
438
	/* Fetch the size of the Data Element structure from the header, increment the current buffer pos */
439
440
441
442
	uint8_t SizeIndex = (*((uint8_t*)*DataElementHeader) & 0x07);
	*DataElementHeader += sizeof(uint8_t);
	
	uint32_t ElementValue;
443
444

	/* Convert the Data Element size index into a size in bytes */
445
446
447
448
449
450
451
452
453
454
455
456
	switch (SizeIndex)
	{
		case 5:
			ElementValue = *((uint8_t*)*DataElementHeader);
			*DataElementHeader += sizeof(uint8_t);
			*ElementHeaderSize  = (1 + sizeof(uint8_t));
			break;
		case 6:
			ElementValue = *((uint16_t*)*DataElementHeader);
			*DataElementHeader += sizeof(uint16_t);
			*ElementHeaderSize  = (1 + sizeof(uint16_t));
			break;
457
		case 7:
458
459
460
461
			ElementValue = *((uint32_t*)*DataElementHeader);
			*DataElementHeader += sizeof(uint32_t);
			*ElementHeaderSize  = (1 + sizeof(uint32_t));
			break;
462
		default:
463
464
			ElementValue = (1 << SizeIndex);
			*ElementHeaderSize = 1;
465
			break;
466
467
468
469
	}
	
	return ElementValue;
}