bool SdpParseGetServiceName(const uint8 size_service_record, const uint8* service_record, uint8 size_service_name, char** service_name, uint8* length_service_name)
{
Region value;
uint8 k;
/* if found service name field */
if(findServiceName(size_service_record, service_record, saServiceName, &value))
{
/* read in size of service name string */
value.end = value.begin;
value.begin--;
/* Set length_service_name to no. of chars. in service name */
*length_service_name = (uint8)RegionReadUnsigned(&value);
/* if array has been allocated and field length is valid */
if(*length_service_name && size_service_name)
{
/* Ensure we dont try to use more memory than has been allocated */
if(*length_service_name > size_service_name - 1)
*length_service_name = size_service_name - 1;
/* move to first string element */
value.begin++;
value.end = value.begin + 1;
/* copy string element into array and move to next */
for(k = 0; k < (*length_service_name); k++)
{
service_name[0][k] = RegionReadUnsigned(&value);
value.end++;
}
/* set null char */
(*length_service_name)++;
service_name[0][k] = '\0';
/* Accessed Successfully */
return TRUE;
}
}
/* set return string to "Failed" */
*length_service_name = 0;
*service_name = NULL;
/* Failed */
return FALSE;
}
/* Get the supported features from the returned attribute list */
static uint16 getHfpAgSupportedFeatures(const uint8 *begin, const uint8 *end, uint16 *features)
{
Region value;
if(findHfpSupportedFeatures(begin, end, &value))
{
*features = (uint16) RegionReadUnsigned(&value);
return 1;
}
return 0;
}
/* Retrieve the rfcomm server channel */
static uint16 getRfcommChannelNumber(const uint8 *begin, const uint8 *end, uint16 *chan)
{
Region value;
if(findRfcommServerChannel(begin, end, &value))
{
*chan = (uint16) RegionReadUnsigned(&value);
return 1;
}
return 0;
}
bool SdpParseGetPbapRepos(const uint8 size_service_record, const uint8* service_record, uint8* repos)
{
Region value;
if(findPbapRepos(size_service_record, service_record, &value))
{
*repos = RegionReadUnsigned(&value);
/* Accessed Successfully */
return TRUE;
}
/* Failed */
return FALSE;
}
bool SdpParseGetSupportedFeatures(const uint8 size_service_record, const uint8* service_record, uint16* features)
{
Region value;
if(findSupportedFeatures(size_service_record, service_record, &value))
{
*features = (uint16) RegionReadUnsigned(&value);
/* Accessed Successfully */
return TRUE;
}
/* Failed */
return FALSE;
}
/****************************************************************************
* NAME
* SdpParseGetMapMasInstance
*
* DESCRIPTION
* API to access the MAS support message feature.
*
* PARAMETERS
* Refer sdp_parse.h
*
* RETURNS
* TRUE on success with MsgFeature contains the MASInstanceID.
**************************************************************************/
bool SdpParseGetMapMasMsgFeature( const uint8 size_service_record,
uint8* service_record,
uint8* msg_feature )
{
Region value;
if(findMapMasMsgFeature(size_service_record, service_record, &value))
{
*msg_feature = RegionReadUnsigned(&value);
/* Accessed Successfully */
return TRUE;
}
/* Failed */
return FALSE;
}
/****************************************************************************
* NAME
* SdpParseGetMapMasInstance
*
* DESCRIPTION
* API to access the MAS instance ID
*
* PARAMETERS
* Refer sdp_parse.h
*
* RETURNS
* TRUE on success with instanceId contains the MASInstanceID.
**************************************************************************/
bool SdpParseGetMapMasInstance( const uint8 size_service_record,
uint8* service_record,
uint8* instance_id )
{
Region value;
if(findMapMasInstance(size_service_record, service_record, &value))
{
*instance_id = RegionReadUnsigned(&value);
/* Accessed Successfully */
return TRUE;
}
/* Failed */
return FALSE;
}
bool SdpParseInsertServiceName(const uint8 size_service_record, const uint8* service_record, char* service_name)
{
Region value;
uint8 size_service_name, size_old_service_name, k;
size_service_name= strlen(service_name);
if(size_service_name <= MAX_SIZE_SERVICE_NAME && size_service_name > 0)
{
/* if found service name field */
if(findServiceName(size_service_record, service_record, saServiceName, &value))
{
/* move to size service name value */
value.end = value.begin;
value.begin--;
/* read in old value */
size_old_service_name = RegionReadUnsigned(&value);
if(size_service_name <= size_old_service_name)
{
/* move to first string element */
value.begin++;
value.end = value.begin + 1;
/* copy string element into array and move to next */
for(k = 0; k < size_service_name; k++)
{
RegionWriteUnsigned(&value, (uint32)service_name[k]);
value.begin ++;
value.end ++;
}
/* fill the rest with spaces */
for(k = size_service_name; k < size_old_service_name; k++)
{
RegionWriteUnsigned(&value, (uint32)' ');
value.begin++;
value.end++;
}
return TRUE;
}
}
}
/* Failed */
return FALSE;
}
bool SdpParseGetMultipleRfcommServerChannels(uint8 size_service_record, uint8* service_record, uint8 size_chans, uint8** chans, uint8* chans_found)
{
Region protocols, value;
*chans_found = 0;
if(findProtocolDescriptorList(size_service_record, service_record, &protocols))
while(findServerChannel(&protocols, (uint32) UUID_RFCOMM, &value))
{
/* reset protocols.begin so next search starts from after the channel we just found */
protocols.begin = value.end;
/* if space in the array then read in value, else break */
if((*chans_found) < size_chans)
{
/* Read in found channel */
chans[0][*chans_found] = (uint8)RegionReadUnsigned(&value);
(*chans_found)++;
}
else
{
break;
}
}
/* If we found any rfcomm channels */
if(*chans_found)
{
/* Accessed Successfully */
return TRUE;
}
else
{
/* Failed */
return FALSE;
}
}
/* Obtain the profile version number */
static bool getHfpAgProfileVersion(const uint8 *begin, const uint8 *end, uint16 *profile)
{
Region value;
if (findProfileVersion(begin, end, &value))
{
if (RegionSize(&value) == 2)
{
uint32 profile_version = RegionReadUnsigned(&value);
if ( profile_version==0x0105 )
{
*profile = (uint16)hfp_handsfree_15_profile;
}
else
{ /* Not explicitly declared as v1.5, so assume v1.1 */
*profile = (uint16)hfp_handsfree_profile;
}
return TRUE;
}
}
return FALSE;
}
bool RegionMatchesUUID32(const Region *r, uint32 uuid)
{
/* Valid sizes are 2, 4, and 16 so this is good enough */
return RegionReadUnsigned(r) == uuid && (RegionSize(r) != 16 || memcmp(uuid_suffix, r->begin, 12) == 0);
}
