summaryrefslogtreecommitdiffstats
path: root/stack/sdp/sdp_utils.c
diff options
context:
space:
mode:
Diffstat (limited to 'stack/sdp/sdp_utils.c')
-rw-r--r--stack/sdp/sdp_utils.c1040
1 files changed, 1040 insertions, 0 deletions
diff --git a/stack/sdp/sdp_utils.c b/stack/sdp/sdp_utils.c
new file mode 100644
index 0000000..cda0570
--- /dev/null
+++ b/stack/sdp/sdp_utils.c
@@ -0,0 +1,1040 @@
+/******************************************************************************
+ *
+ * Copyright (C) 1999-2012 Broadcom Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at:
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ ******************************************************************************/
+
+/******************************************************************************
+ *
+ * This file contains SDP utility functions
+ *
+ ******************************************************************************/
+
+#include <stdlib.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <stdio.h>
+
+#include "gki.h"
+#include "bt_types.h"
+
+#include "l2cdefs.h"
+#include "hcidefs.h"
+#include "hcimsgs.h"
+
+#include "sdp_api.h"
+#include "sdpint.h"
+
+#include "btu.h"
+
+
+static const UINT8 sdp_base_uuid[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
+ 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB};
+
+/*******************************************************************************
+**
+** Function sdpu_find_ccb_by_cid
+**
+** Description This function searches the CCB table for an entry with the
+** passed CID.
+**
+** Returns the CCB address, or NULL if not found.
+**
+*******************************************************************************/
+tCONN_CB *sdpu_find_ccb_by_cid (UINT16 cid)
+{
+ UINT16 xx;
+ tCONN_CB *p_ccb;
+
+ /* Look through each connection control block */
+ for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++)
+ {
+ if ((p_ccb->con_state != SDP_STATE_IDLE) && (p_ccb->connection_id == cid))
+ return (p_ccb);
+ }
+
+ /* If here, not found */
+ return (NULL);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_find_ccb_by_db
+**
+** Description This function searches the CCB table for an entry with the
+** passed discovery db.
+**
+** Returns the CCB address, or NULL if not found.
+**
+*******************************************************************************/
+tCONN_CB *sdpu_find_ccb_by_db (tSDP_DISCOVERY_DB *p_db)
+{
+#if SDP_CLIENT_ENABLED == TRUE
+ UINT16 xx;
+ tCONN_CB *p_ccb;
+
+ if (p_db)
+ {
+ /* Look through each connection control block */
+ for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++)
+ {
+ if ((p_ccb->con_state != SDP_STATE_IDLE) && (p_ccb->p_db == p_db))
+ return (p_ccb);
+ }
+ }
+#endif
+ /* If here, not found */
+ return (NULL);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_allocate_ccb
+**
+** Description This function allocates a new CCB.
+**
+** Returns CCB address, or NULL if none available.
+**
+*******************************************************************************/
+tCONN_CB *sdpu_allocate_ccb (void)
+{
+ UINT16 xx;
+ tCONN_CB *p_ccb;
+
+ /* Look through each connection control block for a free one */
+ for (xx = 0, p_ccb = sdp_cb.ccb; xx < SDP_MAX_CONNECTIONS; xx++, p_ccb++)
+ {
+ if (p_ccb->con_state == SDP_STATE_IDLE)
+ {
+ memset (p_ccb, 0, sizeof (tCONN_CB));
+
+ p_ccb->timer_entry.param = (UINT32) p_ccb;
+
+ return (p_ccb);
+ }
+ }
+
+ /* If here, no free CCB found */
+ return (NULL);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_release_ccb
+**
+** Description This function releases a CCB.
+**
+** Returns void
+**
+*******************************************************************************/
+void sdpu_release_ccb (tCONN_CB *p_ccb)
+{
+ /* Ensure timer is stopped */
+ btu_stop_timer (&p_ccb->timer_entry);
+
+ /* Drop any response pointer we may be holding */
+ p_ccb->con_state = SDP_STATE_IDLE;
+#if SDP_CLIENT_ENABLED == TRUE
+ p_ccb->is_attr_search = FALSE;
+#endif
+
+ /* Free the response buffer */
+ if (p_ccb->rsp_list)
+ {
+ SDP_TRACE_DEBUG0("releasing SDP rsp_list");
+
+ GKI_freebuf(p_ccb->rsp_list);
+ p_ccb->rsp_list = NULL;
+ }
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_build_attrib_seq
+**
+** Description This function builds an attribute sequence from the list of
+** passed attributes. It is also passed the address of the output
+** buffer.
+**
+** Returns Pointer to next byte in the output buffer.
+**
+*******************************************************************************/
+UINT8 *sdpu_build_attrib_seq (UINT8 *p_out, UINT16 *p_attr, UINT16 num_attrs)
+{
+ UINT16 xx;
+
+ /* First thing is the data element header. See if the length fits 1 byte */
+ /* If no attributes, assume a 4-byte wildcard */
+ if (!p_attr)
+ xx = 5;
+ else
+ xx = num_attrs * 3;
+
+ if (xx > 255)
+ {
+ UINT8_TO_BE_STREAM (p_out, (DATA_ELE_SEQ_DESC_TYPE << 3) | SIZE_IN_NEXT_WORD);
+ UINT16_TO_BE_STREAM (p_out, xx);
+ }
+ else
+ {
+ UINT8_TO_BE_STREAM (p_out, (DATA_ELE_SEQ_DESC_TYPE << 3) | SIZE_IN_NEXT_BYTE);
+ UINT8_TO_BE_STREAM (p_out, xx);
+ }
+
+ /* If there are no attributes specified, assume caller wants wildcard */
+ if (!p_attr)
+ {
+ UINT8_TO_BE_STREAM (p_out, (UINT_DESC_TYPE << 3) | SIZE_FOUR_BYTES);
+ UINT16_TO_BE_STREAM (p_out, 0);
+ UINT16_TO_BE_STREAM (p_out, 0xFFFF);
+ }
+ else
+ {
+ /* Loop through and put in all the attributes(s) */
+ for (xx = 0; xx < num_attrs; xx++, p_attr++)
+ {
+ UINT8_TO_BE_STREAM (p_out, (UINT_DESC_TYPE << 3) | SIZE_TWO_BYTES);
+ UINT16_TO_BE_STREAM (p_out, *p_attr);
+ }
+ }
+
+ return (p_out);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_build_attrib_entry
+**
+** Description This function builds an attribute entry from the passed
+** attribute record. It is also passed the address of the output
+** buffer.
+**
+** Returns Pointer to next byte in the output buffer.
+**
+*******************************************************************************/
+UINT8 *sdpu_build_attrib_entry (UINT8 *p_out, tSDP_ATTRIBUTE *p_attr)
+{
+ /* First, store the attribute ID. Goes as a UINT */
+ UINT8_TO_BE_STREAM (p_out, (UINT_DESC_TYPE << 3) | SIZE_TWO_BYTES);
+ UINT16_TO_BE_STREAM (p_out, p_attr->id);
+
+ /* the attribute is in the db record.
+ * assuming the attribute len is less than SDP_MAX_ATTR_LEN */
+ switch(p_attr->type)
+ {
+ case TEXT_STR_DESC_TYPE: /* 4 */
+ case DATA_ELE_SEQ_DESC_TYPE:/* 6 */
+ case DATA_ELE_ALT_DESC_TYPE:/* 7 */
+ case URL_DESC_TYPE: /* 8 */
+#if (SDP_MAX_ATTR_LEN > 0xFFFF)
+ if(p_attr->len > 0xFFFF)
+ {
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_IN_NEXT_LONG);
+ UINT32_TO_BE_STREAM (p_out, p_attr->len);
+ }
+ else
+
+#endif /* 0xFFFF - 0xFF */
+#if (SDP_MAX_ATTR_LEN > 0xFF)
+ if(p_attr->len > 0xFF)
+ {
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_IN_NEXT_WORD);
+ UINT16_TO_BE_STREAM (p_out, p_attr->len);
+ }
+ else
+
+#endif /* 0xFF and less*/
+ {
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_IN_NEXT_BYTE);
+ UINT8_TO_BE_STREAM (p_out, p_attr->len);
+ }
+
+ ARRAY_TO_BE_STREAM (p_out, p_attr->value_ptr, (int)p_attr->len);
+
+ return (p_out);
+ }
+
+ /* Now, store the attribute value */
+ switch (p_attr->len)
+ {
+ case 1:
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_ONE_BYTE);
+ break;
+ case 2:
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_TWO_BYTES);
+ break;
+ case 4:
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_FOUR_BYTES);
+ break;
+ case 8:
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_EIGHT_BYTES);
+ break;
+ case 16:
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_SIXTEEN_BYTES);
+ break;
+ default:
+ UINT8_TO_BE_STREAM (p_out, (p_attr->type << 3) | SIZE_IN_NEXT_BYTE);
+ UINT8_TO_BE_STREAM (p_out, p_attr->len);
+ break;
+ }
+
+ ARRAY_TO_BE_STREAM (p_out, p_attr->value_ptr, (int)p_attr->len);
+
+ return (p_out);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_build_n_send_error
+**
+** Description This function builds and sends an error packet.
+**
+** Returns void
+**
+*******************************************************************************/
+void sdpu_build_n_send_error (tCONN_CB *p_ccb, UINT16 trans_num, UINT16 error_code, char *p_error_text)
+{
+ UINT8 *p_rsp, *p_rsp_start, *p_rsp_param_len;
+ UINT16 rsp_param_len;
+ BT_HDR *p_buf;
+
+
+ SDP_TRACE_WARNING2 ("SDP - sdpu_build_n_send_error code: 0x%x CID: 0x%x",
+ error_code, p_ccb->connection_id);
+
+ /* Get a buffer to use to build and send the packet to L2CAP */
+ if ((p_buf = (BT_HDR *)GKI_getpoolbuf (SDP_POOL_ID)) == NULL)
+ {
+ SDP_TRACE_ERROR0 ("SDP - no buf for err msg");
+ return;
+ }
+ p_buf->offset = L2CAP_MIN_OFFSET;
+ p_rsp = p_rsp_start = (UINT8 *)(p_buf + 1) + L2CAP_MIN_OFFSET;
+
+ UINT8_TO_BE_STREAM (p_rsp, SDP_PDU_ERROR_RESPONSE);
+ UINT16_TO_BE_STREAM (p_rsp, trans_num);
+
+ /* Skip the parameter length, we need to add it at the end */
+ p_rsp_param_len = p_rsp;
+ p_rsp += 2;
+
+ UINT16_TO_BE_STREAM (p_rsp, error_code);
+
+ /* Unplugfest example traces do not have any error text */
+ if (p_error_text)
+ ARRAY_TO_BE_STREAM (p_rsp, p_error_text, (int) strlen (p_error_text));
+
+ /* Go back and put the parameter length into the buffer */
+ rsp_param_len = p_rsp - p_rsp_param_len - 2;
+ UINT16_TO_BE_STREAM (p_rsp_param_len, rsp_param_len);
+
+ /* Set the length of the SDP data in the buffer */
+ p_buf->len = p_rsp - p_rsp_start;
+
+
+ /* Send the buffer through L2CAP */
+ L2CA_DataWrite (p_ccb->connection_id, p_buf);
+}
+
+
+
+/*******************************************************************************
+**
+** Function sdpu_extract_uid_seq
+**
+** Description This function extracts a UUID sequence from the passed input
+** buffer, and puts it into the passed output list.
+**
+** Returns Pointer to next byte in the input buffer after the sequence.
+**
+*******************************************************************************/
+UINT8 *sdpu_extract_uid_seq (UINT8 *p, UINT16 param_len, tSDP_UUID_SEQ *p_seq)
+{
+ UINT8 *p_seq_end;
+ UINT8 descr, type, size;
+ UINT32 seq_len, uuid_len;
+
+ /* Assume none found */
+ p_seq->num_uids = 0;
+
+ /* A UID sequence is composed of a bunch of UIDs. */
+
+ BE_STREAM_TO_UINT8 (descr, p);
+ type = descr >> 3;
+ size = descr & 7;
+
+ if (type != DATA_ELE_SEQ_DESC_TYPE)
+ return (NULL);
+
+ switch (size)
+ {
+ case SIZE_TWO_BYTES:
+ seq_len = 2;
+ break;
+ case SIZE_FOUR_BYTES:
+ seq_len = 4;
+ break;
+ case SIZE_SIXTEEN_BYTES:
+ seq_len = 16;
+ break;
+ case SIZE_IN_NEXT_BYTE:
+ BE_STREAM_TO_UINT8 (seq_len, p);
+ break;
+ case SIZE_IN_NEXT_WORD:
+ BE_STREAM_TO_UINT16 (seq_len, p);
+ break;
+ case SIZE_IN_NEXT_LONG:
+ BE_STREAM_TO_UINT32 (seq_len, p);
+ break;
+ default:
+ return (NULL);
+ }
+
+ if (seq_len >= param_len)
+ return (NULL);
+
+ p_seq_end = p + seq_len;
+
+ /* Loop through, extracting the UIDs */
+ for ( ; p < p_seq_end ; )
+ {
+ BE_STREAM_TO_UINT8 (descr, p);
+ type = descr >> 3;
+ size = descr & 7;
+
+ if (type != UUID_DESC_TYPE)
+ return (NULL);
+
+ switch (size)
+ {
+ case SIZE_TWO_BYTES:
+ uuid_len = 2;
+ break;
+ case SIZE_FOUR_BYTES:
+ uuid_len = 4;
+ break;
+ case SIZE_SIXTEEN_BYTES:
+ uuid_len = 16;
+ break;
+ case SIZE_IN_NEXT_BYTE:
+ BE_STREAM_TO_UINT8 (uuid_len, p);
+ break;
+ case SIZE_IN_NEXT_WORD:
+ BE_STREAM_TO_UINT16 (uuid_len, p);
+ break;
+ case SIZE_IN_NEXT_LONG:
+ BE_STREAM_TO_UINT32 (uuid_len, p);
+ break;
+ default:
+ return (NULL);
+ }
+
+ /* If UUID length is valid, copy it across */
+ if ((uuid_len == 2) || (uuid_len == 4) || (uuid_len == 16))
+ {
+ p_seq->uuid_entry[p_seq->num_uids].len = (UINT16) uuid_len;
+ BE_STREAM_TO_ARRAY (p, p_seq->uuid_entry[p_seq->num_uids].value, (int)uuid_len);
+ p_seq->num_uids++;
+ }
+ else
+ return (NULL);
+
+ /* We can only do so many */
+ if (p_seq->num_uids >= MAX_UUIDS_PER_SEQ)
+ return (NULL);
+ }
+
+ if (p != p_seq_end)
+ return (NULL);
+
+ return (p);
+}
+
+
+
+/*******************************************************************************
+**
+** Function sdpu_extract_attr_seq
+**
+** Description This function extracts an attribute sequence from the passed
+** input buffer, and puts it into the passed output list.
+**
+** Returns Pointer to next byte in the input buffer after the sequence.
+**
+*******************************************************************************/
+UINT8 *sdpu_extract_attr_seq (UINT8 *p, UINT16 param_len, tSDP_ATTR_SEQ *p_seq)
+{
+ UINT8 *p_end_list;
+ UINT8 descr, type, size;
+ UINT32 list_len, attr_len;
+
+ /* Assume none found */
+ p_seq->num_attr = 0;
+
+ /* Get attribute sequence info */
+ BE_STREAM_TO_UINT8 (descr, p);
+ type = descr >> 3;
+ size = descr & 7;
+
+ if (type != DATA_ELE_SEQ_DESC_TYPE)
+ return (p);
+
+ switch (size)
+ {
+ case SIZE_IN_NEXT_BYTE:
+ BE_STREAM_TO_UINT8 (list_len, p);
+ break;
+
+ case SIZE_IN_NEXT_WORD:
+ BE_STREAM_TO_UINT16 (list_len, p);
+ break;
+
+ case SIZE_IN_NEXT_LONG:
+ BE_STREAM_TO_UINT32 (list_len, p);
+ break;
+
+ default:
+ return (p);
+ }
+
+ if (list_len > param_len)
+ return (p);
+
+ p_end_list = p + list_len;
+
+ /* Loop through, extracting the attribute IDs */
+ for ( ; p < p_end_list ; )
+ {
+ BE_STREAM_TO_UINT8 (descr, p);
+ type = descr >> 3;
+ size = descr & 7;
+
+ if (type != UINT_DESC_TYPE)
+ return (p);
+
+ switch (size)
+ {
+ case SIZE_TWO_BYTES:
+ attr_len = 2;
+ break;
+ case SIZE_FOUR_BYTES:
+ attr_len = 4;
+ break;
+ case SIZE_IN_NEXT_BYTE:
+ BE_STREAM_TO_UINT8 (attr_len, p);
+ break;
+ case SIZE_IN_NEXT_WORD:
+ BE_STREAM_TO_UINT16 (attr_len, p);
+ break;
+ case SIZE_IN_NEXT_LONG:
+ BE_STREAM_TO_UINT32 (attr_len, p);
+ break;
+ default:
+ return (NULL);
+ break;
+ }
+
+ /* Attribute length must be 2-bytes or 4-bytes for a paired entry. */
+ if (attr_len == 2)
+ {
+ BE_STREAM_TO_UINT16 (p_seq->attr_entry[p_seq->num_attr].start, p);
+ p_seq->attr_entry[p_seq->num_attr].end = p_seq->attr_entry[p_seq->num_attr].start;
+ }
+ else if (attr_len == 4)
+ {
+ BE_STREAM_TO_UINT16 (p_seq->attr_entry[p_seq->num_attr].start, p);
+ BE_STREAM_TO_UINT16 (p_seq->attr_entry[p_seq->num_attr].end, p);
+ }
+ else
+ return (NULL);
+
+ /* We can only do so many */
+ if (++p_seq->num_attr >= MAX_ATTR_PER_SEQ)
+ return (NULL);
+ }
+
+ return (p);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_get_len_from_type
+**
+** Description This function gets the length
+**
+** Returns void
+**
+*******************************************************************************/
+UINT8 *sdpu_get_len_from_type (UINT8 *p, UINT8 type, UINT32 *p_len)
+{
+ UINT8 u8;
+ UINT16 u16;
+ UINT32 u32;
+
+ switch (type & 7)
+ {
+ case SIZE_ONE_BYTE:
+ *p_len = 1;
+ break;
+ case SIZE_TWO_BYTES:
+ *p_len = 2;
+ break;
+ case SIZE_FOUR_BYTES:
+ *p_len = 4;
+ break;
+ case SIZE_EIGHT_BYTES:
+ *p_len = 8;
+ break;
+ case SIZE_SIXTEEN_BYTES:
+ *p_len = 16;
+ break;
+ case SIZE_IN_NEXT_BYTE:
+ BE_STREAM_TO_UINT8 (u8, p);
+ *p_len = u8;
+ break;
+ case SIZE_IN_NEXT_WORD:
+ BE_STREAM_TO_UINT16 (u16, p);
+ *p_len = u16;
+ break;
+ case SIZE_IN_NEXT_LONG:
+ BE_STREAM_TO_UINT32 (u32, p);
+ *p_len = (UINT16) u32;
+ break;
+ }
+
+ return (p);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_is_base_uuid
+**
+** Description This function checks a 128-bit UUID with the base to see if
+** it matches. Only the last 12 bytes are compared.
+**
+** Returns TRUE if matched, else FALSE
+**
+*******************************************************************************/
+BOOLEAN sdpu_is_base_uuid (UINT8 *p_uuid)
+{
+ UINT16 xx;
+
+ for (xx = 4; xx < MAX_UUID_SIZE; xx++)
+ if (p_uuid[xx] != sdp_base_uuid[xx])
+ return (FALSE);
+
+ /* If here, matched */
+ return (TRUE);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_compare_uuid_arrays
+**
+** Description This function compares 2 BE UUIDs. If needed, they are expanded
+** to 128-bit UUIDs, then compared.
+**
+** NOTE it is assumed that the arrays are in Big Endian format
+**
+** Returns TRUE if matched, else FALSE
+**
+*******************************************************************************/
+BOOLEAN sdpu_compare_uuid_arrays (UINT8 *p_uuid1, UINT32 len1, UINT8 *p_uuid2, UINT16 len2)
+{
+ UINT8 nu1[MAX_UUID_SIZE];
+ UINT8 nu2[MAX_UUID_SIZE];
+
+ /* If lengths match, do a straight compare */
+ if (len1 == len2)
+ {
+ if (len1 == 2)
+ return ((p_uuid1[0] == p_uuid2[0]) && (p_uuid1[1] == p_uuid2[1]));
+ if (len1 == 4)
+ return ( (p_uuid1[0] == p_uuid2[0]) && (p_uuid1[1] == p_uuid2[1])
+ && (p_uuid1[2] == p_uuid2[2]) && (p_uuid1[3] == p_uuid2[3]) );
+ else
+ return (memcmp (p_uuid1, p_uuid2, (size_t)len1) == 0);
+ }
+ else if (len1 > len2)
+ {
+ /* If the len1 was 4-byte, (so len2 is 2-byte), compare on the fly */
+ if (len1 == 4)
+ {
+ return ( (p_uuid1[0] == 0) && (p_uuid1[1] == 0)
+ && (p_uuid1[2] == p_uuid2[0]) && (p_uuid1[3] == p_uuid2[1]) );
+ }
+ else
+ {
+ /* Normalize UUIDs to 16-byte form, then compare. Len1 must be 16 */
+ memcpy (nu1, p_uuid1, MAX_UUID_SIZE);
+ memcpy (nu2, sdp_base_uuid, MAX_UUID_SIZE);
+
+ if (len2 == 4)
+ memcpy (nu2, p_uuid2, len2);
+ else
+ memcpy (nu2 + 2, p_uuid2, len2);
+
+ return (memcmp (nu1, nu2, MAX_UUID_SIZE) == 0);
+ }
+ }
+ else
+ {
+ /* len2 is greater than len1 */
+ /* If the len2 was 4-byte, (so len1 is 2-byte), compare on the fly */
+ if (len2 == 4)
+ {
+ return ( (p_uuid2[0] == 0) && (p_uuid2[1] == 0)
+ && (p_uuid2[2] == p_uuid1[0]) && (p_uuid2[3] == p_uuid1[1]) );
+ }
+ else
+ {
+ /* Normalize UUIDs to 16-byte form, then compare. Len1 must be 16 */
+ memcpy (nu2, p_uuid2, MAX_UUID_SIZE);
+ memcpy (nu1, sdp_base_uuid, MAX_UUID_SIZE);
+
+ if (len1 == 4)
+ memcpy (nu1, p_uuid1, (size_t)len1);
+ else
+ memcpy (nu1 + 2, p_uuid1, (size_t)len1);
+
+ return (memcmp (nu1, nu2, MAX_UUID_SIZE) == 0);
+ }
+ }
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_compare_bt_uuids
+**
+** Description This function compares 2 BT UUID structures.
+**
+** NOTE it is assumed that BT UUID structures are compressed to the
+** smallest possible UUIDs (by removing the base SDP UUID)
+**
+** Returns TRUE if matched, else FALSE
+**
+*******************************************************************************/
+BOOLEAN sdpu_compare_bt_uuids (tBT_UUID *p_uuid1, tBT_UUID *p_uuid2)
+{
+ /* Lengths must match for BT UUIDs to match */
+ if (p_uuid1->len == p_uuid2->len)
+ {
+ if (p_uuid1->len == 2)
+ return (p_uuid1->uu.uuid16 == p_uuid2->uu.uuid16);
+ else if (p_uuid1->len == 4)
+ return (p_uuid1->uu.uuid32 == p_uuid2->uu.uuid32);
+ else if (!memcmp (p_uuid1->uu.uuid128, p_uuid2->uu.uuid128, 16))
+ return (TRUE);
+ }
+
+ return (FALSE);
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_compare_uuid_with_attr
+**
+** Description This function compares a BT UUID structure with the UUID in an
+** SDP attribute record. If needed, they are expanded to 128-bit
+** UUIDs, then compared.
+**
+** NOTE - it is assumed that BT UUID structures are compressed to the
+** smallest possible UUIDs (by removing the base SDP UUID).
+** - it is also assumed that the discovery atribute is compressed
+** to the smallest possible
+**
+** Returns TRUE if matched, else FALSE
+**
+*******************************************************************************/
+BOOLEAN sdpu_compare_uuid_with_attr (tBT_UUID *p_btuuid, tSDP_DISC_ATTR *p_attr)
+{
+ UINT16 attr_len = SDP_DISC_ATTR_LEN (p_attr->attr_len_type);
+
+ /* Since both UUIDs are compressed, lengths must match */
+ if (p_btuuid->len != attr_len)
+ return (FALSE);
+
+ if (p_btuuid->len == 2)
+ return (BOOLEAN)(p_btuuid->uu.uuid16 == p_attr->attr_value.v.u16);
+ else if (p_btuuid->len == 4)
+ return (BOOLEAN)(p_btuuid->uu.uuid32 == p_attr->attr_value.v.u32);
+ /* coverity[overrun-buffer-arg] */
+ /*
+ Event overrun-buffer-arg: Overrun of static array "&p_attr->attr_value.v.array" of size 4 bytes by passing it to a function which indexes it with argument "16U" at byte position 15
+ FALSE-POSITIVE error from Coverity test tool. Please do NOT remove following comment.
+ False-positive: SDP uses scratch buffer to hold the attribute value.
+ The actual size of tSDP_DISC_ATVAL does not matter.
+ If the array size in tSDP_DISC_ATVAL is increase, we would increase the system RAM usage unnecessarily
+ */
+ else if (!memcmp (p_btuuid->uu.uuid128, p_attr->attr_value.v.array, MAX_UUID_SIZE))
+ return (TRUE);
+
+ return (FALSE);
+}
+
+/*******************************************************************************
+**
+** Function sdpu_sort_attr_list
+**
+** Description sorts a list of attributes in numeric order from lowest to
+** highest to conform to SDP specification
+**
+** Returns void
+**
+*******************************************************************************/
+void sdpu_sort_attr_list( UINT16 num_attr, tSDP_DISCOVERY_DB *p_db )
+{
+ UINT16 i;
+ UINT16 x;
+
+ /* Done if no attributes to sort */
+ if (num_attr <= 1)
+ {
+ return;
+ }
+ else if (num_attr > SDP_MAX_ATTR_FILTERS)
+ {
+ num_attr = SDP_MAX_ATTR_FILTERS;
+ }
+
+ num_attr--; /* for the for-loop */
+ for( i = 0; i < num_attr; )
+ {
+ if( p_db->attr_filters[i] > p_db->attr_filters[i+1] )
+ {
+ /* swap the attribute IDs and start from the beginning */
+ x = p_db->attr_filters[i];
+ p_db->attr_filters[i] = p_db->attr_filters[i+1];
+ p_db->attr_filters[i+1] = x;
+
+ i = 0;
+ }
+ else
+ i++;
+ }
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_get_list_len
+**
+** Description gets the total list length in the sdp database for a given
+** uid sequence and attr sequence
+**
+** Returns void
+**
+*******************************************************************************/
+UINT16 sdpu_get_list_len(tSDP_UUID_SEQ *uid_seq, tSDP_ATTR_SEQ *attr_seq)
+{
+ tSDP_RECORD *p_rec;
+ UINT16 len = 0;
+ UINT16 len1;
+
+ for (p_rec = sdp_db_service_search (NULL, uid_seq); p_rec; p_rec = sdp_db_service_search (p_rec, uid_seq))
+ {
+ len += 3;
+
+ len1 = sdpu_get_attrib_seq_len(p_rec, attr_seq );
+
+ if (len1 != 0)
+ len += len1;
+ else
+ len -= 3;
+ }
+ return len;
+}
+
+/*******************************************************************************
+**
+** Function sdpu_get_attrib_seq_len
+**
+** Description gets the length of the specific attributes in a given
+** sdp record
+**
+** Returns void
+**
+*******************************************************************************/
+UINT16 sdpu_get_attrib_seq_len(tSDP_RECORD *p_rec, tSDP_ATTR_SEQ *attr_seq)
+{
+ tSDP_ATTRIBUTE *p_attr;
+ UINT16 len1 = 0;
+ UINT16 xx;
+ BOOLEAN is_range = FALSE;
+ UINT16 start_id, end_id;
+
+ for (xx = 0; xx < attr_seq->num_attr; xx++)
+ {
+ if (is_range == FALSE)
+ {
+ start_id = attr_seq->attr_entry[xx].start;
+ end_id = attr_seq->attr_entry[xx].end;
+ }
+ p_attr = sdp_db_find_attr_in_rec (p_rec,
+ start_id,
+ end_id);
+ if (p_attr)
+ {
+ len1 += sdpu_get_attrib_entry_len (p_attr);
+
+ /* If doing a range, stick with this one till no more attributes found */
+ if (start_id != end_id)
+ {
+ /* Update for next time through */
+ start_id = p_attr->id + 1;
+ xx--;
+ is_range = TRUE;
+ }
+ else
+ is_range = FALSE;
+ }
+ else
+ is_range = FALSE;
+ }
+ return len1;
+}
+
+/*******************************************************************************
+**
+** Function sdpu_get_attrib_entry_len
+**
+** Description gets the length of a specific attribute
+**
+** Returns void
+**
+*******************************************************************************/
+UINT16 sdpu_get_attrib_entry_len(tSDP_ATTRIBUTE *p_attr)
+{
+ UINT16 len = 3;
+
+ /* the attribute is in the db record.
+ * assuming the attribute len is less than SDP_MAX_ATTR_LEN */
+ switch(p_attr->type)
+ {
+ case TEXT_STR_DESC_TYPE: /* 4 */
+ case DATA_ELE_SEQ_DESC_TYPE:/* 6 */
+ case DATA_ELE_ALT_DESC_TYPE:/* 7 */
+ case URL_DESC_TYPE: /* 8 */
+#if (SDP_MAX_ATTR_LEN > 0xFFFF)
+ if(p_attr->len > 0xFFFF)
+ {
+ len += 5;
+ }
+ else
+
+#endif/* 0xFFFF - 0xFF */
+#if (SDP_MAX_ATTR_LEN > 0xFF)
+ if(p_attr->len > 0xFF)
+ {
+ len += 3;
+ }
+ else
+
+#endif /* 0xFF and less*/
+ {
+ len += 2;
+ }
+ len += p_attr->len;
+ return len;
+ }
+
+ /* Now, the attribute value */
+ switch (p_attr->len)
+ {
+ case 1:
+ case 2:
+ case 4:
+ case 8:
+ case 16:
+ len += 1;
+ break;
+ default:
+ len += 2;
+ break;
+ }
+
+ len += p_attr->len;
+ return len;
+}
+
+
+/*******************************************************************************
+**
+** Function sdpu_build_partial_attrib_entry
+**
+** Description This function fills a buffer with partial attribute. It is
+** assumed that the maximum size of any attribute is 256 bytes.
+**
+** p_out: output buffer
+** p_attr: attribute to be copied partially into p_out
+** rem_len: num bytes to copy into p_out
+** offset: current start offset within the attr that needs to be copied
+**
+** Returns Pointer to next byte in the output buffer.
+** offset is also updated
+**
+*******************************************************************************/
+UINT8 *sdpu_build_partial_attrib_entry (UINT8 *p_out, tSDP_ATTRIBUTE *p_attr, UINT16 len, UINT16 *offset)
+{
+ UINT8 tmp_attr[MAX_ATTR_LEN];
+ UINT8 *p_tmp_attr = &tmp_attr[0];
+ size_t len_to_copy;
+ UINT16 attr_len;
+
+ sdpu_build_attrib_entry(p_tmp_attr, p_attr);
+ attr_len = sdpu_get_attrib_entry_len(p_attr);
+
+ len_to_copy = ((attr_len - *offset) < len) ? (attr_len - *offset): len;
+
+ memcpy(p_out, &tmp_attr[*offset], len_to_copy);
+
+ p_out = &p_out[len_to_copy];
+ *offset += len_to_copy;
+
+ return p_out;
+}
+
+/*******************************************************************************
+**
+** Function sdpu_uuid16_to_uuid128
+**
+** Description This function converts UUID-16 to UUID-128 by including the base UUID
+**
+** uuid16: 2-byte UUID
+** p_uuid128: Expanded 128-bit UUID
+**
+** Returns None
+**
+*******************************************************************************/
+void sdpu_uuid16_to_uuid128(UINT16 uuid16, UINT8* p_uuid128)
+{
+ UINT16 uuid16_bo;
+ memset(p_uuid128, 0, 16);
+
+ memcpy(p_uuid128, sdp_base_uuid, MAX_UUID_SIZE);
+ uuid16_bo = ntohs(uuid16);
+ memcpy(p_uuid128+ 2, &uuid16_bo, sizeof(uint16_t));
+}
generated by cgit v1.1 at 2024-05-02 11:31:58 +0000