1 /* $NetBSD: sdp_session.c,v 1.3 2010/11/13 19:43:56 plunky Exp $ */
2
3 /*-
4 * Copyright (c) 2009 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Iain Hibbert.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #include <sys/cdefs.h>
33 __RCSID("$NetBSD: sdp_session.c,v 1.3 2010/11/13 19:43:56 plunky Exp $");
34
35 #include <sys/socket.h>
36 #include <sys/un.h>
37
38 #include <errno.h>
39 #include <sdp.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <unistd.h>
43
44 #include "sdp-int.h"
45
46 /*
47 * open session with remote Bluetooth SDP server
48 */
49 struct sdp_session *
_sdp_open(const bdaddr_t * laddr,const bdaddr_t * raddr)50 _sdp_open(const bdaddr_t *laddr, const bdaddr_t *raddr)
51 {
52 struct sdp_session * ss;
53 struct sockaddr_bt sa;
54 struct linger li;
55 socklen_t len;
56
57 ss = calloc(1, sizeof(struct sdp_session));
58 if (ss == NULL)
59 goto fail;
60
61 ss->s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
62 if (ss->s == -1)
63 goto fail;
64
65 memset(&li, 0, sizeof(li));
66 li.l_onoff = 1;
67 li.l_linger = 5;
68 if (setsockopt(ss->s, SOL_SOCKET, SO_LINGER, &li, sizeof(li)) == -1)
69 goto fail;
70
71 if (laddr == NULL)
72 laddr = BDADDR_ANY;
73
74 memset(&sa, 0, sizeof(sa));
75 sa.bt_len = sizeof(sa);
76 sa.bt_family = AF_BLUETOOTH;
77 bdaddr_copy(&sa.bt_bdaddr, laddr);
78 if (bind(ss->s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
79 goto fail;
80
81 sa.bt_psm = L2CAP_PSM_SDP;
82 bdaddr_copy(&sa.bt_bdaddr, raddr);
83 if (connect(ss->s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
84 goto fail;
85
86 len = sizeof(ss->imtu);
87 if (getsockopt(ss->s, BTPROTO_L2CAP, SO_L2CAP_IMTU, &ss->imtu, &len) == -1)
88 goto fail;
89
90 ss->ibuf = malloc((size_t)(ss->imtu));
91 if (ss->ibuf == NULL)
92 goto fail;
93
94 return ss;
95
96 fail:
97 _sdp_close(ss);
98 return NULL;
99 }
100
101 /*
102 * open session with local SDP server
103 */
104 struct sdp_session *
_sdp_open_local(const char * control)105 _sdp_open_local(const char *control)
106 {
107 struct sdp_session * ss;
108 struct sockaddr_un sa;
109
110 ss = calloc(1, sizeof(struct sdp_session));
111 if (ss == NULL)
112 goto fail;
113
114 ss->s = socket(PF_LOCAL, SOCK_STREAM, 0);
115 if (ss->s == -1)
116 goto fail;
117
118 if (control == NULL)
119 control = SDP_LOCAL_PATH;
120
121 memset(&sa, 0, sizeof(sa));
122 sa.sun_len = sizeof(sa);
123 sa.sun_family = AF_LOCAL;
124 strlcpy(sa.sun_path, control, sizeof(sa.sun_path));
125 if (connect(ss->s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
126 goto fail;
127
128 ss->imtu = L2CAP_MTU_DEFAULT;
129
130 ss->ibuf = malloc((size_t)(ss->imtu));
131 if (ss->ibuf == NULL)
132 goto fail;
133
134 return ss;
135
136 fail:
137 _sdp_close(ss);
138 return NULL;
139 }
140
141 /*
142 * close session and release all resources
143 */
144 void
_sdp_close(struct sdp_session * ss)145 _sdp_close(struct sdp_session *ss)
146 {
147
148 if (ss == NULL)
149 return;
150
151 if (ss->s != -1)
152 close(ss->s);
153
154 if (ss->ibuf != NULL)
155 free(ss->ibuf);
156
157 if (ss->rbuf != NULL)
158 free(ss->rbuf);
159
160 free(ss);
161 }
162
163 /*
164 * internal function; send a PDU on session
165 *
166 * caller provides an iovec array with an empty slot at the beginning for
167 * PDU header, num is total iovec count.
168 */
169 bool
_sdp_send_pdu(struct sdp_session * ss,uint8_t pid,struct iovec * iov,int num)170 _sdp_send_pdu(struct sdp_session *ss, uint8_t pid, struct iovec *iov, int num)
171 {
172 sdp_pdu_t pdu;
173 ssize_t len, nw;
174 int i;
175
176 for (len = 0, i = 1; i < num; i++)
177 len += iov[i].iov_len;
178
179 if (len > UINT16_MAX) {
180 errno = EMSGSIZE;
181 return false;
182 }
183
184 ss->tid += 1;
185
186 pdu.pid = pid;
187 pdu.tid = htobe16(ss->tid);
188 pdu.len = htobe16(len);
189
190 iov[0].iov_base = &pdu;
191 iov[0].iov_len = sizeof(pdu);
192
193 do {
194 nw = writev(ss->s, iov, num);
195 } while (nw == -1 && errno == EINTR);
196
197 if ((size_t)nw != sizeof(pdu) + len) {
198 errno = EIO;
199 return false;
200 }
201
202 return true;
203 }
204
205 /*
206 * internal function; receive a PDU on session
207 *
208 * validate the PDU and transaction IDs and data length, stores
209 * received data in the session incoming buffer.
210 */
211 ssize_t
_sdp_recv_pdu(struct sdp_session * ss,uint8_t pid)212 _sdp_recv_pdu(struct sdp_session *ss, uint8_t pid)
213 {
214 struct iovec iov[2];
215 sdp_pdu_t pdu;
216 ssize_t nr;
217
218 iov[0].iov_base = &pdu;
219 iov[0].iov_len = sizeof(pdu);
220
221 iov[1].iov_base = ss->ibuf;
222 iov[1].iov_len = ss->imtu;
223
224 do {
225 nr = readv(ss->s, iov, __arraycount(iov));
226 } while (nr == -1 && errno == EINTR);
227
228 if (nr == -1)
229 return -1;
230
231 if ((size_t)nr < sizeof(pdu)) {
232 errno = EIO;
233 return -1;
234 }
235
236 pdu.tid = be16toh(pdu.tid);
237 pdu.len = be16toh(pdu.len);
238
239 if (pid != pdu.pid
240 || ss->tid != pdu.tid
241 || (size_t)nr != sizeof(pdu) + pdu.len) {
242 if (pdu.pid == SDP_PDU_ERROR_RESPONSE
243 && pdu.len == sizeof(uint16_t))
244 errno = _sdp_errno(be16dec(ss->ibuf));
245 else
246 errno = EIO;
247
248 return -1;
249 }
250
251 return pdu.len;
252 }
253
254 /*
255 * translate ErrorCode to errno
256 */
257 int
_sdp_errno(uint16_t ec)258 _sdp_errno(uint16_t ec)
259 {
260
261 switch (ec) {
262 case SDP_ERROR_CODE_INVALID_SERVICE_RECORD_HANDLE:
263 return ENOATTR;
264
265 case SDP_ERROR_CODE_INVALID_SDP_VERSION:
266 case SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX:
267 case SDP_ERROR_CODE_INVALID_PDU_SIZE:
268 case SDP_ERROR_CODE_INVALID_CONTINUATION_STATE:
269 case SDP_ERROR_CODE_INSUFFICIENT_RESOURCES:
270 default:
271 return EIO;
272 }
273 }
274