attr.c

Affix - Bluetooth Protocol Stack for Linux has been developed at Nokia Research Center in Helsinki

			__put_u8(pdata, pdu->length - 
				sizeof(uint8_t) - sizeof(uint8_t));
			break;
		case SDP_DTD_SEQ16 :
			__put_u16(pdata, htons(pdu->length - 
					sizeof(uint8_t) - sizeof(uint16_t)));
			break;
		case SDP_DTD_SEQ32 :
			__put_u32(pdata, htonl(pdu->length - 
					sizeof(uint8_t) - sizeof(uint32_t)));
			break;
		default :
			break;
	}
}

/*
 ** This function appends data to the PDU form in the buffer "dst"
 ** from source "src". The data length is also computed and set.
 ** Should the PDU form length exceed 2^8, then sequence type is
 ** set accordingly and the data is memmove()'d.
 */
int sdp_append_pdu(sdppdu_t *dst, sdppdu_t *src)
{
	uint8_t	dataType;
	char	*pdata;

	pdata = dst->data;
	dataType = __get_u8(pdata);

	DBPRT("Append src size : %d", src->length);
	DBPRT("Append dst size : %d", dst->length);
	DBPRT("Dst buffer size : %d", dst->size);

	if (!dst || !dst->data)
		return 0;
	if ((dst->length + src->length) > dst->size) {
		/*
		 ** Need to realloc !
		 */
		int neededSize = SDP_PDU_CHUNK_SIZE * ((src->length/SDP_PDU_CHUNK_SIZE) + 1);
		dst->data = (char *)realloc(dst->data, (dst->size + neededSize));
		DBPRT("Realloc'ing : %d", neededSize);
		if (dst->data == NULL) {
			BTERROR("Realloc fails \n");
		}
		dst->size += neededSize;
	}
	if ((dst->length == 0) && (dataType == 0)) {
		//create initial sequence
		__put_u8(pdata, SDP_DTD_SEQ8);
		pdata += sizeof(uint8_t);
		dst->length += sizeof(uint8_t);
		/*
		 ** Space for sequence size
		 */
		pdata += sizeof(uint8_t);
		dst->length += sizeof(uint8_t);
	}
	memcpy((dst->data + dst->length), src->data, src->length);
	dst->length += src->length;

	dataType = *(uint8_t *)dst->data;
	if ((dst->length > UCHAR_MAX) && (dataType == SDP_DTD_SEQ8)) {
		/*
		 ** Need to memmove
		 */
		short offset = sizeof(uint8_t) + sizeof(uint8_t);
		memmove((dst->data + offset + 1), (dst->data + offset),
				(dst->length - offset));
		pdata = dst->data;
		__put_u8(pdata, SDP_DTD_SEQ16);
		pdata += sizeof(uint8_t);
		dst->length += 1;
	}
	sdp_set_seq_length_pdu(dst);
	return src->length;
}

void sdp_gen_attr_pdu(void *value, void *userData)
{
	sdpdata_t	*data = (sdpdata_t*)value;
	uint8_t		dtd;
	int		pduFormSize = 0;

	if (!data)
		return;
	dtd = data->dtd;
	if (dtd < SDP_DTD_UUID128)
		pduFormSize = SDP_BASIC_ATTR_PDU_SIZE;
	else
		pduFormSize = SDP_SEQ_PDU_SIZE;
	if (data->pdu.data == NULL) {
		data->pdu.data = (char *)malloc(pduFormSize);
		if (!data->pdu.data)
			return;
		data->pdu.size = pduFormSize;
	}
	data->pdu.length = 0;
	memset(data->pdu.data, 0, data->pdu.size);
	DBPRT("Adding attr id : 0x%x", data->attrId);
	sdp_set_attr_id(&data->pdu, data->attrId);	// attr id
	sdp_gen_pdu(&data->pdu, data);		// attr value
#ifdef CONFIG_AFFIX_DEBUG
	sdp_print_pdu(&data->pdu);
#endif
	/*
	 ** Append to the overall PDU form
	 */
	if (userData != NULL) {
		/* will be a sequence of attributes */
		sdp_append_pdu((sdppdu_t *)userData, &data->pdu);
	}
}

/*
 *  Main function. Called to serialize Service Record to sdppdu_t
 *  MAIN for sdp_register_service
 */
void sdp_gen_svc_pdu(sdpsvc_t *svcRec)
{
	slist_t	*attrList;

	attrList = svcRec->attributeList;
	if (!attrList)
		return;
	if (!svcRec->pdu.data) {
		svcRec->pdu.data = (char *)malloc(SDP_PDU_CHUNK_SIZE);
		if (!svcRec->pdu.data)
			return;
		svcRec->pdu.size = SDP_PDU_CHUNK_SIZE;
	}
	svcRec->pdu.length = 0;
	memset(svcRec->pdu.data, 0, svcRec->pdu.size);
	s_list_foreach(attrList, sdp_gen_attr_pdu, &svcRec->pdu);
	//sdp_set_seq_length_pdu(&svcRec->pdu);
#ifdef CONFIG_AFFIX_DEBUG
	sdp_print_pdu(&svcRec->pdu);
#endif
}

sdpdata_t *sdp_put_u8(uint8_t val)
{
	return sdp_create_data(SDP_DTD_UINT8, &val);
}

sdpdata_t *sdp_append_u8(sdpdata_t *seq, uint8_t val)
{
	return sdp_append_data(seq, sdp_put_u8(val));
}

uint8_t sdp_get_u8(sdpdata_t *data)
{
	return data->value.uint8;
}

sdpdata_t *sdp_put_i8(int8_t val)
{
	return sdp_create_data(SDP_DTD_INT8, &val);
}

sdpdata_t *sdp_append_i8(sdpdata_t *seq, int8_t val)
{
	return sdp_append_data(seq, sdp_put_i8(val));
}

int8_t sdp_get_i8(sdpdata_t *data)
{
	return data->value.int8;
}

sdpdata_t *sdp_put_bool(int8_t val)
{
	return sdp_create_data(SDP_DTD_ABOOL, &val);
}

sdpdata_t *sdp_append_bool(sdpdata_t *seq, int8_t val)
{
	return sdp_append_data(seq, sdp_put_bool(val));
}

int8_t sdp_get_bool(sdpdata_t *data)
{
	return data->value.int8;
}

sdpdata_t *sdp_put_u16(uint16_t val)
{
	return sdp_create_data(SDP_DTD_UINT16, &val);
}

sdpdata_t *sdp_append_u16(sdpdata_t *seq, uint16_t val)
{
	return sdp_append_data(seq, sdp_put_u16(val));
}

uint16_t sdp_get_u16(sdpdata_t *data)
{
	return data->value.uint16;
}

sdpdata_t *sdp_put_i16(int16_t val)
{
	return sdp_create_data(SDP_DTD_INT16, &val);
}

sdpdata_t *sdp_append_i16(sdpdata_t *seq, int16_t val)
{
	return sdp_append_data(seq, sdp_put_i16(val));
}

int16_t sdp_get_i16(sdpdata_t *data)
{
	return data->value.int16;
}

sdpdata_t *sdp_put_u32(uint32_t val)
{
	return sdp_create_data(SDP_DTD_UINT32, &val);
}

sdpdata_t *sdp_append_u32(sdpdata_t *seq, uint32_t val)
{
	return sdp_append_data(seq, sdp_put_u32(val));
}

uint32_t sdp_get_u32(sdpdata_t *data)
{
	return data->value.uint32;
}

sdpdata_t *sdp_put_i32(int32_t val)
{
	return sdp_create_data(SDP_DTD_INT32, &val);
}

sdpdata_t *sdp_append_i32(sdpdata_t *seq, int32_t val)
{
	return sdp_append_data(seq, sdp_put_i32(val));
}

int32_t sdp_get_i32(sdpdata_t *data)
{
	return data->value.int32;
}

sdpdata_t *sdp_put_u64(uint64_t val)
{
	return sdp_create_data(SDP_DTD_UINT64, &val);
}

sdpdata_t *sdp_append_u64(sdpdata_t *seq, uint64_t val)
{
	return sdp_append_data(seq, sdp_put_u64(val));
}

uint64_t sdp_get_u64(sdpdata_t *data)
{
	return data->value.uint64;
}

sdpdata_t *sdp_put_i64(int64_t val)
{
	return sdp_create_data(SDP_DTD_INT64, &val);
}

sdpdata_t *sdp_append_i64(sdpdata_t *seq, int64_t val)
{
	return sdp_append_data(seq, sdp_put_i64(val));
}

int64_t sdp_get_i64(sdpdata_t *data)
{
	return data->value.int64;
}

sdpdata_t *sdp_put_u128(uint128_t *val)
{
	return sdp_create_data(SDP_DTD_UINT128, val);
}

sdpdata_t *sdp_append_u128(sdpdata_t *seq, uint128_t *val)
{
	return sdp_append_data(seq, sdp_put_u128(val));
}

uint128_t *sdp_get_u128(sdpdata_t *data)
{
	return &data->value.uint128;
}

sdpdata_t *sdp_put_i128(int128_t *val)
{
	return sdp_create_data(SDP_DTD_INT128, val);
}

sdpdata_t *sdp_append_i128(sdpdata_t *seq, int128_t *val)
{
	return sdp_append_data(seq, sdp_put_i128(val));
}

int128_t *sdp_get_i128(sdpdata_t *data)
{
	return &data->value.int128;
}

sdpdata_t *sdp_put_uuid(uuid_t *val)
{
	return sdp_create_data(SDP_DTD_AUUID, val);
}

sdpdata_t *sdp_append_uuid(sdpdata_t *seq, uuid_t *val)
{
	return sdp_append_data(seq, sdp_put_uuid(val));
}

uuid_t *sdp_get_uuid(sdpdata_t *data)
{
	return &data->value.uuid;
}

sdpdata_t *sdp_put_uuid16(uint16_t val)
{
	return sdp_create_data(SDP_DTD_UUID16, &val);
}

sdpdata_t *sdp_append_uuid16(sdpdata_t *seq, uint16_t val)
{
	return sdp_append_data(seq, sdp_put_uuid16(val));
}

sdpdata_t *sdp_put_uuid32(uint32_t val)
{
	return sdp_create_data(SDP_DTD_UUID32, &val);
}

sdpdata_t *sdp_append_uuid32(sdpdata_t *seq, uint32_t val)
{
	return sdp_append_data(seq, sdp_put_uuid32(val));
}

sdpdata_t *sdp_put_uuid128(uint128_t *val)
{
	return sdp_create_data(SDP_DTD_UUID128, val);
}

sdpdata_t *sdp_append_uuid128(sdpdata_t *seq, uint128_t *val)
{
	return sdp_append_data(seq, sdp_put_uuid128(val));
}

sdpdata_t *sdp_put_str(char *str)
{
	return sdp_create_data(SDP_DTD_STR8, str);
}

sdpdata_t *sdp_append_str(sdpdata_t *seq, char *str)
{
	return sdp_append_data(seq, sdp_put_str(str));
}

char *sdp_get_str(sdpdata_t *data)
{
	return data->value.stringPtr;
}

sdpdata_t *sdp_put_url(char *url)
{
	return sdp_create_data(SDP_DTD_URL8, url);
}

sdpdata_t *sdp_append_url(sdpdata_t *seq, char *str)
{
	return sdp_append_data(seq, sdp_put_url(str));
}

char *sdp_get_url(sdpdata_t *data)
{
	return data->value.stringPtr;
}

sdpdata_t *sdp_create_seq(void)
{
	return sdp_create_data(SDP_DTD_SEQ8, NULL);
}

sdpdata_t *sdp_append_seq(sdpdata_t *seq)
{
	return sdp_append_data(seq, sdp_create_seq());
}

slist_t *sdp_get_seq(sdpdata_t *data)
{
	return data->value.dataSeq;
}

sdpdata_t *sdp_create_alt(void)
{
	return sdp_create_data(SDP_DTD_ALT8, NULL);
}

sdpdata_t *sdp_append_alt(sdpdata_t *seq)
{
	return sdp_append_data(seq, sdp_create_alt());
}


#ifdef CONFIG_AFFIX_DEBUG

void sdp_print_pdu(sdppdu_t *pdu)
{
	if (pdu->length == 0)
		DBPRT("NULL buffer");
	BTDUMP(pdu->data, pdu->length);
}

void sdp_print_int(sdpdata_t *pData)
{
	if (pData != NULL)
		DBPRT("Integer : 0x%x", pData->value.uint32);
}

void sdp_print_str(sdpdata_t *pData)
{
	if (pData != NULL)
		DBPRT("String : %s", pData->value.stringPtr);
}

void sdp_print_seq(slist_t *dataSeq)
{
	sdpdata_t		*data;

	for (;dataSeq; dataSeq = s_list_next(dataSeq)) {
		data = dataSeq->data;
		sdp_print_data(data);
	}
}

void sdp_print_data(sdpdata_t *data)
{
	uint8_t dtd;

	dtd = data->dtd;
	switch (dtd) {
		case SDP_DTD_ABOOL :
		case SDP_DTD_UINT8 :
		case SDP_DTD_UINT16 :
		case SDP_DTD_UINT32 :
		case SDP_DTD_UINT64 :
		case SDP_DTD_UINT128 :
		case SDP_DTD_INT8 :
		case SDP_DTD_INT16 :
		case SDP_DTD_INT32 :
		case SDP_DTD_INT64 :
		case SDP_DTD_INT128 :
			sdp_print_int(data);
			break;

		case SDP_DTD_UUID16 :
		case SDP_DTD_UUID32 :
		case SDP_DTD_UUID128 :
			DBPRT("uuid_t");
			sdp_print_uuid(&data->value.uuid);
			break;

		case SDP_DTD_STR8 :
		case SDP_DTD_STR16 :
		case SDP_DTD_STR32 :
			DBPRT("Text : %s", data->value.stringPtr);
			break;
		case SDP_DTD_URL8 :
		case SDP_DTD_URL16 :
		case SDP_DTD_URL32 :
			DBPRT("URL : %s", data->value.stringPtr);
			break;

		case SDP_DTD_SEQ8 :
		case SDP_DTD_SEQ16 :
		case SDP_DTD_SEQ32 :
			sdp_print_seq(data->value.dataSeq);
			break;

		case SDP_DTD_ALT8 :
		case SDP_DTD_ALT16 :
		case SDP_DTD_ALT32 :
			DBPRT("Data Sequence Alternates");
			sdp_print_seq(data->value.dataSeq);
			break;
	}
}

void sdp_print_attr(void * value, void * userData)
{
	sdpdata_t *data = NULL;
	uint16_t attrId;

	DBPRT("[%s-%d] : ", __FUNCTION__, __LINE__);
	data = (sdpdata_t *)value;
	attrId = data->attrId;
	DBPRT("=====================================");
	DBPRT("ATTRIBUTE IDENTIFIER : 0x%x", attrId);
	DBPRT("ATTRIBUTE VALUE PTR : 0x%x", (uint32_t)value);
	if (data != NULL) {
		sdp_print_data(data);
	} else
		DBPRT("NULL value");
	DBPRT("=====================================");
}

void sdp_print_svc(slist_t *svcAttrList)
{
	s_list_foreach(svcAttrList, sdp_print_attr, NULL);
}

#endif	// CONFIG_AFFIX_DEBUG