ng_btsocket_hci_raw.c revision 125037
1193323Sed/* 2193323Sed * ng_btsocket_hci_raw.c 3193323Sed * 4193323Sed * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> 5193323Sed * All rights reserved. 6193323Sed * 7193323Sed * Redistribution and use in source and binary forms, with or without 8193323Sed * modification, are permitted provided that the following conditions 9193323Sed * are met: 10193323Sed * 1. Redistributions of source code must retain the above copyright 11193323Sed * notice, this list of conditions and the following disclaimer. 12193323Sed * 2. Redistributions in binary form must reproduce the above copyright 13193323Sed * notice, this list of conditions and the following disclaimer in the 14193323Sed * documentation and/or other materials provided with the distribution. 15193323Sed * 16199989Srdivacky * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17199989Srdivacky * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18193323Sed * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19193323Sed * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20198090Srdivacky * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21193323Sed * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22193323Sed * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23193323Sed * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24193323Sed * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25193323Sed * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26193323Sed * SUCH DAMAGE. 27193323Sed * 28193323Sed * $Id: ng_btsocket_hci_raw.c,v 1.14 2003/09/14 23:29:06 max Exp $ 29193323Sed * $FreeBSD: head/sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c 125037 2004-01-26 15:19:43Z harti $ 30198892Srdivacky */ 31193323Sed 32193323Sed#include <sys/param.h> 33193323Sed#include <sys/systm.h> 34193323Sed#include <sys/bitstring.h> 35198090Srdivacky#include <sys/domain.h> 36193323Sed#include <sys/endian.h> 37193323Sed#include <sys/errno.h> 38193323Sed#include <sys/filedesc.h> 39193323Sed#include <sys/ioccom.h> 40193323Sed#include <sys/kernel.h> 41193323Sed#include <sys/lock.h> 42193323Sed#include <sys/malloc.h> 43193323Sed#include <sys/mbuf.h> 44193323Sed#include <sys/mutex.h> 45193323Sed#include <sys/protosw.h> 46193323Sed#include <sys/queue.h> 47193323Sed#include <sys/socket.h> 48198892Srdivacky#include <sys/socketvar.h> 49193323Sed#include <sys/sysctl.h> 50193323Sed#include <sys/taskqueue.h> 51193323Sed#include <netgraph/ng_message.h> 52193323Sed#include <netgraph/netgraph.h> 53193323Sed#include "ng_bluetooth.h" 54193323Sed#include "ng_hci.h" 55198090Srdivacky#include "ng_l2cap.h" 56193323Sed#include "ng_btsocket.h" 57193323Sed#include "ng_btsocket_hci_raw.h" 58198090Srdivacky 59193323Sed/* MALLOC define */ 60193323Sed#ifdef NG_SEPARATE_MALLOC 61193323SedMALLOC_DEFINE(M_NETGRAPH_BTSOCKET_HCI_RAW, "netgraph_btsocks_hci_raw", 62193323Sed "Netgraph Bluetooth raw HCI sockets"); 63193323Sed#else 64193323Sed#define M_NETGRAPH_BTSOCKET_HCI_RAW M_NETGRAPH 65193323Sed#endif /* NG_SEPARATE_MALLOC */ 66193323Sed 67193323Sed/* Netgraph node methods */ 68193323Sedstatic ng_constructor_t ng_btsocket_hci_raw_node_constructor; 69193323Sedstatic ng_rcvmsg_t ng_btsocket_hci_raw_node_rcvmsg; 70199481Srdivackystatic ng_shutdown_t ng_btsocket_hci_raw_node_shutdown; 71193323Sedstatic ng_newhook_t ng_btsocket_hci_raw_node_newhook; 72193323Sedstatic ng_connect_t ng_btsocket_hci_raw_node_connect; 73193323Sedstatic ng_rcvdata_t ng_btsocket_hci_raw_node_rcvdata; 74193323Sedstatic ng_disconnect_t ng_btsocket_hci_raw_node_disconnect; 75193323Sed 76193323Sedstatic void ng_btsocket_hci_raw_input (void *, int); 77193323Sedstatic void ng_btsocket_hci_raw_output(node_p, hook_p, void *, int); 78193323Sedstatic void ng_btsocket_hci_raw_savctl(ng_btsocket_hci_raw_pcb_p, 79193323Sed struct mbuf **, 80193323Sed struct mbuf *); 81193323Sedstatic int ng_btsocket_hci_raw_filter(ng_btsocket_hci_raw_pcb_p, 82193323Sed struct mbuf *, int); 83193323Sed 84193323Sed#define ng_btsocket_hci_raw_wakeup_input_task() \ 85193323Sed taskqueue_enqueue(taskqueue_swi_giant, &ng_btsocket_hci_raw_task) 86193323Sed 87193323Sed/* Security filter */ 88193323Sedstruct ng_btsocket_hci_raw_sec_filter { 89193323Sed bitstr_t bit_decl(events, 0xff); 90193323Sed bitstr_t bit_decl(commands[0x3f], 0x3ff); 91193323Sed}; 92193323Sed 93193323Sed/* Netgraph type descriptor */ 94193323Sedstatic struct ng_type typestruct = { 95193323Sed NG_ABI_VERSION, 96193323Sed NG_BTSOCKET_HCI_RAW_NODE_TYPE, /* typename */ 97193323Sed NULL, /* modevent */ 98193323Sed ng_btsocket_hci_raw_node_constructor, /* constructor */ 99193323Sed ng_btsocket_hci_raw_node_rcvmsg, /* control message */ 100193323Sed ng_btsocket_hci_raw_node_shutdown, /* destructor */ 101193323Sed ng_btsocket_hci_raw_node_newhook, /* new hook */ 102193323Sed NULL, /* find hook */ 103193323Sed ng_btsocket_hci_raw_node_connect, /* connect hook */ 104193323Sed ng_btsocket_hci_raw_node_rcvdata, /* data */ 105193323Sed ng_btsocket_hci_raw_node_disconnect, /* disconnect hook */ 106193323Sed NULL /* node command list */ 107193323Sed}; 108193323Sed 109193323Sed/* Globals */ 110193323Sedextern int ifqmaxlen; 111193323Sedstatic u_int32_t ng_btsocket_hci_raw_debug_level; 112193323Sedstatic u_int32_t ng_btsocket_hci_raw_ioctl_timeout; 113193323Sedstatic node_p ng_btsocket_hci_raw_node; 114193323Sedstatic struct ng_bt_itemq ng_btsocket_hci_raw_queue; 115193323Sedstatic struct mtx ng_btsocket_hci_raw_queue_mtx; 116193323Sedstatic struct task ng_btsocket_hci_raw_task; 117193323Sedstatic LIST_HEAD(, ng_btsocket_hci_raw_pcb) ng_btsocket_hci_raw_sockets; 118193323Sedstatic struct mtx ng_btsocket_hci_raw_sockets_mtx; 119193323Sedstatic u_int32_t ng_btsocket_hci_raw_token; 120193323Sedstatic struct mtx ng_btsocket_hci_raw_token_mtx; 121193323Sedstatic struct ng_btsocket_hci_raw_sec_filter *ng_btsocket_hci_raw_sec_filter; 122193323Sed 123193323Sed/* Sysctl tree */ 124193323SedSYSCTL_DECL(_net_bluetooth_hci_sockets); 125193323SedSYSCTL_NODE(_net_bluetooth_hci_sockets, OID_AUTO, raw, CTLFLAG_RW, 126193323Sed 0, "Bluetooth raw HCI sockets family"); 127193323SedSYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, debug_level, CTLFLAG_RW, 128193323Sed &ng_btsocket_hci_raw_debug_level, NG_BTSOCKET_WARN_LEVEL, 129193323Sed "Bluetooth raw HCI sockets debug level"); 130193323SedSYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, ioctl_timeout, CTLFLAG_RW, 131193323Sed &ng_btsocket_hci_raw_ioctl_timeout, 5, 132193323Sed "Bluetooth raw HCI sockets ioctl timeout"); 133193323SedSYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, queue_len, CTLFLAG_RD, 134193323Sed &ng_btsocket_hci_raw_queue.len, 0, 135193323Sed "Bluetooth raw HCI sockets input queue length"); 136193323SedSYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, queue_maxlen, CTLFLAG_RD, 137193323Sed &ng_btsocket_hci_raw_queue.maxlen, 0, 138193323Sed "Bluetooth raw HCI sockets input queue max. length"); 139193323SedSYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, queue_drops, CTLFLAG_RD, 140193323Sed &ng_btsocket_hci_raw_queue.drops, 0, 141193323Sed "Bluetooth raw HCI sockets input queue drops"); 142193323Sed 143193323Sed/* Debug */ 144193323Sed#define NG_BTSOCKET_HCI_RAW_INFO \ 145193323Sed if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_INFO_LEVEL) \ 146193323Sed printf 147202878Srdivacky 148193323Sed#define NG_BTSOCKET_HCI_RAW_WARN \ 149193323Sed if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_WARN_LEVEL) \ 150193323Sed printf 151193323Sed 152193323Sed#define NG_BTSOCKET_HCI_RAW_ERR \ 153198892Srdivacky if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_ERR_LEVEL) \ 154193323Sed printf 155193323Sed 156198892Srdivacky#define NG_BTSOCKET_HCI_RAW_ALERT \ 157198892Srdivacky if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_ALERT_LEVEL) \ 158198892Srdivacky printf 159198892Srdivacky 160198892Srdivacky/**************************************************************************** 161193323Sed **************************************************************************** 162198090Srdivacky ** Netgraph specific 163198090Srdivacky **************************************************************************** 164198090Srdivacky ****************************************************************************/ 165202375Srdivacky 166198892Srdivacky/* 167198090Srdivacky * Netgraph node constructor. Do not allow to create node of this type. 168198090Srdivacky */ 169198090Srdivacky 170198090Srdivackystatic int 171193323Sedng_btsocket_hci_raw_node_constructor(node_p node) 172193323Sed{ 173193323Sed return (EINVAL); 174193323Sed} /* ng_btsocket_hci_raw_node_constructor */ 175193323Sed 176193323Sed/* 177193323Sed * Netgraph node destructor. Just let old node go and create new fresh one. 178193323Sed */ 179193323Sed 180193323Sedstatic int 181193323Sedng_btsocket_hci_raw_node_shutdown(node_p node) 182193323Sed{ 183193323Sed int error = 0; 184193323Sed 185193323Sed NG_NODE_UNREF(node); 186193323Sed 187193323Sed error = ng_make_node_common(&typestruct, &ng_btsocket_hci_raw_node); 188193323Sed if (error != 0) { 189193323Sed NG_BTSOCKET_HCI_RAW_ALERT( 190193323Sed"%s: Could not create Netgraph node, error=%d\n", __func__, error); 191193323Sed 192193323Sed ng_btsocket_hci_raw_node = NULL; 193193323Sed 194193323Sed return (ENOMEM); 195193323Sed } 196193323Sed 197193323Sed error = ng_name_node(ng_btsocket_hci_raw_node, 198193323Sed NG_BTSOCKET_HCI_RAW_NODE_TYPE); 199193323Sed if (error != 0) { 200193323Sed NG_BTSOCKET_HCI_RAW_ALERT( 201193323Sed"%s: Could not name Netgraph node, error=%d\n", __func__, error); 202193323Sed 203193323Sed NG_NODE_UNREF(ng_btsocket_hci_raw_node); 204193323Sed ng_btsocket_hci_raw_node = NULL; 205193323Sed 206193323Sed return (EINVAL); 207193323Sed } 208193323Sed 209193323Sed return (0); 210193323Sed} /* ng_btsocket_hci_raw_node_shutdown */ 211193323Sed 212193323Sed/* 213193323Sed * Create new hook. Just say "yes" 214193323Sed */ 215193323Sed 216193323Sedstatic int 217193323Sedng_btsocket_hci_raw_node_newhook(node_p node, hook_p hook, char const *name) 218193323Sed{ 219193323Sed return (0); 220193323Sed} /* ng_btsocket_hci_raw_node_newhook */ 221193323Sed 222193323Sed/* 223193323Sed * Connect hook. Just say "yes" 224193323Sed */ 225193323Sed 226193323Sedstatic int 227193323Sedng_btsocket_hci_raw_node_connect(hook_p hook) 228193323Sed{ 229193323Sed return (0); 230198090Srdivacky} /* ng_btsocket_hci_raw_node_connect */ 231198090Srdivacky 232198090Srdivacky/* 233198090Srdivacky * Disconnect hook 234198396Srdivacky */ 235193323Sed 236193323Sedstatic int 237193323Sedng_btsocket_hci_raw_node_disconnect(hook_p hook) 238193323Sed{ 239193323Sed return (0); 240193323Sed} /* ng_btsocket_hci_raw_node_disconnect */ 241193323Sed 242193323Sed/* 243193323Sed * Receive control message. 244193323Sed * Make sure it is a message from HCI node and it is a response. 245193323Sed * Enqueue item and schedule input task. 246193323Sed */ 247193323Sed 248193323Sedstatic int 249193323Sedng_btsocket_hci_raw_node_rcvmsg(node_p node, item_p item, hook_p lasthook) 250193323Sed{ 251193323Sed struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ 252193323Sed int empty, error = 0; 253193323Sed 254193323Sed mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); 255193323Sed empty = LIST_EMPTY(&ng_btsocket_hci_raw_sockets); 256193323Sed mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 257193323Sed 258193323Sed if (empty) { 259193323Sed NG_FREE_ITEM(item); 260193323Sed return (0); 261193323Sed } 262193323Sed 263193323Sed if (msg != NULL && 264193323Sed msg->header.typecookie == NGM_HCI_COOKIE && 265198090Srdivacky msg->header.flags & NGF_RESP) { 266198090Srdivacky if (msg->header.token == 0) { 267198090Srdivacky NG_FREE_ITEM(item); 268198090Srdivacky return (0); 269193323Sed } 270193323Sed 271193323Sed mtx_lock(&ng_btsocket_hci_raw_queue_mtx); 272193323Sed if (NG_BT_ITEMQ_FULL(&ng_btsocket_hci_raw_queue)) { 273193323Sed NG_BTSOCKET_HCI_RAW_ERR( 274193323Sed"%s: Input queue is full\n", __func__); 275193323Sed 276193323Sed NG_BT_ITEMQ_DROP(&ng_btsocket_hci_raw_queue); 277193323Sed NG_FREE_ITEM(item); 278198090Srdivacky error = ENOBUFS; 279193323Sed } else { 280193323Sed NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_hci_raw_queue, item); 281199989Srdivacky error = ng_btsocket_hci_raw_wakeup_input_task(); 282193323Sed } 283193323Sed mtx_unlock(&ng_btsocket_hci_raw_queue_mtx); 284193323Sed } else { 285193323Sed NG_FREE_ITEM(item); 286193323Sed error = EINVAL; 287193323Sed } 288199989Srdivacky 289193323Sed return (error); 290193323Sed} /* ng_btsocket_hci_raw_node_rcvmsg */ 291193323Sed 292193323Sed/* 293198090Srdivacky * Receive packet from the one of our hook. 294193323Sed * Prepend every packet with sockaddr_hci and record sender's node name. 295193323Sed * Enqueue item and schedule input task. 296193323Sed */ 297193323Sed 298193323Sedstatic int 299198090Srdivackyng_btsocket_hci_raw_node_rcvdata(hook_p hook, item_p item) 300193323Sed{ 301198090Srdivacky struct mbuf *nam = NULL; 302193323Sed int empty, error; 303198090Srdivacky 304198090Srdivacky mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); 305193323Sed empty = LIST_EMPTY(&ng_btsocket_hci_raw_sockets); 306193323Sed mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 307198090Srdivacky 308198090Srdivacky if (empty) { 309198090Srdivacky NG_FREE_ITEM(item); 310193323Sed return (0); 311193323Sed } 312193323Sed 313193323Sed MGET(nam, M_DONTWAIT, MT_SONAME); 314193323Sed if (nam != NULL) { 315193323Sed struct sockaddr_hci *sa = mtod(nam, struct sockaddr_hci *); 316193323Sed 317193323Sed nam->m_len = sizeof(struct sockaddr_hci); 318193323Sed 319198090Srdivacky sa->hci_len = sizeof(*sa); 320193323Sed sa->hci_family = AF_BLUETOOTH; 321193323Sed strlcpy(sa->hci_node, NG_PEER_NODE_NAME(hook), 322193323Sed sizeof(sa->hci_node)); 323198090Srdivacky 324198090Srdivacky NGI_GET_M(item, nam->m_next); 325193323Sed NGI_M(item) = nam; 326193323Sed 327193323Sed mtx_lock(&ng_btsocket_hci_raw_queue_mtx); 328202375Srdivacky if (NG_BT_ITEMQ_FULL(&ng_btsocket_hci_raw_queue)) { 329193323Sed NG_BTSOCKET_HCI_RAW_ERR( 330193323Sed"%s: Input queue is full\n", __func__); 331193323Sed 332193323Sed NG_BT_ITEMQ_DROP(&ng_btsocket_hci_raw_queue); 333199989Srdivacky NG_FREE_ITEM(item); 334199989Srdivacky error = ENOBUFS; 335193323Sed } else { 336193323Sed NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_hci_raw_queue, item); 337193323Sed error = ng_btsocket_hci_raw_wakeup_input_task(); 338193323Sed } 339193323Sed mtx_unlock(&ng_btsocket_hci_raw_queue_mtx); 340193323Sed } else { 341193323Sed NG_BTSOCKET_HCI_RAW_ERR( 342193323Sed"%s: Failed to allocate address mbuf\n", __func__); 343193323Sed 344193323Sed NG_FREE_ITEM(item); 345193323Sed error = ENOBUFS; 346193323Sed } 347193323Sed 348193323Sed return (error); 349193323Sed} /* ng_btsocket_hci_raw_node_rcvdata */ 350193323Sed 351193323Sed/**************************************************************************** 352193323Sed **************************************************************************** 353193323Sed ** Sockets specific 354193323Sed **************************************************************************** 355193323Sed ****************************************************************************/ 356193323Sed 357193323Sed/* 358193323Sed * Get next token. We need token to avoid theoretical race where process 359193323Sed * submits ioctl() message then interrupts ioctl() and re-submits another 360193323Sed * ioctl() on the same socket *before* first ioctl() complete. 361193323Sed */ 362193323Sed 363200581Srdivackystatic void 364200581Srdivackyng_btsocket_hci_raw_get_token(u_int32_t *token) 365201360Srdivacky{ 366200581Srdivacky mtx_lock(&ng_btsocket_hci_raw_token_mtx); 367201360Srdivacky 368201360Srdivacky if (++ ng_btsocket_hci_raw_token == 0) 369201360Srdivacky ng_btsocket_hci_raw_token = 1; 370201360Srdivacky 371201360Srdivacky *token = ng_btsocket_hci_raw_token; 372201360Srdivacky 373200581Srdivacky mtx_unlock(&ng_btsocket_hci_raw_token_mtx); 374201360Srdivacky} /* ng_btsocket_hci_raw_get_token */ 375200581Srdivacky 376201360Srdivacky/* 377201360Srdivacky * Send Netgraph message to the node - do not expect reply 378200581Srdivacky */ 379201360Srdivacky 380201360Srdivackystatic int 381201360Srdivackyng_btsocket_hci_raw_send_ngmsg(char *path, int cmd, void *arg, int arglen) 382201360Srdivacky{ 383201360Srdivacky struct ng_mesg *msg = NULL; 384200581Srdivacky int error = 0; 385200581Srdivacky 386200581Srdivacky NG_MKMESSAGE(msg, NGM_HCI_COOKIE, cmd, arglen, M_NOWAIT); 387201360Srdivacky if (msg == NULL) 388200581Srdivacky return (ENOMEM); 389200581Srdivacky 390200581Srdivacky if (arg != NULL && arglen > 0) 391200581Srdivacky bcopy(arg, msg->data, arglen); 392200581Srdivacky 393193323Sed NG_SEND_MSG_PATH(error, ng_btsocket_hci_raw_node, msg, path, 0); 394193323Sed 395199989Srdivacky return (error); 396199989Srdivacky} /* ng_btsocket_hci_raw_send_ngmsg */ 397199989Srdivacky 398201360Srdivacky/* 399193323Sed * Send Netgraph message to the node (no data) and wait for reply 400198090Srdivacky */ 401198090Srdivacky 402199989Srdivackystatic int 403201360Srdivackyng_btsocket_hci_raw_send_sync_ngmsg(ng_btsocket_hci_raw_pcb_p pcb, char *path, 404200581Srdivacky int cmd, void *rsp, int rsplen) 405200581Srdivacky{ 406200581Srdivacky struct ng_mesg *msg = NULL; 407200581Srdivacky int error = 0; 408200581Srdivacky 409200581Srdivacky mtx_assert(&pcb->pcb_mtx, MA_OWNED); 410200581Srdivacky 411198090Srdivacky NG_MKMESSAGE(msg, NGM_HCI_COOKIE, cmd, 0, M_NOWAIT); 412198090Srdivacky if (msg == NULL) 413193323Sed return (ENOMEM); 414199989Srdivacky 415198090Srdivacky ng_btsocket_hci_raw_get_token(&msg->header.token); 416198090Srdivacky pcb->token = msg->header.token; 417198090Srdivacky pcb->msg = NULL; 418198090Srdivacky 419199989Srdivacky NG_SEND_MSG_PATH(error, ng_btsocket_hci_raw_node, msg, path, 0); 420193323Sed if (error != 0) { 421198090Srdivacky pcb->token = 0; 422198090Srdivacky return (error); 423198090Srdivacky } 424193323Sed 425198090Srdivacky error = msleep(&pcb->msg, &pcb->pcb_mtx, PZERO|PCATCH, "hcictl", 426201360Srdivacky ng_btsocket_hci_raw_ioctl_timeout * hz); 427199989Srdivacky pcb->token = 0; 428200581Srdivacky 429198090Srdivacky if (error != 0) 430193323Sed return (error); 431198090Srdivacky 432193323Sed if (pcb->msg != NULL && pcb->msg->header.cmd == cmd) 433199989Srdivacky bcopy(pcb->msg->data, rsp, rsplen); 434193323Sed else 435193323Sed error = EINVAL; 436193323Sed 437199989Srdivacky NG_FREE_MSG(pcb->msg); /* checks for != NULL */ 438199989Srdivacky 439193323Sed return (0); 440193323Sed} /* ng_btsocket_hci_raw_send_sync_ngmsg */ 441202375Srdivacky 442202375Srdivacky/* 443202375Srdivacky * Create control information for the packet 444202375Srdivacky */ 445202375Srdivacky 446202375Srdivackystatic void 447202375Srdivackyng_btsocket_hci_raw_savctl(ng_btsocket_hci_raw_pcb_p pcb, struct mbuf **ctl, 448202375Srdivacky struct mbuf *m) 449202375Srdivacky{ 450202375Srdivacky int dir; 451202375Srdivacky struct timeval tv; 452202375Srdivacky 453202375Srdivacky mtx_assert(&pcb->pcb_mtx, MA_OWNED); 454202375Srdivacky 455202375Srdivacky if (pcb->flags & NG_BTSOCKET_HCI_RAW_DIRECTION) { 456202375Srdivacky dir = (m->m_flags & M_PROTO1)? 1 : 0; 457202375Srdivacky *ctl = sbcreatecontrol((caddr_t) &dir, sizeof(dir), 458202375Srdivacky SCM_HCI_RAW_DIRECTION, SOL_HCI_RAW); 459202375Srdivacky if (*ctl != NULL) 460203954Srdivacky ctl = &((*ctl)->m_next); 461203954Srdivacky } 462203954Srdivacky 463203954Srdivacky if (pcb->so->so_options & SO_TIMESTAMP) { 464203954Srdivacky microtime(&tv); 465203954Srdivacky *ctl = sbcreatecontrol((caddr_t) &tv, sizeof(tv), 466203954Srdivacky SCM_TIMESTAMP, SOL_SOCKET); 467203954Srdivacky if (*ctl != NULL) 468203954Srdivacky ctl = &((*ctl)->m_next); 469203954Srdivacky } 470203954Srdivacky} /* ng_btsocket_hci_raw_savctl */ 471203954Srdivacky 472203954Srdivacky/* 473203954Srdivacky * Raw HCI sockets data input routine 474203954Srdivacky */ 475202375Srdivacky 476202375Srdivackystatic void 477202375Srdivackyng_btsocket_hci_raw_data_input(struct mbuf *nam) 478202375Srdivacky{ 479202375Srdivacky ng_btsocket_hci_raw_pcb_p pcb = NULL; 480202375Srdivacky struct mbuf *m0 = NULL, *m = NULL; 481202375Srdivacky struct sockaddr_hci *sa = NULL; 482202375Srdivacky 483202375Srdivacky m0 = nam->m_next; 484202375Srdivacky nam->m_next = NULL; 485202375Srdivacky 486202375Srdivacky KASSERT((nam->m_type == MT_SONAME), 487202375Srdivacky ("%s: m_type=%d\n", __func__, nam->m_type)); 488202375Srdivacky KASSERT((m0->m_flags & M_PKTHDR), 489202375Srdivacky ("%s: m_flags=%#x\n", __func__, m0->m_flags)); 490202375Srdivacky 491202375Srdivacky sa = mtod(nam, struct sockaddr_hci *); 492202375Srdivacky 493202375Srdivacky mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); 494202375Srdivacky 495202375Srdivacky LIST_FOREACH(pcb, &ng_btsocket_hci_raw_sockets, next) { 496202375Srdivacky 497202375Srdivacky mtx_lock(&pcb->pcb_mtx); 498202375Srdivacky 499202375Srdivacky /* 500202375Srdivacky * If socket was bound then check address and 501202375Srdivacky * make sure it matches. 502202375Srdivacky */ 503202375Srdivacky 504202375Srdivacky if (pcb->addr.hci_node[0] != 0 && 505202375Srdivacky strcmp(sa->hci_node, pcb->addr.hci_node) != 0) 506202375Srdivacky goto next; 507203954Srdivacky 508203954Srdivacky /* 509203954Srdivacky * Check packet against filters 510202375Srdivacky * XXX do we have to call m_pullup() here? 511202375Srdivacky */ 512202375Srdivacky 513202375Srdivacky if (ng_btsocket_hci_raw_filter(pcb, m0, 1) != 0) 514202375Srdivacky goto next; 515202375Srdivacky 516202375Srdivacky /* 517202375Srdivacky * Make a copy of the packet, append to the socket's 518202375Srdivacky * receive queue and wakeup socket. sbappendaddr() 519202375Srdivacky * will check if socket has enough buffer space. 520202375Srdivacky */ 521202375Srdivacky 522202375Srdivacky m = m_dup(m0, M_DONTWAIT); 523202375Srdivacky if (m != NULL) { 524202375Srdivacky struct mbuf *ctl = NULL; 525202375Srdivacky 526202375Srdivacky ng_btsocket_hci_raw_savctl(pcb, &ctl, m); 527202375Srdivacky 528202375Srdivacky if (sbappendaddr(&pcb->so->so_rcv, 529202375Srdivacky (struct sockaddr *) sa, m, ctl)) 530202375Srdivacky sorwakeup(pcb->so); 531202375Srdivacky else { 532202375Srdivacky NG_BTSOCKET_HCI_RAW_INFO( 533202375Srdivacky"%s: sbappendaddr() failed\n", __func__); 534202375Srdivacky 535202375Srdivacky NG_FREE_M(m); 536202375Srdivacky NG_FREE_M(ctl); 537202375Srdivacky } 538202375Srdivacky } 539202375Srdivackynext: 540202375Srdivacky mtx_unlock(&pcb->pcb_mtx); 541202375Srdivacky } 542202375Srdivacky 543202375Srdivacky mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 544202375Srdivacky 545202375Srdivacky NG_FREE_M(nam); 546202375Srdivacky NG_FREE_M(m0); 547193323Sed} /* ng_btsocket_hci_raw_data_input */ 548193323Sed 549193323Sed/* 550198090Srdivacky * Raw HCI sockets message input routine 551193323Sed */ 552198090Srdivacky 553193323Sedstatic void 554193323Sedng_btsocket_hci_raw_msg_input(struct ng_mesg *msg) 555193323Sed{ 556198090Srdivacky ng_btsocket_hci_raw_pcb_p pcb = NULL; 557202375Srdivacky 558202375Srdivacky mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); 559198090Srdivacky 560193323Sed LIST_FOREACH(pcb, &ng_btsocket_hci_raw_sockets, next) { 561193323Sed mtx_lock(&pcb->pcb_mtx); 562193323Sed 563198090Srdivacky if (msg->header.token == pcb->token) { 564193323Sed pcb->msg = msg; 565193323Sed wakeup(&pcb->msg); 566193323Sed 567193323Sed mtx_unlock(&pcb->pcb_mtx); 568198090Srdivacky mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 569193323Sed 570193323Sed return; 571193323Sed } 572198090Srdivacky 573193323Sed mtx_unlock(&pcb->pcb_mtx); 574193323Sed } 575193323Sed 576198090Srdivacky mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 577193323Sed 578193323Sed NG_FREE_MSG(msg); /* checks for != NULL */ 579198090Srdivacky} /* ng_btsocket_hci_raw_msg_input */ 580193323Sed 581193323Sed/* 582198090Srdivacky * Raw HCI sockets input routines 583193323Sed */ 584193323Sed 585193323Sedstatic void 586198090Srdivackyng_btsocket_hci_raw_input(void *context, int pending) 587193323Sed{ 588193323Sed item_p item = NULL; 589193323Sed 590198090Srdivacky for (;;) { 591198090Srdivacky mtx_lock(&ng_btsocket_hci_raw_queue_mtx); 592198090Srdivacky NG_BT_ITEMQ_DEQUEUE(&ng_btsocket_hci_raw_queue, item); 593198090Srdivacky mtx_unlock(&ng_btsocket_hci_raw_queue_mtx); 594193323Sed 595193323Sed if (item == NULL) 596193323Sed break; 597193323Sed 598202375Srdivacky switch(item->el_flags & NGQF_TYPE) { 599193323Sed case NGQF_DATA: { 600193323Sed struct mbuf *m = NULL; 601193323Sed 602193323Sed NGI_GET_M(item, m); 603193323Sed ng_btsocket_hci_raw_data_input(m); 604193323Sed } break; 605193323Sed 606193323Sed case NGQF_MESG: { 607193323Sed struct ng_mesg *msg = NULL; 608193323Sed 609198090Srdivacky NGI_GET_MSG(item, msg); 610198090Srdivacky ng_btsocket_hci_raw_msg_input(msg); 611193323Sed } break; 612202375Srdivacky 613193323Sed default: 614193323Sed KASSERT(0, 615193323Sed("%s: invalid item type=%ld\n", __func__, (item->el_flags & NGQF_TYPE))); 616193323Sed break; 617193323Sed } 618193323Sed 619193323Sed NG_FREE_ITEM(item); 620193323Sed } 621193323Sed} /* ng_btsocket_hci_raw_input */ 622193323Sed 623193323Sed/* 624198090Srdivacky * Raw HCI sockets output routine 625202375Srdivacky */ 626193323Sed 627198090Srdivackystatic void 628193323Sedng_btsocket_hci_raw_output(node_p node, hook_p hook, void *arg1, int arg2) 629193323Sed{ 630200581Srdivacky struct mbuf *nam = (struct mbuf *) arg1, *m = NULL; 631200581Srdivacky struct sockaddr_hci *sa = NULL; 632193323Sed int error; 633200581Srdivacky 634200581Srdivacky m = nam->m_next; 635200581Srdivacky nam->m_next = NULL; 636200581Srdivacky 637200581Srdivacky KASSERT((nam->m_type == MT_SONAME), 638200581Srdivacky ("%s: m_type=%d\n", __func__, nam->m_type)); 639200581Srdivacky KASSERT((m->m_flags & M_PKTHDR), 640200581Srdivacky ("%s: m_flags=%#x\n", __func__, m->m_flags)); 641202375Srdivacky 642200581Srdivacky sa = mtod(nam, struct sockaddr_hci *); 643200581Srdivacky 644200581Srdivacky /* 645200581Srdivacky * Find downstream hook 646200581Srdivacky * XXX For now access node hook list directly. Should be safe because 647200581Srdivacky * we used ng_send_fn() and we should have exclusive lock on the node. 648200581Srdivacky */ 649193323Sed 650200581Srdivacky LIST_FOREACH(hook, &node->nd_hooks, hk_hooks) { 651200581Srdivacky if (hook == NULL || NG_HOOK_NOT_VALID(hook) || 652193323Sed NG_NODE_NOT_VALID(NG_PEER_NODE(hook))) 653200581Srdivacky continue; 654193323Sed 655193323Sed if (strcmp(sa->hci_node, NG_PEER_NODE_NAME(hook)) == 0) { 656202375Srdivacky NG_SEND_DATA_ONLY(error, hook, m); /* sets m to NULL */ 657193323Sed break; 658200581Srdivacky } 659193323Sed } 660200581Srdivacky 661200581Srdivacky NG_FREE_M(nam); /* check for != NULL */ 662200581Srdivacky NG_FREE_M(m); 663200581Srdivacky} /* ng_btsocket_hci_raw_output */ 664200581Srdivacky 665200581Srdivacky/* 666193323Sed * Check frame against security and socket filters. 667200581Srdivacky * d (direction bit) == 1 means incoming frame. 668200581Srdivacky */ 669200581Srdivacky 670201360Srdivackystatic int 671200581Srdivackyng_btsocket_hci_raw_filter(ng_btsocket_hci_raw_pcb_p pcb, struct mbuf *m, int d) 672201360Srdivacky{ 673193323Sed int type, event, opcode; 674193323Sed 675200581Srdivacky mtx_assert(&pcb->pcb_mtx, MA_OWNED); 676200581Srdivacky 677200581Srdivacky switch ((type = *mtod(m, u_int8_t *))) { 678200581Srdivacky case NG_HCI_CMD_PKT: 679193323Sed if (!(pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED)) { 680200581Srdivacky opcode = le16toh(mtod(m, ng_hci_cmd_pkt_t *)->opcode); 681200581Srdivacky 682193323Sed if (!bit_test( 683200581Srdivackyng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF(opcode) - 1], 684193323SedNG_HCI_OCF(opcode) - 1)) 685193323Sed return (EPERM); 686202375Srdivacky } 687200581Srdivacky 688193323Sed if (d && !bit_test(pcb->filter.packet_mask, NG_HCI_CMD_PKT - 1)) 689198090Srdivacky return (EPERM); 690193323Sed break; 691193323Sed 692193323Sed case NG_HCI_ACL_DATA_PKT: 693193323Sed case NG_HCI_SCO_DATA_PKT: 694200581Srdivacky if (!(pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) || 695193323Sed !bit_test(pcb->filter.packet_mask, type - 1) || 696200581Srdivacky !d) 697193323Sed return (EPERM); 698198090Srdivacky break; 699202375Srdivacky 700193323Sed case NG_HCI_EVENT_PKT: 701198090Srdivacky if (!d) 702193323Sed return (EINVAL); 703193323Sed 704193323Sed event = mtod(m, ng_hci_event_pkt_t *)->event - 1; 705193323Sed 706193323Sed if (!(pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED)) 707193323Sed if (!bit_test(ng_btsocket_hci_raw_sec_filter->events, event)) 708193323Sed return (EPERM); 709193323Sed 710193323Sed if (!bit_test(pcb->filter.event_mask, event)) 711198090Srdivacky return (EPERM); 712202375Srdivacky break; 713193323Sed 714193323Sed default: 715193323Sed return (EINVAL); 716198090Srdivacky } 717202375Srdivacky 718202375Srdivacky return (0); 719193323Sed} /* ng_btsocket_hci_raw_filter */ 720202375Srdivacky 721193323Sed/* 722193323Sed * Initialize everything 723193323Sed */ 724193323Sed 725193323Sedvoid 726193323Sedng_btsocket_hci_raw_init(void) 727193323Sed{ 728193323Sed bitstr_t *f = NULL; 729193323Sed int error = 0; 730193323Sed 731202375Srdivacky ng_btsocket_hci_raw_node = NULL; 732193323Sed ng_btsocket_hci_raw_debug_level = NG_BTSOCKET_WARN_LEVEL; 733193323Sed ng_btsocket_hci_raw_ioctl_timeout = 5; 734193323Sed 735193323Sed /* Register Netgraph node type */ 736193323Sed error = ng_newtype(&typestruct); 737193323Sed if (error != 0) { 738193323Sed NG_BTSOCKET_HCI_RAW_ALERT( 739193323Sed"%s: Could not register Netgraph node type, error=%d\n", __func__, error); 740193323Sed 741193323Sed return; 742193323Sed } 743193323Sed 744193323Sed /* Create Netgrapg node */ 745193323Sed error = ng_make_node_common(&typestruct, &ng_btsocket_hci_raw_node); 746193323Sed if (error != 0) { 747198090Srdivacky NG_BTSOCKET_HCI_RAW_ALERT( 748193323Sed"%s: Could not create Netgraph node, error=%d\n", __func__, error); 749193323Sed 750193323Sed ng_btsocket_hci_raw_node = NULL; 751199989Srdivacky 752193323Sed return; 753199989Srdivacky } 754193323Sed 755193323Sed error = ng_name_node(ng_btsocket_hci_raw_node, 756193323Sed NG_BTSOCKET_HCI_RAW_NODE_TYPE); 757193323Sed if (error != 0) { 758193323Sed NG_BTSOCKET_HCI_RAW_ALERT( 759193323Sed"%s: Could not name Netgraph node, error=%d\n", __func__, error); 760193323Sed 761193323Sed NG_NODE_UNREF(ng_btsocket_hci_raw_node); 762193323Sed ng_btsocket_hci_raw_node = NULL; 763193323Sed 764202375Srdivacky return; 765193323Sed } 766198090Srdivacky 767193323Sed /* Create input queue */ 768193323Sed NG_BT_ITEMQ_INIT(&ng_btsocket_hci_raw_queue, ifqmaxlen); 769193323Sed mtx_init(&ng_btsocket_hci_raw_queue_mtx, 770193323Sed "btsocks_hci_raw_queue_mtx", NULL, MTX_DEF); 771193323Sed TASK_INIT(&ng_btsocket_hci_raw_task, 0, 772193323Sed ng_btsocket_hci_raw_input, NULL); 773193323Sed 774193323Sed /* Create list of sockets */ 775193323Sed LIST_INIT(&ng_btsocket_hci_raw_sockets); 776193323Sed mtx_init(&ng_btsocket_hci_raw_sockets_mtx, 777193323Sed "btsocks_hci_raw_sockets_mtx", NULL, MTX_DEF); 778193323Sed 779193323Sed /* Tokens */ 780193323Sed ng_btsocket_hci_raw_token = 0; 781193323Sed mtx_init(&ng_btsocket_hci_raw_token_mtx, 782193323Sed "btsocks_hci_raw_token_mtx", NULL, MTX_DEF); 783193323Sed 784193323Sed /* 785201360Srdivacky * Security filter 786198090Srdivacky * XXX never FREE()ed 787193323Sed */ 788193323Sed 789193323Sed ng_btsocket_hci_raw_sec_filter = NULL; 790193323Sed 791193323Sed MALLOC(ng_btsocket_hci_raw_sec_filter, 792193323Sed struct ng_btsocket_hci_raw_sec_filter *, 793193323Sed sizeof(struct ng_btsocket_hci_raw_sec_filter), 794193323Sed M_NETGRAPH_BTSOCKET_HCI_RAW, M_NOWAIT|M_ZERO); 795193323Sed if (ng_btsocket_hci_raw_sec_filter == NULL) { 796193323Sed printf("%s: Could not allocate security filter!\n", __func__); 797193323Sed return; 798193323Sed } 799193323Sed 800193323Sed /* 801193323Sed * XXX How paranoid can we get? 802193323Sed * 803193323Sed * Initialize security filter. If bit is set in the mask then 804193323Sed * unprivileged socket is allowed to send (receive) this command 805193323Sed * (event). 806193323Sed */ 807193323Sed 808193323Sed /* Enable all events */ 809202375Srdivacky memset(&ng_btsocket_hci_raw_sec_filter->events, 0xff, 810193323Sed sizeof(ng_btsocket_hci_raw_sec_filter->events)/ 811193323Sed sizeof(ng_btsocket_hci_raw_sec_filter->events[0])); 812193323Sed 813193323Sed /* Disable some critical events */ 814193323Sed f = ng_btsocket_hci_raw_sec_filter->events; 815193323Sed bit_clear(f, NG_HCI_EVENT_RETURN_LINK_KEYS - 1); 816193323Sed bit_clear(f, NG_HCI_EVENT_LINK_KEY_NOTIFICATION - 1); 817193323Sed bit_clear(f, NG_HCI_EVENT_VENDOR - 1); 818193323Sed 819193323Sed /* Commands - Link control */ 820193323Sed f = ng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF_LINK_CONTROL-1]; 821203954Srdivacky bit_set(f, NG_HCI_OCF_INQUIRY - 1); 822199989Srdivacky bit_set(f, NG_HCI_OCF_INQUIRY_CANCEL - 1); 823193323Sed bit_set(f, NG_HCI_OCF_PERIODIC_INQUIRY - 1); 824193323Sed bit_set(f, NG_HCI_OCF_EXIT_PERIODIC_INQUIRY - 1); 825193323Sed bit_set(f, NG_HCI_OCF_REMOTE_NAME_REQ - 1); 826193323Sed bit_set(f, NG_HCI_OCF_READ_REMOTE_FEATURES - 1); 827193323Sed bit_set(f, NG_HCI_OCF_READ_REMOTE_VER_INFO - 1); 828193323Sed bit_set(f, NG_HCI_OCF_READ_CLOCK_OFFSET - 1); 829193323Sed 830193323Sed /* Commands - Link policy */ 831193323Sed f = ng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF_LINK_POLICY-1]; 832193323Sed bit_set(f, NG_HCI_OCF_ROLE_DISCOVERY - 1); 833193323Sed bit_set(f, NG_HCI_OCF_READ_LINK_POLICY_SETTINGS - 1); 834193323Sed 835193323Sed /* Commands - Host controller and baseband */ 836193323Sed f = ng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF_HC_BASEBAND-1]; 837193323Sed bit_set(f, NG_HCI_OCF_READ_PIN_TYPE - 1); 838193323Sed bit_set(f, NG_HCI_OCF_READ_LOCAL_NAME - 1); 839202375Srdivacky bit_set(f, NG_HCI_OCF_READ_CON_ACCEPT_TIMO - 1); 840202375Srdivacky bit_set(f, NG_HCI_OCF_READ_PAGE_TIMO - 1); 841202375Srdivacky bit_set(f, NG_HCI_OCF_READ_SCAN_ENABLE - 1); 842202375Srdivacky bit_set(f, NG_HCI_OCF_READ_PAGE_SCAN_ACTIVITY - 1); 843193323Sed bit_set(f, NG_HCI_OCF_READ_INQUIRY_SCAN_ACTIVITY - 1); 844193323Sed bit_set(f, NG_HCI_OCF_READ_AUTH_ENABLE - 1); 845193323Sed bit_set(f, NG_HCI_OCF_READ_ENCRYPTION_MODE - 1); 846193323Sed bit_set(f, NG_HCI_OCF_READ_UNIT_CLASS - 1); 847193323Sed bit_set(f, NG_HCI_OCF_READ_VOICE_SETTINGS - 1); 848193323Sed bit_set(f, NG_HCI_OCF_READ_AUTO_FLUSH_TIMO - 1); 849193323Sed bit_set(f, NG_HCI_OCF_READ_NUM_BROADCAST_RETRANS - 1); 850193323Sed bit_set(f, NG_HCI_OCF_READ_HOLD_MODE_ACTIVITY - 1); 851193323Sed bit_set(f, NG_HCI_OCF_READ_XMIT_LEVEL - 1); 852193323Sed bit_set(f, NG_HCI_OCF_READ_SCO_FLOW_CONTROL - 1); 853199989Srdivacky bit_set(f, NG_HCI_OCF_READ_LINK_SUPERVISION_TIMO - 1); 854193323Sed bit_set(f, NG_HCI_OCF_READ_SUPPORTED_IAC_NUM - 1); 855193323Sed bit_set(f, NG_HCI_OCF_READ_IAC_LAP - 1); 856193323Sed bit_set(f, NG_HCI_OCF_READ_PAGE_SCAN_PERIOD - 1); 857193323Sed bit_set(f, NG_HCI_OCF_READ_PAGE_SCAN - 1); 858193323Sed 859193323Sed /* Commands - Informational */ 860193323Sed f = ng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF_INFO - 1]; 861193323Sed bit_set(f, NG_HCI_OCF_READ_LOCAL_VER - 1); 862199989Srdivacky bit_set(f, NG_HCI_OCF_READ_LOCAL_FEATURES - 1); 863193323Sed bit_set(f, NG_HCI_OCF_READ_BUFFER_SIZE - 1); 864199989Srdivacky bit_set(f, NG_HCI_OCF_READ_COUNTRY_CODE - 1); 865193323Sed bit_set(f, NG_HCI_OCF_READ_BDADDR - 1); 866193323Sed 867193323Sed /* Commands - Status */ 868193323Sed f = ng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF_STATUS - 1]; 869193323Sed bit_set(f, NG_HCI_OCF_READ_FAILED_CONTACT_CNTR - 1); 870193323Sed bit_set(f, NG_HCI_OCF_GET_LINK_QUALITY - 1); 871193323Sed bit_set(f, NG_HCI_OCF_READ_RSSI - 1); 872193323Sed 873200581Srdivacky /* Commands - Testing */ 874193323Sed f = ng_btsocket_hci_raw_sec_filter->commands[NG_HCI_OGF_TESTING - 1]; 875202375Srdivacky bit_set(f, NG_HCI_OCF_READ_LOOPBACK_MODE - 1); 876193323Sed} /* ng_btsocket_hci_raw_init */ 877193323Sed 878198090Srdivacky/* 879198090Srdivacky * Abort connection on socket 880193323Sed */ 881193323Sed 882193323Sedint 883201360Srdivackyng_btsocket_hci_raw_abort(struct socket *so) 884200581Srdivacky{ 885202375Srdivacky return (ng_btsocket_hci_raw_detach(so)); 886200581Srdivacky} /* ng_btsocket_hci_raw_abort */ 887200581Srdivacky 888193323Sed/* 889200581Srdivacky * Create new raw HCI socket 890193323Sed */ 891200581Srdivacky 892200581Srdivackyint 893200581Srdivackyng_btsocket_hci_raw_attach(struct socket *so, int proto, struct thread *td) 894193323Sed{ 895193323Sed ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 896193323Sed int error = 0; 897193323Sed 898202375Srdivacky if (pcb != NULL) 899193323Sed return (EISCONN); 900193323Sed 901193323Sed if (ng_btsocket_hci_raw_node == NULL) 902202375Srdivacky return (EPROTONOSUPPORT); 903193323Sed if (proto != BLUETOOTH_PROTO_HCI) 904193323Sed return (EPROTONOSUPPORT); 905193323Sed if (so->so_type != SOCK_RAW) 906193323Sed return (ESOCKTNOSUPPORT); 907193323Sed 908199989Srdivacky error = soreserve(so, NG_BTSOCKET_HCI_RAW_SENDSPACE, 909200581Srdivacky NG_BTSOCKET_HCI_RAW_RECVSPACE); 910199989Srdivacky if (error != 0) 911199989Srdivacky return (error); 912199989Srdivacky 913199989Srdivacky MALLOC(pcb, ng_btsocket_hci_raw_pcb_p, sizeof(*pcb), 914199989Srdivacky M_NETGRAPH_BTSOCKET_HCI_RAW, M_NOWAIT|M_ZERO); 915199989Srdivacky if (pcb == NULL) 916199989Srdivacky return (ENOMEM); 917193323Sed 918193323Sed so->so_pcb = (caddr_t) pcb; 919193323Sed pcb->so = so; 920193323Sed 921193323Sed if (suser(td) == 0) 922193323Sed pcb->flags |= NG_BTSOCKET_HCI_RAW_PRIVILEGED; 923193323Sed 924193323Sed /* 925193323Sed * Set default socket filter. By default socket only accepts HCI 926193323Sed * Command_Complete and Command_Status event packets. 927202375Srdivacky */ 928193323Sed 929193323Sed bit_set(pcb->filter.event_mask, NG_HCI_EVENT_COMMAND_COMPL - 1); 930193323Sed bit_set(pcb->filter.event_mask, NG_HCI_EVENT_COMMAND_STATUS - 1); 931193323Sed 932193323Sed mtx_init(&pcb->pcb_mtx, "btsocks_hci_raw_pcb_mtx", NULL, MTX_DEF); 933198090Srdivacky 934193323Sed mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); 935193323Sed LIST_INSERT_HEAD(&ng_btsocket_hci_raw_sockets, pcb, next); 936193323Sed mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 937193323Sed 938193323Sed return (0); 939193323Sed} /* ng_btsocket_hci_raw_attach */ 940193323Sed 941193323Sed/* 942193323Sed * Bind raw HCI socket 943199989Srdivacky */ 944199989Srdivacky 945193323Sedint 946193323Sedng_btsocket_hci_raw_bind(struct socket *so, struct sockaddr *nam, 947193323Sed struct thread *td) 948193323Sed{ 949193323Sed ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 950193323Sed struct sockaddr_hci *sa = (struct sockaddr_hci *) nam; 951193323Sed 952193323Sed if (pcb == NULL) 953193323Sed return (EINVAL); 954193323Sed if (ng_btsocket_hci_raw_node == NULL) 955193323Sed return (EINVAL); 956202375Srdivacky 957193323Sed if (sa == NULL) 958193323Sed return (EINVAL); 959202375Srdivacky if (sa->hci_family != AF_BLUETOOTH) 960199989Srdivacky return (EAFNOSUPPORT); 961199989Srdivacky if (sa->hci_len != sizeof(*sa)) 962202375Srdivacky return (EINVAL); 963199989Srdivacky if (sa->hci_node[0] == 0) 964199989Srdivacky return (EINVAL); 965198090Srdivacky 966193323Sed bcopy(sa, &pcb->addr, sizeof(pcb->addr)); 967193323Sed 968199989Srdivacky return (0); 969199989Srdivacky} /* ng_btsocket_hci_raw_bind */ 970199989Srdivacky 971199989Srdivacky/* 972199989Srdivacky * Connect raw HCI socket 973203954Srdivacky */ 974193323Sed 975199989Srdivackyint 976193323Sedng_btsocket_hci_raw_connect(struct socket *so, struct sockaddr *nam, 977193323Sed struct thread *td) 978193323Sed{ 979199989Srdivacky ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 980193323Sed struct sockaddr_hci *sa = (struct sockaddr_hci *) nam; 981193323Sed 982193323Sed if (pcb == NULL) 983199989Srdivacky return (EINVAL); 984193323Sed if (ng_btsocket_hci_raw_node == NULL) 985199989Srdivacky return (EINVAL); 986193323Sed 987199989Srdivacky if (sa == NULL) 988199989Srdivacky return (EINVAL); 989193323Sed if (sa->hci_family != AF_BLUETOOTH) 990199989Srdivacky return (EAFNOSUPPORT); 991199989Srdivacky if (sa->hci_len != sizeof(*sa)) 992193323Sed return (EINVAL); 993199989Srdivacky if (sa->hci_node[0] == 0) 994198090Srdivacky return (EDESTADDRREQ); 995193323Sed if (bcmp(sa, &pcb->addr, sizeof(pcb->addr)) != 0) 996199989Srdivacky return (EADDRNOTAVAIL); 997193323Sed 998199989Srdivacky soisconnected(so); 999199989Srdivacky 1000193323Sed return (0); 1001193323Sed} /* ng_btsocket_hci_raw_connect */ 1002199989Srdivacky 1003199989Srdivacky/* 1004199989Srdivacky * Process ioctl on socket 1005193323Sed */ 1006199989Srdivacky 1007199989Srdivackyint 1008199989Srdivackyng_btsocket_hci_raw_control(struct socket *so, u_long cmd, caddr_t data, 1009198090Srdivacky struct ifnet *ifp, struct thread *td) 1010198090Srdivacky{ 1011199989Srdivacky ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 1012193323Sed char path[NG_NODESIZ + 1]; 1013199989Srdivacky struct ng_mesg *msg = NULL; 1014193323Sed int error = 0; 1015193323Sed 1016193323Sed if (pcb == NULL) 1017199989Srdivacky return (EINVAL); 1018199989Srdivacky if (ng_btsocket_hci_raw_node == NULL) 1019193323Sed return (EINVAL); 1020203954Srdivacky 1021193323Sed mtx_lock(&pcb->pcb_mtx); 1022193323Sed 1023193323Sed /* Check if we have device name */ 1024199989Srdivacky if (pcb->addr.hci_node[0] == 0) { 1025202375Srdivacky mtx_unlock(&pcb->pcb_mtx); 1026202375Srdivacky return (EHOSTUNREACH); 1027199989Srdivacky } 1028202375Srdivacky 1029202375Srdivacky /* Check if we have pending ioctl() */ 1030199989Srdivacky if (pcb->token != 0) { 1031193323Sed mtx_unlock(&pcb->pcb_mtx); 1032193323Sed return (EBUSY); 1033193323Sed } 1034199989Srdivacky 1035193323Sed snprintf(path, sizeof(path), "%s:", pcb->addr.hci_node); 1036199989Srdivacky 1037202375Srdivacky switch (cmd) { 1038202375Srdivacky case SIOC_HCI_RAW_NODE_GET_STATE: { 1039202375Srdivacky struct ng_btsocket_hci_raw_node_state *p = 1040193323Sed (struct ng_btsocket_hci_raw_node_state *) data; 1041193323Sed 1042193323Sed error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1043193323Sed NGM_HCI_NODE_GET_STATE, 1044193323Sed &p->state, sizeof(p->state)); 1045199989Srdivacky } break; 1046193323Sed 1047193323Sed case SIOC_HCI_RAW_NODE_INIT: 1048193323Sed if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1049193323Sed error = ng_btsocket_hci_raw_send_ngmsg(path, 1050199989Srdivacky NGM_HCI_NODE_INIT, NULL, 0); 1051193323Sed else 1052199989Srdivacky error = EPERM; 1053193323Sed break; 1054199989Srdivacky 1055199989Srdivacky case SIOC_HCI_RAW_NODE_GET_DEBUG: { 1056193323Sed struct ng_btsocket_hci_raw_node_debug *p = 1057199989Srdivacky (struct ng_btsocket_hci_raw_node_debug *) data; 1058199989Srdivacky 1059193323Sed error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1060199989Srdivacky NGM_HCI_NODE_GET_DEBUG, 1061193323Sed &p->debug, sizeof(p->debug)); 1062198090Srdivacky } break; 1063193323Sed 1064199989Srdivacky case SIOC_HCI_RAW_NODE_SET_DEBUG: { 1065199989Srdivacky struct ng_btsocket_hci_raw_node_debug *p = 1066193323Sed (struct ng_btsocket_hci_raw_node_debug *) data; 1067199989Srdivacky 1068199989Srdivacky if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1069193323Sed error = ng_btsocket_hci_raw_send_ngmsg(path, 1070199989Srdivacky NGM_HCI_NODE_SET_DEBUG, &p->debug, 1071198090Srdivacky sizeof(p->debug)); 1072193323Sed else 1073199989Srdivacky error = EPERM; 1074199989Srdivacky } break; 1075193323Sed 1076203954Srdivacky case SIOC_HCI_RAW_NODE_GET_BUFFER: { 1077193323Sed struct ng_btsocket_hci_raw_node_buffer *p = 1078193323Sed (struct ng_btsocket_hci_raw_node_buffer *) data; 1079199989Srdivacky 1080198090Srdivacky error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1081199989Srdivacky NGM_HCI_NODE_GET_BUFFER, 1082198090Srdivacky &p->buffer, sizeof(p->buffer)); 1083199989Srdivacky } break; 1084193323Sed 1085193323Sed case SIOC_HCI_RAW_NODE_GET_BDADDR: { 1086202375Srdivacky struct ng_btsocket_hci_raw_node_bdaddr *p = 1087198090Srdivacky (struct ng_btsocket_hci_raw_node_bdaddr *) data; 1088199989Srdivacky 1089193323Sed error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1090193323Sed NGM_HCI_NODE_GET_BDADDR, 1091193323Sed &p->bdaddr, sizeof(p->bdaddr)); 1092193323Sed } break; 1093199989Srdivacky 1094198090Srdivacky case SIOC_HCI_RAW_NODE_GET_FEATURES: { 1095193323Sed struct ng_btsocket_hci_raw_node_features *p = 1096193323Sed (struct ng_btsocket_hci_raw_node_features *) data; 1097199989Srdivacky 1098199989Srdivacky error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1099203954Srdivacky NGM_HCI_NODE_GET_FEATURES, 1100193323Sed &p->features, sizeof(p->features)); 1101193323Sed } break; 1102199989Srdivacky 1103193323Sed case SIOC_HCI_RAW_NODE_GET_STAT: { 1104193323Sed struct ng_btsocket_hci_raw_node_stat *p = 1105193323Sed (struct ng_btsocket_hci_raw_node_stat *) data; 1106193323Sed 1107198090Srdivacky error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1108193323Sed NGM_HCI_NODE_GET_STAT, 1109193323Sed &p->stat, sizeof(p->stat)); 1110199989Srdivacky } break; 1111193323Sed 1112199989Srdivacky case SIOC_HCI_RAW_NODE_RESET_STAT: 1113199989Srdivacky if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1114198090Srdivacky error = ng_btsocket_hci_raw_send_ngmsg(path, 1115193323Sed NGM_HCI_NODE_RESET_STAT, NULL, 0); 1116199989Srdivacky else 1117199989Srdivacky error = EPERM; 1118193323Sed break; 1119198090Srdivacky 1120193323Sed case SIOC_HCI_RAW_NODE_FLUSH_NEIGHBOR_CACHE: 1121193323Sed if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1122193323Sed error = ng_btsocket_hci_raw_send_ngmsg(path, 1123193323Sed NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE, 1124199989Srdivacky NULL, 0); 1125198090Srdivacky else 1126198090Srdivacky error = EPERM; 1127198090Srdivacky break; 1128198090Srdivacky 1129199989Srdivacky case SIOC_HCI_RAW_NODE_GET_NEIGHBOR_CACHE: { 1130199989Srdivacky struct ng_btsocket_hci_raw_node_neighbor_cache *p = 1131198090Srdivacky (struct ng_btsocket_hci_raw_node_neighbor_cache *) data; 1132202375Srdivacky ng_hci_node_get_neighbor_cache_ep *p1 = NULL; 1133202375Srdivacky ng_hci_node_neighbor_cache_entry_ep *p2 = NULL; 1134202375Srdivacky 1135202375Srdivacky if (p->num_entries <= 0 || 1136203954Srdivacky p->num_entries > NG_HCI_MAX_NEIGHBOR_NUM || 1137202375Srdivacky p->entries == NULL) { 1138202375Srdivacky error = EINVAL; 1139202375Srdivacky break; 1140202375Srdivacky } 1141202375Srdivacky 1142202375Srdivacky NG_MKMESSAGE(msg, NGM_HCI_COOKIE, 1143202375Srdivacky NGM_HCI_NODE_GET_NEIGHBOR_CACHE, 0, M_NOWAIT); 1144202375Srdivacky if (msg == NULL) { 1145202375Srdivacky error = ENOMEM; 1146202375Srdivacky break; 1147202375Srdivacky } 1148202375Srdivacky ng_btsocket_hci_raw_get_token(&msg->header.token); 1149193323Sed pcb->token = msg->header.token; 1150193323Sed pcb->msg = NULL; 1151193323Sed 1152198090Srdivacky NG_SEND_MSG_PATH(error, ng_btsocket_hci_raw_node, msg, path, 0); 1153193323Sed if (error != 0) { 1154199989Srdivacky pcb->token = 0; 1155199989Srdivacky break; 1156198090Srdivacky } 1157193323Sed 1158199989Srdivacky error = msleep(&pcb->msg, &pcb->pcb_mtx, 1159199989Srdivacky PZERO|PCATCH, "hcictl", 1160193323Sed ng_btsocket_hci_raw_ioctl_timeout * hz); 1161199989Srdivacky pcb->token = 0; 1162199989Srdivacky 1163193323Sed if (error != 0) 1164199989Srdivacky break; 1165193323Sed 1166199989Srdivacky if (pcb->msg != NULL && 1167193323Sed pcb->msg->header.cmd == NGM_HCI_NODE_GET_NEIGHBOR_CACHE) { 1168193323Sed /* Return data back to user space */ 1169193323Sed p1 = (ng_hci_node_get_neighbor_cache_ep *) 1170193323Sed (pcb->msg->data); 1171193323Sed p2 = (ng_hci_node_neighbor_cache_entry_ep *) 1172193323Sed (p1 + 1); 1173193323Sed 1174193323Sed p->num_entries = min(p->num_entries, p1->num_entries); 1175193323Sed if (p->num_entries > 0) 1176198090Srdivacky error = copyout((caddr_t) p2, 1177193323Sed (caddr_t) p->entries, 1178193323Sed p->num_entries * sizeof(*p2)); 1179193323Sed } else 1180193323Sed error = EINVAL; 1181198090Srdivacky 1182193323Sed NG_FREE_MSG(pcb->msg); /* checks for != NULL */ 1183193323Sed }break; 1184193323Sed 1185193323Sed case SIOC_HCI_RAW_NODE_GET_CON_LIST: { 1186193323Sed struct ng_btsocket_hci_raw_con_list *p = 1187193323Sed (struct ng_btsocket_hci_raw_con_list *) data; 1188193323Sed ng_hci_node_con_list_ep *p1 = NULL; 1189193323Sed ng_hci_node_con_ep *p2 = NULL; 1190193323Sed 1191193323Sed if (p->num_connections == 0 || 1192193323Sed p->num_connections > NG_HCI_MAX_CON_NUM || 1193193323Sed p->connections == NULL) { 1194193323Sed error = EINVAL; 1195193323Sed break; 1196193323Sed } 1197193323Sed 1198198090Srdivacky NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_NODE_GET_CON_LIST, 1199193323Sed 0, M_NOWAIT); 1200193323Sed if (msg == NULL) { 1201193323Sed error = ENOMEM; 1202198090Srdivacky break; 1203193323Sed } 1204193323Sed ng_btsocket_hci_raw_get_token(&msg->header.token); 1205193323Sed pcb->token = msg->header.token; 1206198090Srdivacky pcb->msg = NULL; 1207193323Sed 1208193323Sed NG_SEND_MSG_PATH(error, ng_btsocket_hci_raw_node, msg, path, 0); 1209193323Sed if (error != 0) { 1210198090Srdivacky pcb->token = 0; 1211193323Sed break; 1212193323Sed } 1213193323Sed 1214193323Sed error = msleep(&pcb->msg, &pcb->pcb_mtx, 1215193323Sed PZERO|PCATCH, "hcictl", 1216198090Srdivacky ng_btsocket_hci_raw_ioctl_timeout * hz); 1217193323Sed pcb->token = 0; 1218193323Sed 1219193323Sed if (error != 0) 1220193323Sed break; 1221193323Sed 1222193323Sed if (pcb->msg != NULL && 1223193323Sed pcb->msg->header.cmd == NGM_HCI_NODE_GET_CON_LIST) { 1224193323Sed /* Return data back to user space */ 1225193323Sed p1 = (ng_hci_node_con_list_ep *)(pcb->msg->data); 1226193323Sed p2 = (ng_hci_node_con_ep *)(p1 + 1); 1227198090Srdivacky 1228193323Sed p->num_connections = min(p->num_connections, 1229193323Sed p1->num_connections); 1230193323Sed if (p->num_connections > 0) 1231198090Srdivacky error = copyout((caddr_t) p2, 1232193323Sed (caddr_t) p->connections, 1233193323Sed p->num_connections * sizeof(*p2)); 1234193323Sed } else 1235198090Srdivacky error = EINVAL; 1236193323Sed 1237193323Sed NG_FREE_MSG(pcb->msg); /* checks for != NULL */ 1238193323Sed } break; 1239198090Srdivacky 1240193323Sed case SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK: { 1241193323Sed struct ng_btsocket_hci_raw_node_link_policy_mask *p = 1242193323Sed (struct ng_btsocket_hci_raw_node_link_policy_mask *) 1243198090Srdivacky data; 1244193323Sed 1245193323Sed error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1246198090Srdivacky NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK, 1247193323Sed &p->policy_mask, sizeof(p->policy_mask)); 1248193323Sed } break; 1249193323Sed 1250198090Srdivacky case SIOC_HCI_RAW_NODE_SET_LINK_POLICY_MASK: { 1251193323Sed struct ng_btsocket_hci_raw_node_link_policy_mask *p = 1252198090Srdivacky (struct ng_btsocket_hci_raw_node_link_policy_mask *) 1253193323Sed data; 1254193323Sed 1255193323Sed if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1256193323Sed error = ng_btsocket_hci_raw_send_ngmsg(path, 1257193323Sed NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK, 1258193323Sed &p->policy_mask, 1259193323Sed sizeof(p->policy_mask)); 1260193323Sed else 1261193323Sed error = EPERM; 1262193323Sed } break; 1263193323Sed 1264193323Sed case SIOC_HCI_RAW_NODE_GET_PACKET_MASK: { 1265193323Sed struct ng_btsocket_hci_raw_node_packet_mask *p = 1266193323Sed (struct ng_btsocket_hci_raw_node_packet_mask *) data; 1267193323Sed 1268193323Sed error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1269193323Sed NGM_HCI_NODE_GET_PACKET_MASK, 1270193323Sed &p->packet_mask, sizeof(p->packet_mask)); 1271198090Srdivacky } break; 1272193323Sed 1273193323Sed case SIOC_HCI_RAW_NODE_SET_PACKET_MASK: { 1274193323Sed struct ng_btsocket_hci_raw_node_packet_mask *p = 1275193323Sed (struct ng_btsocket_hci_raw_node_packet_mask *) data; 1276193323Sed 1277193323Sed if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1278193323Sed error = ng_btsocket_hci_raw_send_ngmsg(path, 1279193323Sed NGM_HCI_NODE_SET_PACKET_MASK, 1280193323Sed &p->packet_mask, 1281193323Sed sizeof(p->packet_mask)); 1282193323Sed else 1283193323Sed error = EPERM; 1284193323Sed } break; 1285198090Srdivacky 1286198090Srdivacky case SIOC_HCI_RAW_NODE_GET_ROLE_SWITCH: { 1287193323Sed struct ng_btsocket_hci_raw_node_role_switch *p = 1288198090Srdivacky (struct ng_btsocket_hci_raw_node_role_switch *) data; 1289193323Sed 1290193323Sed error = ng_btsocket_hci_raw_send_sync_ngmsg(pcb, path, 1291201360Srdivacky NGM_HCI_NODE_GET_ROLE_SWITCH, 1292193323Sed &p->role_switch, sizeof(p->role_switch)); 1293193323Sed } break; 1294193323Sed 1295193323Sed case SIOC_HCI_RAW_NODE_SET_ROLE_SWITCH: { 1296198090Srdivacky struct ng_btsocket_hci_raw_node_role_switch *p = 1297193323Sed (struct ng_btsocket_hci_raw_node_role_switch *) data; 1298193323Sed 1299193323Sed if (pcb->flags & NG_BTSOCKET_HCI_RAW_PRIVILEGED) 1300193323Sed error = ng_btsocket_hci_raw_send_ngmsg(path, 1301193323Sed NGM_HCI_NODE_SET_ROLE_SWITCH, 1302198090Srdivacky &p->role_switch, 1303193323Sed sizeof(p->role_switch)); 1304193323Sed else 1305193323Sed error = EPERM; 1306193323Sed } break; 1307193323Sed 1308193323Sed default: 1309193323Sed error = EINVAL; 1310193323Sed break; 1311193323Sed } 1312193323Sed 1313193323Sed mtx_unlock(&pcb->pcb_mtx); 1314193323Sed 1315193323Sed return (error); 1316193323Sed} /* ng_btsocket_hci_raw_control */ 1317193323Sed 1318193323Sed/* 1319193323Sed * Process getsockopt/setsockopt system calls 1320193323Sed */ 1321193323Sed 1322193323Sedint 1323193323Sedng_btsocket_hci_raw_ctloutput(struct socket *so, struct sockopt *sopt) 1324193323Sed{ 1325193323Sed ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 1326193323Sed struct ng_btsocket_hci_raw_filter filter; 1327193323Sed int error = 0, dir; 1328193323Sed 1329193323Sed if (pcb == NULL) 1330193323Sed return (EINVAL); 1331193323Sed if (ng_btsocket_hci_raw_node == NULL) 1332193323Sed return (EINVAL); 1333193323Sed 1334193323Sed if (sopt->sopt_level != SOL_HCI_RAW) 1335193323Sed return (0); 1336193323Sed 1337193323Sed mtx_lock(&pcb->pcb_mtx); 1338193323Sed 1339193323Sed switch (sopt->sopt_dir) { 1340193323Sed case SOPT_GET: 1341193323Sed switch (sopt->sopt_name) { 1342193323Sed case SO_HCI_RAW_FILTER: 1343193323Sed error = sooptcopyout(sopt, &pcb->filter, 1344203954Srdivacky sizeof(pcb->filter)); 1345193323Sed break; 1346193323Sed 1347193323Sed case SO_HCI_RAW_DIRECTION: 1348193323Sed dir = (pcb->flags & NG_BTSOCKET_HCI_RAW_DIRECTION)?1:0; 1349193323Sed error = sooptcopyout(sopt, &dir, sizeof(dir)); 1350193323Sed break; 1351193323Sed 1352193323Sed default: 1353193323Sed error = EINVAL; 1354193323Sed break; 1355203954Srdivacky } 1356203954Srdivacky break; 1357203954Srdivacky 1358203954Srdivacky case SOPT_SET: 1359193323Sed switch (sopt->sopt_name) { 1360203954Srdivacky case SO_HCI_RAW_FILTER: 1361203954Srdivacky error = sooptcopyin(sopt, &filter, sizeof(filter), 1362193323Sed sizeof(filter)); 1363203954Srdivacky if (error == 0) 1364203954Srdivacky bcopy(&filter, &pcb->filter, 1365203954Srdivacky sizeof(pcb->filter)); 1366203954Srdivacky break; 1367203954Srdivacky 1368193323Sed case SO_HCI_RAW_DIRECTION: 1369193323Sed error = sooptcopyin(sopt, &dir, sizeof(dir), 1370193323Sed sizeof(dir)); 1371193323Sed if (error != 0) 1372193323Sed break; 1373193323Sed 1374193323Sed if (dir) 1375193323Sed pcb->flags |= NG_BTSOCKET_HCI_RAW_DIRECTION; 1376193323Sed else 1377193323Sed pcb->flags &= ~NG_BTSOCKET_HCI_RAW_DIRECTION; 1378193323Sed break; 1379193323Sed 1380193323Sed default: 1381193323Sed error = EINVAL; 1382193323Sed break; 1383193323Sed } 1384193323Sed break; 1385193323Sed 1386193323Sed default: 1387193323Sed error = EINVAL; 1388193323Sed break; 1389193323Sed } 1390193323Sed 1391193323Sed mtx_unlock(&pcb->pcb_mtx); 1392193323Sed 1393193323Sed return (error); 1394193323Sed} /* ng_btsocket_hci_raw_ctloutput */ 1395193323Sed 1396193323Sed/* 1397193323Sed * Detach raw HCI socket 1398193323Sed */ 1399193323Sed 1400193323Sedint 1401193323Sedng_btsocket_hci_raw_detach(struct socket *so) 1402193323Sed{ 1403193323Sed ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 1404193323Sed 1405193323Sed if (pcb == NULL) 1406193323Sed return (EINVAL); 1407193323Sed if (ng_btsocket_hci_raw_node == NULL) 1408193323Sed return (EINVAL); 1409193323Sed 1410198090Srdivacky mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); 1411193323Sed mtx_lock(&pcb->pcb_mtx); 1412193323Sed 1413193323Sed LIST_REMOVE(pcb, next); 1414193323Sed 1415193323Sed mtx_unlock(&pcb->pcb_mtx); 1416193323Sed mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); 1417193323Sed 1418193323Sed mtx_destroy(&pcb->pcb_mtx); 1419203954Srdivacky 1420193323Sed bzero(pcb, sizeof(*pcb)); 1421193323Sed FREE(pcb, M_NETGRAPH_BTSOCKET_HCI_RAW); 1422202375Srdivacky 1423202375Srdivacky so->so_pcb = NULL; 1424198892Srdivacky sotryfree(so); 1425198892Srdivacky 1426198892Srdivacky return (0); 1427198892Srdivacky} /* ng_btsocket_hci_raw_detach */ 1428198892Srdivacky 1429202375Srdivacky/* 1430198892Srdivacky * Disconnect raw HCI socket 1431198892Srdivacky */ 1432198892Srdivacky 1433193323Sedint 1434202375Srdivackyng_btsocket_hci_raw_disconnect(struct socket *so) 1435203954Srdivacky{ 1436198892Srdivacky ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 1437198892Srdivacky 1438202375Srdivacky if (pcb == NULL) 1439202375Srdivacky return (EINVAL); 1440198892Srdivacky if (ng_btsocket_hci_raw_node == NULL) 1441198892Srdivacky return (EINVAL); 1442203954Srdivacky 1443198892Srdivacky soisdisconnected(so); 1444198892Srdivacky 1445198892Srdivacky return (0); 1446202375Srdivacky} /* ng_btsocket_hci_raw_disconnect */ 1447198892Srdivacky 1448198892Srdivacky/* 1449198892Srdivacky * Get socket peer's address 1450202878Srdivacky */ 1451198892Srdivacky 1452198892Srdivackyint 1453198892Srdivackyng_btsocket_hci_raw_peeraddr(struct socket *so, struct sockaddr **nam) 1454202375Srdivacky{ 1455202375Srdivacky return (ng_btsocket_hci_raw_sockaddr(so, nam)); 1456198892Srdivacky} /* ng_btsocket_hci_raw_peeraddr */ 1457202375Srdivacky 1458202375Srdivacky/* 1459198892Srdivacky * Send data 1460202375Srdivacky */ 1461202375Srdivacky 1462198892Srdivackyint 1463198892Srdivackyng_btsocket_hci_raw_send(struct socket *so, int flags, struct mbuf *m, 1464198892Srdivacky struct sockaddr *sa, struct mbuf *control, struct thread *td) 1465198892Srdivacky{ 1466198892Srdivacky ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 1467193323Sed struct mbuf *nam = NULL; 1468 int error = 0; 1469 1470 if (ng_btsocket_hci_raw_node == NULL) { 1471 error = ENETDOWN; 1472 goto drop; 1473 } 1474 if (pcb == NULL) { 1475 error = EINVAL; 1476 goto drop; 1477 } 1478 if (control != NULL) { 1479 error = EINVAL; 1480 goto drop; 1481 } 1482 1483 if (m->m_pkthdr.len < sizeof(ng_hci_cmd_pkt_t) || 1484 m->m_pkthdr.len > sizeof(ng_hci_cmd_pkt_t) + NG_HCI_CMD_PKT_SIZE) { 1485 error = EMSGSIZE; 1486 goto drop; 1487 } 1488 1489 if (m->m_len < sizeof(ng_hci_cmd_pkt_t)) { 1490 if ((m = m_pullup(m, sizeof(ng_hci_cmd_pkt_t))) == NULL) { 1491 error = ENOBUFS; 1492 goto drop; 1493 } 1494 } 1495 if (*mtod(m, u_int8_t *) != NG_HCI_CMD_PKT) { 1496 error = ENOTSUP; 1497 goto drop; 1498 } 1499 1500 mtx_lock(&pcb->pcb_mtx); 1501 1502 error = ng_btsocket_hci_raw_filter(pcb, m, 0); 1503 if (error != 0) { 1504 mtx_unlock(&pcb->pcb_mtx); 1505 goto drop; 1506 } 1507 1508 if (sa == NULL) { 1509 if (pcb->addr.hci_node[0] == 0) { 1510 mtx_unlock(&pcb->pcb_mtx); 1511 error = EDESTADDRREQ; 1512 goto drop; 1513 } 1514 1515 sa = (struct sockaddr *) &pcb->addr; 1516 } 1517 1518 MGET(nam, M_DONTWAIT, MT_SONAME); 1519 if (nam == NULL) { 1520 mtx_unlock(&pcb->pcb_mtx); 1521 error = ENOBUFS; 1522 goto drop; 1523 } 1524 1525 nam->m_len = sizeof(struct sockaddr_hci); 1526 bcopy(sa,mtod(nam, struct sockaddr_hci *),sizeof(struct sockaddr_hci)); 1527 1528 nam->m_next = m; 1529 m = NULL; 1530 1531 mtx_unlock(&pcb->pcb_mtx); 1532 1533 return (ng_send_fn(ng_btsocket_hci_raw_node, NULL, 1534 ng_btsocket_hci_raw_output, nam, 0)); 1535drop: 1536 NG_FREE_M(control); /* NG_FREE_M checks for != NULL */ 1537 NG_FREE_M(nam); 1538 NG_FREE_M(m); 1539 1540 return (error); 1541} /* ng_btsocket_hci_raw_send */ 1542 1543/* 1544 * Get socket address 1545 */ 1546 1547int 1548ng_btsocket_hci_raw_sockaddr(struct socket *so, struct sockaddr **nam) 1549{ 1550 ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); 1551 struct sockaddr_hci sa; 1552 1553 if (pcb == NULL) 1554 return (EINVAL); 1555 if (ng_btsocket_hci_raw_node == NULL) 1556 return (EINVAL); 1557 1558 bzero(&sa, sizeof(sa)); 1559 sa.hci_len = sizeof(sa); 1560 sa.hci_family = AF_BLUETOOTH; 1561 strlcpy(sa.hci_node, pcb->addr.hci_node, sizeof(sa.hci_node)); 1562 1563 *nam = dup_sockaddr((struct sockaddr *) &sa, 0); 1564 1565 return ((*nam == NULL)? ENOMEM : 0); 1566} /* ng_btsocket_hci_raw_sockaddr */ 1567 1568