xref: /dragonfly/sys/netbt/l2cap_socket.c (revision 8a7bdfea) 
1 /* $DragonFly: src/sys/netbt/l2cap_socket.c,v 1.2 2008/03/18 13:41:42 hasso Exp $ */
2 /* $OpenBSD: l2cap_socket.c,v 1.1 2007/06/01 02:46:11 uwe Exp $ */
3 /* $NetBSD: l2cap_socket.c,v 1.7 2007/04/21 06:15:23 plunky Exp $ */
4 
5 /*-
6  * Copyright (c) 2005 Iain Hibbert.
7  * Copyright (c) 2006 Itronix Inc.
8  * All rights reserved.
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  * 3. The name of Itronix Inc. may not be used to endorse
19  *    or promote products derived from this software without specific
20  *    prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY
26  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
27  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
29  * ON ANY THEORY OF LIABILITY, WHETHER IN
30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  */
34 
35 #include <sys/cdefs.h>
36 
37 /* load symbolic names */
38 #ifdef BLUETOOTH_DEBUG
39 #define PRUREQUESTS
40 #define PRCOREQUESTS
41 #endif
42 
43 #include <sys/param.h>
44 #include <sys/domain.h>
45 #include <sys/kernel.h>
46 #include <sys/mbuf.h>
47 #include <sys/proc.h>
48 #include <sys/protosw.h>
49 #include <sys/socket.h>
50 #include <sys/socketvar.h>
51 #include <sys/systm.h>
52 #include <vm/vm_zone.h>
53 
54 #include <netbt/bluetooth.h>
55 #include <netbt/hci.h>		/* XXX for EPASSTHROUGH */
56 #include <netbt/l2cap.h>
57 
58 /*
59  * L2CAP Sockets
60  *
61  *	SOCK_SEQPACKET - normal L2CAP connection
62  *
63  *	SOCK_DGRAM - connectionless L2CAP - XXX not yet
64  */
65 
66 static void l2cap_connecting(void *);
67 static void l2cap_connected(void *);
68 static void l2cap_disconnected(void *, int);
69 static void *l2cap_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
70 static void l2cap_complete(void *, int);
71 static void l2cap_linkmode(void *, int);
72 static void l2cap_input(void *, struct mbuf *);
73 
74 static const struct btproto l2cap_proto = {
75 	l2cap_connecting,
76 	l2cap_connected,
77 	l2cap_disconnected,
78 	l2cap_newconn,
79 	l2cap_complete,
80 	l2cap_linkmode,
81 	l2cap_input,
82 };
83 
84 /* sysctl variables */
85 int l2cap_sendspace = 4096;
86 int l2cap_recvspace = 4096;
87 
88 /*
89  * l2cap_ctloutput(request, socket, level, optname, opt)
90  *
91  *	Apply configuration commands to channel. This corresponds to
92  *	"Reconfigure Channel Request" in the L2CAP specification.
93  */
94 int
95 l2cap_ctloutput(struct socket *so, struct sockopt *sopt)
96 {
97 	struct l2cap_channel *pcb = (struct l2cap_channel *) so->so_pcb;
98 	struct mbuf *m;
99 	int err = 0;
100 
101 #ifdef notyet			/* XXX */
102 	DPRINTFN(2, "%s\n", prcorequests[req]);
103 #endif
104 
105 	if (pcb == NULL)
106 		return EINVAL;
107 
108 	if (sopt->sopt_level != BTPROTO_L2CAP)
109 		return ENOPROTOOPT;
110 
111 	switch(sopt->sopt_dir) {
112 	case PRCO_GETOPT:
113 		m = m_get(M_NOWAIT, MT_DATA);
114 		if (m == NULL) {
115 		    err = ENOMEM;
116 		    break;
117 		}
118 		m->m_len = l2cap_getopt(pcb, sopt->sopt_name, mtod(m, void *));
119 		if (m->m_len == 0) {
120 			m_freem(m);
121 			m = NULL;
122 			err = ENOPROTOOPT;
123 		}
124 		err = sooptcopyout(sopt, mtod(m, void *), m->m_len);
125 		break;
126 
127 	case PRCO_SETOPT:
128 		err = l2cap_setopt2(pcb, sopt->sopt_name, so, sopt);
129 		break;
130 
131 	default:
132 		err = ENOPROTOOPT;
133 		break;
134 	}
135 
136 	return err;
137 }
138 
139 /**********************************************************************
140  *
141  *	L2CAP Protocol socket callbacks
142  *
143  */
144 
145 static void
146 l2cap_connecting(void *arg)
147 {
148 	struct socket *so = arg;
149 
150 	DPRINTF("Connecting\n");
151 	soisconnecting(so);
152 }
153 
154 static void
155 l2cap_connected(void *arg)
156 {
157 	struct socket *so = arg;
158 
159 	DPRINTF("Connected\n");
160 	soisconnected(so);
161 }
162 
163 static void
164 l2cap_disconnected(void *arg, int err)
165 {
166 	struct socket *so = arg;
167 
168 	DPRINTF("Disconnected (%d)\n", err);
169 
170 	so->so_error = err;
171 	soisdisconnected(so);
172 }
173 
174 static void *
175 l2cap_newconn(void *arg, struct sockaddr_bt *laddr,
176     struct sockaddr_bt *raddr)
177 {
178 	struct socket *so = arg;
179 
180 	DPRINTF("New Connection\n");
181 	so = sonewconn(so, 0);
182 	if (so == NULL)
183 		return NULL;
184 
185 	soisconnecting(so);
186 
187 	return so->so_pcb;
188 }
189 
190 static void
191 l2cap_complete(void *arg, int count)
192 {
193 	struct socket *so = arg;
194 
195 	while (count-- > 0)
196 		sbdroprecord(&so->so_snd.sb);
197 
198 	sowwakeup(so);
199 }
200 
201 static void
202 l2cap_linkmode(void *arg, int new)
203 {
204 	struct socket *so = arg;
205 	int mode;
206 
207 	DPRINTF("auth %s, encrypt %s, secure %s\n",
208 		(new & L2CAP_LM_AUTH ? "on" : "off"),
209 		(new & L2CAP_LM_ENCRYPT ? "on" : "off"),
210 		(new & L2CAP_LM_SECURE ? "on" : "off"));
211 
212 	(void)l2cap_getopt(so->so_pcb, SO_L2CAP_LM, &mode);
213 	if (((mode & L2CAP_LM_AUTH) && !(new & L2CAP_LM_AUTH))
214 	    || ((mode & L2CAP_LM_ENCRYPT) && !(new & L2CAP_LM_ENCRYPT))
215 	    || ((mode & L2CAP_LM_SECURE) && !(new & L2CAP_LM_SECURE)))
216 		l2cap_disconnect(so->so_pcb, 0);
217 }
218 
219 static void
220 l2cap_input(void *arg, struct mbuf *m)
221 {
222 	struct socket *so = arg;
223 
224 	if (m->m_pkthdr.len > sbspace(&so->so_rcv)) {
225 		kprintf("%s: packet (%d bytes) dropped (socket buffer full)\n",
226 			__func__, m->m_pkthdr.len);
227 		m_freem(m);
228 		return;
229 	}
230 
231 	DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len);
232 
233 	sbappendrecord(&so->so_rcv.sb, m);
234 	sorwakeup(so);
235 }
236 
237 
238 /*
239  * Implementation of usrreqs.
240  */
241 static int
242 l2cap_sdetach(struct socket *so)
243 {
244 	return l2cap_detach((struct l2cap_channel **)&so->so_pcb);
245 }
246 
247 static int
248 l2cap_sabort (struct socket *so)
249 {
250 	struct l2cap_channel *pcb = so->so_pcb;
251 
252 	l2cap_disconnect(pcb, 0);
253 	soisdisconnected(so);
254 
255 	return l2cap_sdetach(so);
256 }
257 
258 static int
259 l2cap_sdisconnect (struct socket *so)
260 {
261 	struct l2cap_channel *pcb = so->so_pcb;
262 
263 	soisdisconnecting(so);
264 
265 	return l2cap_disconnect(pcb, so->so_linger);
266 }
267 
268 static int
269 l2cap_scontrol (struct socket *so, u_long cmd, caddr_t data,
270     struct ifnet *ifp, struct thread *td)
271 {
272 	return EPASSTHROUGH;
273 }
274 
275 static int
276 l2cap_sattach (struct socket *so, int proto,
277 			       struct pru_attach_info *ai)
278 {
279 	struct l2cap_channel *pcb = so->so_pcb;
280 	int err = 0;
281 
282 	if (pcb != NULL)
283 		return EINVAL;
284 
285 	/*
286 	 * For L2CAP socket PCB we just use an l2cap_channel structure
287 	 * since we have nothing to add..
288 	 */
289 	err = soreserve(so, l2cap_sendspace, l2cap_recvspace, NULL);
290 	if (err)
291 		return err;
292 
293 	return l2cap_attach((struct l2cap_channel **)&so->so_pcb,
294 	    &l2cap_proto, so);
295 }
296 
297 static int
298 l2cap_sbind (struct socket *so, struct sockaddr *nam,
299 				 struct thread *td)
300 {
301 	struct l2cap_channel *pcb = so->so_pcb;
302 	struct sockaddr_bt *sa;
303 
304 	KKASSERT(nam != NULL);
305 	sa = (struct sockaddr_bt *)nam;
306 
307 	if (sa->bt_len != sizeof(struct sockaddr_bt))
308 		return EINVAL;
309 
310 	if (sa->bt_family != AF_BLUETOOTH)
311 		return EAFNOSUPPORT;
312 
313 	return l2cap_bind(pcb, sa);
314 }
315 
316 static int
317 l2cap_sconnect (struct socket *so, struct sockaddr *nam,
318 				    struct thread *td)
319 {
320 	struct l2cap_channel *pcb = so->so_pcb;
321 	struct sockaddr_bt *sa;
322 
323 	KKASSERT(nam != NULL);
324 	sa = (struct sockaddr_bt *)nam;
325 
326 	if (sa->bt_len != sizeof(struct sockaddr_bt))
327 		return EINVAL;
328 
329 	if (sa->bt_family != AF_BLUETOOTH)
330 		return EAFNOSUPPORT;
331 
332 	soisconnecting(so);
333 	return l2cap_connect(pcb, sa);
334 }
335 
336 static int
337 l2cap_speeraddr (struct socket *so, struct sockaddr **nam)
338 {
339 	struct l2cap_channel *pcb = so->so_pcb;
340 	struct sockaddr_bt *sa, ssa;
341 	int e;
342 
343 	sa = &ssa;
344 	bzero(sa, sizeof *sa);
345 	sa->bt_len = sizeof(struct sockaddr_bt);
346 	sa->bt_family = AF_BLUETOOTH;
347 	e = l2cap_peeraddr(pcb, sa);
348 	*nam = dup_sockaddr((struct sockaddr *)sa);
349 
350 	return (e);
351 }
352 
353 static int
354 l2cap_ssockaddr (struct socket *so, struct sockaddr **nam)
355 {
356 	struct l2cap_channel *pcb = so->so_pcb;
357 	struct sockaddr_bt *sa, ssa;
358 	int e;
359 
360 	sa = &ssa;
361 	bzero(sa, sizeof *sa);
362 	sa->bt_len = sizeof(struct sockaddr_bt);
363 	sa->bt_family = AF_BLUETOOTH;
364 	e = l2cap_sockaddr(pcb, sa);
365 	*nam = dup_sockaddr((struct sockaddr *)sa);
366 
367 	return (e);
368 }
369 
370 static int
371 l2cap_sshutdown (struct socket *so)
372 {
373 	socantsendmore(so);
374 	return 0;
375 }
376 
377 static int
378 l2cap_ssend (struct socket *so, int flags, struct mbuf *m,
379     struct sockaddr *addr, struct mbuf *control, struct thread *td)
380 {
381 	struct l2cap_channel *pcb = so->so_pcb;
382 	struct mbuf *m0;
383 
384 	int err = 0;
385 
386 	KKASSERT(m != NULL);
387 	if (m->m_pkthdr.len == 0)
388 		goto error;
389 
390 	if (m->m_pkthdr.len > pcb->lc_omtu) {
391 		err = EMSGSIZE;
392 		goto error;
393 	}
394 
395 	m0 = m_copym(m, 0, M_COPYALL, MB_DONTWAIT);
396 	if (m0 == NULL) {
397 		err = ENOMEM;
398 		goto error;
399 	}
400 
401 	if (control)	/* no use for that */
402 		m_freem(control);
403 
404 	sbappendrecord(&so->so_snd.sb, m);
405 	return l2cap_send(pcb, m0);
406 
407 error:
408 	if (m)
409 		m_freem(m);
410 	if (control)
411 		m_freem(control);
412 
413 	return err;
414 }
415 
416 static int
417 l2cap_saccept(struct socket *so, struct sockaddr **nam)
418 {
419 	struct l2cap_channel *pcb = so->so_pcb;
420 	struct sockaddr_bt sa;
421 	int e;
422 
423 	KKASSERT(nam != NULL);
424 
425 	bzero(&sa, sizeof (sa) );
426 	sa.bt_len = sizeof(struct sockaddr_bt);
427 	sa.bt_family = AF_BLUETOOTH;
428 
429 	e = l2cap_peeraddr(pcb, &sa);
430 	*nam = dup_sockaddr((struct sockaddr *)&sa);
431 
432 	return e;
433 }
434 
435 static int
436 l2cap_slisten(struct socket *so, struct thread *td)
437 {
438 	struct l2cap_channel *pcb = so->so_pcb;
439 	return l2cap_listen(pcb);
440 }
441 
442 
443 struct pr_usrreqs l2cap_usrreqs = {
444         .pru_abort = l2cap_sabort,
445         .pru_accept = l2cap_saccept,
446         .pru_attach = l2cap_sattach,
447         .pru_bind = l2cap_sbind,
448         .pru_connect = l2cap_sconnect,
449         .pru_connect2 = pru_connect2_notsupp,
450         .pru_control = l2cap_scontrol,
451         .pru_detach = l2cap_sdetach,
452         .pru_disconnect = l2cap_sdisconnect,
453         .pru_listen = l2cap_slisten,
454         .pru_peeraddr = l2cap_speeraddr,
455         .pru_rcvd = pru_rcvd_notsupp,
456         .pru_rcvoob = pru_rcvoob_notsupp,
457         .pru_send = l2cap_ssend,
458         .pru_sense = pru_sense_null,
459         .pru_shutdown = l2cap_sshutdown,
460         .pru_sockaddr = l2cap_ssockaddr,
461         .pru_sosend = sosend,
462         .pru_soreceive = soreceive,
463         .pru_sopoll = sopoll
464 };
465