static int32_t
sd_profile_create_protocol_descriptor_list(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
if (buf + 13 > eob)
return (-1);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(11, buf);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(9, buf);
SDP_PUT8(SDP_DATA_UUID16, buf);
SDP_PUT16(SDP_UUID_PROTOCOL_L2CAP, buf);
SDP_PUT8(SDP_DATA_UINT16, buf);
SDP_PUT16(L2CAP_PSM_SDP, buf);
SDP_PUT8(SDP_DATA_UINT16, buf);
SDP_PUT16(1, buf); /* version */
return (13);
}
static int32_t
sd_profile_create_version_number_list(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
if (buf + 5 > eob)
return (-1);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(3, buf);
/*
* The VersionNumberList is a data element sequence in which each
* element of the sequence is a version number supported by the SDP
* server. A version number is a 16-bit unsigned integer consisting
* of two fields. The higher-order 8 bits contain the major version
* number field and the low-order 8 bits contain the minor version
* number field. The initial version of SDP has a major version of
* 1 and a minor version of 0
*/
SDP_PUT8(SDP_DATA_UINT16, buf);
SDP_PUT16(0x0100, buf);
return (5);
}
int32_t
server_prepare_service_register_response(server_p srv, int32_t fd)
{
uint8_t const *req = srv->req + sizeof(sdp_pdu_t);
uint8_t const *req_end = req + ((sdp_pdu_p)(srv->req))->len;
uint8_t *rsp = srv->fdidx[fd].rsp;
profile_t *profile = NULL;
provider_t *provider = NULL;
bdaddr_t const *bdaddr = NULL;
int32_t uuid;
/*
* Minimal Service Register Request
*
* value16 - uuid 2 bytes
* bdaddr - BD_ADDR 6 bytes
*/
if (!srv->fdidx[fd].control ||
!srv->fdidx[fd].priv || req_end - req < 8)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get ServiceClass UUID */
SDP_GET16(uuid, req);
/* Get BD_ADDR */
bdaddr = (bdaddr_t const *) req;
req += sizeof(*bdaddr);
/* Lookup profile descriptror */
profile = profile_get_descriptor(uuid);
if (profile == NULL)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Validate user data */
if (req_end - req < profile->dsize ||
profile->valid == NULL ||
(profile->valid)(req, req_end - req) == 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Register provider */
provider = provider_register(profile, bdaddr, fd, req, req_end - req);
if (provider == NULL)
return (SDP_ERROR_CODE_INSUFFICIENT_RESOURCES);
SDP_PUT16(0, rsp);
SDP_PUT32(provider->handle, rsp);
/* Set reply size */
srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t);
srv->fdidx[fd].rsp_size = rsp - srv->fdidx[fd].rsp;
srv->fdidx[fd].rsp_cs = 0;
return (0);
}
int32_t
server_prepare_attr_list(provider_p const provider,
uint8_t const *req, uint8_t const * const req_end,
uint8_t *rsp, uint8_t const * const rsp_end)
{
uint8_t *ptr = rsp + 3;
int32_t type, hi, lo, len;
if (ptr > rsp_end)
return (-1);
while (req < req_end) {
SDP_GET8(type, req);
switch (type) {
case SDP_DATA_UINT16:
if (req + 2 > req_end)
return (-1);
SDP_GET16(lo, req);
hi = lo;
break;
case SDP_DATA_UINT32:
if (req + 4 > req_end)
return (-1);
SDP_GET16(lo, req);
SDP_GET16(hi, req);
break;
default:
return (-1);
/* NOT REACHED */
}
for (; lo <= hi; lo ++) {
len = server_prepare_attr_value_pair(provider, lo, ptr, rsp_end);
if (len < 0)
return (-1);
ptr += len;
}
}
len = ptr - rsp; /* we put this much bytes in rsp */
/* Fix SEQ16 header for the rsp */
SDP_PUT8(SDP_DATA_SEQ16, rsp);
SDP_PUT16(len - 3, rsp);
return (len);
}
static int32_t
bgd_profile_create_group_id(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
if (buf + 3 > eob)
return (-1);
SDP_PUT8(SDP_DATA_UUID16, buf);
SDP_PUT16(SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP, buf);
return (3);
}
static int32_t
sd_profile_create_protocol_descriptor_list(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
if (buf + 12 > eob)
return (-1);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(10, buf);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(3, buf);
SDP_PUT8(SDP_DATA_UUID16, buf);
SDP_PUT16(SDP_UUID_PROTOCOL_L2CAP, buf);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(3, buf);
SDP_PUT8(SDP_DATA_UUID16, buf);
SDP_PUT16(SDP_UUID_PROTOCOL_SDP, buf);
return (12);
}
static int32_t
nap_profile_create_max_net_access_rate(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
provider_p provider = (provider_p) data;
sdp_nap_profile_p nap = (sdp_nap_profile_p) provider->data;
if (buf + 3 > eob)
return (-1);
SDP_PUT8(SDP_DATA_UINT16, buf);
SDP_PUT16(nap->max_net_access_rate, buf);
return (3);
}
int32_t
server_prepare_service_change_response(server_p srv, int32_t fd)
{
uint8_t const *req = srv->req + sizeof(sdp_pdu_t);
uint8_t const *req_end = req + ((sdp_pdu_p)(srv->req))->len;
uint8_t *rsp = srv->fdidx[fd].rsp;
provider_t *provider = NULL;
uint32_t handle;
/*
* Minimal Service Change Request
*
* value32 - handle 4 bytes
*/
if (!srv->fdidx[fd].control ||
!srv->fdidx[fd].priv || req_end - req < 4)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get handle */
SDP_GET32(handle, req);
/* Lookup provider */
provider = provider_by_handle(handle);
if (provider == NULL || provider->fd != fd)
return (SDP_ERROR_CODE_INVALID_SERVICE_RECORD_HANDLE);
/* Validate user data */
if (req_end - req < provider->profile->dsize ||
provider->profile->valid == NULL ||
(provider->profile->valid)(req, req_end - req) == 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Update provider */
if (provider_update(provider, req, req_end - req) < 0)
return (SDP_ERROR_CODE_INSUFFICIENT_RESOURCES);
SDP_PUT16(0, rsp);
/* Set reply size */
srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t);
srv->fdidx[fd].rsp_size = rsp - srv->fdidx[fd].rsp;
srv->fdidx[fd].rsp_cs = 0;
return (0);
}
static int32_t
sd_profile_create_service_id(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
if (buf + 3 > eob)
return (-1);
/*
* The ServiceID is a UUID that universally and uniquely identifies
* the service instance described by the service record. This service
* attribute is particularly useful if the same service is described
* by service records in more than one SDP server
*/
SDP_PUT8(SDP_DATA_UUID16, buf);
SDP_PUT16(SDP_UUID_PROTOCOL_SDP, buf); /* XXX ??? */
return (3);
}
int32_t
server_prepare_service_unregister_response(server_p srv, int32_t fd)
{
uint8_t const *req = srv->req + sizeof(sdp_pdu_t);
uint8_t const *req_end = req + ((sdp_pdu_p)(srv->req))->len;
uint8_t *rsp = srv->fdidx[fd].rsp;
provider_t *provider = NULL;
uint32_t handle;
/*
* Minimal Service Unregister Request
*
* value32 - uuid 4 bytes
*/
if (!srv->fdidx[fd].control ||
!srv->fdidx[fd].priv || req_end - req < 4)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get handle */
SDP_GET32(handle, req);
/* Lookup provider */
provider = provider_by_handle(handle);
if (provider == NULL || provider->fd != fd)
return (SDP_ERROR_CODE_INVALID_SERVICE_RECORD_HANDLE);
provider_unregister(provider);
SDP_PUT16(0, rsp);
/* Set reply size */
srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t);
srv->fdidx[fd].rsp_size = rsp - srv->fdidx[fd].rsp;
srv->fdidx[fd].rsp_cs = 0;
return (0);
}
static int32_t
sd_profile_create_browse_group_list(
uint8_t *buf, uint8_t const * const eob,
uint8_t const *data, uint32_t datalen)
{
if (buf + 5 > eob)
return (-1);
SDP_PUT8(SDP_DATA_SEQ8, buf);
SDP_PUT8(3, buf);
/*
* The top-level browse group ID, called PublicBrowseRoot and
* representing the root of the browsing hierarchy, has the value
* 00001002-0000-1000-8000-00805F9B34FB (UUID16: 0x1002) from the
* Bluetooth Assigned Numbers document
*/
SDP_PUT8(SDP_DATA_UUID16, buf);
SDP_PUT16(SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP, buf);
return (5);
}
static int32_t
server_prepare_attr_value_pair(
provider_p const provider, uint16_t attr,
uint8_t *buf, uint8_t const * const eob)
{
profile_attr_create_p cf = profile_get_attr(provider->profile, attr);
int32_t len;
if (cf == NULL)
return (0); /* no attribute */
if (buf + 3 > eob)
return (-1);
SDP_PUT8(SDP_DATA_UINT16, buf);
SDP_PUT16(attr, buf);
len = cf(buf, eob, (uint8_t const *) provider, sizeof(*provider));
if (len < 0)
return (-1);
return (3 + len);
}
int32_t
server_prepare_service_search_attribute_response(server_p srv, int32_t fd)
{
uint8_t const *req = srv->req + sizeof(sdp_pdu_t);
uint8_t const *req_end = req + ((sdp_pdu_p)(srv->req))->len;
uint8_t *rsp = srv->fdidx[fd].rsp;
uint8_t const *rsp_end = rsp + NG_L2CAP_MTU_MAXIMUM;
uint8_t const *sspptr = NULL, *aidptr = NULL;
uint8_t *ptr = NULL;
provider_t *provider = NULL;
int32_t type, rsp_limit, ssplen, aidlen, cslen, cs;
uint128_t uuid, puuid;
/*
* Minimal Service Search Attribute Request request
*
* seq8 len8 - 2 bytes
* uuid16 value16 - 3 bytes ServiceSearchPattern
* value16 - 2 bytes MaximumAttributeByteCount
* seq8 len8 - 2 bytes
* uint16 value16 - 3 bytes AttributeIDList
* value8 - 1 byte ContinuationState
*/
if (req_end - req < 13)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get size of ServiceSearchPattern */
ssplen = 0;
SDP_GET8(type, req);
switch (type) {
case SDP_DATA_SEQ8:
SDP_GET8(ssplen, req);
break;
case SDP_DATA_SEQ16:
SDP_GET16(ssplen, req);
break;
case SDP_DATA_SEQ32:
SDP_GET32(ssplen, req);
break;
}
if (ssplen <= 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
sspptr = req;
req += ssplen;
/* Get MaximumAttributeByteCount */
if (req + 2 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET16(rsp_limit, req);
if (rsp_limit <= 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get size of AttributeIDList */
if (req + 1 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
aidlen = 0;
SDP_GET8(type, req);
switch (type) {
case SDP_DATA_SEQ8:
if (req + 1 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET8(aidlen, req);
break;
case SDP_DATA_SEQ16:
if (req + 2 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET16(aidlen, req);
break;
case SDP_DATA_SEQ32:
if (req + 4 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET32(aidlen, req);
break;
}
if (aidlen <= 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
aidptr = req;
req += aidlen;
/* Get ContinuationState */
if (req + 1 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET8(cslen, req);
if (cslen != 0) {
if (cslen != 2 || req_end - req != 2)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET16(cs, req);
} else
cs = 0;
/* Process the request. First, check continuation state */
if (srv->fdidx[fd].rsp_cs != cs)
return (SDP_ERROR_CODE_INVALID_CONTINUATION_STATE);
if (srv->fdidx[fd].rsp_size > 0)
return (0);
/*
* Service Search Attribute Response format
*
* value16 - 2 bytes AttributeListByteCount (not incl.)
* seq8 len16 - 3 bytes
* attr list - 3+ bytes AttributeLists
* [ attr list ]
*/
ptr = rsp + 3;
while (ssplen > 0) {
SDP_GET8(type, sspptr);
ssplen --;
switch (type) {
case SDP_DATA_UUID16:
if (ssplen < 2)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
memcpy(&uuid, &uuid_base, sizeof(uuid));
uuid.b[2] = *sspptr ++;
uuid.b[3] = *sspptr ++;
ssplen -= 2;
break;
case SDP_DATA_UUID32:
if (ssplen < 4)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
memcpy(&uuid, &uuid_base, sizeof(uuid));
uuid.b[0] = *sspptr ++;
uuid.b[1] = *sspptr ++;
uuid.b[2] = *sspptr ++;
uuid.b[3] = *sspptr ++;
ssplen -= 4;
break;
case SDP_DATA_UUID128:
if (ssplen < 16)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
memcpy(uuid.b, sspptr, 16);
sspptr += 16;
ssplen -= 16;
break;
default:
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* NOT REACHED */
}
for (provider = provider_get_first();
provider != NULL;
provider = provider_get_next(provider)) {
if (!provider_match_bdaddr(provider, &srv->req_sa.l2cap_bdaddr))
continue;
memcpy(&puuid, &uuid_base, sizeof(puuid));
puuid.b[2] = provider->profile->uuid >> 8;
puuid.b[3] = provider->profile->uuid;
if (memcmp(&uuid, &puuid, sizeof(uuid)) != 0 &&
memcmp(&uuid, &uuid_public_browse_group, sizeof(uuid)) != 0)
continue;
cs = server_prepare_attr_list(provider,
aidptr, aidptr + aidlen, ptr, rsp_end);
if (cs < 0)
return (SDP_ERROR_CODE_INSUFFICIENT_RESOURCES);
ptr += cs;
}
}
/* Set reply size (not counting PDU header and continuation state) */
srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t) - 2;
if (srv->fdidx[fd].rsp_limit > rsp_limit)
srv->fdidx[fd].rsp_limit = rsp_limit;
srv->fdidx[fd].rsp_size = ptr - rsp;
srv->fdidx[fd].rsp_cs = 0;
/* Fix AttributeLists sequence header */
ptr = rsp;
SDP_PUT8(SDP_DATA_SEQ16, ptr);
SDP_PUT16(srv->fdidx[fd].rsp_size - 3, ptr);
return (0);
}
int32_t
server_prepare_service_search_attribute_response(server_p srv, int32_t fd)
{
uint8_t const *req = srv->req + sizeof(sdp_pdu_t);
uint8_t const *req_end = req + ((sdp_pdu_p)(srv->req))->len;
uint8_t *rsp = srv->fdidx[fd].rsp;
uint8_t const *rsp_end = rsp + L2CAP_MTU_MAXIMUM;
uint8_t const *aidptr = NULL;
provider_t *provider = NULL;
int32_t type, rsp_limit, ucount, aidlen, cslen, cs;
uint128_t ulist[12];
/*
* Minimal Service Search Attribute Request request
*
* seq8 len8 - 2 bytes
* uuid16 value16 - 3 bytes ServiceSearchPattern
* value16 - 2 bytes MaximumAttributeByteCount
* seq8 len8 - 2 bytes
* uint16 value16 - 3 bytes AttributeIDList
* value8 - 1 byte ContinuationState
*/
/* Get ServiceSearchPattern */
ucount = server_get_service_search_pattern(&req, req_end, ulist);
if (ucount < 1 || ucount > 12)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get MaximumAttributeByteCount */
if (req + 2 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET16(rsp_limit, req);
if (rsp_limit <= 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Get size of AttributeIDList */
if (req + 1 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
aidlen = 0;
SDP_GET8(type, req);
switch (type) {
case SDP_DATA_SEQ8:
if (req + 1 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET8(aidlen, req);
break;
case SDP_DATA_SEQ16:
if (req + 2 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET16(aidlen, req);
break;
case SDP_DATA_SEQ32:
if (req + 4 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET32(aidlen, req);
break;
}
if (aidlen <= 0)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
aidptr = req;
req += aidlen;
/* Get ContinuationState */
if (req + 1 > req_end)
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
SDP_GET8(cslen, req);
if (cslen == 2 && req + 2 == req_end)
SDP_GET16(cs, req);
else if (cslen == 0 && req == req_end)
cs = 0;
else
return (SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX);
/* Process the request. First, check continuation state */
if (srv->fdidx[fd].rsp_cs != cs)
return (SDP_ERROR_CODE_INVALID_CONTINUATION_STATE);
if (srv->fdidx[fd].rsp_size > 0)
return (0);
/*
* Service Search Attribute Response format
*
* value16 - 2 bytes AttributeListByteCount (not incl.)
* seq8 len16 - 3 bytes
* attr list - 3+ bytes AttributeLists
* [ attr list ]
*/
rsp += 3; /* leave space for sequence header */
for (provider = provider_get_first();
provider != NULL;
provider = provider_get_next(provider)) {
if (!provider_match_bdaddr(provider, &srv->req_sa.bt_bdaddr))
continue;
if (!provider_match_uuid(provider, ulist, ucount))
continue;
cs = server_prepare_attr_list(provider,
aidptr, aidptr + aidlen, rsp, rsp_end);
if (cs < 0)
return (SDP_ERROR_CODE_INSUFFICIENT_RESOURCES);
rsp += cs;
}
/* Set reply size (not counting PDU header and continuation state) */
srv->fdidx[fd].rsp_limit = srv->fdidx[fd].omtu - sizeof(sdp_pdu_t) - 2;
if (srv->fdidx[fd].rsp_limit > rsp_limit)
srv->fdidx[fd].rsp_limit = rsp_limit;
srv->fdidx[fd].rsp_size = rsp - srv->fdidx[fd].rsp;
srv->fdidx[fd].rsp_cs = 0;
/* Fix AttributeLists sequence header */
rsp = srv->fdidx[fd].rsp;
SDP_PUT8(SDP_DATA_SEQ16, rsp);
SDP_PUT16(srv->fdidx[fd].rsp_size - 3, rsp);
return (0);
}
