/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
 *
 *  BlueZ - Bluetooth protocol stack for Linux
 *
 *  Copyright (C) 2001-2002  Nokia Corporation
 *  Copyright (C) 2002-2003  Maxim Krasnyansky <maxk@qualcomm.com>
 *  Copyright (C) 2002-2010  Marcel Holtmann <marcel@holtmann.org>
 *  Copyright (C) 2002-2003  Stephen Crane <steve.crane@rococosoft.com>
 *
 *
 */

#ifndef __SDP_LIB_H
#define __SDP_LIB_H

#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>

#ifdef __cplusplus
extern "C" {
#endif

/*
 * SDP lists
 */
typedef void(*sdp_list_func_t)(void *, void *);
typedef void(*sdp_free_func_t)(void *);
typedef int (*sdp_comp_func_t)(const void *, const void *);

sdp_list_t *sdp_list_append(sdp_list_t *list, void *d);
sdp_list_t *sdp_list_remove(sdp_list_t *list, void *d);
sdp_list_t *sdp_list_insert_sorted(sdp_list_t *list, void *data, sdp_comp_func_t f);
void        sdp_list_free(sdp_list_t *list, sdp_free_func_t f);

static inline int sdp_list_len(const sdp_list_t *list)
{
	int n = 0;
	for (; list; list = list->next)
		n++;
	return n;
}

static inline sdp_list_t *sdp_list_find(sdp_list_t *list, void *u, sdp_comp_func_t f)
{
	for (; list; list = list->next)
		if (f(list->data, u) == 0)
			return list;
	return NULL;
}

static inline void sdp_list_foreach(sdp_list_t *list, sdp_list_func_t f, void *u)
{
	for (; list; list = list->next)
		f(list->data, u);
}

/*
 * Values of the flags parameter to sdp_record_register
 */
#define SDP_RECORD_PERSIST	0x01
#define SDP_DEVICE_RECORD	0x02

/*
 * Values of the flags parameter to sdp_connect
 */
#define SDP_RETRY_IF_BUSY	0x01
#define SDP_WAIT_ON_CLOSE	0x02
#define SDP_NON_BLOCKING	0x04
#define SDP_LARGE_MTU		0x08

/*
 * a session with an SDP server
 */
typedef struct {
	int sock;
	int state;
	int local;
	int flags;
	uint16_t tid;	/* Current transaction ID */
	void *priv;
} sdp_session_t;

typedef enum {
	/*
	 *  Attributes are specified as individual elements
	 */
	SDP_ATTR_REQ_INDIVIDUAL = 1,
	/*
	 *  Attributes are specified as a range
	 */
	SDP_ATTR_REQ_RANGE
} sdp_attrreq_type_t;

/*
 * 	When the pdu_id(type) is a sdp error response, check the status value
 * 	to figure out the error reason. For status values 0x0001-0x0006 check
 * 	Bluetooth SPEC. If the status is 0xffff, call sdp_get_error function
 * 	to get the real reason:
 * 	    - wrong transaction ID(EPROTO)
 * 	    - wrong PDU id or(EPROTO)
 * 	    - I/O error
 */
typedef void sdp_callback_t(uint8_t type, uint16_t status, uint8_t *rsp, size_t size, void *udata);

/*
 * create an L2CAP connection to a Bluetooth device
 *
 * INPUT:
 *
 *  bdaddr_t *src:
 *	Address of the local device to use to make the connection
 *	(or BDADDR_ANY)
 *
 *  bdaddr_t *dst:
 *    Address of the SDP server device
 */
sdp_session_t *sdp_connect(const bdaddr_t *src, const bdaddr_t *dst, uint32_t flags);
int sdp_close(sdp_session_t *session);
int sdp_get_socket(const sdp_session_t *session);

/*
 * SDP transaction: functions for asynchronous search.
 */
sdp_session_t *sdp_create(int sk, uint32_t flags);
int sdp_get_error(sdp_session_t *session);
int sdp_process(sdp_session_t *session);
int sdp_set_notify(sdp_session_t *session, sdp_callback_t *func, void *udata);

int sdp_service_search_async(sdp_session_t *session, const sdp_list_t *search, uint16_t max_rec_num);
int sdp_service_attr_async(sdp_session_t *session, uint32_t handle, sdp_attrreq_type_t reqtype, const sdp_list_t *attrid_list);
int sdp_service_search_attr_async(sdp_session_t *session, const sdp_list_t *search, sdp_attrreq_type_t reqtype, const sdp_list_t *attrid_list);

uint16_t sdp_gen_tid(sdp_session_t *session);

/*
 * find all devices in the piconet
 */
int sdp_general_inquiry(inquiry_info *ii, int dev_num, int duration, uint8_t *found);

/* flexible extraction of basic attributes - Jean II */
int sdp_get_int_attr(const sdp_record_t *rec, uint16_t attr, int *value);
int sdp_get_string_attr(const sdp_record_t *rec, uint16_t attr, char *value, int valuelen);

/*
 * Basic sdp data functions
 */
sdp_data_t *sdp_data_alloc(uint8_t dtd, const void *value);
sdp_data_t *sdp_data_alloc_with_length(uint8_t dtd, const void *value, uint32_t length);
void sdp_data_free(sdp_data_t *data);
sdp_data_t *sdp_data_get(const sdp_record_t *rec, uint16_t attr_id);

sdp_data_t *sdp_seq_alloc(void **dtds, void **values, int len);
sdp_data_t *sdp_seq_alloc_with_length(void **dtds, void **values, int *length, int len);
sdp_data_t *sdp_seq_append(sdp_data_t *seq, sdp_data_t *data);

int sdp_attr_add(sdp_record_t *rec, uint16_t attr, sdp_data_t *data);
void sdp_attr_remove(sdp_record_t *rec, uint16_t attr);
void sdp_attr_replace(sdp_record_t *rec, uint16_t attr, sdp_data_t *data);
int sdp_set_uuidseq_attr(sdp_record_t *rec, uint16_t attr, sdp_list_t *seq);
int sdp_get_uuidseq_attr(const sdp_record_t *rec, uint16_t attr, sdp_list_t **seqp);

/*
 * NOTE that none of the functions below will update the SDP server,
 * unless the {register, update}sdp_record_t() function is invoked.
 * All functions which return an integer value, return 0 on success
 * or -1 on failure.
 */

/*
 * Create an attribute and add it to the service record's attribute list.
 * This consists of the data type descriptor of the attribute,
 * the value of the attribute and the attribute identifier.
 */
int sdp_attr_add_new(sdp_record_t *rec, uint16_t attr, uint8_t dtd, const void *p);

/*
 * Set the information attributes of the service record.
 * The set of attributes comprises service name, description
 * and provider name
 */
void sdp_set_info_attr(sdp_record_t *rec, const char *name, const char *prov, const char *desc);

/*
 * Set the ServiceClassID attribute to the sequence specified by seq.
 * Note that the identifiers need to be in sorted order from the most
 * specific to the most generic service class that this service
 * conforms to.
 */
static inline int sdp_set_service_classes(sdp_record_t *rec, sdp_list_t *seq)
{
	return sdp_set_uuidseq_attr(rec, SDP_ATTR_SVCLASS_ID_LIST, seq);
}

/*
 * Get the service classes to which the service conforms.
 *
 * When set, the list contains elements of ServiceClassIdentifer(uint16_t)
 * ordered from most specific to most generic
 */
static inline int sdp_get_service_classes(const sdp_record_t *rec, sdp_list_t **seqp)
{
	return sdp_get_uuidseq_attr(rec, SDP_ATTR_SVCLASS_ID_LIST, seqp);
}

/*
 * Set the BrowseGroupList attribute to the list specified by seq.
 *
 * A service can belong to one or more service groups
 * and the list comprises such group identifiers (UUIDs)
 */
static inline int sdp_set_browse_groups(sdp_record_t *rec, sdp_list_t *seq)
{
	return sdp_set_uuidseq_attr(rec, SDP_ATTR_BROWSE_GRP_LIST, seq);
}

/*
 * Set the access protocols of the record to those specified in proto
 */
int sdp_set_access_protos(sdp_record_t *rec, const sdp_list_t *proto);

/*
 * Set the additional access protocols of the record to those specified in proto
 */
int sdp_set_add_access_protos(sdp_record_t *rec, const sdp_list_t *proto);

/*
 * Get protocol port (i.e. PSM for L2CAP, Channel for RFCOMM)
 */
int sdp_get_proto_port(const sdp_list_t *list, int proto);

/*
 * Get protocol descriptor.
 */
sdp_data_t *sdp_get_proto_desc(sdp_list_t *list, int proto);

/*
 * Set the LanguageBase attributes to the values specified in list
 * (a linked list of sdp_lang_attr_t objects, one for each language in
 * which user-visible attributes are present).
 */
int sdp_set_lang_attr(sdp_record_t *rec, const sdp_list_t *list);

/*
 * Set the ServiceInfoTimeToLive attribute of the service.
 * This is the number of seconds that this record is guaranteed
 * not to change after being obtained by a client.
 */
static inline int sdp_set_service_ttl(sdp_record_t *rec, uint32_t ttl)
{
	return sdp_attr_add_new(rec, SDP_ATTR_SVCINFO_TTL, SDP_UINT32, &ttl);
}

/*
 * Set the ServiceRecordState attribute of a service. This is
 * guaranteed to change if there is any kind of modification to
 * the record.
 */
static inline int sdp_set_record_state(sdp_record_t *rec, uint32_t state)
{
	return sdp_attr_add_new(rec, SDP_ATTR_RECORD_STATE, SDP_UINT32, &state);
}

/*
 * Set the ServiceID attribute of a service.
 */
void sdp_set_service_id(sdp_record_t *rec, uuid_t uuid);

/*
 * Set the GroupID attribute of a service
 */
void sdp_set_group_id(sdp_record_t *rec, uuid_t grouuuid);

/*
 * Set the ServiceAvailability attribute of a service.
 *
 * Note that this represents the relative availability
 * of the service: 0x00 means completely unavailable;
 * 0xFF means maximum availability.
 */
static inline int sdp_set_service_avail(sdp_record_t *rec, uint8_t avail)
{
	return sdp_attr_add_new(rec, SDP_ATTR_SERVICE_AVAILABILITY, SDP_UINT8, &avail);
}

/*
 * Set the profile descriptor list attribute of a record.
 *
 * Each element in the list is an object of type
 * sdp_profile_desc_t which is a definition of the
 * Bluetooth profile that this service conforms to.
 */
int sdp_set_profile_descs(sdp_record_t *rec, const sdp_list_t *desc);

/*
 * Set URL attributes of a record.
 *
 * ClientExecutableURL: a URL to a client's platform specific (WinCE,
 * PalmOS) executable code that can be used to access this service.
 *
 * DocumentationURL: a URL pointing to service documentation
 *
 * IconURL: a URL to an icon that can be used to represent this service.
 *
 * Note: pass NULL for any URLs that you don't want to set or remove
 */
void sdp_set_url_attr(sdp_record_t *rec, const char *clientExecURL, const char *docURL, const char *iconURL);

/*
 * a service search request.
 *
 *  INPUT :
 *
 *    sdp_list_t *search
 *      list containing elements of the search
 *      pattern. Each entry in the list is a UUID
 *      of the service to be searched
 *
 *    uint16_t max_rec_num
 *       An integer specifying the maximum number of
 *       entries that the client can handle in the response.
 *
 *  OUTPUT :
 *
 *    int return value
 *      0
 *        The request completed successfully. This does not
 *        mean the requested services were found
 *      -1
 *        The request completed unsuccessfully
 *
 *    sdp_list_t *rsp_list
 *      This variable is set on a successful return if there are
 *      non-zero service handles. It is a singly linked list of
 *      service record handles (uint16_t)
 */
int sdp_service_search_req(sdp_session_t *session, const sdp_list_t *search, uint16_t max_rec_num, sdp_list_t **rsp_list);

/*
 *  a service attribute request.
 *
 *  INPUT :
 *
 *    uint32_t handle
 *      The handle of the service for which the attribute(s) are
 *      requested
 *
 *    sdp_attrreq_type_t reqtype
 *      Attribute identifiers are 16 bit unsigned integers specified
 *      in one of 2 ways described below :
 *      SDP_ATTR_REQ_INDIVIDUAL - 16bit individual identifiers
 *         They are the actual attribute identifiers in ascending order
 *
 *      SDP_ATTR_REQ_RANGE - 32bit identifier range
 *         The high-order 16bits is the start of range
 *         the low-order 16bits are the end of range
 *         0x0000 to 0xFFFF gets all attributes
 *
 *    sdp_list_t *attrid_list
 *      Singly linked list containing attribute identifiers desired.
 *      Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
 *      or a uint32_t(attrSpec=SDP_ATTR_REQ_RANGE)
 *
 *  OUTPUT :
 *    int return value
 *      0
 *        The request completed successfully. This does not
 *        mean the requested services were found
 *      -1
 *        The request completed unsuccessfully due to a timeout
 */
sdp_record_t *sdp_service_attr_req(sdp_session_t *session, uint32_t handle, sdp_attrreq_type_t reqtype, const sdp_list_t *attrid_list);

/*
 *  This is a service search request combined with the service
 *  attribute request. First a service class match is done and
 *  for matching service, requested attributes are extracted
 *
 *  INPUT :
 *
 *    sdp_list_t *search
 *      Singly linked list containing elements of the search
 *      pattern. Each entry in the list is a UUID(DataTypeSDP_UUID16)
 *      of the service to be searched
 *
 *    AttributeSpecification attrSpec
 *      Attribute identifiers are 16 bit unsigned integers specified
 *      in one of 2 ways described below :
 *      SDP_ATTR_REQ_INDIVIDUAL - 16bit individual identifiers
 *         They are the actual attribute identifiers in ascending order
 *
 *      SDP_ATTR_REQ_RANGE - 32bit identifier range
 *         The high-order 16bits is the start of range
 *         the low-order 16bits are the end of range
 *         0x0000 to 0xFFFF gets all attributes
 *
 *    sdp_list_t *attrid_list
 *      Singly linked list containing attribute identifiers desired.
 *      Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
 *      or a uint32_t(attrSpec=SDP_ATTR_REQ_RANGE)
 *
 *  OUTPUT :
 *    int return value
 *      0
 *        The request completed successfully. This does not
 *        mean the requested services were found
 *      -1
 *        The request completed unsuccessfully due to a timeout
 *
 *    sdp_list_t *rsp_list
 *      This variable is set on a successful return to point to
 *      service(s) found. Each element of this list is of type
 *      sdp_record_t *.
 */
int sdp_service_search_attr_req(sdp_session_t *session, const sdp_list_t *search, sdp_attrreq_type_t reqtype, const sdp_list_t *attrid_list, sdp_list_t **rsp_list);

/*
 * Allocate/free a service record and its attributes
 */
sdp_record_t *sdp_record_alloc(void);
void sdp_record_free(sdp_record_t *rec);

/*
 * Register a service record.
 *
 * Note: It is the responsbility of the Service Provider to create the
 * record first and set its attributes using setXXX() methods.
 *
 * The service provider must then call sdp_record_register() to make
 * the service record visible to SDP clients.  This function returns 0
 * on success or -1 on failure (and sets errno).
 */
int sdp_device_record_register_binary(sdp_session_t *session, bdaddr_t *device, uint8_t *data, uint32_t size, uint8_t flags, uint32_t *handle);
int sdp_device_record_register(sdp_session_t *session, bdaddr_t *device, sdp_record_t *rec, uint8_t flags);
int sdp_record_register(sdp_session_t *session, sdp_record_t *rec, uint8_t flags);

/*
 * Unregister a service record.
 */
int sdp_device_record_unregister_binary(sdp_session_t *session, bdaddr_t *device, uint32_t handle);
int sdp_device_record_unregister(sdp_session_t *session, bdaddr_t *device, sdp_record_t *rec);
int sdp_record_unregister(sdp_session_t *session, sdp_record_t *rec);

/*
 * Update an existing service record.  (Calling this function
 * before a previous call to sdp_record_register() will result
 * in an error.)
 */
int sdp_device_record_update_binary(sdp_session_t *session, bdaddr_t *device, uint32_t handle, uint8_t *data, uint32_t size);
int sdp_device_record_update(sdp_session_t *session, bdaddr_t *device, const sdp_record_t *rec);
int sdp_record_update(sdp_session_t *sess, const sdp_record_t *rec);

void sdp_record_print(const sdp_record_t *rec);

/*
 * UUID functions
 */
uuid_t *sdp_uuid16_create(uuid_t *uuid, uint16_t data);
uuid_t *sdp_uuid32_create(uuid_t *uuid, uint32_t data);
uuid_t *sdp_uuid128_create(uuid_t *uuid, const void *data);
int sdp_uuid16_cmp(const void *p1, const void *p2);
int sdp_uuid128_cmp(const void *p1, const void *p2);
int sdp_uuid_cmp(const void *p1, const void *p2);
uuid_t *sdp_uuid_to_uuid128(const uuid_t *uuid);
void sdp_uuid16_to_uuid128(uuid_t *uuid128, const uuid_t *uuid16);
void sdp_uuid32_to_uuid128(uuid_t *uuid128, const uuid_t *uuid32);
int sdp_uuid128_to_uuid(uuid_t *uuid);
int sdp_uuid_to_proto(uuid_t *uuid);
int sdp_uuid_extract(const uint8_t *buffer, int bufsize, uuid_t *uuid, int *scanned);
void sdp_uuid_print(const uuid_t *uuid);

#define MAX_LEN_UUID_STR 37
#define MAX_LEN_PROTOCOL_UUID_STR 8
#define MAX_LEN_SERVICECLASS_UUID_STR 28
#define MAX_LEN_PROFILEDESCRIPTOR_UUID_STR 28

int sdp_uuid2strn(const uuid_t *uuid, char *str, size_t n);
int sdp_proto_uuid2strn(const uuid_t *uuid, char *str, size_t n);
int sdp_svclass_uuid2strn(const uuid_t *uuid, char *str, size_t n);
int sdp_profile_uuid2strn(const uuid_t *uuid, char *str, size_t n);

/*
 * In all the sdp_get_XXX(handle, XXX *xxx) functions below,
 * the XXX * is set to point to the value, should it exist
 * and 0 is returned. If the value does not exist, -1 is
 * returned and errno set to ENODATA.
 *
 * In all the methods below, the memory management rules are
 * simple. Don't free anything! The pointer returned, in the
 * case of constructed types, is a pointer to the contents
 * of the sdp_record_t.
 */

/*
 * Get the access protocols from the service record
 */
int sdp_get_access_protos(const sdp_record_t *rec, sdp_list_t **protos);

/*
 * Get the additional access protocols from the service record
 */
int sdp_get_add_access_protos(const sdp_record_t *rec, sdp_list_t **protos);

/*
 * Extract the list of browse groups to which the service belongs.
 * When set, seqp contains elements of GroupID (uint16_t)
 */
static inline int sdp_get_browse_groups(const sdp_record_t *rec, sdp_list_t **seqp)
{
	return sdp_get_uuidseq_attr(rec, SDP_ATTR_BROWSE_GRP_LIST, seqp);
}

/*
 * Extract language attribute meta-data of the service record.
 * For each language in the service record, LangSeq has a struct of type
 * sdp_lang_attr_t.
 */
int sdp_get_lang_attr(const sdp_record_t *rec, sdp_list_t **langSeq);

/*
 * Extract the Bluetooth profile descriptor sequence from a record.
 * Each element in the list is of type sdp_profile_desc_t
 * which contains the UUID of the profile and its version number
 * (encoded as major and minor in the high-order 8bits
 * and low-order 8bits respectively of the uint16_t)
 */
int sdp_get_profile_descs(const sdp_record_t *rec, sdp_list_t **profDesc);

/*
 * Extract SDP server version numbers
 *
 * Note: that this is an attribute of the SDP server only and
 * contains a list of uint16_t each of which represent the
 * major and minor SDP version numbers supported by this server
 */
int sdp_get_server_ver(const sdp_record_t *rec, sdp_list_t **pVnumList);

int sdp_get_service_id(const sdp_record_t *rec, uuid_t *uuid);
int sdp_get_group_id(const sdp_record_t *rec, uuid_t *uuid);
int sdp_get_record_state(const sdp_record_t *rec, uint32_t *svcRecState);
int sdp_get_service_avail(const sdp_record_t *rec, uint8_t *svcAvail);
int sdp_get_service_ttl(const sdp_record_t *rec, uint32_t *svcTTLInfo);
int sdp_get_database_state(const sdp_record_t *rec, uint32_t *svcDBState);

static inline int sdp_get_service_name(const sdp_record_t *rec, char *str, int len)
{
	return sdp_get_string_attr(rec, SDP_ATTR_SVCNAME_PRIMARY, str, len);
}

static inline int sdp_get_service_desc(const sdp_record_t *rec, char *str, int len)
{
	return sdp_get_string_attr(rec, SDP_ATTR_SVCDESC_PRIMARY, str, len);
}

static inline int sdp_get_provider_name(const sdp_record_t *rec, char *str, int len)
{
	return sdp_get_string_attr(rec, SDP_ATTR_PROVNAME_PRIMARY, str, len);
}

static inline int sdp_get_doc_url(const sdp_record_t *rec, char *str, int len)
{
	return sdp_get_string_attr(rec, SDP_ATTR_DOC_URL, str, len);
}

static inline int sdp_get_clnt_exec_url(const sdp_record_t *rec, char *str, int len)
{
	return sdp_get_string_attr(rec, SDP_ATTR_CLNT_EXEC_URL, str, len);
}

static inline int sdp_get_icon_url(const sdp_record_t *rec, char *str, int len)
{
	return sdp_get_string_attr(rec, SDP_ATTR_ICON_URL, str, len);
}

/*
 * Set the supported features
 * sf should be a list of list with each feature data
 * Returns 0 on success -1 on fail
 */
int sdp_set_supp_feat(sdp_record_t *rec, const sdp_list_t *sf);

/*
 * Get the supported features
 * seqp is set to a list of list with each feature data
 * Returns 0 on success, if an error occurred -1 is returned and errno is set
 */
int sdp_get_supp_feat(const sdp_record_t *rec, sdp_list_t **seqp);

sdp_record_t *sdp_extract_pdu(const uint8_t *pdata, int bufsize, int *scanned);
sdp_record_t *sdp_copy_record(sdp_record_t *rec);

void sdp_data_print(sdp_data_t *data);
void sdp_print_service_attr(sdp_list_t *alist);

int sdp_attrid_comp_func(const void *key1, const void *key2);

void sdp_set_seq_len(uint8_t *ptr, uint32_t length);
void sdp_set_attrid(sdp_buf_t *pdu, uint16_t id);
void sdp_append_to_pdu(sdp_buf_t *dst, sdp_data_t *d);
void sdp_append_to_buf(sdp_buf_t *dst, uint8_t *data, uint32_t len);

int sdp_gen_pdu(sdp_buf_t *pdu, sdp_data_t *data);
int sdp_gen_record_pdu(const sdp_record_t *rec, sdp_buf_t *pdu);

int sdp_extract_seqtype(const uint8_t *buf, int bufsize, uint8_t *dtdp, int *size);

sdp_data_t *sdp_extract_attr(const uint8_t *pdata, int bufsize, int *extractedLength, sdp_record_t *rec);

void sdp_pattern_add_uuid(sdp_record_t *rec, uuid_t *uuid);
void sdp_pattern_add_uuidseq(sdp_record_t *rec, sdp_list_t *seq);

int sdp_send_req_w4_rsp(sdp_session_t *session, uint8_t *req, uint8_t *rsp, uint32_t reqsize, uint32_t *rspsize);

void sdp_add_lang_attr(sdp_record_t *rec);

#ifdef __cplusplus
}
#endif

#endif /* __SDP_LIB_H */
