1 /* $OpenBSD: src/sys/netbt/rfcomm_socket.c,v 1.2 2008/02/24 21:34:48 uwe Exp $ */
2 /* $NetBSD: rfcomm_socket.c,v 1.8 2007/10/15 18:04:34 plunky Exp $ */
3
4 /*-
5 * Copyright (c) 2006 Itronix Inc.
6 * All rights reserved.
7 *
8 * Written by Iain Hibbert for Itronix Inc.
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 /* load symbolic names */
36 #ifdef BLUETOOTH_DEBUG
37 #define PRUREQUESTS
38 #define PRCOREQUESTS
39 #endif
40
41 #include <sys/param.h>
42 #include <sys/domain.h>
43 #include <sys/kernel.h>
44 #include <sys/malloc.h> /* for M_NOWAIT */
45 #include <sys/mbuf.h>
46 #include <sys/proc.h>
47 #include <sys/protosw.h>
48 #include <sys/socket.h>
49 #include <sys/socketvar.h>
50 #include <sys/systm.h>
51
52 #include <sys/msgport2.h>
53
54 #include <vm/vm_zone.h>
55
56 #include <netbt/bluetooth.h>
57 #include <netbt/hci.h> /* XXX for EPASSTHROUGH */
58 #include <netbt/rfcomm.h>
59
60 /****************************************************************************
61 *
62 * RFCOMM SOCK_STREAM Sockets - serial line emulation
63 *
64 */
65
66 static void rfcomm_connecting(void *);
67 static void rfcomm_connected(void *);
68 static void rfcomm_disconnected(void *, int);
69 static void *rfcomm_newconn(void *, struct sockaddr_bt *, struct sockaddr_bt *);
70 static void rfcomm_complete(void *, int);
71 static void rfcomm_linkmode(void *, int);
72 static void rfcomm_input(void *, struct mbuf *);
73
74 static const struct btproto rfcomm_proto = {
75 rfcomm_connecting,
76 rfcomm_connected,
77 rfcomm_disconnected,
78 rfcomm_newconn,
79 rfcomm_complete,
80 rfcomm_linkmode,
81 rfcomm_input,
82 };
83
84 /* sysctl variables */
85 int rfcomm_sendspace = 4096;
86 int rfcomm_recvspace = 4096;
87
88 /*
89 * rfcomm_ctloutput(request, socket, level, optname, opt)
90 *
91 */
92 void
rfcomm_ctloutput(netmsg_t msg)93 rfcomm_ctloutput(netmsg_t msg)
94 {
95 struct socket *so = msg->ctloutput.base.nm_so;
96 struct sockopt *sopt = msg->ctloutput.nm_sopt;
97 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
98 struct mbuf *m;
99 int error = 0;
100
101 #ifdef notyet /* XXX */
102 DPRINTFN(2, "%s\n", prcorequests[sopt->sopt_dir]);
103 #endif
104
105 if (pcb == NULL) {
106 error = EINVAL;
107 goto out;
108 }
109
110 if (sopt->sopt_level != BTPROTO_RFCOMM) {
111 error = ENOPROTOOPT;
112 goto out;
113 }
114
115 switch(sopt->sopt_dir) {
116 case PRCO_GETOPT:
117 m = m_get(M_WAITOK, MT_DATA);
118 crit_enter();
119 m->m_len = rfcomm_getopt(pcb, sopt->sopt_name, mtod(m, void *));
120 crit_exit();
121 if (m->m_len == 0) {
122 m_freem(m);
123 m = NULL;
124 error = ENOPROTOOPT;
125 }
126 soopt_from_kbuf(sopt, mtod(m, void *), m->m_len);
127 break;
128
129 case PRCO_SETOPT:
130 error = rfcomm_setopt2(pcb, sopt->sopt_name, so, sopt);
131
132 break;
133
134 default:
135 error = ENOPROTOOPT;
136 break;
137 }
138 out:
139 lwkt_replymsg(&msg->ctloutput.base.lmsg, error);
140 }
141
142 /**********************************************************************
143 *
144 * RFCOMM callbacks
145 */
146
147 static void
rfcomm_connecting(void * arg)148 rfcomm_connecting(void *arg)
149 {
150 /* struct socket *so = arg; */
151
152 KKASSERT(arg != NULL);
153 DPRINTF("Connecting\n");
154 }
155
156 static void
rfcomm_connected(void * arg)157 rfcomm_connected(void *arg)
158 {
159 struct socket *so = arg;
160
161 KKASSERT(so != NULL);
162 DPRINTF("Connected\n");
163 soisconnected(so);
164 }
165
166 static void
rfcomm_disconnected(void * arg,int err)167 rfcomm_disconnected(void *arg, int err)
168 {
169 struct socket *so = arg;
170
171 KKASSERT(so != NULL);
172 DPRINTF("Disconnected\n");
173
174 so->so_error = err;
175 soisdisconnected(so);
176 }
177
178 static void *
rfcomm_newconn(void * arg,struct sockaddr_bt * laddr,struct sockaddr_bt * raddr)179 rfcomm_newconn(void *arg, struct sockaddr_bt *laddr,
180 struct sockaddr_bt *raddr)
181 {
182 struct socket *so = arg;
183
184 DPRINTF("New Connection\n");
185 so = sonewconn(so, 0);
186 if (so == NULL)
187 return NULL;
188
189 soisconnecting(so);
190
191 return so->so_pcb;
192 }
193
194 /*
195 * rfcomm_complete(rfcomm_dlc, length)
196 *
197 * length bytes are sent and may be removed from socket buffer
198 */
199 static void
rfcomm_complete(void * arg,int length)200 rfcomm_complete(void *arg, int length)
201 {
202 struct socket *so = arg;
203
204 sbdrop(&so->so_snd.sb, length);
205 sowwakeup(so);
206 }
207
208 /*
209 * rfcomm_linkmode(rfcomm_dlc, new)
210 *
211 * link mode change notification.
212 */
213 static void
rfcomm_linkmode(void * arg,int new)214 rfcomm_linkmode(void *arg, int new)
215 {
216 struct socket *so = arg;
217 int mode;
218
219 DPRINTF("auth %s, encrypt %s, secure %s\n",
220 (new & RFCOMM_LM_AUTH ? "on" : "off"),
221 (new & RFCOMM_LM_ENCRYPT ? "on" : "off"),
222 (new & RFCOMM_LM_SECURE ? "on" : "off"));
223
224 (void)rfcomm_getopt(so->so_pcb, SO_RFCOMM_LM, &mode);
225 if (((mode & RFCOMM_LM_AUTH) && !(new & RFCOMM_LM_AUTH))
226 || ((mode & RFCOMM_LM_ENCRYPT) && !(new & RFCOMM_LM_ENCRYPT))
227 || ((mode & RFCOMM_LM_SECURE) && !(new & RFCOMM_LM_SECURE)))
228 rfcomm_disconnect(so->so_pcb, 0);
229 }
230
231 /*
232 * rfcomm_input(rfcomm_dlc, mbuf)
233 */
234 static void
rfcomm_input(void * arg,struct mbuf * m)235 rfcomm_input(void *arg, struct mbuf *m)
236 {
237 struct socket *so = arg;
238
239 KKASSERT(so != NULL);
240
241 if (m->m_pkthdr.len > sbspace(&so->so_rcv)) {
242 kprintf("%s: %d bytes dropped (socket buffer full)\n",
243 __func__, m->m_pkthdr.len);
244 m_freem(m);
245 return;
246 }
247
248 DPRINTFN(10, "received %d bytes\n", m->m_pkthdr.len);
249
250 sbappendstream(&so->so_rcv.sb, m);
251 sorwakeup(so);
252 }
253
254 /*
255 * Implementation of usrreqs.
256 */
257 static void
rfcomm_sdetach(netmsg_t msg)258 rfcomm_sdetach(netmsg_t msg)
259 {
260 struct socket *so = msg->detach.base.nm_so;
261 int error;
262
263 error = rfcomm_detach((struct rfcomm_dlc **)&so->so_pcb);
264 lwkt_replymsg(&msg->detach.base.lmsg, error);
265 }
266
267 /*
268 * NOTE: (so) is referenced from soabort*() and netmsg_pru_abort()
269 * will sofree() it when we return.
270 */
271 static void
rfcomm_sabort(netmsg_t msg)272 rfcomm_sabort(netmsg_t msg)
273 {
274 struct socket *so = msg->abort.base.nm_so;
275 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
276
277 rfcomm_disconnect(pcb, 0);
278 soisdisconnected(so);
279 rfcomm_sdetach(msg);
280 /* msg invalid now */
281 }
282
283 static void
rfcomm_sdisconnect(netmsg_t msg)284 rfcomm_sdisconnect(netmsg_t msg)
285 {
286 struct socket *so = msg->abort.base.nm_so;
287 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
288 int error;
289
290 soisdisconnecting(so);
291 error = rfcomm_disconnect(pcb, so->so_linger);
292 lwkt_replymsg(&msg->disconnect.base.lmsg, error);
293 }
294
295 static void
rfcomm_scontrol(netmsg_t msg)296 rfcomm_scontrol(netmsg_t msg)
297 {
298 lwkt_replymsg(&msg->control.base.lmsg, EPASSTHROUGH);
299 }
300
301 static void
rfcomm_sattach(netmsg_t msg)302 rfcomm_sattach(netmsg_t msg)
303 {
304 struct socket *so = msg->attach.base.nm_so;
305 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
306 int error;
307
308 if (pcb != NULL) {
309 error = EINVAL;
310 goto out;
311 }
312
313 /*
314 * Since we have nothing to add, we attach the DLC
315 * structure directly to our PCB pointer.
316 */
317 error = soreserve(so, rfcomm_sendspace, rfcomm_recvspace, NULL);
318 if (error)
319 goto out;
320
321 error = rfcomm_attach((struct rfcomm_dlc **)&so->so_pcb,
322 &rfcomm_proto, so);
323 if (error)
324 goto out;
325
326 error = rfcomm_rcvd(so->so_pcb, sbspace(&so->so_rcv));
327 if (error)
328 rfcomm_detach((struct rfcomm_dlc **)&so->so_pcb);
329 out:
330 lwkt_replymsg(&msg->attach.base.lmsg, error);
331 }
332
333 static void
rfcomm_sbind(netmsg_t msg)334 rfcomm_sbind(netmsg_t msg)
335 {
336 struct socket *so = msg->bind.base.nm_so;
337 struct sockaddr *nam = msg->bind.nm_nam;
338 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
339 struct sockaddr_bt *sa;
340 int error;
341
342 KKASSERT(nam != NULL);
343 sa = (struct sockaddr_bt *)nam;
344
345 if (sa->bt_len != sizeof(struct sockaddr_bt)) {
346 error = EINVAL;
347 } else if (sa->bt_family != AF_BLUETOOTH) {
348 error = EAFNOSUPPORT;
349 } else {
350 error = rfcomm_bind(pcb, sa);
351 }
352 lwkt_replymsg(&msg->bind.base.lmsg, error);
353 }
354
355 static void
rfcomm_sconnect(netmsg_t msg)356 rfcomm_sconnect(netmsg_t msg)
357 {
358 struct socket *so = msg->connect.base.nm_so;
359 struct sockaddr *nam = msg->connect.nm_nam;
360 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
361 struct sockaddr_bt *sa;
362 int error;
363
364 KKASSERT(nam != NULL);
365 sa = (struct sockaddr_bt *)nam;
366
367 if (sa->bt_len != sizeof(struct sockaddr_bt)) {
368 error = EINVAL;
369 } else if (sa->bt_family != AF_BLUETOOTH) {
370 error = EAFNOSUPPORT;
371 } else {
372 soisconnecting(so);
373 error = rfcomm_connect(pcb, sa);
374 }
375 lwkt_replymsg(&msg->connect.base.lmsg, error);
376 }
377
378 static void
rfcomm_speeraddr(netmsg_t msg)379 rfcomm_speeraddr(netmsg_t msg)
380 {
381 struct socket *so = msg->peeraddr.base.nm_so;
382 struct sockaddr **nam = msg->peeraddr.nm_nam;
383 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
384 struct sockaddr_bt *sa, ssa;
385 int error;
386
387 sa = &ssa;
388 bzero(sa, sizeof *sa);
389 sa->bt_len = sizeof(struct sockaddr_bt);
390 sa->bt_family = AF_BLUETOOTH;
391 error = rfcomm_peeraddr(pcb, sa);
392 *nam = dup_sockaddr((struct sockaddr *)sa);
393
394 lwkt_replymsg(&msg->peeraddr.base.lmsg, error);
395 }
396
397 static void
rfcomm_ssockaddr(netmsg_t msg)398 rfcomm_ssockaddr(netmsg_t msg)
399 {
400 struct socket *so = msg->sockaddr.base.nm_so;
401 struct sockaddr **nam = msg->sockaddr.nm_nam;
402 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
403 struct sockaddr_bt *sa, ssa;
404 int error;
405
406 sa = &ssa;
407 bzero(sa, sizeof *sa);
408 sa->bt_len = sizeof(struct sockaddr_bt);
409 sa->bt_family = AF_BLUETOOTH;
410 error = rfcomm_sockaddr(pcb, sa);
411 *nam = dup_sockaddr((struct sockaddr *)sa);
412
413 lwkt_replymsg(&msg->sockaddr.base.lmsg, error);
414 }
415
416 static void
rfcomm_sshutdown(netmsg_t msg)417 rfcomm_sshutdown(netmsg_t msg)
418 {
419 struct socket *so = msg->shutdown.base.nm_so;
420
421 socantsendmore(so);
422 lwkt_replymsg(&msg->shutdown.base.lmsg, 0);
423 }
424
425 static void
rfcomm_ssend(netmsg_t msg)426 rfcomm_ssend(netmsg_t msg)
427 {
428 struct socket *so = msg->send.base.nm_so;
429 struct mbuf *m = msg->send.nm_m;
430 struct mbuf *control = msg->send.nm_control;
431 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
432 struct mbuf *m0;
433 int error;
434
435 KKASSERT(m != NULL);
436
437 /* no use for that */
438 if (control) {
439 m_freem(control);
440 control = NULL;
441 }
442
443 m0 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
444 if (m0) {
445 sbappendstream(&so->so_snd.sb, m);
446 error = rfcomm_send(pcb, m0);
447 } else {
448 error = ENOMEM;
449 }
450 lwkt_replymsg(&msg->send.base.lmsg, error);
451 }
452
453 static void
rfcomm_saccept(netmsg_t msg)454 rfcomm_saccept(netmsg_t msg)
455 {
456 struct socket *so = msg->accept.base.nm_so;
457 struct sockaddr **nam = msg->accept.nm_nam;
458 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
459 struct sockaddr_bt *sa, ssa;
460 int error;
461
462 sa = &ssa;
463 bzero(sa, sizeof *sa);
464 sa->bt_len = sizeof(struct sockaddr_bt);
465 sa->bt_family = AF_BLUETOOTH;
466 error = rfcomm_peeraddr(pcb, sa);
467 *nam = dup_sockaddr((struct sockaddr *)sa);
468
469 lwkt_replymsg(&msg->accept.base.lmsg, error);
470 }
471
472 static void
rfcomm_slisten(netmsg_t msg)473 rfcomm_slisten(netmsg_t msg)
474 {
475 struct socket *so = msg->listen.base.nm_so;
476 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *)so->so_pcb;
477 int error;
478
479 error = rfcomm_listen(pcb);
480 lwkt_replymsg(&msg->listen.base.lmsg, error);
481 }
482
483 static void
rfcomm_srcvd(netmsg_t msg)484 rfcomm_srcvd(netmsg_t msg)
485 {
486 struct socket *so = msg->rcvd.base.nm_so;
487 struct rfcomm_dlc *pcb = (struct rfcomm_dlc *) so->so_pcb;
488 int error;
489
490 error = rfcomm_rcvd(pcb, sbspace(&so->so_rcv));
491 lwkt_replymsg(&msg->rcvd.base.lmsg, error);
492 }
493
494 struct pr_usrreqs rfcomm_usrreqs = {
495 .pru_abort = rfcomm_sabort,
496 .pru_accept = rfcomm_saccept,
497 .pru_attach = rfcomm_sattach,
498 .pru_bind = rfcomm_sbind,
499 .pru_connect = rfcomm_sconnect,
500 .pru_connect2 = pr_generic_notsupp,
501 .pru_control = rfcomm_scontrol,
502 .pru_detach = rfcomm_sdetach,
503 .pru_disconnect = rfcomm_sdisconnect,
504 .pru_listen = rfcomm_slisten,
505 .pru_peeraddr = rfcomm_speeraddr,
506 .pru_rcvd = rfcomm_srcvd,
507 .pru_rcvoob = pr_generic_notsupp,
508 .pru_send = rfcomm_ssend,
509 .pru_sense = pru_sense_null,
510 .pru_shutdown = rfcomm_sshutdown,
511 .pru_sockaddr = rfcomm_ssockaddr,
512 .pru_sosend = sosend,
513 .pru_soreceive = soreceive
514 };
515