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); }
static int32_t dun_profile_create_audio_feedback_support( uint8_t *buf, uint8_t const * const eob, uint8_t const *data, uint32_t datalen) { provider_p provider = (provider_p) data; sdp_dun_profile_p dun = (sdp_dun_profile_p) provider->data; if (buf + 2 > eob) return (-1); SDP_PUT8(SDP_DATA_BOOL, buf); SDP_PUT8(dun->audio_feedback_support, buf); return (2); }
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); }
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); }
int32_t common_profile_create_service_record_handle( 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_UINT32, buf); SDP_PUT32(((provider_p) data)->handle, buf); return (5); }
static int32_t lan_profile_create_ip_subnet( uint8_t *buf, uint8_t const * const eob, uint8_t const *data, uint32_t datalen) { provider_p provider = (provider_p) data; sdp_lan_profile_p lan = (sdp_lan_profile_p) provider->data; char net[32]; int32_t len; len = snprintf(net, sizeof(net), "%s/%d", inet_ntoa(* (struct in_addr *) &lan->ip_subnet), lan->ip_subnet_radius); if (len < 0 || buf + 2 + len > eob) return (-1); SDP_PUT8(SDP_DATA_STR8, buf); SDP_PUT8(len, buf); memcpy(buf, net, len); return (2 + len); }
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 sd_profile_create_service_database_state( uint8_t *buf, uint8_t const * const eob, uint8_t const *data, uint32_t datalen) { uint32_t change_state = provider_get_change_state(); if (buf + 5 > eob) return (-1); SDP_PUT8(SDP_DATA_UINT32, buf); SDP_PUT32(change_state, buf); return (5); }
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); }
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); }
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 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); }