« back to all changes in this revision
Viewing changes to lib/sdp.c
- browse files at revision 1.2.2
- compare with another revision
- download diff
- download tarball
- view history from revision 1.2.2
- Committer: Bazaar Package Importer
- Author(s): Nobuhiro Iwamatsu
- Date: 2010-12-02 12:17:48 UTC
- mfrom: (1.3.7 upstream)
- mto: (1.1.23 upstream) (6.2.2 experimental)
- mto: This revision was merged to the branch mainline in revision 51.
- Revision ID: james.westby@ubuntu.com-20101202121748-9y64u4vc3vmk1wvl
Import upstream version 4.81
- files added:
- Makefile.tools
- attrib
- btio
- health
- tracer
- files removed:
- audio/Makefile.am
- client
- common
- include
- rfcomm
- files modified:
- AUTHORS
added
removed
lib/sdp.c
4
4
*
5
5
* Copyright (C) 2001-2002 Nokia Corporation
6
6
* Copyright (C) 2002-2003 Maxim Krasnyansky <maxk@qualcomm.com>
7
* Copyright (C) 2002-2009 Marcel Holtmann <marcel@holtmann.org>
7
* Copyright (C) 2002-2010 Marcel Holtmann <marcel@holtmann.org>
8
8
* Copyright (C) 2002-2003 Stephen Crane <steve.crane@rococosoft.com>
9
9
*
10
10
*
40
40
#include <sys/types.h>
41
41
#include <sys/socket.h>
42
42
#include <sys/un.h>
43
44
#include <bluetooth/bluetooth.h>
45
#include <bluetooth/hci.h>
46
#include <bluetooth/hci_lib.h>
47
#include <bluetooth/l2cap.h>
48
#include <bluetooth/sdp.h>
49
#include <bluetooth/sdp_lib.h>
50
51
43
#include <netinet/in.h>
52
44
45
#include "bluetooth.h"
46
#include "hci.h"
47
#include "hci_lib.h"
48
#include "l2cap.h"
49
#include "sdp.h"
50
#include "sdp_lib.h"
51
53
52
#define SDPINF(fmt, arg...) syslog(LOG_INFO, fmt "\n", ## arg)
54
53
#define SDPERR(fmt, arg...) syslog(LOG_ERR, "%s: " fmt "\n", __func__ , ## arg)
55
54
55
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
56
56
57
#ifdef SDP_DEBUG
57
58
#define SDPDBG(fmt, arg...) syslog(LOG_DEBUG, "%s: " fmt "\n", __func__ , ## arg)
58
59
#else
67
68
for (i = 0; i < 16; i++)
68
69
dst->data[i] = src->data[i];
69
70
}
71
72
static inline void btoh128(uint128_t *src, uint128_t *dst)
73
{
74
int i;
75
for (i = 0; i < 16; i++)
76
dst->data[15 - i] = src->data[i];
77
78
}
79
70
80
#else
71
81
static inline uint64_t ntoh64(uint64_t n)
72
82
{
76
86
h |= tmp << 32;
77
87
return h;
78
88
}
89
79
90
static inline void ntoh128(uint128_t *src, uint128_t *dst)
80
91
{
81
92
int i;
82
93
for (i = 0; i < 16; i++)
83
94
dst->data[15 - i] = src->data[i];
84
95
}
96
97
static inline void btoh128(uint128_t *src, uint128_t *dst)
98
{
99
memcpy(src, dst, sizeof(uint128_t));
100
}
101
85
102
#endif
86
103
87
104
#define hton64(x) ntoh64(x)
88
105
#define hton128(x, y) ntoh128(x, y)
106
#define htob128(x, y) btoh128(x, y)
89
107
90
108
#define BASE_UUID "00000000-0000-1000-8000-00805F9B34FB"
91
109
99
117
static sdp_data_t *sdp_copy_seq(sdp_data_t *data);
100
118
static int sdp_attr_add_new_with_length(sdp_record_t *rec,
101
119
uint16_t attr, uint8_t dtd, const void *value, uint32_t len);
120
static int sdp_gen_buffer(sdp_buf_t *buf, sdp_data_t *d);
102
121
103
122
/* Message structure. */
104
123
struct tupla {
131
150
{ MCAP_CTRL_UUID, "MCAP-Ctrl" },
132
151
{ MCAP_DATA_UUID, "MCAP-Data" },
133
152
{ L2CAP_UUID, "L2CAP" },
153
{ ATT_UUID, "ATT" },
134
154
{ 0 }
135
155
};
136
156
199
219
{ VIDEO_SOURCE_SVCLASS_ID, "Video Source" },
200
220
{ VIDEO_SINK_SVCLASS_ID, "Video Sink" },
201
221
{ VIDEO_DISTRIBUTION_SVCLASS_ID, "Video Distribution" },
202
{ MDP_SVCLASS_ID, "MDP" },
203
{ MDP_SOURCE_SVCLASS_ID, "MDP Source" },
204
{ MDP_SINK_SVCLASS_ID, "MDP Sink" },
222
{ HDP_SVCLASS_ID, "HDP" },
223
{ HDP_SOURCE_SVCLASS_ID, "HDP Source" },
224
{ HDP_SINK_SVCLASS_ID, "HDP Sink" },
205
225
{ APPLE_AGENT_SVCLASS_ID, "Apple Agent" },
226
{ GENERIC_ATTRIB_SVCLASS_ID, "Generic Attribute" },
206
227
{ 0 }
207
228
};
208
229
635
656
636
657
void sdp_set_seq_len(uint8_t *ptr, uint32_t length)
637
658
{
638
uint8_t dtd = *(uint8_t *) ptr++;
659
uint8_t dtd = *ptr++;
639
660
640
661
switch (dtd) {
641
662
case SDP_SEQ8:
642
663
case SDP_ALT8:
643
664
case SDP_TEXT_STR8:
644
665
case SDP_URL_STR8:
645
*(uint8_t *)ptr = (uint8_t) length;
666
*ptr = (uint8_t) length;
646
667
break;
647
668
case SDP_SEQ16:
648
669
case SDP_ALT16:
659
680
}
660
681
}
661
682
683
static int sdp_get_data_type(sdp_buf_t *buf, uint8_t dtd)
684
{
685
int data_type = 0;
686
687
data_type += sizeof(uint8_t);
688
689
switch (dtd) {
690
case SDP_SEQ8:
691
case SDP_TEXT_STR8:
692
case SDP_URL_STR8:
693
case SDP_ALT8:
694
data_type += sizeof(uint8_t);
695
break;
696
case SDP_SEQ16:
697
case SDP_TEXT_STR16:
698
case SDP_URL_STR16:
699
case SDP_ALT16:
700
data_type += sizeof(uint16_t);
701
break;
702
case SDP_SEQ32:
703
case SDP_TEXT_STR32:
704
case SDP_URL_STR32:
705
case SDP_ALT32:
706
data_type += sizeof(uint32_t);
707
break;
708
}
709
710
if (!buf->data)
711
buf->buf_size += data_type;
712
713
return data_type;
714
}
715
662
716
static int sdp_set_data_type(sdp_buf_t *buf, uint8_t dtd)
663
717
{
664
int orig = buf->data_size;
718
int data_type = 0;
665
719
uint8_t *p = buf->data + buf->data_size;
666
720
667
721
*p++ = dtd;
668
buf->data_size += sizeof(uint8_t);
669
670
switch (dtd) {
671
case SDP_SEQ8:
672
case SDP_TEXT_STR8:
673
case SDP_URL_STR8:
674
case SDP_ALT8:
675
buf->data_size += sizeof(uint8_t);
676
break;
677
case SDP_SEQ16:
678
case SDP_TEXT_STR16:
679
case SDP_URL_STR16:
680
case SDP_ALT16:
681
buf->data_size += sizeof(uint16_t);
682
break;
683
case SDP_SEQ32:
684
case SDP_TEXT_STR32:
685
case SDP_URL_STR32:
686
case SDP_ALT32:
687
buf->data_size += sizeof(uint32_t);
688
break;
689
}
690
691
return buf->data_size - orig;
722
data_type = sdp_get_data_type(buf, dtd);
723
buf->data_size += data_type;
724
725
return data_type;
692
726
}
693
727
694
728
void sdp_set_attrid(sdp_buf_t *buf, uint16_t attr)
708
742
sdp_data_t *d;
709
743
int n = 0;
710
744
711
for (d = sdpdata->val.dataseq; d; d = d->next)
712
n += sdp_gen_pdu(buf, d);
745
for (d = sdpdata->val.dataseq; d; d = d->next) {
746
if (buf->data)
747
n += sdp_gen_pdu(buf, d);
748
else
749
n += sdp_gen_buffer(buf, d);
750
}
713
751
714
752
return n;
715
753
}
716
754
755
static int sdp_get_data_size(sdp_buf_t *buf, sdp_data_t *d)
756
{
757
uint32_t data_size = 0;
758
uint8_t dtd = d->dtd;
759
760
switch (dtd) {
761
case SDP_DATA_NIL:
762
break;
763
case SDP_UINT8:
764
data_size = sizeof(uint8_t);
765
break;
766
case SDP_UINT16:
767
data_size = sizeof(uint16_t);
768
break;
769
case SDP_UINT32:
770
data_size = sizeof(uint32_t);
771
break;
772
case SDP_UINT64:
773
data_size = sizeof(uint64_t);
774
break;
775
case SDP_UINT128:
776
data_size = sizeof(uint128_t);
777
break;
778
case SDP_INT8:
779
case SDP_BOOL:
780
data_size = sizeof(int8_t);
781
break;
782
case SDP_INT16:
783
data_size = sizeof(int16_t);
784
break;
785
case SDP_INT32:
786
data_size = sizeof(int32_t);
787
break;
788
case SDP_INT64:
789
data_size = sizeof(int64_t);
790
break;
791
case SDP_INT128:
792
data_size = sizeof(uint128_t);
793
break;
794
case SDP_TEXT_STR8:
795
case SDP_TEXT_STR16:
796
case SDP_TEXT_STR32:
797
case SDP_URL_STR8:
798
case SDP_URL_STR16:
799
case SDP_URL_STR32:
800
data_size = d->unitSize - sizeof(uint8_t);
801
break;
802
case SDP_SEQ8:
803
case SDP_SEQ16:
804
case SDP_SEQ32:
805
data_size = get_data_size(buf, d);
806
break;
807
case SDP_ALT8:
808
case SDP_ALT16:
809
case SDP_ALT32:
810
data_size = get_data_size(buf, d);
811
break;
812
case SDP_UUID16:
813
data_size = sizeof(uint16_t);
814
break;
815
case SDP_UUID32:
816
data_size = sizeof(uint32_t);
817
break;
818
case SDP_UUID128:
819
data_size = sizeof(uint128_t);
820
break;
821
default:
822
break;
823
}
824
825
if (!buf->data)
826
buf->buf_size += data_size;
827
828
return data_size;
829
}
830
831
static int sdp_gen_buffer(sdp_buf_t *buf, sdp_data_t *d)
832
{
833
int orig = buf->buf_size;
834
835
if (buf->buf_size == 0 && d->dtd == 0) {
836
/* create initial sequence */
837
buf->buf_size += sizeof(uint8_t);
838
839
/* reserve space for sequence size */
840
buf->buf_size += sizeof(uint8_t);
841
}
842
843
/* attribute length */
844
buf->buf_size += sizeof(uint8_t) + sizeof(uint16_t);
845
846
sdp_get_data_type(buf, d->dtd);
847
sdp_get_data_size(buf, d);
848
849
if (buf->buf_size > UCHAR_MAX && d->dtd == SDP_SEQ8)
850
buf->buf_size += sizeof(uint8_t);
851
852
return buf->buf_size - orig;
853
}
854
717
855
int sdp_gen_pdu(sdp_buf_t *buf, sdp_data_t *d)
718
856
{
719
857
uint32_t pdu_size = 0, data_size = 0;
726
864
uint8_t *seqp = buf->data + buf->data_size;
727
865
728
866
pdu_size = sdp_set_data_type(buf, dtd);
867
data_size = sdp_get_data_size(buf, d);
729
868
730
869
switch (dtd) {
731
870
case SDP_DATA_NIL:
732
871
break;
733
872
case SDP_UINT8:
734
873
src = &d->val.uint8;
735
data_size = sizeof(uint8_t);
736
874
break;
737
875
case SDP_UINT16:
738
876
u16 = htons(d->val.uint16);
739
877
src = (unsigned char *) &u16;
740
data_size = sizeof(uint16_t);
741
878
break;
742
879
case SDP_UINT32:
743
880
u32 = htonl(d->val.uint32);
744
881
src = (unsigned char *) &u32;
745
data_size = sizeof(uint32_t);
746
882
break;
747
883
case SDP_UINT64:
748
884
u64 = hton64(d->val.uint64);
749
885
src = (unsigned char *) &u64;
750
data_size = sizeof(uint64_t);
751
886
break;
752
887
case SDP_UINT128:
753
888
hton128(&d->val.uint128, &u128);
754
889
src = (unsigned char *) &u128;
755
data_size = sizeof(uint128_t);
756
890
break;
757
891
case SDP_INT8:
758
892
case SDP_BOOL:
759
893
src = (unsigned char *) &d->val.int8;
760
data_size = sizeof(int8_t);
761
894
break;
762
895
case SDP_INT16:
763
896
u16 = htons(d->val.int16);
764
897
src = (unsigned char *) &u16;
765
data_size = sizeof(int16_t);
766
898
break;
767
899
case SDP_INT32:
768
900
u32 = htonl(d->val.int32);
769
901
src = (unsigned char *) &u32;
770
data_size = sizeof(int32_t);
771
902
break;
772
903
case SDP_INT64:
773
904
u64 = hton64(d->val.int64);
774
905
src = (unsigned char *) &u64;
775
data_size = sizeof(int64_t);
776
906
break;
777
907
case SDP_INT128:
778
908
hton128(&d->val.int128, &u128);
779
909
src = (unsigned char *) &u128;
780
data_size = sizeof(uint128_t);
781
910
break;
782
911
case SDP_TEXT_STR8:
783
912
case SDP_TEXT_STR16:
786
915
case SDP_URL_STR16:
787
916
case SDP_URL_STR32:
788
917
src = (unsigned char *) d->val.str;
789
data_size = d->unitSize - sizeof(uint8_t);
790
918
sdp_set_seq_len(seqp, data_size);
791
919
break;
792
920
case SDP_SEQ8:
793
921
case SDP_SEQ16:
794
922
case SDP_SEQ32:
795
923
is_seq = 1;
796
data_size = get_data_size(buf, d);
797
924
sdp_set_seq_len(seqp, data_size);
798
925
break;
799
926
case SDP_ALT8:
800
927
case SDP_ALT16:
801
928
case SDP_ALT32:
802
929
is_alt = 1;
803
data_size = get_data_size(buf, d);
804
930
sdp_set_seq_len(seqp, data_size);
805
931
break;
806
932
case SDP_UUID16:
807
933
u16 = htons(d->val.uuid.value.uuid16);
808
934
src = (unsigned char *) &u16;
809
data_size = sizeof(uint16_t);
810
935
break;
811
936
case SDP_UUID32:
812
937
u32 = htonl(d->val.uuid.value.uuid32);
813
938
src = (unsigned char *) &u32;
814
data_size = sizeof(uint32_t);
815
939
break;
816
940
case SDP_UUID128:
817
941
src = (unsigned char *) &d->val.uuid.value.uuid128;
818
data_size = sizeof(uint128_t);
819
942
break;
820
943
default:
821
944
break;
840
963
sdp_append_to_pdu((sdp_buf_t *)udata, (sdp_data_t *)value);
841
964
}
842
965
966
static void sdp_attr_size(void *value, void *udata)
967
{
968
sdp_gen_buffer((sdp_buf_t *)udata, (sdp_data_t *)value);
969
}
970
843
971
int sdp_gen_record_pdu(const sdp_record_t *rec, sdp_buf_t *buf)
844
972
{
845
buf->data = malloc(SDP_PDU_CHUNK_SIZE);
973
memset(buf, 0, sizeof(sdp_buf_t));
974
sdp_list_foreach(rec->attrlist, sdp_attr_size, buf);
975
976
buf->data = malloc(buf->buf_size);
846
977
if (!buf->data)
847
978
return -ENOMEM;
848
849
buf->buf_size = SDP_PDU_CHUNK_SIZE;
850
979
buf->data_size = 0;
851
980
memset(buf->data, 0, buf->buf_size);
981
852
982
sdp_list_foreach(rec->attrlist, sdp_attr_pdu, buf);
853
983
854
984
return 0;
967
1097
}
968
1098
969
1099
d = malloc(sizeof(sdp_data_t));
1100
if (!d)
1101
return NULL;
970
1102
971
1103
SDPDBG("Extracting integer\n");
972
1104
memset(d, 0, sizeof(sdp_data_t));
1041
1173
{
1042
1174
sdp_data_t *d = malloc(sizeof(sdp_data_t));
1043
1175
1176
if (!d)
1177
return NULL;
1178
1044
1179
SDPDBG("Extracting UUID");
1045
1180
memset(d, 0, sizeof(sdp_data_t));
1046
1181
if (sdp_uuid_extract(p, bufsize, &d->val.uuid, len) < 0) {
1047
1182
free(d);
1048
1183
return NULL;
1049
1184
}
1050
d->dtd = *(uint8_t *) p;
1185
d->dtd = *p;
1051
1186
if (rec)
1052
1187
sdp_pattern_add_uuid(rec, &d->val.uuid);
1053
1188
return d;
1068
1203
}
1069
1204
1070
1205
d = malloc(sizeof(sdp_data_t));
1206
if (!d)
1207
return NULL;
1071
1208
1072
1209
memset(d, 0, sizeof(sdp_data_t));
1073
1210
d->dtd = *(uint8_t *) p;
1103
1240
default:
1104
1241
SDPERR("Sizeof text string > UINT16_MAX\n");
1105
1242
free(d);
1106
return 0;
1243
return NULL;
1107
1244
}
1108
1245
1109
1246
if (bufsize < n) {
1191
1328
sdp_data_t *curr, *prev;
1192
1329
sdp_data_t *d = malloc(sizeof(sdp_data_t));
1193
1330
1331
if (!d)
1332
return NULL;
1333
1194
1334
SDPDBG("Extracting SEQ");
1195
1335
memset(d, 0, sizeof(sdp_data_t));
1196
1336
*len = sdp_extract_seqtype(p, bufsize, &d->dtd, &seqlen);
1207
1347
1208
1348
p += *len;
1209
1349
bufsize -= *len;
1210
curr = prev = NULL;
1350
prev = NULL;
1211
1351
while (n < seqlen) {
1212
1352
int attrlen = 0;
1213
1353
curr = sdp_extract_attr(p, bufsize, &attrlen, rec);
1463
1603
1464
1604
value = sdp_data_value(tmp, NULL);
1465
1605
datatmp = sdp_data_alloc_with_length(tmp->dtd, value,
1466
tmp->unitSize);
1606
tmp->unitSize);
1467
1607
1468
1608
if (cur)
1469
1609
cur->next = datatmp;
1489
1629
sdp_attr_add_new(rec, data->attrId, data->dtd, val);
1490
1630
else
1491
1631
sdp_attr_add_new_with_length(rec, data->attrId,
1492
data->dtd, val, len);
1632
data->dtd, val, len);
1493
1633
}
1494
1634
1495
1635
sdp_record_t *sdp_copy_record(sdp_record_t *rec)
1591
1731
sdpTemplate.attrId = attrId;
1592
1732
p = sdp_list_find(rec->attrlist, &sdpTemplate, sdp_attrid_comp_func);
1593
1733
if (p)
1594
return (sdp_data_t *)p->data;
1734
return p->data;
1595
1735
}
1596
1736
return NULL;
1597
1737
}
1632
1772
uint8_t *rspbuf, uint32_t reqsize, uint32_t *rspsize)
1633
1773
{
1634
1774
int n;
1635
sdp_pdu_hdr_t *reqhdr = (sdp_pdu_hdr_t *)reqbuf;
1636
sdp_pdu_hdr_t *rsphdr = (sdp_pdu_hdr_t *)rspbuf;
1775
sdp_pdu_hdr_t *reqhdr = (sdp_pdu_hdr_t *) reqbuf;
1776
sdp_pdu_hdr_t *rsphdr = (sdp_pdu_hdr_t *) rspbuf;
1637
1777
1638
1778
SDPDBG("");
1639
1779
if (0 > sdp_send_req(session, reqbuf, reqsize)) {
1660
1800
sdp_list_t *q, *n = malloc(sizeof(sdp_list_t));
1661
1801
1662
1802
if (!n)
1663
return 0;
1803
return NULL;
1664
1804
1665
1805
n->data = d;
1666
1806
n->next = 0;
1698
1838
1699
1839
n = malloc(sizeof(sdp_list_t));
1700
1840
if (!n)
1701
return 0;
1841
return NULL;
1702
1842
n->data = d;
1703
1843
for (q = 0, p = list; p; q = p, p = p->next)
1704
1844
if (f(p->data, d) >= 0)
1755
1895
for (; list; list = list->next) {
1756
1896
sdp_list_t *p;
1757
1897
for (p = list->data; p; p = p->next) {
1758
sdp_data_t *seq = (sdp_data_t *) p->data;
1898
sdp_data_t *seq = p->data;
1759
1899
int port = __find_port(seq, proto);
1760
1900
if (port)
1761
1901
return port;
1769
1909
for (; list; list = list->next) {
1770
1910
sdp_list_t *p;
1771
1911
for (p = list->data; p; p = p->next) {
1772
sdp_data_t *seq = (sdp_data_t *) p->data;
1912
sdp_data_t *seq = p->data;
1773
1913
if (SDP_IS_UUID(seq->dtd) &&
1774
1914
sdp_uuid_to_proto(&seq->val.uuid) == proto)
1775
1915
return seq->next;
1834
1974
sdp_data_t *d;
1835
1975
for (d = sdpdata->val.dataseq; d; d = d->next) {
1836
1976
uuid_t *u;
1837
if (d->dtd < SDP_UUID16 || d->dtd > SDP_UUID128)
1977
if (d->dtd < SDP_UUID16 || d->dtd > SDP_UUID128) {
1978
errno = EINVAL;
1838
1979
goto fail;
1980
}
1839
1981
1840
1982
u = malloc(sizeof(uuid_t));
1983
if (!u)
1984
goto fail;
1985
1841
1986
memset(u, 0, sizeof(uuid_t));
1842
1987
*u = d->val.uuid;
1843
1988
*seqp = sdp_list_append(*seqp, u);
1846
1991
}
1847
1992
fail:
1848
1993
sdp_list_free(*seqp, free);
1849
errno = EINVAL;
1994
*seqp = NULL;
1850
1995
return -1;
1851
1996
}
1852
1997
1862
2007
len = sdp_list_len(seq);
1863
2008
if (!seq || len == 0)
1864
2009
return -1;
1865
dtds = (void **)malloc(len * sizeof(void *));
1866
values = (void **)malloc(len * sizeof(void *));
2010
dtds = malloc(len * sizeof(void *));
2011
if (!dtds)
2012
return -1;
2013
2014
values = malloc(len * sizeof(void *));
2015
if (!values) {
2016
free(dtds);
2017
return -1;
2018
}
2019
1867
2020
for (p = seq, i = 0; i < len; i++, p = p->next) {
1868
uuid_t *uuid = (uuid_t *)p->data;
2021
uuid_t *uuid = p->data;
1869
2022
if (uuid)
1870
2023
switch (uuid->type) {
1871
2024
case SDP_UUID16:
1915
2068
sdp_data_t *pCode = curr_data;
1916
2069
sdp_data_t *pEncoding = pCode->next;
1917
2070
sdp_data_t *pOffset = pEncoding->next;
1918
if (pCode && pEncoding && pOffset) {
2071
if (pEncoding && pOffset) {
1919
2072
lang = malloc(sizeof(sdp_lang_attr_t));
2073
if (!lang) {
2074
sdp_list_free(*langSeq, free);
2075
*langSeq = NULL;
2076
return -1;
2077
}
1920
2078
lang->code_ISO639 = pCode->val.uint16;
1921
2079
lang->encoding = pEncoding->val.uint16;
1922
2080
lang->base_offset = pOffset->val.uint16;
1958
2116
1959
2117
if (uuid != NULL) {
1960
2118
profDesc = malloc(sizeof(sdp_profile_desc_t));
2119
if (!profDesc) {
2120
sdp_list_free(*profDescSeq, free);
2121
*profDescSeq = NULL;
2122
return -1;
2123
}
1961
2124
profDesc->uuid = *uuid;
1962
2125
profDesc->version = version;
1963
2126
#ifdef SDP_DEBUG
2100
2263
const char *desc)
2101
2264
{
2102
2265
if (name)
2103
sdp_attr_add_new(rec, SDP_ATTR_SVCNAME_PRIMARY, SDP_TEXT_STR8,
2104
(void *)name);
2266
sdp_attr_add_new(rec, SDP_ATTR_SVCNAME_PRIMARY,
2267
SDP_TEXT_STR8, name);
2105
2268
if (prov)
2106
sdp_attr_add_new(rec, SDP_ATTR_PROVNAME_PRIMARY, SDP_TEXT_STR8,
2107
(void *)prov);
2269
sdp_attr_add_new(rec, SDP_ATTR_PROVNAME_PRIMARY,
2270
SDP_TEXT_STR8, prov);
2108
2271
if (desc)
2109
sdp_attr_add_new(rec, SDP_ATTR_SVCDESC_PRIMARY, SDP_TEXT_STR8,
2110
(void *)desc);
2272
sdp_attr_add_new(rec, SDP_ATTR_SVCDESC_PRIMARY,
2273
SDP_TEXT_STR8, desc);
2111
2274
}
2112
2275
2113
2276
static sdp_data_t *access_proto_to_dataseq(sdp_record_t *rec, sdp_list_t *proto)
2119
2282
sdp_list_t *p;
2120
2283
2121
2284
seqlen = sdp_list_len(proto);
2122
seqDTDs = (void **)malloc(seqlen * sizeof(void *));
2123
seqs = (void **)malloc(seqlen * sizeof(void *));
2285
seqDTDs = malloc(seqlen * sizeof(void *));
2286
if (!seqDTDs)
2287
return NULL;
2288
2289
seqs = malloc(seqlen * sizeof(void *));
2290
if (!seqs) {
2291
free(seqDTDs);
2292
return NULL;
2293
}
2294
2124
2295
for (i = 0, p = proto; p; p = p->next, i++) {
2125
sdp_list_t *elt = (sdp_list_t *)p->data;
2296
sdp_list_t *elt = p->data;
2126
2297
sdp_data_t *s;
2127
2298
uuid_t *uuid = NULL;
2128
2299
unsigned int pslen = 0;
2129
for (; elt && pslen < sizeof(dtds); elt = elt->next, pslen++) {
2130
sdp_data_t *d = (sdp_data_t *)elt->data;
2300
for (; elt && pslen < ARRAY_SIZE(dtds); elt = elt->next, pslen++) {
2301
sdp_data_t *d = elt->data;
2131
2302
dtds[pslen] = &d->dtd;
2132
2303
switch (d->dtd) {
2133
2304
case SDP_UUID16:
2192
2363
sdp_data_t *protos = NULL;
2193
2364
2194
2365
for (p = ap; p; p = p->next) {
2195
sdp_data_t *seq = access_proto_to_dataseq(rec,
2196
(sdp_list_t *) p->data);
2366
sdp_data_t *seq = access_proto_to_dataseq(rec, p->data);
2197
2367
protos = sdp_seq_append(protos, seq);
2198
2368
}
2199
2369
2208
2378
sdp_data_t *protos = NULL;
2209
2379
2210
2380
for (p = ap; p; p = p->next) {
2211
sdp_data_t *seq = access_proto_to_dataseq(rec,
2212
(sdp_list_t *) p->data);
2381
sdp_data_t *seq = access_proto_to_dataseq(rec, p->data);
2213
2382
protos = sdp_seq_append(protos, seq);
2214
2383
}
2215
2384
2239
2408
{
2240
2409
uint8_t uint16 = SDP_UINT16;
2241
2410
int status = 0, i = 0, seqlen = sdp_list_len(seq);
2242
void **dtds = (void **)malloc(3 * seqlen * sizeof(void *));
2243
void **values = (void **)malloc(3 * seqlen * sizeof(void *));
2411
void **dtds, **values;
2244
2412
const sdp_list_t *p;
2245
2413
2414
dtds = malloc(3 * seqlen * sizeof(void *));
2415
if (!dtds)
2416
return -1;
2417
2418
values = malloc(3 * seqlen * sizeof(void *));
2419
if (!values) {
2420
free(dtds);
2421
return -1;
2422
}
2423
2246
2424
for (p = seq; p; p = p->next) {
2247
sdp_lang_attr_t *lang = (sdp_lang_attr_t *)p->data;
2425
sdp_lang_attr_t *lang = p->data;
2248
2426
if (!lang) {
2249
2427
status = -1;
2250
2428
break;
2344
2522
uint8_t uuid128 = SDP_UUID128;
2345
2523
uint8_t uint16 = SDP_UINT16;
2346
2524
int i = 0, seqlen = sdp_list_len(profiles);
2347
void **seqDTDs = (void **)malloc(seqlen * sizeof(void *));
2348
void **seqs = (void **)malloc(seqlen * sizeof(void *));
2525
void **seqDTDs, **seqs;
2349
2526
const sdp_list_t *p;
2350
2527
2528
seqDTDs = malloc(seqlen * sizeof(void *));
2529
if (!seqDTDs)
2530
return -1;
2531
2532
seqs = malloc(seqlen * sizeof(void *));
2533
if (!seqs) {
2534
free(seqDTDs);
2535
return -1;
2536
}
2537
2351
2538
for (p = profiles; p; p = p->next) {
2352
2539
sdp_data_t *seq;
2353
2540
void *dtds[2], *values[2];
2354
sdp_profile_desc_t *profile = (sdp_profile_desc_t *)p->data;
2541
sdp_profile_desc_t *profile = p->data;
2355
2542
if (!profile) {
2356
2543
status = -1;
2357
2544
break;
2444
2631
* UUID comparison function
2445
2632
* returns 0 if uuidValue1 == uuidValue2 else -1
2446
2633
*/
2634
int sdp_uuid_cmp(const void *p1, const void *p2)
2635
{
2636
uuid_t *u1 = sdp_uuid_to_uuid128(p1);
2637
uuid_t *u2 = sdp_uuid_to_uuid128(p2);
2638
int ret;
2639
2640
ret = sdp_uuid128_cmp(u1, u2);
2641
2642
bt_free(u1);
2643
bt_free(u2);
2644
2645
return ret;
2646
}
2647
2648
/*
2649
* UUID comparison function
2650
* returns 0 if uuidValue1 == uuidValue2 else -1
2651
*/
2447
2652
int sdp_uuid16_cmp(const void *p1, const void *p2)
2448
2653
{
2449
const uuid_t *u1 = (const uuid_t *)p1;
2450
const uuid_t *u2 = (const uuid_t *)p2;
2654
const uuid_t *u1 = p1;
2655
const uuid_t *u2 = p2;
2451
2656
return memcmp(&u1->value.uuid16, &u2->value.uuid16, sizeof(uint16_t));
2452
2657
}
2453
2658
2457
2662
*/
2458
2663
int sdp_uuid128_cmp(const void *p1, const void *p2)
2459
2664
{
2460
const uuid_t *u1 = (const uuid_t *)p1;
2461
const uuid_t *u2 = (const uuid_t *)p2;
2665
const uuid_t *u1 = p1;
2666
const uuid_t *u2 = p2;
2462
2667
return memcmp(&u1->value.uuid128, &u2->value.uuid128, sizeof(uint128_t));
2463
2668
}
2464
2669
2467
2672
* yet to be implemented. Note that the input is in NBO in
2468
2673
* both 32 and 128 bit UUIDs and conversion is needed
2469
2674
*/
2470
void sdp_uuid16_to_uuid128(uuid_t *uuid128, uuid_t *uuid16)
2675
void sdp_uuid16_to_uuid128(uuid_t *uuid128, const uuid_t *uuid16)
2471
2676
{
2472
2677
/*
2473
2678
* We have a 16 bit value, which needs to be added to
2489
2694
memcpy(&uuid128->value.uuid128.data[2], &data1, 2);
2490
2695
}
2491
2696
2492
void sdp_uuid32_to_uuid128(uuid_t *uuid128, uuid_t *uuid32)
2697
void sdp_uuid32_to_uuid128(uuid_t *uuid128, const uuid_t *uuid32)
2493
2698
{
2494
2699
/*
2495
2700
* We have a 32 bit value, which needs to be added to
2511
2716
memcpy(&uuid128->value.uuid128.data[0], &data0, 4);
2512
2717
}
2513
2718
2514
uuid_t *sdp_uuid_to_uuid128(uuid_t *uuid)
2719
uuid_t *sdp_uuid_to_uuid128(const uuid_t *uuid)
2515
2720
{
2516
2721
uuid_t *uuid128 = bt_malloc(sizeof(uuid_t));
2722
2723
if (!uuid128)
2724
return NULL;
2725
2517
2726
memset(uuid128, 0, sizeof(uuid_t));
2518
2727
switch (uuid->type) {
2519
2728
case SDP_UUID128:
2585
2794
void sdp_append_to_buf(sdp_buf_t *dst, uint8_t *data, uint32_t len)
2586
2795
{
2587
2796
uint8_t *p = dst->data;
2588
uint8_t dtd = *(uint8_t *) p;
2797
uint8_t dtd = *p;
2589
2798
2590
2799
SDPDBG("Append src size: %d\n", len);
2591
2800
SDPDBG("Append dst size: %d\n", dst->data_size);
2592
2801
SDPDBG("Dst buffer size: %d\n", dst->buf_size);
2593
if (dst->data_size + len > dst->buf_size) {
2594
int need = SDP_PDU_CHUNK_SIZE * ((len / SDP_PDU_CHUNK_SIZE) + 1);
2595
dst->data = realloc(dst->data, dst->buf_size + need);
2596
2597
SDPDBG("Realloc'ing : %d\n", need);
2598
2599
if (dst->data == NULL) {
2600
SDPERR("Realloc fails \n");
2601
}
2602
dst->buf_size += need;
2603
}
2604
2802
if (dst->data_size == 0 && dtd == 0) {
2605
2803
/* create initial sequence */
2606
*(uint8_t *)p = SDP_SEQ8;
2804
*p = SDP_SEQ8;
2607
2805
p += sizeof(uint8_t);
2608
2806
dst->data_size += sizeof(uint8_t);
2609
2807
/* reserve space for sequence size */
2614
2812
memcpy(dst->data + dst->data_size, data, len);
2615
2813
dst->data_size += len;
2616
2814
2617
dtd = *(uint8_t *)dst->data;
2815
dtd = *(uint8_t *) dst->data;
2618
2816
if (dst->data_size > UCHAR_MAX && dtd == SDP_SEQ8) {
2619
2817
short offset = sizeof(uint8_t) + sizeof(uint8_t);
2620
2818
memmove(dst->data + offset + 1, dst->data + offset,
2621
2819
dst->data_size - offset);
2622
2820
p = dst->data;
2623
*(uint8_t *) p = SDP_SEQ16;
2821
*p = SDP_SEQ16;
2624
2822
p += sizeof(uint8_t);
2625
2823
dst->data_size += 1;
2626
2824
}
2642
2840
2643
2841
void sdp_append_to_pdu(sdp_buf_t *pdu, sdp_data_t *d)
2644
2842
{
2645
uint8_t buf[512];
2646
2843
sdp_buf_t append;
2647
2844
2648
2845
memset(&append, 0, sizeof(sdp_buf_t));
2649
append.data = buf;
2650
append.buf_size = sizeof(buf);
2651
append.data_size = 0;
2846
sdp_gen_buffer(&append, d);
2847
append.data = malloc(append.buf_size);
2848
if (!append.data)
2849
return;
2652
2850
2653
2851
sdp_set_attrid(&append, d->attrId);
2654
2852
sdp_gen_pdu(&append, d);
2655
2853
sdp_append_to_buf(pdu, append.data, append.data_size);
2854
free(append.data);
2656
2855
}
2657
2856
2658
2857
/*
2735
2934
}
2736
2935
2737
2936
end:
2738
if (req)
2739
free(req);
2740
2741
if (rsp)
2742
free(rsp);
2937
free(req);
2938
free(rsp);
2743
2939
2744
2940
return status;
2745
2941
}
2845
3041
status = -1;
2846
3042
}
2847
3043
end:
2848
if (reqbuf)
2849
free(reqbuf);
2850
2851
if (rspbuf)
2852
free(rspbuf);
3044
free(reqbuf);
3045
free(rspbuf);
2853
3046
2854
3047
return status;
2855
3048
}
2953
3146
status = -1;
2954
3147
}
2955
3148
end:
2956
if (reqbuf)
2957
free(reqbuf);
2958
if (rspbuf)
2959
free(rspbuf);
3149
free(reqbuf);
3150
free(rspbuf);
2960
3151
return status;
2961
3152
}
2962
3153
2968
3159
sdp_record_t *sdp_record_alloc()
2969
3160
{
2970
3161
sdp_record_t *rec = malloc(sizeof(sdp_record_t));
2971
memset((void *)rec, 0, sizeof(sdp_record_t));
3162
3163
if (!rec)
3164
return NULL;
3165
3166
memset(rec, 0, sizeof(sdp_record_t));
2972
3167
rec->handle = 0xffffffff;
2973
3168
return rec;
2974
3169
}
2978
3173
*/
2979
3174
void sdp_record_free(sdp_record_t *rec)
2980
3175
{
2981
sdp_list_free(rec->attrlist, (sdp_free_func_t)sdp_data_free);
3176
sdp_list_free(rec->attrlist, (sdp_free_func_t) sdp_data_free);
2982
3177
sdp_list_free(rec->pattern, free);
2983
3178
free(rec);
2984
3179
}
2987
3182
{
2988
3183
uuid_t *uuid128 = sdp_uuid_to_uuid128(uuid);
2989
3184
2990
SDPDBG("SvcRec : 0x%lx\n", (unsigned long)rec);
2991
3185
SDPDBG("Elements in target pattern : %d\n", sdp_list_len(rec->pattern));
2992
SDPDBG("Trying to add : 0x%lx\n", (unsigned long)uuid128);
3186
SDPDBG("Trying to add : 0x%lx\n", (unsigned long) uuid128);
2993
3187
2994
3188
if (sdp_list_find(rec->pattern, uuid128, sdp_uuid128_cmp) == NULL)
2995
3189
rec->pattern = sdp_list_insert_sorted(rec->pattern, uuid128, sdp_uuid128_cmp);
3050
3244
// Fill up the value and the dtd arrays
3051
3245
SDPDBG("");
3052
3246
3053
memset(&buf, 0, sizeof(sdp_buf_t));
3054
buf.data = malloc(512);
3055
buf.buf_size = 512;
3056
3057
if (!buf.data)
3058
return -ENOMEM;
3059
3060
3247
SDPDBG("Seq length : %d\n", seqlen);
3061
3248
3062
3249
types = malloc(seqlen * sizeof(void *));
3250
if (!types)
3251
return -ENOMEM;
3252
3063
3253
values = malloc(seqlen * sizeof(void *));
3254
if (!values) {
3255
free(types);
3256
return -ENOMEM;
3257
}
3258
3064
3259
for (i = 0; i < seqlen; i++) {
3065
3260
void *data = seq->data;
3066
3261
types[i] = &dtd;
3071
3266
}
3072
3267
3073
3268
dataseq = sdp_seq_alloc(types, values, seqlen);
3269
if (!dataseq) {
3270
free(types);
3271
free(values);
3272
return -ENOMEM;
3273
}
3274
3275
memset(&buf, 0, sizeof(sdp_buf_t));
3276
sdp_gen_buffer(&buf, dataseq);
3277
buf.data = malloc(buf.buf_size);
3278
3279
if (!buf.data) {
3280
sdp_data_free(dataseq);
3281
free(types);
3282
free(values);
3283
return -ENOMEM;
3284
}
3285
3074
3286
SDPDBG("Data Seq : 0x%p\n", seq);
3075
3287
seqlen = sdp_gen_pdu(&buf, dataseq);
3076
3288
SDPDBG("Copying : %d\n", buf.data_size);
3086
3298
3087
3299
static int gen_searchseq_pdu(uint8_t *dst, const sdp_list_t *seq)
3088
3300
{
3089
uuid_t *uuid = (uuid_t *) seq->data;
3301
uuid_t *uuid = seq->data;
3090
3302
return gen_dataseq_pdu(dst, seq, uuid->type);
3091
3303
}
3092
3304
3117
3329
}
3118
3330
3119
3331
/*
3120
* This is a service search request.
3332
* This is a service search request.
3121
3333
*
3122
3334
* INPUT :
3123
3335
*
3271
3483
} while (cstate);
3272
3484
3273
3485
end:
3274
if (reqbuf)
3275
free(reqbuf);
3276
if (rspbuf)
3277
free(rspbuf);
3486
free(reqbuf);
3487
free(rspbuf);
3278
3488
3279
3489
return status;
3280
3490
}
3281
3491
3282
3492
/*
3283
* This is a service attribute request.
3493
* This is a service attribute request.
3284
3494
*
3285
3495
* INPUT :
3286
3496
*
3301
3511
*
3302
3512
* sdp_list_t *attrid
3303
3513
* Singly linked list containing attribute identifiers desired.
3304
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
3514
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
3305
3515
* or a uint32_t(attrSpec=SDP_ATTR_REQ_RANGE)
3306
3516
*
3307
3517
* OUTPUT :
3311
3521
* !0:
3312
3522
* The service record
3313
3523
*/
3314
sdp_record_t *sdp_service_attr_req(sdp_session_t *session, uint32_t handle,
3524
sdp_record_t *sdp_service_attr_req(sdp_session_t *session, uint32_t handle,
3315
3525
sdp_attrreq_type_t reqtype, const sdp_list_t *attrids)
3316
3526
{
3317
int status = 0;
3318
3527
uint32_t reqsize = 0, _reqsize;
3319
3528
uint32_t rspsize = 0, rsp_count;
3320
3529
int attr_list_len = 0;
3330
3539
3331
3540
if (reqtype != SDP_ATTR_REQ_INDIVIDUAL && reqtype != SDP_ATTR_REQ_RANGE) {
3332
3541
errno = EINVAL;
3333
return 0;
3542
return NULL;
3334
3543
}
3335
3544
3545
memset(&rsp_concat_buf, 0, sizeof(sdp_buf_t));
3546
3336
3547
reqbuf = malloc(SDP_REQ_BUFFER_SIZE);
3337
3548
rspbuf = malloc(SDP_RSP_BUFFER_SIZE);
3338
3549
if (!reqbuf || !rspbuf) {
3339
3550
errno = ENOMEM;
3340
status = -1;
3341
3551
goto end;
3342
3552
}
3343
memset((char *) &rsp_concat_buf, 0, sizeof(sdp_buf_t));
3344
3553
reqhdr = (sdp_pdu_hdr_t *) reqbuf;
3345
3554
reqhdr->pdu_id = SDP_SVC_ATTR_REQ;
3346
3555
3358
3567
pdata += sizeof(uint16_t);
3359
3568
3360
3569
// get attr seq PDU form
3361
seqlen = gen_attridseq_pdu(pdata, attrids,
3570
seqlen = gen_attridseq_pdu(pdata, attrids,
3362
3571
reqtype == SDP_ATTR_REQ_INDIVIDUAL? SDP_UINT16 : SDP_UINT32);
3363
3572
if (seqlen == -1) {
3364
3573
errno = EINVAL;
3365
status = -1;
3366
3574
goto end;
3367
3575
}
3368
3576
pdata += seqlen;
3374
3582
_reqsize = reqsize;
3375
3583
3376
3584
do {
3585
int status;
3586
3377
3587
// add NULL continuation state
3378
3588
reqsize = _reqsize + copy_cstate(_pdata,
3379
3589
SDP_REQ_BUFFER_SIZE - _reqsize, cstate);
3388
3598
3389
3599
if (rspsize < sizeof(sdp_pdu_hdr_t)) {
3390
3600
SDPERR("Unexpected end of packet");
3391
status = -1;
3392
3601
goto end;
3393
3602
}
3394
3603
3395
rsp_count = 0;
3396
3604
rsphdr = (sdp_pdu_hdr_t *) rspbuf;
3397
3605
if (rsphdr->pdu_id == SDP_ERROR_RSP) {
3398
3606
SDPDBG("PDU ID : 0x%x\n", rsphdr->pdu_id);
3399
status = -1;
3400
3607
goto end;
3401
3608
}
3402
3609
pdata = rspbuf + sizeof(sdp_pdu_hdr_t);
3404
3611
3405
3612
if (pdata_len < sizeof(uint16_t)) {
3406
3613
SDPERR("Unexpected end of packet");
3407
status = -1;
3408
3614
goto end;
3409
3615
}
3410
3616
3416
3622
// if continuation state set need to re-issue request before parsing
3417
3623
if (pdata_len < rsp_count + sizeof(uint8_t)) {
3418
3624
SDPERR("Unexpected end of packet: continuation state data missing");
3419
status = -1;
3420
3625
goto end;
3421
3626
}
3422
3627
cstate_len = *(uint8_t *) (pdata + rsp_count);
3426
3631
SDPDBG("sdp_cstate_t length : %d\n", cstate_len);
3427
3632
3428
3633
/*
3429
* a split response: concatenate intermediate responses
3634
* a split response: concatenate intermediate responses
3430
3635
* and the last one (which has cstate_len == 0)
3431
3636
*/
3432
3637
if (cstate_len > 0 || rsp_concat_buf.data_size != 0) {
3450
3655
pdata_len = rsp_concat_buf.data_size;
3451
3656
}
3452
3657
rec = sdp_extract_pdu(pdata, pdata_len, &scanned);
3453
3454
if (!rec)
3455
status = -1;
3456
3658
}
3457
3659
3458
3660
end:
3459
if (reqbuf)
3460
free(reqbuf);
3461
if (rsp_concat_buf.data)
3462
free(rsp_concat_buf.data);
3463
if (rspbuf)
3464
free(rspbuf);
3661
free(reqbuf);
3662
free(rsp_concat_buf.data);
3663
free(rspbuf);
3465
3664
return rec;
3466
3665
}
3467
3666
3547
3746
3548
3747
/*
3549
3748
* This function starts an asynchronous service search request.
3550
* The incomming and outgoing data are stored in the transaction structure
3749
* The incomming and outgoing data are stored in the transaction structure
3551
3750
* buffers. When there is incomming data the sdp_process function must be
3552
3751
* called to get the data and handle the continuation state.
3553
3752
*
3584
3783
3585
3784
t = session->priv;
3586
3785
3587
/* check if the buffer is already allocated */
3588
if (t->rsp_concat_buf.data)
3589
free(t->rsp_concat_buf.data);
3786
/* clean possible allocated buffer */
3787
free(t->rsp_concat_buf.data);
3590
3788
memset(&t->rsp_concat_buf, 0, sizeof(sdp_buf_t));
3591
3789
3592
3790
if (!t->reqbuf) {
3632
3830
return 0;
3633
3831
end:
3634
3832
3635
if (t->reqbuf) {
3636
free(t->reqbuf);
3637
t->reqbuf = NULL;
3638
}
3833
free(t->reqbuf);
3834
t->reqbuf = NULL;
3639
3835
3640
3836
return -1;
3641
3837
}
3642
3838
3643
3839
/*
3644
3840
* This function starts an asynchronous service attribute request.
3645
* The incomming and outgoing data are stored in the transaction structure
3841
* The incomming and outgoing data are stored in the transaction structure
3646
3842
* buffers. When there is incomming data the sdp_process function must be
3647
3843
* called to get the data and handle the continuation state.
3648
3844
*
3667
3863
*
3668
3864
* sdp_list_t *attrid_list
3669
3865
* Singly linked list containing attribute identifiers desired.
3670
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
3866
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
3671
3867
* or a uint32_t(attrSpec=SDP_ATTR_REQ_RANGE)
3672
3868
*
3673
3869
* OUTPUT :
3688
3884
3689
3885
t = session->priv;
3690
3886
3691
/* check if the buffer is already allocated */
3692
if (t->rsp_concat_buf.data)
3693
free(t->rsp_concat_buf.data);
3887
/* clean possible allocated buffer */
3888
free(t->rsp_concat_buf.data);
3694
3889
memset(&t->rsp_concat_buf, 0, sizeof(sdp_buf_t));
3695
3890
3696
3891
if (!t->reqbuf) {
3746
3941
return 0;
3747
3942
end:
3748
3943
3749
if (t->reqbuf) {
3750
free(t->reqbuf);
3751
t->reqbuf = NULL;
3752
}
3944
free(t->reqbuf);
3945
t->reqbuf = NULL;
3753
3946
3754
3947
return -1;
3755
3948
}
3783
3976
*
3784
3977
* sdp_list_t *attrid_list
3785
3978
* Singly linked list containing attribute identifiers desired.
3786
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
3979
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
3787
3980
* or a uint32_t(attrSpec=SDP_ATTR_REQ_RANGE)
3788
3981
*
3789
3982
3803
3996
3804
3997
t = session->priv;
3805
3998
3806
/* check if the buffer is already allocated */
3807
if (t->rsp_concat_buf.data)
3808
free(t->rsp_concat_buf.data);
3999
/* clean possible allocated buffer */
4000
free(t->rsp_concat_buf.data);
3809
4001
memset(&t->rsp_concat_buf, 0, sizeof(sdp_buf_t));
3810
4002
3811
4003
if (!t->reqbuf) {
3865
4057
return 0;
3866
4058
end:
3867
4059
3868
if (t->reqbuf) {
3869
free(t->reqbuf);
3870
t->reqbuf = NULL;
3871
}
4060
free(t->reqbuf);
4061
t->reqbuf = NULL;
3872
4062
3873
4063
return -1;
3874
4064
}
4001
4191
pdata += sizeof(uint16_t); /* point to csrc */
4002
4192
4003
4193
/* the first csrc contains the sum of partial csrc responses */
4004
*pcsrc += bt_get_unaligned((uint16_t *) pdata);
4194
*pcsrc += bt_get_unaligned((uint16_t *) pdata);
4005
4195
4006
4196
pdata += sizeof(uint16_t); /* point to the first handle */
4007
4197
rsp_count = csrc * 4;
4012
4202
case SDP_SVC_SEARCH_ATTR_RSP:
4013
4203
rsp_count = ntohs(bt_get_unaligned((uint16_t *) pdata));
4014
4204
SDPDBG("Attrlist byte count : %d\n", rsp_count);
4015
4016
/*
4205
4206
/*
4017
4207
* Number of bytes in the AttributeLists parameter(without
4018
4208
* continuation state) + AttributeListsByteCount field size.
4019
4209
*/
4039
4229
4040
4230
SDPDBG("Cstate length : %d\n", pcstate->length);
4041
4231
4042
/*
4232
/*
4043
4233
* Check out of bound. Continuation state must have at least
4044
4234
* 1 byte: ZERO to indicate that it is not a partial response.
4045
4235
*/
4073
4263
4074
4264
// set the request header's param length
4075
4265
reqhdr->plen = htons(reqsize - sizeof(sdp_pdu_hdr_t));
4076
4266
4077
4267
if (sdp_send_req(session, t->reqbuf, reqsize) < 0) {
4078
4268
SDPERR("Error sendind data:%s(%d)", strerror(errno), errno);
4079
4269
status = 0xffff;
4093
4283
t->cb(pdu_id, status, pdata, size, t->udata);
4094
4284
}
4095
4285
4096
if (rspbuf)
4097
free(rspbuf);
4286
free(rspbuf);
4098
4287
4099
4288
return err;
4100
4289
}
4124
4313
*
4125
4314
* sdp_list_t *attrids
4126
4315
* Singly linked list containing attribute identifiers desired.
4127
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
4316
* Every element is either a uint16_t(attrSpec = SDP_ATTR_REQ_INDIVIDUAL)
4128
4317
* or a uint32_t(attrSpec=SDP_ATTR_REQ_RANGE)
4129
4318
*
4130
4319
* OUTPUT :
4160
4349
errno = EINVAL;
4161
4350
return -1;
4162
4351
}
4352
4353
memset(&rsp_concat_buf, 0, sizeof(sdp_buf_t));
4354
4163
4355
reqbuf = malloc(SDP_REQ_BUFFER_SIZE);
4164
4356
rspbuf = malloc(SDP_RSP_BUFFER_SIZE);
4165
4357
if (!reqbuf || !rspbuf) {
4168
4360
goto end;
4169
4361
}
4170
4362
4171
memset((char *)&rsp_concat_buf, 0, sizeof(sdp_buf_t));
4172
4363
reqhdr = (sdp_pdu_hdr_t *) reqbuf;
4173
4364
reqhdr->pdu_id = SDP_SVC_SEARCH_ATTR_REQ;
4174
4365
4326
4517
}
4327
4518
}
4328
4519
end:
4329
if (rsp_concat_buf.data)
4330
free(rsp_concat_buf.data);
4331
if (reqbuf)
4332
free(reqbuf);
4333
if (rspbuf)
4334
free(rspbuf);
4520
free(rsp_concat_buf.data);
4521
free(reqbuf);
4522
free(rspbuf);
4335
4523
return status;
4336
4524
}
4337
4525
4362
4550
t = session->priv;
4363
4551
4364
4552
if (t) {
4365
if (t->reqbuf)
4366
free(t->reqbuf);
4553
free(t->reqbuf);
4367
4554
4368
if (t->rsp_concat_buf.data)
4369
free(t->rsp_concat_buf.data);
4555
free(t->rsp_concat_buf.data);
4370
4556
4371
4557
free(t);
4372
4558
}
4391
4577
sa.sun_family = AF_UNIX;
4392
4578
strcpy(sa.sun_path, SDP_UNIX_PATH);
4393
4579
4394
return connect(session->sock, (struct sockaddr *)&sa, sizeof(sa));
4580
return connect(session->sock, (struct sockaddr *) &sa, sizeof(sa));
4395
4581
}
4396
4582
4397
4583
static int sdp_connect_l2cap(const bdaddr_t *src,
4473
4659
err = errno;
4474
4660
if (session->sock >= 0)
4475
4661
close(session->sock);
4476
if (session->priv)
4477
free(session->priv);
4662
free(session->priv);
4478
4663
free(session);
4479
4664
errno = err;
4480
4665
4490
4675
{
4491
4676
return session->tid++;
4492
4677
}
4678
4679
/*
4680
* Set the supported features
4681
*/
4682
int sdp_set_supp_feat(sdp_record_t *rec, const sdp_list_t *sf)
4683
{
4684
const sdp_list_t *p, *r;
4685
sdp_data_t *feat, *seq_feat;
4686
int seqlen, i;
4687
void **seqDTDs, **seqVals;
4688
4689
seqlen = sdp_list_len(sf);
4690
seqDTDs = malloc(seqlen * sizeof(void *));
4691
if (!seqDTDs)
4692
return -1;
4693
seqVals = malloc(seqlen * sizeof(void *));
4694
if (!seqVals) {
4695
free(seqDTDs);
4696
return -1;
4697
}
4698
4699
for (p = sf, i = 0; p; p = p->next, i++) {
4700
int plen, j;
4701
void **dtds, **vals;
4702
int *lengths;
4703
4704
plen = sdp_list_len(p->data);
4705
dtds = malloc(plen * sizeof(void *));
4706
if (!dtds)
4707
goto fail;
4708
vals = malloc(plen * sizeof(void *));
4709
if (!vals) {
4710
free(dtds);
4711
goto fail;
4712
}
4713
lengths = malloc(plen * sizeof(int *));
4714
if (!lengths) {
4715
free(dtds);
4716
free(vals);
4717
goto fail;
4718
}
4719
for (r = p->data, j = 0; r; r = r->next, j++) {
4720
sdp_data_t *data = (sdp_data_t*)r->data;
4721
dtds[j] = &data->dtd;
4722
switch (data->dtd) {
4723
case SDP_URL_STR8:
4724
case SDP_URL_STR16:
4725
case SDP_TEXT_STR8:
4726
case SDP_TEXT_STR16:
4727
vals[j] = data->val.str;
4728
lengths[j] = data->unitSize - sizeof(uint8_t);
4729
break;
4730
case SDP_ALT8:
4731
case SDP_ALT16:
4732
case SDP_ALT32:
4733
case SDP_SEQ8:
4734
case SDP_SEQ16:
4735
case SDP_SEQ32:
4736
vals[j] = data->val.dataseq;
4737
lengths[j] = 0;
4738
break;
4739
default:
4740
vals[j] = &data->val;
4741
lengths[j] = 0;
4742
break;
4743
}
4744
}
4745
feat = sdp_seq_alloc_with_length(dtds, vals, lengths, plen);
4746
free(dtds);
4747
free(vals);
4748
free(lengths);
4749
if (!feat)
4750
goto fail;
4751
seqDTDs[i] = &feat->dtd;
4752
seqVals[i] = feat;
4753
}
4754
seq_feat = sdp_seq_alloc(seqDTDs, seqVals, seqlen);
4755
if (!seq_feat)
4756
goto fail;
4757
sdp_attr_replace(rec, SDP_ATTR_SUPPORTED_FEATURES_LIST, seq_feat);
4758
4759
free(seqVals);
4760
free(seqDTDs);
4761
return 0;
4762
4763
fail:
4764
free(seqVals);
4765
free(seqDTDs);
4766
return -1;
4767
}
4768
4769
/*
4770
* Get the supported features
4771
* If an error occurred -1 is returned and errno is set
4772
*/
4773
int sdp_get_supp_feat(const sdp_record_t *rec, sdp_list_t **seqp)
4774
{
4775
sdp_data_t *sdpdata, *d;
4776
sdp_list_t *tseq;
4777
tseq = NULL;
4778
4779
sdpdata = sdp_data_get(rec, SDP_ATTR_SUPPORTED_FEATURES_LIST);
4780
4781
if (!sdpdata || sdpdata->dtd < SDP_SEQ8 || sdpdata->dtd > SDP_SEQ32)
4782
return sdp_get_uuidseq_attr(rec,
4783
SDP_ATTR_SUPPORTED_FEATURES_LIST, seqp);
4784
4785
for (d = sdpdata->val.dataseq; d; d = d->next) {
4786
sdp_data_t *dd;
4787
sdp_list_t *subseq;
4788
4789
if (d->dtd < SDP_SEQ8 || d->dtd > SDP_SEQ32)
4790
goto fail;
4791
4792
subseq = NULL;
4793
4794
for (dd = d->val.dataseq; dd; dd = dd->next) {
4795
sdp_data_t *data;
4796
void *val;
4797
int length;
4798
4799
switch (dd->dtd) {
4800
case SDP_URL_STR8:
4801
case SDP_URL_STR16:
4802
case SDP_TEXT_STR8:
4803
case SDP_TEXT_STR16:
4804
val = dd->val.str;
4805
length = dd->unitSize - sizeof(uint8_t);
4806
break;
4807
case SDP_UINT8:
4808
case SDP_UINT16:
4809
val = &dd->val;
4810
length = 0;
4811
break;
4812
default:
4813
goto fail;
4814
}
4815
4816
data = sdp_data_alloc_with_length(dd->dtd, val, length);
4817
if (data)
4818
subseq = sdp_list_append(subseq, data);
4819
}
4820
tseq = sdp_list_append(tseq, subseq);
4821
}
4822
*seqp = tseq;
4823
return 0;
4824
4825
fail:
4826
while (tseq) {
4827
sdp_list_t * next;
4828
4829
next = tseq->next;
4830
sdp_list_free(tseq, free);
4831
tseq = next;
4832
}
4833
errno = EINVAL;
4834
return -1;
4835
}
4836
Loggerhead is a web-based interface for Breezy
Version: 2.0.1