ServiceDiscoveryProtocol.c 21 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, indicating the service's availability. */
35
36
37
38
const struct
{
	uint8_t Header;
	uint8_t Data;
39
} PROGMEM SDP_Attribute_Availability = {(SDP_DATATYPE_UnsignedInt | SDP_DATASIZE_8Bit), 0xFF};
40
41
42
43

const struct
{
	uint8_t  Header;
44
	uint32_t Data;
45
} PROGMEM SDP_Attribute_ServiceHandle = {(SDP_DATATYPE_UnsignedInt | SDP_DATASIZE_32Bit), 0x00010000};
46

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
const struct
{
	uint8_t   Header;
	uint8_t   Size;
	Version_t VersionList[];
} PROGMEM SDP_Attribute_Version =
	{
		.Header = (SDP_DATATYPE_Sequence | SDP_DATASIZE_Variable8Bit),
		.Size   = (sizeof(Version_t) * 1),
		.VersionList =
			{
				{.Header = (SDP_DATATYPE_UnsignedInt | SDP_DATASIZE_16Bit), .Version = 0x0100}
			}
	};

62
63
64
const struct
{
	uint8_t     Header;
65
	uint16_t    Size;
66
67
	ClassUUID_t UUIDList[];
} PROGMEM SDP_Attribute_ServiceClassIDs =
68
	{
69
70
71
72
73
74
		.Header = (SDP_DATATYPE_Sequence | SDP_DATASIZE_Variable16Bit),
		.Size   = (sizeof(ClassUUID_t) * 1),
		.UUIDList =
			{
				{.Header = (SDP_DATATYPE_UUID | SDP_DATASIZE_128Bit), .UUID = {BASE_96BIT_UUID, 0x01, 0x00, 0x00, 0x00}}
			}
75
76
	};

77
78
/** Service Discovery Protocol attribute table, listing all supported attributes of the service. */
const ServiceAttributeTable_t SDP_Attribute_Table[] PROGMEM =
79
	{
80
81
		{.AttributeID = SDP_ATTRIBUTE_ID_SERVICERECORDHANDLE, .Data = &SDP_Attribute_ServiceHandle    },
		{.AttributeID = SDP_ATTRIBUTE_ID_SERVICECLASSIDS,     .Data = &SDP_Attribute_ServiceClassIDs  },
82
		{.AttributeID = SDP_ATTRIBUTE_ID_VERSION,             .Data = &SDP_Attribute_Version          },
83

84
85
		SERVICE_ATTRIBUTE_TABLE_TERMINATOR
	};
86

87
88
89
/** Master service table, listing all supported services (and their attribute tables) of the device, including
 *  each service's UUID.
 */
90
const ServiceTable_t SDP_Services_Table[] PROGMEM =
91
	{
92
93
		{   // 128-bit UUID for the SDP service
			.UUID  = {BASE_96BIT_UUID, 0x00, 0x00, 0x00, 0x01},
94
			.AttributeTable = SDP_Attribute_Table,
95
96
97
		},
	};

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

101

102
103
104
105
106
107
108
/** 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
 */
109
void SDP_ProcessPacket(void* Data, Bluetooth_Channel_t* Channel)
110
111
112
113
114
115
116
117
118
119
120
{
	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:
121
			SDP_ProcessServiceSearch(SDPHeader, Channel);
122
123
			break;		
		case SDP_PDU_SERVICEATTRIBUTEREQUEST:
124
			SDP_ProcessServiceAttribute(SDPHeader, Channel);
125
126
			break;
		case SDP_PDU_SERVICESEARCHATTRIBUTEREQUEST:
127
			SDP_ProcessServiceSearchAttribute(SDPHeader, Channel);
128
129
130
131
			break;
	}
}

132
133
134
135
136
137
/** 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)
138
139
140
141
{
	BT_SDP_DEBUG(1, "<< Service Search");
}

142
143
144
145
146
147
/** 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)
148
149
150
151
{
	BT_SDP_DEBUG(1, "<< Service Attribute");
}

152
153
154
155
156
157
/** 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)
158
{
159
	const void* CurrentParameter = ((void*)SDPHeader + sizeof(SDP_PDUHeader_t));
160
161
162
	
	BT_SDP_DEBUG(1, "<< Service Search Attribute");

163
	/* Retrieve the list of search UUIDs from the request */
164
	uint8_t UUIDList[12][UUID_SIZE_BYTES];
165
	uint8_t TotalUUIDs = SDP_GetUUIDList(UUIDList, &CurrentParameter);
166
	BT_SDP_DEBUG(2, "-- Total UUIDs: %d", TotalUUIDs);
167
	
168
169
170
	/* Retrieve the maximum Attribute reponse size from the request */
	uint16_t MaxAttributeSize = *((uint16_t*)CurrentParameter);
	CurrentParameter += sizeof(uint16_t);
171
	BT_SDP_DEBUG(2, "-- Max Return Attribute Bytes: 0x%04X", MaxAttributeSize);
172
	
173
	/* Retrieve the list of Attributes from the request */
174
	uint16_t AttributeList[15][2];
175
	uint8_t  TotalAttributes = SDP_GetAttributeList(AttributeList, &CurrentParameter);
176
177
	BT_SDP_DEBUG(2, "-- Total Attributes: %d", TotalAttributes);
	
178
179
180
	struct
	{
		SDP_PDUHeader_t SDPHeader;
181
		uint16_t        AttributeListByteCount;
182
183
184
		uint8_t         ResponseData[100];
	} ResponsePacket;
	
185
	/* Create a pointer to the buffer to indicate the current location for response data to be added */
186
	void* CurrResponsePos = ResponsePacket.ResponseData;
187

188
	/* Clamp the maximum attribute size to the size of the allocated buffer */
189
190
	if (MaxAttributeSize > sizeof(ResponsePacket.ResponseData))
	  MaxAttributeSize = sizeof(ResponsePacket.ResponseData);
191

192
	/* Add the outer Data Element Sequence header for all of the retrieved Attributes */
193
194
195
	uint16_t* TotalResponseSize = SDP_AddDataElementHeader16(&CurrResponsePos, SDP_DATATYPE_Sequence);
	
	/* Search through the list of UUIDs one at a time looking for matching search Attributes */
196
197
	for (uint8_t CurrUUIDItem = 0; CurrUUIDItem < TotalUUIDs; CurrUUIDItem++)
	{
198
199
		/* Retrieve the attribute table of the current search UUID from the global UUID table if it exists */
		ServiceAttributeTable_t* AttributeTable = SDP_GetAttributeTable(UUIDList[CurrUUIDItem]);
200
		
201
		/* If the UUID does not exist in the global UUID table, continue on to the next search UUID */
202
203
204
		if (AttributeTable == NULL)
		  continue;
		  
205
206
		BT_SDP_DEBUG(2, " -- Found UUID %d in table", CurrUUIDItem);

207
208
209
210
		/* 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 */
211
212
213
214
		for (uint8_t CurrAttribute = 0; CurrAttribute < TotalAttributes; CurrAttribute++)
		{
			uint16_t* AttributeIDRange = AttributeList[CurrAttribute];
		
215
			/* Look in the current Attribute Range for a matching Attribute ID in the UUID's Attribute table */
216
			for (uint32_t CurrAttributeID = AttributeIDRange[0]; CurrAttributeID <= AttributeIDRange[1]; CurrAttributeID++)
217
			{
218
219
				/* 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);
220
				
221
				/* If the Attribute does not exist in the current UUID's Attribute table, continue to the next Attribute ID */
222
223
				if (AttributeValue == NULL)
				  continue;
224
				
225
226
				BT_SDP_DEBUG(2, " -- Add Attribute 0x%04X", CurrAttributeID);

227
				/* Increment the current UUID's returned Attribute container size by the number of added bytes */
228
				*CurrentUUIDResponseSize += SDP_AddAttributeToResponse(CurrAttributeID, AttributeValue, &CurrResponsePos);
229
			}
230

231
			/* Increment the outer container size by the number of added bytes */
232
			*TotalResponseSize += 3 + *CurrentUUIDResponseSize;
233
234
		}
	}
235
236
237
	
	/* Continuation state - always zero */
	*((uint8_t*)CurrResponsePos) = 0;
238

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

	/* Fill in the response packet's header */
243
244
245
	ResponsePacket.SDPHeader.PDU             = SDP_PDU_SERVICESEARCHATTRIBUTERESPONSE;
	ResponsePacket.SDPHeader.TransactionID   = SDPHeader->TransactionID;
	ResponsePacket.SDPHeader.ParameterLength = (ResponsePacket.AttributeListByteCount + sizeof(ResponsePacket.AttributeListByteCount));
246

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

250
	/* Send the completed response packet to the sender */
251
252
253
254
	Bluetooth_SendPacket(&ResponsePacket, (sizeof(ResponsePacket.SDPHeader) + ResponsePacket.SDPHeader.ParameterLength),
	                     Channel);
}

255
256
257
258
259
260
261
262
263
264
265
/** 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 */
266
267
	uint8_t  AttributeHeaderLength;
	uint32_t AttributeValueLength = SDP_GetLocalAttributeContainerSize(AttributeValue, &AttributeHeaderLength);
268
269
270
271
272
273
274
275
276
277

	/* 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 */
	*((uint16_t*)*ResponseBuffer) = AttributeID;
	*ResponseBuffer += sizeof(uint16_t);
	
	/* Copy over the Attribute value Data Element container to the response */
278
279
	memcpy_P(*ResponseBuffer, AttributeValue, AttributeHeaderLength + AttributeValueLength);
	*ResponseBuffer += AttributeHeaderLength + AttributeValueLength;
280
	
281
	return (sizeof(uint8_t) + sizeof(uint16_t) + AttributeHeaderLength + AttributeValueLength);
282
283
}

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

308
309
310
311
312
313
314
/** 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)
315
{
316
	/* Search through the global UUID list an item at a time */
317
318
	for (uint8_t CurrTableItem = 0; CurrTableItem < (sizeof(SDP_Services_Table) / sizeof(ServiceTable_t)); CurrTableItem++)
	{
319
320
321
		/* 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);
	
322
		/* If the current table item's UUID matches the search UUID, return a pointer the table item's Attribute table */
323
		if (!(memcmp_P(UUID, SDP_Services_Table[CurrTableItem].UUID, UUID_SIZE_BYTES)))
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
		  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 */
342
			if (!(memcmp_P(UUID, &((ClassUUID_t*)ClassUUIDs)->UUID, UUID_SIZE_BYTES)))
343
344
			  return CurrAttributeTable;
		
345
346
			ClassUUIDListSize -= sizeof(ClassUUID_t);
			ClassUUIDs        += sizeof(ClassUUID_t);
347
		}	
348
349
350
351
352
	}
	
	return NULL;
}

353
354
355
356
357
358
359
360
361
/** 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)
362
{
363
364
	uint8_t ElementHeaderSize;
	uint8_t TotalAttributes = 0;
365

366
367
	/* Retrieve the total size of the Attribute container, and unwrap the outer Data Element Sequence container */
	uint16_t AttributeIDListLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
368
369
370
	BT_SDP_DEBUG(2, "-- Total Attribute Length: 0x%04X", AttributeIDListLength);
	while (AttributeIDListLength)
	{
371
372
373
		/* 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);
374
		
375
376
		/* Copy over the starting Attribute ID and (if it the current element is a range) the ending Attribute ID */
		memcpy(&CurrentAttributeRange[0], *CurrentParameter, AttributeLength);
377
		
378
		/* If the element is not an Attribute Range, copy over the starting ID to the ending ID to make a range of 1 */
379
		if (AttributeLength == 2)
380
		  memcpy(&CurrentAttributeRange[1], *CurrentParameter, 2);
381

382
		BT_SDP_DEBUG(2, "-- Attribute: 0x%04X-0x%04X", CurrentAttributeRange[0], CurrentAttributeRange[1]);
383
		
384
		AttributeIDListLength -= (AttributeLength + ElementHeaderSize);
385
		*CurrentParameter     += AttributeLength;
386
	}
387
	
388
	return TotalAttributes;
389
390
}

391
392
393
394
395
396
397
398
399
/** 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)
400
401
402
403
{
	uint8_t ElementHeaderSize;
	uint8_t TotalUUIDs = 0;

404
405
	/* Retrieve the total size of the UUID container, and unwrap the outer Data Element Sequence container */
	uint16_t ServicePatternLength = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
406
407
408
	BT_SDP_DEBUG(2, "-- Total UUID Length: 0x%04X", ServicePatternLength);
	while (ServicePatternLength)
	{
409
		/* Retrieve the size of the next UUID in the container and get a pointer to the next free UUID element in the list */
410
		uint8_t* CurrentUUID = UUIDList[TotalUUIDs++];
411
		uint8_t  UUIDLength  = SDP_GetDataElementSize(CurrentParameter, &ElementHeaderSize);
412
		
413
		/* Copy over the base UUID value to the free UUID slot in the list */
414
		memcpy_P(CurrentUUID, BaseUUID, sizeof(BaseUUID));
415
416
417

		/* 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 */
418
		memcpy(&CurrentUUID[(UUIDLength <= 4) ? (UUID_SIZE_BYTES - 4) : 0], *CurrentParameter, UUIDLength);
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
		
		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;
}

434
435
436
437
438
439
/** 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
 */
440
static uint32_t SDP_GetLocalAttributeContainerSize(const void* const AttributeData, uint8_t* const HeaderSize)
441
442
443
444
445
446
447
{
	/* 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)
	{
448
		case SDP_DATASIZE_Variable8Bit:
449
450
			*HeaderSize = (1 + sizeof(uint8_t));
			return pgm_read_byte(AttributeData + 1);
451
		case SDP_DATASIZE_Variable16Bit:
452
453
			*HeaderSize = (1 + sizeof(uint16_t));
			return pgm_read_word(AttributeData + 1);
454
		case SDP_DATASIZE_Variable32Bit:
455
456
			*HeaderSize = (1 + sizeof(uint32_t));
			return pgm_read_dword(AttributeData + 1);
457
		default:
458
459
			*HeaderSize = 1;
			return (1 << SizeIndex);
460
461
462
463
464
	}

	return 0;
}

465
466
467
468
469
470
471
472
473
/** 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)
474
{
475
	/* Fetch the size of the Data Element structure from the header, increment the current buffer pos */
476
477
478
479
	uint8_t SizeIndex = (*((uint8_t*)*DataElementHeader) & 0x07);
	*DataElementHeader += sizeof(uint8_t);
	
	uint32_t ElementValue;
480
481

	/* Convert the Data Element size index into a size in bytes */
482
483
	switch (SizeIndex)
	{
484
		case SDP_DATASIZE_Variable8Bit:
485
486
487
488
			ElementValue = *((uint8_t*)*DataElementHeader);
			*DataElementHeader += sizeof(uint8_t);
			*ElementHeaderSize  = (1 + sizeof(uint8_t));
			break;
489
		case SDP_DATASIZE_Variable16Bit:
490
491
492
493
			ElementValue = *((uint16_t*)*DataElementHeader);
			*DataElementHeader += sizeof(uint16_t);
			*ElementHeaderSize  = (1 + sizeof(uint16_t));
			break;
494
		case SDP_DATASIZE_Variable32Bit:
495
496
497
498
			ElementValue = *((uint32_t*)*DataElementHeader);
			*DataElementHeader += sizeof(uint32_t);
			*ElementHeaderSize  = (1 + sizeof(uint32_t));
			break;
499
		default:
500
501
			ElementValue = (1 << SizeIndex);
			*ElementHeaderSize = 1;
502
			break;
503
504
505
506
	}
	
	return ElementValue;
}