sdpclt.c

affix是一个Open Source的蓝牙协议栈

	for (list = sdp_get_seq(attr); list; list = s_list_next(list)) {
get:
		*seq = s_list_data(list);	/* seq data element */
		if (state)
			*state = s_list_next(list);
		return 0;
	}
	if (state)
		*state = NULL;
	return -1;
}

int sdp_get_proto_attr(sdpsvc_t *svcRec, void *alt, uuid_t **uuid, void **param, void **state)
{
	sdpdata_t	*attr;
	slist_t		*list;

	if (state && *state) {
		list = *state;
		goto get;
	}
	if (!alt) {
		attr = sdp_get_attr(svcRec, SDP_ATTR_PROTO_DESC_LIST);
		if (!attr)
			return SDP_ERR_NOT_EXIST;
	} else {
		attr = alt;
	}
	for (list = sdp_get_seq(attr); list; list = s_list_next(list)) {
get:
		/* 
		 * first element - protocol UUID
		 */
		*param = sdp_get_seq(s_list_data(list));
		if (!*param)
			continue;
		*uuid = sdp_get_uuid(s_list_data(*param));
		/* next parameters */
		*param = s_list_next(*param);
		if (state)
			*state = s_list_next(list);
		return 0;
	}
	if (state)
		*state = NULL;
	return -1;
}

int sdp_get_uuid_attr(sdpsvc_t *svcRec, uint16_t attrID, uuid_t **uuid, void **state)
{
	sdpdata_t	*data;
	slist_t		*list;

	if (state && *state) {
		list = *state;
		goto get;
	}
	data = sdp_get_attr(svcRec, attrID);
	if (!data)
		return SDP_ERR_NOT_EXIST;
	for (list = sdp_get_seq(data); list; list = s_list_next(list)) {
get:
		*uuid = sdp_get_uuid(s_list_data(list));
		if (state)
			*state = s_list_next(list);
		return 0;
	}
	if (state)
		*state = NULL;
	return -1;
}

uuid_t *sdp_get_service_attr(sdpsvc_t *svcRec)
{
	sdpdata_t	*data;
	
	data = sdp_get_attr(svcRec, SDP_ATTR_SERVICEID);
	if (!data)
		return NULL;
	return sdp_get_uuid(data);
}

uuid_t *sdp_get_group_attr(sdpsvc_t *svcRec)
{
	sdpdata_t	*data;
	
	data = sdp_get_attr(svcRec, SDP_ATTR_GROUPID);
	if (!data)
		return NULL;
	return sdp_get_uuid(data);
}

int sdp_is_group(sdpsvc_t *svcRec)
{
	sdpdata_t *data = sdp_get_attr(svcRec, SDP_ATTR_GROUPID);
	if (data && (svcRec->serviceRecordHandle != SDP_ATTR_SERVICE_RECORD_HANDLE))
		return 1;
	return 0;
}

int sdp_get_state_attr(sdpsvc_t *svcRec, uint32_t *state)
{
	sdpdata_t	*data;
	
	data = sdp_get_attr(svcRec, SDP_ATTR_SERVICE_RECORD_STATE);
	if (!data)
		return SDP_ERR_NOT_EXIST;
	*state = sdp_get_u32(data);
	return 0;
}

int sdp_get_availability_attr(sdpsvc_t *svcRec, uint8_t *avail)
{
	sdpdata_t	*data;
	
	data = sdp_get_attr(svcRec, SDP_ATTR_SERVICE_AVAILABILITY);
	if (!data)
		return SDP_ERR_NOT_EXIST;
	*avail = sdp_get_u8(data);
	return 0;
}

int sdp_get_ttl_attr(sdpsvc_t *svcRec, uint32_t *ttl)
{
	sdpdata_t	*data;
	
	data = sdp_get_attr(svcRec, SDP_ATTR_SERVICE_INFO_TTL);
	if (!data)
		return SDP_ERR_NOT_EXIST;
	*ttl = sdp_get_u32(data);
	return 0;
}

int sdp_get_lang_attr(sdpsvc_t *svcRec, slist_t **langSeq)
{
	return 0; 
}

/*
 * get profile descriptor
 *
 * state - store next descriptor ptr
 */
int sdp_get_profile_attr(sdpsvc_t *svcRec, uuid_t **uuid, uint16_t *ver, void **state)
{
	sdpdata_t		*attr;
	slist_t			*list, *param;

	if (state && *state) {
		list = *state;
		goto get_desc;
	}
	attr = sdp_get_attr(svcRec, SDP_ATTR_PROFILE_DESC_LIST);
	if (!attr)
		return SDP_ERR_NOT_EXIST;
	for (list = sdp_get_seq(attr); list; list = s_list_next(list)) {
		/* get parameters */
get_desc:
		/* first param - UUID */
		param = sdp_get_seq(s_list_data(list));
		if (!param)
			continue;
		*uuid = sdp_get_uuid(s_list_data(param));
		/* next - version */
		param = s_list_next(param);
		if (!param)
			continue;
		*ver = sdp_get_u16(s_list_data(param));
		if (state)
			*state = s_list_next(list);
		return 0;
	}
	if (state)
		*state = NULL;
	return -1;
}

int sdp_get_info_attr(sdpsvc_t *svcRec, char **name, char **prov, char **desc)
{
	sdpdata_t	*data;
	
	if (name) {
		data = sdp_get_attr(svcRec, SDP_ATTR_SERVICE_NAME_PRIM);
		if (data)
			*name = sdp_get_str(data);
		else
			*name = NULL;
	}
	if (prov) {
		data = sdp_get_attr(svcRec, SDP_ATTR_PROVIDER_NAME_PRIM);
		if (data)
			*prov = sdp_get_str(data);
		else
			*prov = NULL;
	}
	if (name) {
		data = sdp_get_attr(svcRec, SDP_ATTR_SERVICE_DESC_PRIM);
		if (data)
			*desc = sdp_get_str(data);
		else
			*desc = NULL;
	}
	return 0;
}

int sdp_get_url_attr(sdpsvc_t *svcRec, char **doc, char **exec, char **icon)
{
	sdpdata_t	*data;
	
	if (doc) {
		data = sdp_get_attr(svcRec, SDP_ATTR_DOC_URL);
		if (data)
			*doc = sdp_get_str(data);
		else
			*doc = NULL;
	}
	if (exec) {
		data = sdp_get_attr(svcRec, SDP_ATTR_EXEC_URL);
		if (data)
			*exec = sdp_get_str(data);
		else
			*exec = NULL;
	}
	if (icon) {
		data = sdp_get_attr(svcRec, SDP_ATTR_ICON_URL);
		if (data)
			*icon = sdp_get_str(data);
		else
			*icon = NULL;
	}
	return 0;
}

/*
 * SDP server attributes
 */
int sdp_get_dbstate_attr(sdpsvc_t *svcRec, uint32_t *state)
{
	sdpdata_t	*data;
	
	data = sdp_get_attr(svcRec, SDP_ATTR_SERVICE_DB_STATE);
	if (!data)
		return SDP_ERR_NOT_EXIST;
	*state = sdp_get_u32(data);
	return 0;
}

int sdp_get_version_attr(sdpsvc_t *svcRec, uint16_t *ver, void **state)
{
	sdpdata_t	*data;
	slist_t		*list;

	if (state && *state) {
		list = *state;
		goto get;
	}
	data = sdp_get_attr(svcRec, SDP_ATTR_VERSION_NUMBER_LIST);
	if (!data)
		return SDP_ERR_NOT_EXIST;
	for (list = sdp_get_seq(data); list; list = s_list_next(list)) {
get:
		*ver = sdp_get_u16(s_list_data(list));
		if (state)
			*state = s_list_next(list);
		return 0;
	}
	if (state)
		*state = NULL;
	return -1;
}

/* -------------------------------  new ------------------------ */

int sdp_get_rfcomm_port(sdpsvc_t *svcRec)
{
	sdpdata_t	*attr, *data;
	slist_t		*alt, *list, *param;
	uuid_t		*uuid;

	attr = sdp_get_attr(svcRec, SDP_ATTR_PROTO_DESC_LIST);
	if (!attr)
		return SDP_ERR_NOT_EXIST;

	if (sdp_is_seq(attr)) {
		/* no alt  */
		alt = NULL;
		data = attr;
		goto dlist;
	} else {
		/* cycle around alternatives */
		for (alt = sdp_get_seq(attr); alt; alt = s_list_next(alt)) {
			data = s_list_data(alt);
dlist:
			/* cycle around protocol descriptors */
			for (list = sdp_get_seq(data); list; list = s_list_next(list)) {
				/* 
				 * first element - protocol UUID
				 */
				param = sdp_get_seq(s_list_data(list));
				if (!param)
					continue;
				uuid = sdp_get_uuid(s_list_data(param));
				if (sdp_uuidcmp32(uuid, SDP_UUID_RFCOMM) == 0) {
					/* next param - port */
					param = s_list_next(param);
					if (!param)
						return -1;
					return sdp_get_u8(s_list_data(param));
				}
			}
			if (!alt)
				break;
		}
	}
	return -1;
}

int sdp_find_uuid(sdpsvc_t *svcRec,  uint32_t uuid32)
{
	int		status = 0;
	slist_t		*searchPattern = NULL;
	uuid_t		uuid;

	sdp_val2uuid32(&uuid, uuid32);
	s_list_append(&searchPattern, &uuid);
	if (!sdp_match_uuid(searchPattern, svcRec->targetPattern))
		status = -1;
	s_list_free(&searchPattern);
	return status;
}

/* some new service functions */
uuid_t *s_list_append_uuid16(slist_t **list, uint16_t uuid16)
{
	uuid_t	*uuid;
	
	uuid = malloc(sizeof(uuid_t));
	if (!uuid)
		return NULL;
	sdp_val2uuid16(uuid, uuid16);
	s_list_append(list, uuid);
	return uuid;
}

uuid_t *s_list_append_uuid32(slist_t **list, uint32_t uuid32)
{
	uuid_t	*uuid;
	
	uuid = malloc(sizeof(uuid_t));
	if (!uuid)
		return NULL;
	sdp_val2uuid32(uuid, uuid32);
	s_list_append(list, uuid);
	return uuid;
}

int sdp_find_port(struct sockaddr_affix *saddr, uint16_t ServiceID)
{
	int		sch, err;
	uint16_t	count;
	slist_t		*searchList = NULL;
	slist_t		*attrList = NULL;
	slist_t		*svcList = NULL;
	sdpsvc_t	*svcRec;

	/* search for service ServiceID */
	s_list_append_uuid16(&searchList, ServiceID);
	/* set attributes to find */
	s_list_append_uint(&attrList, SDP_ATTR_SERVICE_RECORD_HANDLE);
	s_list_append_uint(&attrList, SDP_ATTR_PROTO_DESC_LIST);

	err = __sdp_search_attr_req(saddr, searchList, 
			IndividualAttributes, attrList, 0xffff, &svcList, &count);
	s_list_destroy(&searchList);
	s_list_free(&attrList);
	if (err) {
		fprintf(stderr, "%s\n", sdp_error(err));
		return -1;
	}
	if (count == 0) {
		fprintf(stderr, "no services found\n");
		return -1;
	}
	svcRec = s_list_dequeue(&svcList);	// get first
	sdp_free_svclist(&svcList);
	sch = sdp_get_rfcomm_port(svcRec);
	sdp_free_svc(svcRec);
	if (sch > 0) {
		fprintf(stderr, "Service found on channel: %d\n", sch);
		return sch;
	} else if (sch == 0) {
		fprintf(stderr, "Service is not available\n");
		return -1;
	} else {
		fprintf(stderr, "Unable to get service channel\n");
		return -2;
	}
	return -1;
}