diff options
96 files changed, 34992 insertions, 0 deletions
diff --git a/share/man/man4/ng_bluetooth.4 b/share/man/man4/ng_bluetooth.4 new file mode 100644 index 0000000..4022786 --- /dev/null +++ b/share/man/man4/ng_bluetooth.4 @@ -0,0 +1,109 @@ +.\" ng_bluetooth.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_bluetooth.4,v 1.2 2002/11/12 22:14:10 max Exp $ +.\" $FreeBSD$ +.Dd November 9, 2002 +.Dt NG_BLUETOOTH 4 +.Os +.Sh NAME +.Nm bluetooth +.Nd placeholder for global Bluetooth variables +.Sh SYNOPSIS +.In sys/types.h +.In ng_bluetooth.h +.Sh DESCRIPTION +The +.Nm +module is a placeholder for global Bluetooth variables. All Bluetooth +variables can be examined and changed via +.Xr sysctl 8 . +.Sh BLUETOOTH VARIABLES +Below is the description of default variables. Each Bluetooth module +might add its own variables to the tree. +.Bl -tag -width foobar +.It net.bluetooth.version +A read only integer variable that shows the current version of the +Bluetooth stack. +.It net.bluetooth.hci.command_timeout +A read-write interger variable that controls the Host Controller Interface +(HCI) command timeout (in seconds), i.e. how long the HCI layer will wait +for the +.Dv Command_Complete +or +.Dv Command_Status +event from a Bluetooth device. +.It net.bluetooth.hci.connection_timeout +A read-write integer variable that controls the HCI connection timeout, i.e. +how long the HCI layer will wait for the +.Dv Connection_Complete +event. Normaly this should not be required as Bluetooth devices have +connection timeout of their own and will send event back. This timeout +is required to ensure that no connection will stall in case when the HCI +transport layer is broken. Be careful when changing this variable. +Make sure you understand what you are doing. +.It net.bluetooth.hci.watchdog_timeout +A read-write integer variable that controls the HCI connection watchdog +timeout in seconds), i.e. how long the HCI layer should wait before +disconnecting an inactive baseband connection. +.Em This has not been implemented yet . +.It net.bluetooth.hci.max_neighbor_age +A read-write integer variable that controls time-to-live (in seconds) for +entries in the HCI neighbor cache. Every time a Bluetooth device performs +an +.Dv Inquiry +operation, the results will be put in cache. Later when a Bluetooth device +establishes a baseband connection, it will try to find the matching entry in +the cache and use it. This might speed up establishment of the baseband +connection. +.It net.bluetooth.l2cap.rtx_timeout +A read-write integer variable that controls the Link Layer Control and +Adaptation Protocol (L2CAP) Retransmission Timeout (RTX) (in seconds). +Every time the L2CAP layer submits a control command, the RTX timeout is set. +The value of the RTX timeout should be greater or equal to the value of +the HCI connection timeout. Be careful when changing this variable. Make +sure you understand what you are doing. +.It net.bluetooth.l2cap.ertx_timeout +A read-write integer variable that controls the L2CAP Extended Retransmission +Timeout (ERTX) (in seconds). In some cases remote peer may respond with +.Dv PENDING +status to the L2CAP control command. In this case the L2CAP command timeout +is reset to the ERTX timeout value. The value of the ERTX timeout should be +greater or equal to the value of the RTX timeout. Be careful when changing +this variable. Make sure you understand what you are doing. +.El +.Sh SEE ALSO +.Xr sysctl 8 , +.Xr ng_hci 4 , +.Xr ng_l2cap 4 , +.Xr ng_btsocket 4 +.Sh HISTORY +The +.Nm +module was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/share/man/man4/ng_bt3c.4 b/share/man/man4/ng_bt3c.4 new file mode 100644 index 0000000..f651ea9 --- /dev/null +++ b/share/man/man4/ng_bt3c.4 @@ -0,0 +1,136 @@ +.\" ng_bt3c.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_bt3c.4,v 1.3 2002/11/12 17:03:58 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt NG_BT3C 4 +.Os +.Sh NAME +.Nm BTCCC +.Nd Netgraph node type that is also a 3Com Bluetooth PC card driver +.Sh SYNOPSIS +.In sys/types.h +.In ng_bt3c.h +.Sh DESCRIPTION +The +.Nm BTCCC +node type is both a persistent Netgraph node type and a driver for +3Com Bluetooth PC card (3CRWB6096-HP). It implements a Bluetooth HCI +UART transport layer as per chapter H4 of the Bluetooth Specification +Book v1.1. A new node is created when the card is plugged. +.Pp +In order to use the card one +.Em MUST +download firmware first. Due to copyright issues I will no longer +provide firmware with the driver. The firmware can be obtained +from the Windows driver package that can be downloaded from the 3COM web +site at no charge. The firmware name is BT3CPCC.BIN. To load firmware +info the card use +.Xr bt3cfw 8 . +I'm using original firmware that came with the card on CD-ROM. +.Bd -literal -offset indent +MD5 (BT3CPCC.BIN) = 36170fda56ea9fdbf1702c966f8a97f1 +.Ed +.Pp +For OLDCARD systems the entry in +.Xr pccard.conf 5 +might look like this +.Bd -literal -offset indent +# 3Com 3CRWB60-A Bluetooth PC Card +card "3COM" "3CRWB60-A" "Bluetooth PC Card" + config auto "btccc" ? + insert /usr/sbin/bt3cfw -n $device -f /etc/BT3CPCC.bin +.Ed +.Pp +Do not forget to load module and SIGHUP +.Xr pccardd 8 . +.Pp +The node has a single hook called +.Dv hook . +Incoming bytes received on the device are re-assembled into HCI frames +(according to the length). Full HCI frames are sent out on the hook. HCI +frames received on +.Dv hook +are transmitted out. No modification to the data is performed in +either direction. +.Sh HOOKS +This node type supports the following hooks: +.Pp +.Bl -tag -width foobar +.It Dv hook +single HCI frame contained in single +.Dv mbuf +structure. +.El +.Sh CONTROL MESSAGES +This node type supports the generic control messages, plus the following: +.Bl -tag -width foo +.It Dv NGM_BT3C_NODE_GET_STATE +Returns current receiving state for the node. +.It Dv NGM_BT3C_NODE_GET_DEBUG +Returns an integer containing the current debug level for the node. +.It Dv NGM_BT3C_NODE_SET_DEBUG +This command takes an integer argument and sets current debug level +for the node. +.It Dv NGM_BT3C_NODE_GET_QLEN +This command takes a parameter that specifies queue number and returns +current length of the queue for the node. +.It Dv NGM_BT3C_NODE_SET_QLEN +This command takes two parameters that specify queue number and and +maximum length of the queue and sets maximum length of the queue for +the node. +.It Dv NGM_BT3C_NODE_GET_STAT +Returns various statistic information for the node, such as: number of +bytes (frames) sent, number of bytes (frames) received and number of +input (output) errors. +.It Dv NGM_BT3C_NODE_RESET_STAT +Reset all statistic counters to zero. +.It Dv NGM_BT3C_NODE_DOWNLOAD_FIRMWARE +Download card firmware. +.El +.Sh SHUTDOWN +This node shuts down when the corresponding card is un-plugged. +.Sh BUGS +The driver is based on information obrained from Jose Orlando Pereira +<jop@di.uminho.pt> and disassembled W2K driver. +.Sh SEE ALSO +.Xr cardbus 4 , +.Xr pccbb 4 , +.Xr pcic 4 , +.Xr pccardc 8 , +.Xr pccardd 8 , +.Xr pccard.conf 5 , +.Xr netgraph 4 , +.Xr ngctl 8 , +.Xr bt3cfw 8 +.Sh HISTORY +The +.Nm BTCCC +node type was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/share/man/man4/ng_btsocket.4 b/share/man/man4/ng_btsocket.4 new file mode 100644 index 0000000..bb2b360 --- /dev/null +++ b/share/man/man4/ng_btsocket.4 @@ -0,0 +1,255 @@ +.\" ng_btsocket.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_btsocket.4,v 1.4 2002/11/12 22:31:39 max Exp $ +.\" $FreeBSD$ +.Dd July 8, 2002 +.Dt NG_BTSOCKET 4 +.Os +.Sh NAME +.Nm btsocket +.Nd Bluetooth sockets layer +.Sh SYNOPSIS +.In sys/types.h +.In sys/socket.h +.In bitstring.h +.In netgraph.h +.In ng_hci.h +.In ng_l2cap.h +.In ng_btsocket.h +.Sh DESCRIPTION +The +.Nm +module implements three Netgraph node types. Each type in its turn implements +one protocol within +.Dv PF_BLUETOOTH +domain. +.Pp +.Sh BLUETOOTH_PROTO_HCI protocol +.Ss SOCK_RAW HCI sockets +Implemented by +.Cm btsock_hci_raw +Netgraph type. Raw HCI sockets allow sending of raw HCI command datagrams +only to correspondents named in +.Xr send 2 +calls. Raw HCI datagrams (HCI commands, events and data) are generally +received with +.Xr recvfrom 2 , +which returns the next datagram with its return address. Also raw HCI +sockets can be used to control HCI nodes. +.Pp +The Bluetooth raw HCI socket address is defined as follows: +.Bd -literal -offset indent +/* Bluetooth version of struct sockaddr for raw HCI sockets */ +struct sockaddr_hci { + u_char hci_len; /* total length */ + u_char hci_family; /* address family */ + char hci_node[16]; /* HCI node name */ +}; +.Ed +.Pp +Raw HCI sockets support number of +.Xr ioctl 2 +requests such as: +.Bl -tag -width foo +.It Dv SIOC_HCI_RAW_NODE_GET_STATE +Returns current state for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_INIT +Turn on +.Dq inited +bit for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_DEBUG +Returns current debug level for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_SET_DEBUG +Sets current debug level for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_BUFFER +Returns current state of data buffers for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_BDADDR +Returns BD_ADDR for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_FEATURES +Returns the list of features supported by hardware for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_STAT +Returns various statistic counters for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_RESET_STAT +Resets all statistic counters for the HCI node to zero. +.It Dv SIOC_HCI_RAW_NODE_FLUSH_NEIGHBOR_CACHE +Remove all neighbor cache entries for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_NEIGHBOR_CACHE +Returns content of the neighbor cache for the HCI node. +.It Dv SIOC_HCI_RAW_NODE_GET_CON_LIST +Returns list of active baseband connections (i.e. ACL and SCO links) for +the HCI node. +.It SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK +Returns current link policy settings mask for the HCI node. +.It SIOC_HCI_RAW_NODE_SET_LINK_POLICY_MASK +Sets current link policy settings mask for the HCI node. +.It SIOC_HCI_RAW_NODE_GET_PACKET_MASK +Returns current packet mask for the HCI node. +.It SIOC_HCI_RAW_NODE_SET_PACKET_MASK +Sets current packet mask for the HCI node. +.El +.Pp +Raw HCI sockets support filters. The application can filter certain +HCI datagram types. For HCI event datagrams the application can set +additional filter. The raw HCI socket filter defined as follows: +.Bd -literal -offset indent +/* + * Raw HCI socket filter. + * + * For packet mask use (1 << (HCI packet indicator - 1)) + * For event mask use (1 << (Event - 1)) + */ + +struct ng_btsocket_hci_raw_filter { + bitstr_t bit_decl(packet_mask, 32); + bitstr_t bit_decl(event_mask, (NG_HCI_EVENT_MASK_SIZE * 8)); +}; +.Ed +.Pp +The +.Dv SO_HCI_RAW_FILTER +option defined at +.Dv SOL_HCI_RAW +level can be used to obtain via +.Xr getsockopt 2 +or change via +.Xr setsockopt 2 +raw HCI socket's filter. +.Pp +.Sh BLUETOOTH_PROTO_L2CAP protocol +The Bluetooth L2CAP socket address is defined as follows: +.Bd -literal -offset indent +/* Bluetooth version of struct sockaddr for L2CAP sockets */ +struct sockaddr_l2cap { + u_char l2cap_len; /* total length */ + u_char l2cap_family; /* address family */ + u_int16_t l2cap_psm; /* Protocol/Service Multiplexor */ + bdaddr_t l2cap_bdaddr; /* address */ +}; +.Ed +.Pp +.Ss SOCK_RAW L2CAP sockets +Implemented by +.Cm btsock_l2c_raw +Netgraph type. +Raw L2CAP sockets do not provide access to raw L2CAP datagrams. These +sockets used to control L2CAP nodes and to issue special L2CAP requests +such as ECHO_REQUEST and GET_INFO request. +.Pp +Raw L2CAP sockets support number of +.Xr ioctl 2 +requests such as: +.Bl -tag -width foo +.It Dv SIOC_L2CAP_NODE_GET_FLAGS +Returns current state for the L2CAP node. +.It Dv SIOC_L2CAP_NODE_GET_DEBUG +Returns current debug level for the L2CAP node. +.It Dv SIOC_L2CAP_NODE_SET_DEBUG +Sets current debug level for the L2CAP node. +.It Dv SIOC_L2CAP_NODE_GET_CON_LIST +Returns list of active baseband connections (i.e. ACL links) for the L2CAP +node. +.It Dv SIOC_L2CAP_NODE_GET_CHAN_LIST +Returns list of active channels for the L2CAP node. +.It Dv SIOC_L2CAP_L2CA_PING +Issues L2CAP ECHO_REQUEST. +.It Dv SIOC_L2CAP_L2CA_GET_INFO +Issues L2CAP GET_INFO request. +.El +.Pp +.Ss SOCK_SEQPACKET L2CAP sockets +Implemented by +.Cm btsock_l2c +Netgraph type. +L2CAP sockets are either +.Dq active +or +.Dq passive . +Active sockets initiate connections to passive sockets. By default L2CAP +sockets are created active; to create a passive socket the +.Xr listen 2 +system call must be used after binding the socket with the +.Xr bind 2 +system call. Only passive sockets may use the +.Xr accept 2 +call to accept incoming connections. Only active sockets may use the +.Xr connect 2 +call to initiate connections. +.Pp +L2CAP sockets supports +.Dq wildcard addressing . +In this case socket must be bound to +.Dv NG_HCI_BDADDR_ANY +address. Note that PSM (Protocol/Service Multiplexor) filed is always +required. Once a connection has been established the socket's address is +fixed by the peer entity's location. The address assigned the socket is +the address associated with the Bluetooth device through which packets are +being transmitted and received, and PSM (Protocol/Service Multiplexor). +.Pp +L2CAP sockets support number of options defined at +.Dv SOL_L2CAP +level which can be set with +.Xr setsockopt 2 +and tested with +.Xr getsockopt 2 : +.Bl -tag -width foo +.It Dv SO_L2CAP_IMTU +Get (set) maximum payload size the local socket is capable of accepting. +.It Dv SO_L2CAP_OMTU +Get maximum payload size the remote socket is capable of accepting. +.It Dv SO_L2CAP_IFLOW +Get incoming flow specification for the socket. +.Em Not implemented . +.It Dv SO_L2CAP_OFLOW +Get (set) outgoing flow specification for the socket. +.Em Not implemented . +.It Dv SO_L2CAP_FLUSH +Get (set) value of the flush timeout. +.Em Not implemeted . +.El +.Sh HOOKS +This node type supports hooks with arbitrary names (as long as they are +unique) and always accepts hook connection requests. +.Sh NETGRAPH CONTROL MESSAGES +This node type supports the generic control messages. +.Sh SHUTDOWN +These nodes are persistent and cannot be shut down. +.Sh BUGS +Most likely. Please report if found. +.Sh SEE ALSO +.Xr socket 2 , +.Xr netgraph 4 , +.Xr ngctl 8 , +.Xr ng_hci 4 , +.Xr ng_l2cap 4 , +.Xr btsockstat 1 +.Sh HISTORY +The +.Nm +node type was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/share/man/man4/ng_h4.4 b/share/man/man4/ng_h4.4 new file mode 100644 index 0000000..bc76e1c --- /dev/null +++ b/share/man/man4/ng_h4.4 @@ -0,0 +1,121 @@ +.\" ng_h4.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_h4.4,v 1.3 2002/11/12 17:10:13 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt NG_H4 4 +.Os +.Sh NAME +.Nm h4 +.Nd Netgraph node type that is also a H4 line discipline +.Sh SYNOPSIS +.In sys/types.h +.In sys/ttycom.h +.In netgraph/ng_message.h +.In netgraph/ng_h4.h +.Sh DESCRIPTION +The +.Nm +node type is both a persistent Netgraph node type and a H4 line +discipline. It implements a Bluetooth HCI UART transport layer as +per chapter H4 of the Bluetooth Specification Book v1.1. A new +node is created when the corresponding line discipline, +.Dv H4DISC , +is registered on a tty device (see +.Xr tty 4 ) . +.Pp +The node has a single hook called +.Dv hook . +Incoming bytes received on the tty device are re-assembled into +HCI frames (according to the length). Full HCI frames are sent out on +the hook. HCI frames received on +.Dv hook +are transmitted out on the tty device. +No modification to the data is performed in either direction. +While the line discipline is installed on a tty, the normal +read and write operations are unavailable, returning +.Er EIO . +.Pp +Information about the node is available via the netgraph +.Xr ioctl 2 +command +.Dv NGIOCGINFO . +This command returns a +.Dv "struct nodeinfo" +similar to the +.Dv NGM_NODEINFO +netgraph control message. +.Sh HOOKS +This node type supports the following hooks: +.Pp +.Bl -tag -width foobar +.It Dv hook +single HCI frame contained in single +.Dv mbuf +structure. +.El +.Sh CONTROL MESSAGES +This node type supports the generic control messages, plus the following: +.Bl -tag -width foo +.It Dv NGM_H4_NODE_RESET +Reset the node. +.It Dv NGM_H4_NODE_GET_STATE +Returns current receiving state for the node. +.It Dv NGM_H4_NODE_GET_DEBUG +Returns an integer containing the current debug level for the node. +.It Dv NGM_H4_NODE_SET_DEBUG +This command takes an integer argument and sets current debug level +for the node. +.It Dv NGM_H4_NODE_GET_QLEN +Returns current length of outgoing queue for the node. +.It Dv NGM_H4_NODE_SET_QLEN +This command takes an integer argument and sets maximum length of +outgoing queue for the node. +.It Dv NGM_H4_NODE_GET_STAT +Returns various statistic information for the node, such as: number of +bytes (frames) sent, number of bytes (frames) received and number of +input (output) errors. +.It Dv NGM_H4_NODE_RESET_STAT +Reset all statistic counters to zero. +.El +.Sh SHUTDOWN +This node shuts down when the corresponding device is closed +(or the line discipline is uninstalled on the device). +.Sh BUGS +This node still uses spltty() to lock tty layer. This is wrong. +.Sh SEE ALSO +.Xr ioctl 2 , +.Xr netgraph 4 , +.Xr tty 4 , +.Xr ngctl 8 +.Sh HISTORY +The +.Nm +node type was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/share/man/man4/ng_hci.4 b/share/man/man4/ng_hci.4 new file mode 100644 index 0000000..36272e0 --- /dev/null +++ b/share/man/man4/ng_hci.4 @@ -0,0 +1,342 @@ +.\" ng_hci.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_hci.4,v 1.8 2002/11/12 22:35:39 max Exp $ +.\" $FreeBSD$ +.Dd June 25, 2002 +.Dt NG_HCI 4 +.Os +.Sh NAME +.Nm hci +.Nd Netgraph node type that is also a Bluetooth Host Controller Interface +(HCI) layer +.Sh SYNOPSIS +.In sys/types.h +.In netgraph/ng_message.h +.In netgraph/netgraph.h +.In netgraph/ng_hci.h +.Sh DESCRIPTION +The +.Nm +node type is a Netgraph node type that implements Bluetooth Host Controller +Interface (HCI) layer as per chapter H1 of the Bluetooth Specification Book +v1.1. +.Sh INTRODUCTION TO BLUETOOTH +Bluetooth is a short-range radio link intended to replace the cable(s) +connecting portable and/or fixed electronic devices. Bluetooth operates +in the unlicensed ISM band at 2.4 GHz. The Bluetooth protocol uses a +combination of circuit and packet switching. Bluetooth can support an +asynchronous data channel, up to three simultaneous synchronous voice +channels, or a channel which simultaneously supports asynchronous data +and synchronous voice. Each voice channel supports a 64 kb/s synchronous +(voice) channel in each direction. The asynchronous channel can support +maximal 723.2 kb/s asymmetric (and still up to 57.6 kb/s in the return +direction), or 433.9 kb/s symmetric. +.Pp +The Bluetooth system provides a point-to-point connection (only two +Bluetooth units involved), or a point-to-multipoint connection. In the +point-to-multipoint connection, the channel is shared among several +Bluetooth units. Two or more units sharing the same channel form a +.Em piconet . +One Bluetooth unit acts as the master of the piconet, whereas the other +unit(s) acts as slave(s). Up to seven slaves can be active in the piconet. +In addition, many more slaves can remain locked to the master in a so-called +parked state. These parked slaves cannot be active on the channel, but remain +synchronized to the master. Both for active and parked slaves, the channel +access is controlled by the master. +.Pp +Multiple piconets with overlapping coverage areas form a +.Em scatternet . +Each piconet can only have a single master. However, slaves can participate +in different piconets on a time-division multiplex basis. In addition, a +master in one piconet can be a slave in another piconet. The piconets shall +not be frequency-synchronized. Each piconet has its own hopping channel. +.Ss Time slots +The channel is divided into time slots, each 625 usec in length. The time +slots are numbered according to the Bluetooth clock of the piconet master. +The slot numbering ranges from 0 to 2^27 -1 and is cyclic with a cycle length +of 2^27. In the time slots, master and slave can transmit packets. +.Ss SCO link +The SCO link is a symmetric, point-to-point link between the master and a +specific slave. The SCO link reserves slots and can therefore be considered +as a circuit-switched connection between the master and the slave. The SCO +link typically supports time-bounded information like voice. The master can +support up to three SCO links to the same slave or to different slaves. A +slave can support up to three SCO links from the same master, or two SCO +links if the links originate from different masters. SCO packets are never +retransmitted. +.Ss ACL link +In the slots not reserved for SCO links, the master can exchange packets +with any slave on a per-slot basis. The ACL link provides a packet-switched +connection between the master and all active slaves participating in the +piconet. Both asynchronous and isochronous services are supported. Between +a master and a slave only a single ACL link can exist. For most ACL packets, +packet retransmission is applied to assure data integrity. +.Sh HOST CONTROLLER INTERFACE (HCI) +The HCI provides a command interface to the baseband controller and link +manager, and access to hardware status and control registers. This interface +provides a uniform method of accessing the Bluetooth baseband capabilities. +.Pp +The HCI layer on the Host exchanges data and commands with the HCI firmware +on the Bluetooth hardware. The Host Controller Transport Layer (i.e. physical +bus) driver provides both HCI layers with the ability to exchange information +with each other. +.Pp +The Host will receive asynchronous notifications of HCI events independent +of which Host Controller Transport Layer is used. HCI events are used for +notifying the Host when something occurs. When the Host discovers that an +event has occurred it will then parse the received event packet to determine +which event occurred. +The next sections specify the HCI packet formats. +.Ss HCI command packet +.Bd -literal -offset indent +#define NG_HCI_CMD_PKT 0x01 +typedef struct { + u_int8_t type; /* MUST be 0x1 */ + u_int16_t opcode; /* OpCode */ + u_int8_t length; /* parameter(s) length in bytes */ +} __attribute__ ((packed)) ng_hci_cmd_pkt_t; +.Ed +.Pp +The HCI command packet is used to send commands to the Host Controller +from the Host. When the Host Controller completes most of the commands, +a Command Complete event is sent to the Host. Some commands do not receive +a Command Complete event when they have been completed. Instead, when the +Host Controller receives one of these commands the Host Controller sends +a Command Status event back to the Host when it has begun to execute the +command. Later on, when the actions associated with the command have finished, +an event that is associated with the sent command will be sent by the Host +Controller to the Host. +.Ss HCI event packet +.Bd -literal -offset indent +#define NG_HCI_EVENT_PKT 0x04 +typedef struct { + u_int8_t type; /* MUST be 0x4 */ + u_int8_t event; /* event */ + u_int8_t length; /* parameter(s) length in bytes */ +} __attribute__ ((packed)) ng_hci_event_pkt_t; +.Ed +.Pp +The HCI event packet is used by the Host Controller to notify the Host +when events occur. +.Ss HCI ACL data packet +.Bd -literal -offset indent +#define NG_HCI_ACL_DATA_PKT 0x02 +typedef struct { + u_int8_t type; /* MUST be 0x2 */ + u_int16_t con_handle; /* connection handle + PB + BC flags */ + u_int16_t length; /* payload length in bytes */ +} __attribute__ ((packed)) ng_hci_acldata_pkt_t; +.Ed +.Pp +HCI ACL data packets are used to exchange ACL data between the Host and +Host Controller. +.Ss HCI SCO data packet +.Bd -literal -offset indent +#define NG_HCI_SCO_DATA_PKT 0x03 +typedef struct { + u_int8_t type; /* MUST be 0x3 */ + u_int16_t con_handle; /* connection handle + reserved bits */ + u_int8_t length; /* payload length in bytes */ +} __attribute__ ((packed)) ng_hci_scodata_pkt_t; +.Ed +.Pp +HCI SCO data packets are used to exchange SCO data between the Host and +Host Controller. +.Sh HCI INITIALIZATION +On initialization, HCI control application must issue the following HCI +commands (in any order). +.Bl -tag -width foobar +.It Dv Read_BD_ADDR +To obtain BD_ADDR of the Bluetooth unit. +.It Dv Read_Local_Supported_Features +To obtain the list of features supported by Bluetooth unit. +.It Dv Read_Buffer_Size +To determine the maximum size of HCI ACL and SCO HCI data packets (excluding +header) that can be sent from the Host to the Host Controller. There are also +two additional return parameters that specify the total number of HCI ACL and +SCO data packets that the Host Controller can have waiting for transmission in +its buffers. +.El +.Pp +As soon as HCI initialization has been successfuly performed, HCI control +application must turn on +.Dq inited +bit for the node. Once HCI node has been initialized all upsteam hooks +will receive a +.Dv NGM_HCI_NODE_UP +Netgraph message defined as follows. +.Bd -literal -offset indent +#define NGM_HCI_NODE_UP 112 /* HCI -> Upper */ +typedef struct { + u_int16_t pkt_size; /* max. ACL/SCO packet size (w/o hdr) */ + u_int16_t num_pkts; /* ACL/SCO packet queue size */ + u_int16_t reserved; /* place holder */ + bdaddr_t bdaddr; /* bdaddr */ +} ng_hci_node_up_ep; +.Ed +.Sh HCI FLOW CONTROL +HCI layer performs flow control on baseband connection basis (i.e. ACL and +SCO link). Each baseband connection has +.Em connection handle +and queue of outgoing data packets. Upper layers protocols are allowed to +send up to ( +.Dv num_pkts - +.Dv pending ) +packets at one time. HCI layer will send +.Dv NGM_HCI_SYNC_CON_QUEUE +Netgraph messages to inform upper layers about current queue state for each +connection handle. The +.Dv NGM_HCI_SYNC_CON_QUEUE +Netgraph message is defined as follows. +.Bd -literal -offset indent +#define NGM_HCI_SYNC_CON_QUEUE 113 /* HCI -> Upper */ +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t completed; /* number of completed packets */ +} ng_hci_sync_con_queue_ep; +.Ed +.Sh HOOKS +This node type supports the following hooks: +.Pp +.Bl -tag -width foobar +.It Dv drv +Bluetooth Host Controller Transport Layer hook. Single HCI packet contained in +single +.Dv mbuf +structure. +.It Dv acl +Upper layer protocol/node is connected to the hook. Single HCI ACL +data packet contained in single +.Dv mbuf +structure. +.It Dv sco +Upper layer protocol/node is connected to the hook. Single HCI SCO +data packet contained in single +.Dv mbuf +structure. +.It Dv raw +Raw hook. Every HCI frame (including HCI command frame) that goes in +or out will be delivired to the hook. Usually Bluetooth raw HCI sockets +layer is connected to the hook. Single HCI frame contained in single +. Dv mbuf +structure. +.El +.Sh BLUETOOTH UPPER LAYER PROTOCOLS INTERFACE (LP CONTROL MESSAGES) +.Bl -tag -width foo +.It Dv NGM_HCI_LP_CON_REQ +Requests the lower protocol to create a connection. If a physical link +to the remote device does not exist, this message must be sent to the lower +protocol (baseband) to establish the physical connection. +.It Dv NGM_HCI_LP_DISCON_REQ +Requests the lower protocol (baseband) to terminate a connection. +.It Dv NGM_HCI_LP_CON_CFM +Confirms success or failure of the +.Dv +NGM_HCI_LP_CON_REQ request to establish a lower layer (baseband) connection. +This includes passing the authentication challenge if authentication is +required to establish the physical link. +.It Dv NGM_HCI_LP_CON_IND +Indicates the lower protocol (baseband) has successfully established +incoming connection. +.It Dv NGM_HCI_LP_CON_RSP +A response accepting or rejecting the previous connection indication request. +.It Dv NGM_HCI_LP_DISCON_IND +Indicates the lower protocol (baseband) has terminated connection. This +could be a response to +.Dv NGM_HCI_LP_DISCON_REQ +or a timeout event. +.It Dv NGM_HCI_LP_QOS_REQ +Requests the lower protocol (baseband) to accommodate a particular QoS +parameter set. +.It Dv NGM_HCI_LP_QOS_CFM +Confirms success or failure of the request for a given quality of service. +.It Dv NGM_HCI_LP_QOS_IND +Indicates the lower protocol (baseband) has detected a violation of the QoS +agreement. +.El +.Sh NETGRAPH CONTROL MESSAGES +This node type supports the generic control messages, plus the following: +.Bl -tag -width foo +.It Dv NGM_HCI_NODE_GET_STATE +Returns current state for the node. +.It Dv NGM_HCI_NODE_INIT +Turn on +.Dq inited +bit for the node. +.It Dv NGM_HCI_NODE_GET_DEBUG +Returns an integer containing the current debug level for the node. +.It Dv NGM_HCI_NODE_SET_DEBUG +This command takes an integer argument and sets current debug level +for the node. +.It Dv NGM_HCI_NODE_GET_BUFFER +Returns current state of data buffers. +.It Dv NGM_HCI_NODE_GET_BDADDR +Returns BD_ADDR as cached in the node. +.It Dv NGM_HCI_NODE_GET_FEATURES +Returns the list of features supported by hardware (as cached by the node). +.It Dv NGM_HCI_NODE_GET_NEIGHBOR_CACHE +Returns content of the neighbor cache. +.It Dv NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE +Remove all neighbor cache entries. +.It Dv NGM_HCI_NODE_GET_CON_LIST +Returns list of active baseband connections (i.e. ACL and SCO links). +.It Dv NGM_HCI_NODE_GET_STAT +Returns various statistic counters. +.It Dv NGM_HCI_NODE_RESET_STAT +Resets all statistic counters to zero. +.It NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK +Sets current link policy settings mask. After the new ACL connection is +created the HCI node will try set link policy for the ACL connection. By +default every supported Link Manager (LM) mode will be enabled. User can +override this by setting link policy settings mask which specifies LM +modes to be enabled. +.It NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK +Returns current link policy settings mask. +.It NGM_HCI_NODE_SET_PACKET_MASK +Sets current packet mask. When new baseband (ACL or SCO) connection is +created the HCI node will specify every packet type supported by the device. +User can override this by setting packet mask which specifies packet types +to be used for new baseband connections. +.It NGM_HCI_NODE_GET_PACKET_MASK +Returns current packet mask. +.El +.Sh SHUTDOWN +This node shuts down upon receipt of a NGM_SHUTDOWN control message, or +when all hooks have been disconnected. +.Sh BUGS +Most likely. Please report if found. +.Sh SEE ALSO +.Xr netgraph 4 , +.Xr ngctl 8 , +.Xr hccontrol 8 +.Sh HISTORY +The +.Nm +node type was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/share/man/man4/ng_l2cap.4 b/share/man/man4/ng_l2cap.4 new file mode 100644 index 0000000..38f4bc8 --- /dev/null +++ b/share/man/man4/ng_l2cap.4 @@ -0,0 +1,341 @@ +.\" ng_l2cap.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_l2cap.4,v 1.4 2002/11/12 17:16:19 max Exp $ +.\" $FreeBSD$ +.Dd July 4, 2002 +.Dt NG_L2CAP 4 +.Os +.Sh NAME +.Nm l2cap +.Nd Netgraph node type that implements Bluetooth Logical Link Control and +Adaptation Protocol (L2CAP) +.Sh SYNOPSIS +.In sys/types.h +.In netgraph/ng_message.h +.In netgraph/netgraph.h +.In netgraph/ng_hci.h +.In netgraph/ng_l2cap.h +.Sh DESCRIPTION +The +.Nm +node type is a Netgraph node type that implements Bluetooth Logical Link +Control and Adaptation Protocol as per chapter D of the Bluetooth Specification +Book v1.1. +.Pp +L2CAP provides connection-oriented and connectionless data services to upper +layer protocols with protocol multiplexing capability, segmentation and +reassembly operation, and group abstractions. L2CAP permits higher level +protocols and applications to transmit and receive L2CAP data packets up to +64 kilobytes in length. +.Ss L2CAP assumptions +.Bl -enum -offset indent +.It +The ACL link between two units is set up. The Baseband provides orderly +delivery of data packets, although there might be individual packet corruption +and duplicates. No more than 1 ACL link exists between any two devices. +.It +The Baseband always provides the impression of full-duplex communication +channels. This does not imply that all L2CAP communications are bi-directional. +Multicasts and unidirectional traffic (e.g., video) do not require duplex +channels. +.It +L2CAP provides a reliable channel using the mechanisms available at the +Baseband layer. The Baseband always performs data integrity checks when +requested and resends data until it has been successfully acknowledged or +a timeout occurs. Because acknowledgements may be lost, timeouts may +occur even after the data has been successfully sent. +.El +.Sh L2CAP GENERAL OPERATION +The Logical Link Control and Adaptation Protocol (L2CAP) is based around the +concept of +.Em channels . +Each channel is bound to a single protocol in a many-to-one fashion. Multiple +channels can be bound to the same protocol, but a channel cannot be bound to +multiple protocols. Each L2CAP packet received on a channel is directed to +the appropriate higher level protocol. +.Pp +Each one of the end-points of an L2CAP channel is referred to by a channel +identifier. Channel identifiers (CIDs) are local names representing a logical +channel end-point on the device. Identifiers from 0x0001 to 0x003F are reserved +for specific L2CAP functions. The null identifier (0x0000) is defined as an +illegal identifier and must never be used as a destination end-point. +All L2CAP signalling commands are sent to CID 0x0001. CID 0x0002 is reserved +for group-oriented channel. The same CID must not be reused as a local L2CAP +channel endpoint for multiple simultaneous L2CAP channels between a local +device and some remote device. +.Pp +CID assignment is relative to a particular device and a device can assign CIDs +independently from other devices. Thus, even if the same CID value has been +assigned to (remote) channel endpoints by several remote devices connected +to a single local device, the local device can still uniquely associate each +remote CID with a different device. +.Ss Channel operational states +.Bl -tag -width foobar +.It Dv NG_L2CAP_CLOSED +In this state, there is no channel associated with this CID. This is the only +state when a link level connection (Baseband) may not exist. Link disconnection +forces all other states into the NG_L2CAP_CLOSED state. +.It Dv NG_L2CAP_W4_L2CAP_CON_RSP +In this state, the CID represents a local end-point and an L2CAP Connect +Request message has been sent referencing this endpoint and it is now waiting +for the corresponding L2CAP Connect Response message. +.It Dv NG_L2CAP_W4_L2CA_CON_RSP +In this state, the remote end-point exists and an L2CAP Connect Request has +been received by the local L2CAP entity. An L2CA Connect Indication has been +sent to the upper layer and the part of the local L2CAP entity processing the +received L2CAP Connect Request waits for the corresponding response. The +response may require a security check to be performed. +.It Dv NG_L2CAP_CONFIG +In this state, the connection has been established but both sides are still +negotiating the channel parameters. The Configuration state may also be +entered when the channel parameters are being renegotiated. Prior to entering +the NG_L2CAP_CONFIG state, all outgoing data traffic is suspended since +the traffic parameters of the data traffic are to be renegotiated. Incoming +data traffic is accepted until the remote channel endpoint has entered +the NG_L2CAP_CONFIG state. In the NG_L2CAP_CONFIG state, both sides will issue +L2CAP Configuration Request messages if only defaults are being used, a null +message will be sent. If a large amount of parameters need to be negotiated, +multiple messages will be sent to avoid any MTU limitations and negotiate +incrementally. Moving from the NG_L2CAP_CONFIG state to the NG_L2CAP_OPEN state +requires both sides to be ready. An L2CAP entity is ready when it has received +a positive response to its final request and it has positively responded to +the final request from the remote device. +.It Dv NG_L2CAP_OPEN +In this state, the connection has been established and configured, and data +flow may proceed. +.It Dv NG_L2CAP_W4_L2CAP_DISCON_RSP +In this state, the connection is shutting down and an L2CAP Disconnect Request +message has been sent. This state is now waiting for the corresponding response. +.It Dv NG_L2CAP_W4_L2CA_DISCON_RSP +In this state, the connection on the remote endpoint is shutting down and an +L2CAP Disconnect Request message has been received. An L2CA Disconnect +Indication has been sent to the upper layer to notify the owner of the CID +that the remote endpoint is being closed. This state is now waiting for the +corresponding response from the upper layer before responding to the remote +endpoint. +.El +.Ss Protocol Multiplexing +L2CAP supports protocol multiplexing because the Baseband Protocol does not +support any +.Dq type +field identifying the higher layer protocol being multiplexed above it. +L2CAP is able to distinguish between upper layer protocols such as the Service +Discovery Protocol, RFCOMM and Telephony Control. +.Ss Segmentation and Reassembly +The data packets defined by the Baseband Protocol are limited in size. Large +L2CAP packets must be segmented into multiple smaller Baseband packets prior +to their transmission over the air. Similarly, multiple received Baseband +packets may be reassembled into a single larger L2CAP packet. +.Ss Quality of Service +The L2CAP connection establishment process allows the exchange of information +regarding the quality of service (QoS) expected between two Bluetooth units. +.Ss Groups +The Baseband Protocol supports the concept of a piconet, a group of devices +synchronously hopping together using the same clock. The L2CAP group +abstraction permits implementations to efficiently map protocol groups on to +piconets. +.Pp +The following features are outside the scope of L2CAP responsibilities: +.Bl -dash -offset indent +.It +L2CAP does not transport audio designated for SCO links. +.It +L2CAP does not enforce a reliable channel or ensure data integrity, +that is, L2CAP performs no retransmissions or checksum calculations. +.It +L2CAP does not support a reliable multicast channel. +.It +L2CAP does not support the concept of a global group name. +.El +.Sh HOOKS +This node type supports the following hooks: +.Pp +.Bl -tag -width foobar +.It Dv hci +Bluetooth Host Controller Interface downstream hook. +.It Dv l2c +Upper layer protocol upstream hook. Usually Bluetooth L2CAP sockets layer +is connected to the hook. +.It Dv ctl +Control hook. Usually Bluetooth raw L2CAP sockets layer is connected +to the hook. +.El +.Sh INTERFACE TO THE UPPER LAYER PROTOCOLS (L2CA CONTROL MESSAGES) +Bluetooth specification says that L2CA request must block until response +is ready. L2CAP node uses +.Dq token +field from Netgraph message header to match L2CA request and response. The +upper layer protocol must populate +.Dq token . +L2CAP node will queue request and start processing. Later, when response is +ready or timeout has occur L2CAP node will create new Netgraph message, set +.Dq token +and +.Dv NFG_RESP +flag and send message to the upper layer. Note that L2CA indication messages +will not populate +.Dq token +and will not set +.Dv NGF_RESP +flag. There is no reason for this, because they are just notifications and do +not require acknowledgment. +.Pp +.Bl -tag -width foo +.It Dv NGM_L2CAP_L2CA_CON +Requests the creation of a channel representing a logical connection to a +physical address. Input parameters are the target protocol (PSM) and remote +device's 48-bit address (BD_ADDR). Output parameters are the local CID (LCID) +allocated by the local L2CAP entity, and Result of the request. If Result +indicates a pending notification, the Status value may contain more information +of what processing is delaying the establishment of the connection. +.It Dv NGM_L2CAP_L2CA_CON_IND +This message includes the parameters for the address of the remote device that +issued the connection request, the local CID representing the channel being +requested, the Identifier contained in the request, and the PSM value the +request is targeting. +.It Dv NGM_L2CAP_L2CA_CON_RSP +Issues a response to a connection request event indication. Input parameters +are the remote device's 48-bit address, Identifier sent in the request, local +CID, the Response code, and the Status attached to the Response code. The +output parameter is the Result of the service request. This primitive must be +called no more than once after receiving the indication. +.It Dv NGM_L2CAP_L2CA_CFG +Requests the initial configuration (or reconfiguration) of a channel to a new +set of channel parameters. Input parameters are the local CID endpoint, new +incoming receivable MTU (InMTU), new outgoing flow spec-ification, and flush +and link timeouts. Output parameters are the Result, accepted incoming MTU +(InMTU), the remote side's flow requests, and flush and link timeouts. +.It Dv NGM_L2CAP_L2CA_CFG_IND +This message includes the parameters indicating the local CID of the channel +the request has been sent to, the outgoing MTU size (maximum packet that can +be sent across the channel) and the flowspec describing the characteristics of +the incoming data. All other channel parameters are set to their default values if not provided by the remote device. +.It Dv NGM_L2CAP_L2CA_CFG_RSP +Issues a response to a configuration request event indication. Input parameters +include the local CID of the endpoint being configured, outgoing transmit MTU +(which may be equal or less to the OutMTU parameter in the configuration +indication event) and the accepted flowspec for incoming traffic. The output +parameter is the Result value. +.It Dv NGM_L2CAP_L2CA_QOS_IND +This message includes the parameter indicating the address of the remote +Bluetooth device where the QoS contract has been violated. +.It Dv NGM_L2CAP_L2CA_DISCON +Requests the disconnection of the channel. Input parameter is the CID +representing the local channel endpoint. Output parameter is Result. Result +is zero if a L2CAP Disconnect Response is received, otherwise a non-zero value +is returned. Once disconnection has been requested, no process will be able to +successfully read or write from the CID. +.It Dv NGM_L2CAP_L2CA_DISCON_IND +This message includes the parameter indicating the local CID the request has +been sent to. +.It Dv NGM_L2CAP_L2CA_WRITE +Response to transfer of data request. Actual data must be received from +appropriate upstream hook and must be prepended with header defined as follows. +.Pp +.Bd -literal -offset indent +/* L2CA data packet header */ +typedef struct { + u_int32_t token; /* token to use in L2CAP_L2CA_WRITE */ + u_int16_t length; /* length of the data */ + u_int16_t lcid; /* local channel ID */ +} __attribute__ ((packed)) ng_l2cap_l2ca_hdr_t; +.Ed +.Pp +The output parameters are Result and Length of data written. +.It Dv NGM_L2CAP_L2CA_GRP_CREATE +Requests the creation of a CID to represent a logical connection to multiple +devices. Input parameter is the PSM value that the outgoing connectionless +traffic is labelled with, and the filter used for incoming traffic. Output +parameter is the CID representing the local endpoint. On creation, the group +is empty but incoming traffic destined for the PSM value is readable. +.Em This request has not been implemented . +.It Dv NGM_L2CAP_L2CA_GRP_CLOSE +The use of this message closes down a Group. +.Em This request has not been implemented . +.It Dv NGM_L2CAP_L2CA_GRP_ADD_MEMBER +Requests the addition of a member to a group. The input parameter includes the +CID representing the group and the BD_ADDR of the group member to be added. +The output parameter Result confirms the success or failure of the request. +.Em This request has not been implemented . +.It Dv NGM_L2CAP_L2CA_GRP_REM_MEMBER +Requests the removal of a member from a group. The input parameters include +the CID representing the group and BD_ADDR of the group member to be removed. +The output parameter Result confirms the success or failure of the request. +.Em This request has not been implemented . +.It Dv NGM_L2CAP_L2CA_GRP_MEMBERSHIP +Requests a report of the members of a group. The input parameter CID represents +the group being queried. The output parameter Result confirms the success or +failure of the operation. If the Result is successful, BD_ADDR_Lst is a list +of the Bluetooth addresses of the N members of the group. +.Em This request has not been implemented . +.It Dv NGM_L2CAP_L2CA_PING +Initiates a L2CA Echo Request message and the reception of the corresponding +L2CAP Echo Response message. The input parameters are remote Bluetooth device +BD_ADDR, Echo Data and Length of the echo data. The output parameters are +Result, Echo Data and Length of the echo data. +.It Dv NGM_L2CAP_L2CA_GET_INFO +Initiates a L2CA Information Request message and the reception of the +corresponding L2CAP Info Response message. The input parameters are remote +Bluetooth device BD_ADDR and Information Type. The output parameters are +Result, Information Data and Size of the information data. +.It Dv NGM_L2CAP_L2CA_ENABLE_CLT +Request to disable (enable) the reception of connectionless packets. The input +parameter is the PSM value indicating service that should be blocked +(unblocked) and Enable flag. +.El +.Sh NETGRAPH CONTROL MESSAGES +This node type supports the generic control messages, plus the following: +.Bl -tag -width foo +.It Dv NGM_L2CAP_NODE_GET_FLAGS +Returns current state for the node. +.It Dv NGM_L2CAP_NODE_GET_DEBUG +Returns an integer containing the current debug level for the node. +.It Dv NGM_L2CAP_NODE_SET_DEBUG +This command takes an integer argument and sets current debug level +for the node. +.It Dv NGM_L2CAP_NODE_GET_CON_LIST +Returns list of active baseband connections (i.e. ACL links). +.It Dv NGM_L2CAP_NODE_GET_CHAN_LIST +Returns list of active L2CAP channels. +.El +.Sh SHUTDOWN +This node shuts down upon receipt of a NGM_SHUTDOWN control message, or +when all hooks have been disconnected. +.Sh BUGS +Most likely. Please report if found. +.Sh SEE ALSO +.Xr netgraph 4 , +.Xr ngctl 8 , +.Xr l2control 8 , +.Xr l2ping 8 +.Sh HISTORY +The +.Nm +node type was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/share/man/man4/ng_ubt.4 b/share/man/man4/ng_ubt.4 new file mode 100644 index 0000000..648d27b --- /dev/null +++ b/share/man/man4/ng_ubt.4 @@ -0,0 +1,102 @@ +.\" ng_ubt.4 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: ng_ubt.4,v 1.2 2002/11/12 17:20:16 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt NG_UBT 4 +.Os +.Sh NAME +.Nm ubt +.Nd Netgraph node type that is also a driver for Bluetooth USB devices +.Sh SYNOPSIS +.In sys/types.h +.In ng_ubt.h +.Sh DESCRIPTION +The +.Nm +node type is both a persistent Netgraph node type and a driver for +Bluetooth USB devices. It implements a Bluetooth USB transport layer +as per chapter H2 of the Bluetooth Specification Book v1.1. A new +node is created when supported USB device is plugged. +.Pp +The node has a single hook called +.Dv hook . +Incoming bytes received on the device are re-assembled into HCI frames +(according to the length). Full HCI frames are sent out on the hook. The node +will add HCI frame indicator if device did not send it. HCI frames received +on +.Dv hook +are transmitted out. The node will drop HCI frame indicator unless device +requires it to be present. +.Sh HOOKS +This node type supports the following hooks: +.Pp +.Bl -tag -width foobar +.It Dv hook +single HCI frame contained in single +.Dv mbuf +structure. +.El +.Sh CONTROL MESSAGES +This node type supports the generic control messages, plus the following: +.Bl -tag -width foo +.It Dv NGM_UBT_NODE_GET_DEBUG +Returns an integer containing the current debug level for the node. +.It Dv NGM_UBT_NODE_SET_DEBUG +This command takes an integer argument and sets current debug level +for the node. +.It Dv NGM_UBT_NODE_GET_QLEN +This command takes a parameter that specifies queue number and returns +current maximal length of the queue for the node. +.It Dv NGM_UBT_NODE_SET_QLEN +This command takes two parameters that specify queue number and maximum +length of the queue and sets maximal length of the queue for the node. +.It Dv NGM_UBT_NODE_GET_STAT +Returns various statistic information for the node, such as: number of +bytes (frames) sent, number of bytes (frames) received and number of +input (output) errors. +.It Dv NGM_UBT_NODE_RESET_STAT +Reset all statistic counters to zero. +.El +.Sh SHUTDOWN +This node shuts down when the corresponding USB device is un-plugged. +.Sh BUGS +Isochronous USB transfers are probably broken. It means that USB device +probably will not be able to transfer SCO data (voice). Driver does not +support firmware upgrade procedure. USB interrupt transfers are +implemented as bulk-in transfers (not really a bug). +.Sh SEE ALSO +.Xr usb 4 , +.Xr netgraph 4 , +.Xr ngctl 8 +.Sh HISTORY +The +.Nm +node type was implemented in +.Fx 5.0 . +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/sys/modules/netgraph/bluetooth/Makefile b/sys/modules/netgraph/bluetooth/Makefile new file mode 100644 index 0000000..e39315e --- /dev/null +++ b/sys/modules/netgraph/bluetooth/Makefile @@ -0,0 +1,13 @@ +# $FreeBSD$ + +SUBDIR= \ + bluetooth \ + hci \ + l2cap \ + socket \ + bt3c \ + h4 \ + ubt + +.include <bsd.subdir.mk> + diff --git a/sys/modules/netgraph/bluetooth/bluetooth/Makefile b/sys/modules/netgraph/bluetooth/bluetooth/Makefile new file mode 100644 index 0000000..d4aa60f --- /dev/null +++ b/sys/modules/netgraph/bluetooth/bluetooth/Makefile @@ -0,0 +1,13 @@ +# $Id: Makefile,v 1.1.1.1 2002/09/04 21:47:41 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/common + +CFLAGS+= -I../../../../netgraph/bluetooth/include + +KMOD= ng_bluetooth +SRCS= ng_bluetooth.c +MAN4= ng_bluetooth.4 + +.include <bsd.kmod.mk> + diff --git a/sys/modules/netgraph/bluetooth/bt3c/Makefile b/sys/modules/netgraph/bluetooth/bt3c/Makefile new file mode 100644 index 0000000..31f5784 --- /dev/null +++ b/sys/modules/netgraph/bluetooth/bt3c/Makefile @@ -0,0 +1,16 @@ +# $Id: Makefile,v 1.6 2002/09/04 21:42:00 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/drivers/bt3c + +CFLAGS+= -g -I../../../../netgraph/bluetooth/include \ + -I../../../../netgraph/bluetooth/drivers/bt3c \ + -DINVARIANTS=1 -DINVARIANT_SUPPORT=1 \ + -DWITNESS=1 -DWITNESS_SKIPSPIN=1 + +KMOD= ng_bt3c +SRCS= ng_bt3c_pccard.c bus_if.h card_if.h device_if.h +MAN4= ng_bt3c.4 + +.include <bsd.kmod.mk> + diff --git a/sys/modules/netgraph/bluetooth/h4/Makefile b/sys/modules/netgraph/bluetooth/h4/Makefile new file mode 100644 index 0000000..7af1768 --- /dev/null +++ b/sys/modules/netgraph/bluetooth/h4/Makefile @@ -0,0 +1,16 @@ +# $Id: Makefile,v 1.7 2002/11/03 02:15:54 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/drivers/h4 + +CFLAGS+= -g -I../../../../netgraph/bluetooth/include \ + -I../../../../netgraph/bluetooth/drivers/h4 \ + -DINVARIANTS=1 -DINVARIANT_SUPPORT=1 +# -DWITNESS=1 -DWITNESS_SKIPSPIN=1 + +KMOD= ng_h4 +SRCS= ng_h4.c +MAN4= ng_h4.4 + +.include <bsd.kmod.mk> + diff --git a/sys/modules/netgraph/bluetooth/hci/Makefile b/sys/modules/netgraph/bluetooth/hci/Makefile new file mode 100644 index 0000000..92ffcc5 --- /dev/null +++ b/sys/modules/netgraph/bluetooth/hci/Makefile @@ -0,0 +1,16 @@ +# $Id: Makefile,v 1.5 2002/09/04 21:36:51 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/hci + +CFLAGS+= -g -I../../../../netgraph/bluetooth/include \ + -I../../../../netgraph/bluetooth/hci \ + -DINVARIANTS=1 -DINVARIANT_SUPPORT=1 \ + -DWITNESS=1 -DWITNESS_SKIPSPIN=1 + +KMOD= ng_hci +SRCS= ng_hci_main.c ng_hci_cmds.c ng_hci_evnt.c \ + ng_hci_ulpi.c ng_hci_misc.c +MAN4= ng_hci.4 + +.include <bsd.kmod.mk> diff --git a/sys/modules/netgraph/bluetooth/l2cap/Makefile b/sys/modules/netgraph/bluetooth/l2cap/Makefile new file mode 100644 index 0000000..cd90fd3 --- /dev/null +++ b/sys/modules/netgraph/bluetooth/l2cap/Makefile @@ -0,0 +1,16 @@ +# $Id: Makefile,v 1.4 2002/09/04 21:38:38 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/l2cap + +CFLAGS+= -g -I../../../../netgraph/bluetooth/include \ + -I../../../../netgraph/bluetooth/l2cap \ + -DINVARIANTS=1 -DINVARIANT_SUPPORT=1 \ + -DWITNESS=1 -DWITNESS_SKIPSPIN=1 + +KMOD= ng_l2cap +SRCS= ng_l2cap_main.c ng_l2cap_cmds.c ng_l2cap_evnt.c \ + ng_l2cap_ulpi.c ng_l2cap_llpi.c ng_l2cap_misc.c +MAN4= ng_l2cap.4 + +.include <bsd.kmod.mk> diff --git a/sys/modules/netgraph/bluetooth/socket/Makefile b/sys/modules/netgraph/bluetooth/socket/Makefile new file mode 100644 index 0000000..b9969a5 --- /dev/null +++ b/sys/modules/netgraph/bluetooth/socket/Makefile @@ -0,0 +1,17 @@ +# $Id: Makefile,v 1.7 2002/09/04 21:43:59 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/socket + +CFLAGS+= -g -I../../../../netgraph/bluetooth/include \ + -DINVARIANTS=1 -DINVARIANT_SUPPORT=1 \ + -DWITNESS=1 -DWITNESS_SKIPSPIN=1 + +KMOD= ng_btsocket +SRCS= ng_btsocket.c \ + ng_btsocket_hci_raw.c \ + ng_btsocket_l2cap_raw.c \ + ng_btsocket_l2cap.c +MAN4= ng_btsocket.4 + +.include <bsd.kmod.mk> diff --git a/sys/modules/netgraph/bluetooth/ubt/Makefile b/sys/modules/netgraph/bluetooth/ubt/Makefile new file mode 100644 index 0000000..1e07218 --- /dev/null +++ b/sys/modules/netgraph/bluetooth/ubt/Makefile @@ -0,0 +1,16 @@ +# $Id: Makefile,v 1.5 2002/09/04 21:41:06 max Exp $ +# $FreeBSD$ + +.PATH: ${.CURDIR}/../../../../netgraph/bluetooth/drivers/ubt + +CFLAGS+= -g -I../../../../netgraph/bluetooth/include \ + -I../../../../netgraph/bluetooth/drivers/ubt \ + -DINVARIANTS=1 -DINVARIANT_SUPPORT=1 \ + -DWITNESS=1 -DWITNESS_SKIPSPIN=1 + +KMOD= ng_ubt +SRCS= ng_ubt.c bus_if.h device_if.h opt_usb.h +MAN4= ng_ubt.4 + +.include <bsd.kmod.mk> + diff --git a/sys/netgraph/bluetooth/common/ng_bluetooth.c b/sys/netgraph/bluetooth/common/ng_bluetooth.c new file mode 100644 index 0000000..d6604b5 --- /dev/null +++ b/sys/netgraph/bluetooth/common/ng_bluetooth.c @@ -0,0 +1,254 @@ +/* + * bluetooth.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_bluetooth.c,v 1.1.1.1 2002/09/04 21:47:41 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/errno.h> +#include <sys/kernel.h> +#include <sys/sysctl.h> + +#include "ng_bluetooth.h" + +/* + * Bluetooth stack sysctl globals + */ + +static u_int32_t bluetooth_hci_command_timeout_value = 5; /* sec */ +static u_int32_t bluetooth_hci_connect_timeout_value = 60; /* sec */ +static u_int32_t bluetooth_hci_watchdog_timeout_value = 60; /* sec */ +static u_int32_t bluetooth_hci_max_neighbor_age_value = 600; /* sec */ +static u_int32_t bluetooth_l2cap_rtx_timeout_value = 60; /* sec */ +static u_int32_t bluetooth_l2cap_ertx_timeout_value = 300; /* sec */ + +/* + * Define sysctl tree that shared by other parts of Bluetooth stack + */ + +SYSCTL_NODE(_net, OID_AUTO, bluetooth, CTLFLAG_RW, 0, "Bluetooth family"); +SYSCTL_INT(_net_bluetooth, OID_AUTO, version, + CTLFLAG_RD, 0, NG_BLUETOOTH_VERSION, ""); + +/* + * HCI + */ + +SYSCTL_NODE(_net_bluetooth, OID_AUTO, hci, CTLFLAG_RW, + 0, "Bluetooth HCI family"); + +static int +bluetooth_set_hci_command_timeout_value(SYSCTL_HANDLER_ARGS) +{ + u_int32_t value; + int error; + + value = bluetooth_hci_command_timeout_value; + error = sysctl_handle_int(oidp, &value, sizeof(value), req); + if (error == 0 && req->newptr != NULL) { + if (value > 0) + bluetooth_hci_command_timeout_value = value; + else + error = EINVAL; + } + + return (error); +} /* bluetooth_set_hci_command_timeout_value */ + +SYSCTL_PROC(_net_bluetooth_hci, OID_AUTO, command_timeout, + CTLTYPE_INT | CTLFLAG_RW, + &bluetooth_hci_command_timeout_value, 5, + bluetooth_set_hci_command_timeout_value, + "I", "HCI command timeout (sec)"); + +static int +bluetooth_set_hci_connect_timeout_value(SYSCTL_HANDLER_ARGS) +{ + u_int32_t value; + int error; + + value = bluetooth_hci_connect_timeout_value; + error = sysctl_handle_int(oidp, &value, sizeof(value), req); + if (error == 0 && req->newptr != NULL) { + if (0 < value && value <= bluetooth_l2cap_rtx_timeout_value) + bluetooth_hci_connect_timeout_value = value; + else + error = EINVAL; + } + + return (error); +} /* bluetooth_set_hci_connect_timeout_value */ + +SYSCTL_PROC(_net_bluetooth_hci, OID_AUTO, connection_timeout, + CTLTYPE_INT | CTLFLAG_RW, + &bluetooth_hci_connect_timeout_value, 60, + bluetooth_set_hci_connect_timeout_value, + "I", "HCI connect timeout (sec)"); + +SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, watchdog_timeout, CTLFLAG_RW, + &bluetooth_hci_watchdog_timeout_value, 60, + "HCI connection watchdog timeout (sec)"); + +SYSCTL_INT(_net_bluetooth_hci, OID_AUTO, max_neighbor_age, CTLFLAG_RW, + &bluetooth_hci_max_neighbor_age_value, 600, + "Maximal HCI neighbor cache entry age (sec)"); + +/* + * L2CAP + */ + +SYSCTL_NODE(_net_bluetooth, OID_AUTO, l2cap, CTLFLAG_RW, + 0, "Bluetooth L2CAP family"); + +static int +bluetooth_set_l2cap_rtx_timeout_value(SYSCTL_HANDLER_ARGS) +{ + u_int32_t value; + int error; + + value = bluetooth_l2cap_rtx_timeout_value; + error = sysctl_handle_int(oidp, &value, sizeof(value), req); + if (error == 0 && req->newptr != NULL) { + if (bluetooth_hci_connect_timeout_value <= value && + value <= bluetooth_l2cap_ertx_timeout_value) + bluetooth_l2cap_rtx_timeout_value = value; + else + error = EINVAL; + } + + return (error); +} /* bluetooth_set_l2cap_rtx_timeout_value */ + +SYSCTL_PROC(_net_bluetooth_l2cap, OID_AUTO, rtx_timeout, + CTLTYPE_INT | CTLFLAG_RW, + &bluetooth_l2cap_rtx_timeout_value, 60, + bluetooth_set_l2cap_rtx_timeout_value, + "I", "L2CAP RTX timeout (sec)"); + +static int +bluetooth_set_l2cap_ertx_timeout_value(SYSCTL_HANDLER_ARGS) +{ + u_int32_t value; + int error; + + value = bluetooth_l2cap_ertx_timeout_value; + error = sysctl_handle_int(oidp, &value, sizeof(value), req); + if (error == 0 && req->newptr != NULL) { + if (value >= bluetooth_l2cap_rtx_timeout_value) + bluetooth_l2cap_ertx_timeout_value = value; + else + error = EINVAL; + } + + return (error); +} /* bluetooth_set_l2cap_ertx_timeout_value */ + +SYSCTL_PROC(_net_bluetooth_l2cap, OID_AUTO, ertx_timeout, + CTLTYPE_INT | CTLFLAG_RW, + &bluetooth_l2cap_ertx_timeout_value, 300, + bluetooth_set_l2cap_ertx_timeout_value, + "I", "L2CAP ERTX timeout (sec)"); + +/* + * Return various sysctl values + */ + +u_int32_t +bluetooth_hci_command_timeout(void) +{ + return (bluetooth_hci_command_timeout_value * hz); +} /* bluetooth_hci_command_timeout */ + +u_int32_t +bluetooth_hci_connect_timeout(void) +{ + return (bluetooth_hci_connect_timeout_value * hz); +} /* bluetooth_hci_connect_timeout */ + +u_int32_t +bluetooth_hci_watchdog_timeout(void) +{ + return (bluetooth_hci_watchdog_timeout_value * hz); +} /* bluetooth_hci_watchdog_timeout */ + +u_int32_t +bluetooth_hci_max_neighbor_age(void) +{ + return (bluetooth_hci_max_neighbor_age_value); +} /* bluetooth_hci_max_neighbor_age */ + +u_int32_t +bluetooth_l2cap_rtx_timeout(void) +{ + return (bluetooth_l2cap_rtx_timeout_value * hz); +} /* bluetooth_l2cap_rtx_timeout */ + +u_int32_t +bluetooth_l2cap_ertx_timeout(void) +{ + return (bluetooth_l2cap_ertx_timeout_value * hz); +} /* bluetooth_l2cap_ertx_timeout */ + +/* + * Handle loading and unloading for this code. + */ + +static int +bluetooth_modevent(module_t mod, int event, void *data) +{ + int error = 0; + + switch (event) { + case MOD_LOAD: + break; + + case MOD_UNLOAD: + break; + + default: + error = EOPNOTSUPP; + break; + } + + return (error); +} /* bluetooth_modevent */ + +/* + * Module + */ + +static moduledata_t bluetooth_mod = { + "bluetooth", + bluetooth_modevent, + NULL +}; + +DECLARE_MODULE(ng_bluetooth, bluetooth_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); +MODULE_VERSION(ng_bluetooth, NG_BLUETOOTH_VERSION); + diff --git a/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_pccard.c b/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_pccard.c new file mode 100644 index 0000000..443c18a --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_pccard.c @@ -0,0 +1,1247 @@ +/* + * ng_bt3c_pccard.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_bt3c_pccard.c,v 1.2 2002/11/12 00:51:45 max Exp $ + * $FreeBSD$ + * + * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX + * + * Based on information obrained from: Jose Orlando Pereira <jop@di.uminho.pt> + * and disassembled w2k driver. + * + * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX + * + */ + +#include <sys/param.h> +#include <sys/systm.h> + +#include <sys/bus.h> +#include <machine/bus.h> + +#include <sys/conf.h> +#include <sys/endian.h> +#include <sys/interrupt.h> +#include <sys/kernel.h> +#include <sys/mbuf.h> +#include <sys/module.h> + +#include <machine/resource.h> +#include <sys/rman.h> + +#include <sys/socket.h> +#include <net/if.h> +#include <net/if_var.h> + +#include <dev/pccard/pccardreg.h> +#include <dev/pccard/pccardvar.h> +#include <dev/pccard/pccarddevs.h> + +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <netgraph/ng_parse.h> +#include <ng_bluetooth.h> +#include <ng_hci.h> +#include "ng_bt3c.h" +#include "ng_bt3c_var.h" + +/* Netgraph methods */ +static ng_constructor_t ng_bt3c_constructor; +static ng_shutdown_t ng_bt3c_shutdown; +static ng_newhook_t ng_bt3c_newhook; +static ng_connect_t ng_bt3c_connect; +static ng_disconnect_t ng_bt3c_disconnect; +static ng_rcvmsg_t ng_bt3c_rcvmsg; +static ng_rcvdata_t ng_bt3c_rcvdata; + +/* PCMCIA driver methods */ +static int bt3c_pccard_match (device_t); +static int bt3c_pccard_probe (device_t); +static int bt3c_pccard_attach (device_t); +static int bt3c_pccard_detach (device_t); + +static void bt3c_intr (void *); +static void bt3c_receive (bt3c_softc_p); +static int bt3c_append (struct mbuf *, int); + +static void bt3c_swi_intr (void *); +static void bt3c_forward (node_p, hook_p, void *, int); +static void bt3c_send (node_p, hook_p, void *, int); + +static void bt3c_download_firmware (bt3c_softc_p, char const *, int); + +#define bt3c_set_address(sc, address) \ +do { \ + outb(rman_get_start((sc)->iobase) + BT3C_ADDR_L, ((address) & 0xff)); \ + outb(rman_get_start((sc)->iobase) + BT3C_ADDR_H, (((address) >> 8) & 0xff)); \ +} while (0) + +#define bt3c_read_data(sc, data) \ +do { \ + (data) = inb(rman_get_start((sc)->iobase) + BT3C_DATA_L); \ + (data) |= ((inb(rman_get_start((sc)->iobase) + BT3C_DATA_H) & 0xff) << 8); \ +} while (0) + +#define bt3c_write_data(sc, data) \ +do { \ + outb(rman_get_start((sc)->iobase) + BT3C_DATA_L, ((data) & 0xff)); \ + outb(rman_get_start((sc)->iobase) + BT3C_DATA_H, (((data) >> 8) & 0xff)); \ +} while (0) + +#define bt3c_read_control(sc, data) \ +do { \ + (data) = inb(rman_get_start((sc)->iobase) + BT3C_CONTROL); \ +} while (0) + +#define bt3c_write_control(sc, data) \ +do { \ + outb(rman_get_start((sc)->iobase) + BT3C_CONTROL, (data)); \ +} while (0) + +#define bt3c_read(sc, address, data) \ +do { \ + bt3c_set_address((sc), (address)); \ + bt3c_read_data((sc), (data)); \ +} while(0) + +#define bt3c_write(sc, address, data) \ +do { \ + bt3c_set_address((sc), (address)); \ + bt3c_write_data((sc), (data)); \ +} while(0) + +static MALLOC_DEFINE(M_BT3C, "bt3c", "bt3c data structures"); + +/**************************************************************************** + **************************************************************************** + ** Netgraph specific + **************************************************************************** + ****************************************************************************/ + +/* + * Netgraph node type + */ + +/* Queue length */ +static const struct ng_parse_struct_field ng_bt3c_node_qlen_type_fields[] = +{ + { "queue", &ng_parse_int32_type, }, + { "qlen", &ng_parse_int32_type, }, + { NULL, } +}; +static const struct ng_parse_type ng_bt3c_node_qlen_type = { + &ng_parse_struct_type, + &ng_bt3c_node_qlen_type_fields +}; + +/* Stat info */ +static const struct ng_parse_struct_field ng_bt3c_node_stat_type_fields[] = +{ + { "pckts_recv", &ng_parse_uint32_type, }, + { "bytes_recv", &ng_parse_uint32_type, }, + { "pckts_sent", &ng_parse_uint32_type, }, + { "bytes_sent", &ng_parse_uint32_type, }, + { "oerrors", &ng_parse_uint32_type, }, + { "ierrors", &ng_parse_uint32_type, }, + { NULL, } +}; +static const struct ng_parse_type ng_bt3c_node_stat_type = { + &ng_parse_struct_type, + &ng_bt3c_node_stat_type_fields +}; + +static const struct ng_cmdlist ng_bt3c_cmdlist[] = { +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_GET_STATE, + "get_state", + NULL, + &ng_parse_uint16_type +}, +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_SET_DEBUG, + "set_debug", + &ng_parse_uint16_type, + NULL +}, +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_GET_DEBUG, + "get_debug", + NULL, + &ng_parse_uint16_type +}, +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_GET_QLEN, + "get_qlen", + NULL, + &ng_bt3c_node_qlen_type +}, +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_SET_QLEN, + "set_qlen", + &ng_bt3c_node_qlen_type, + NULL +}, +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_GET_STAT, + "get_stat", + NULL, + &ng_bt3c_node_stat_type +}, +{ + NGM_BT3C_COOKIE, + NGM_BT3C_NODE_RESET_STAT, + "reset_stat", + NULL, + NULL +}, +{ 0, } +}; + +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_BT3C_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_bt3c_constructor, /* constructor */ + ng_bt3c_rcvmsg, /* control message */ + ng_bt3c_shutdown, /* destructor */ + ng_bt3c_newhook, /* new hook */ + NULL, /* find hook */ + ng_bt3c_connect, /* connect hook */ + ng_bt3c_rcvdata, /* data */ + ng_bt3c_disconnect, /* disconnect hook */ + ng_bt3c_cmdlist /* node command list */ +}; +NETGRAPH_INIT(bt3c, &typestruct); +MODULE_VERSION(ng_bt3c, NG_BLUETOOTH_VERSION); + +/* + * Netgraph node constructor. Do not allow to create node of this type. + */ + +static int +ng_bt3c_constructor(node_p node) +{ + return (EINVAL); +} /* ng_bt3c_constructor */ + +/* + * Netgraph node destructor. Destroy node only when device has been detached + */ + +static int +ng_bt3c_shutdown(node_p node) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node); + + /* Let old node go */ + NG_NODE_SET_PRIVATE(node, NULL); + NG_NODE_UNREF(node); + + /* Create new fresh one if we are not going down */ + if (sc == NULL) + goto out; + + /* Create new Netgraph node */ + if (ng_make_node_common(&typestruct, &sc->node) != 0) { + device_printf(sc->dev, "Could not create Netgraph node\n"); + sc->node = NULL; + goto out; + } + + /* Name new Netgraph node */ + if (ng_name_node(sc->node, device_get_nameunit(sc->dev)) != 0) { + device_printf(sc->dev, "Could not name Netgraph node\n"); + NG_NODE_UNREF(sc->node); + sc->node = NULL; + goto out; + } + + NG_NODE_SET_PRIVATE(sc->node, sc); +out: + return (0); +} /* ng_bt3c_shutdown */ + +/* + * Create new hook. There can only be one. + */ + +static int +ng_bt3c_newhook(node_p node, hook_p hook, char const *name) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node); + + if (strcmp(name, NG_BT3C_HOOK) != 0) + return (EINVAL); + + if (sc->hook != NULL) + return (EISCONN); + + sc->hook = hook; + + return (0); +} /* ng_bt3c_newhook */ + +/* + * Connect hook. Say YEP, that's OK with me. + */ + +static int +ng_bt3c_connect(hook_p hook) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + if (hook != sc->hook) { + sc->hook = NULL; + return (EINVAL); + } + + /* set the hook into queueing mode (for incoming (from wire) packets) */ + NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); + + return (0); +} /* ng_bt3c_connect */ + +/* + * Disconnect hook + */ + +static int +ng_bt3c_disconnect(hook_p hook) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + /* + * We need to check for sc != NULL because we can be called from + * bt3c_pccard_detach() via ng_rmnode_self() + */ + + if (sc != NULL) { + if (hook != sc->hook) + return (EINVAL); + + IF_DRAIN(&sc->inq); + IF_DRAIN(&sc->outq); + + sc->hook = NULL; + } + + return (0); +} /* ng_bt3c_disconnect */ + +/* + * Process control message + */ + +static int +ng_bt3c_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NULL, *rsp = NULL; + int error = 0; + + if (sc == NULL) { + NG_FREE_ITEM(item); + return (EHOSTDOWN); + } + + NGI_GET_MSG(item, msg); + + switch (msg->header.typecookie) { + case NGM_GENERIC_COOKIE: + switch (msg->header.cmd) { + case NGM_TEXT_STATUS: + NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + snprintf(rsp->data, NG_TEXTRESPONSE, + "Hook: %s\n" \ + "Flags: %#x\n" \ + "Debug: %d\n" \ + "State: %d\n" \ + "IncmQ: [len:%d,max:%d]\n" \ + "OutgQ: [len:%d,max:%d]\n", + (sc->hook != NULL)? NG_BT3C_HOOK : "", + sc->flags, + sc->debug, + sc->state, + _IF_QLEN(&sc->inq), /* XXX */ + sc->inq.ifq_maxlen, /* XXX */ + _IF_QLEN(&sc->outq), /* XXX */ + sc->outq.ifq_maxlen /* XXX */ + ); + break; + + default: + error = EINVAL; + break; + } + break; + + case NGM_BT3C_COOKIE: + switch (msg->header.cmd) { + case NGM_BT3C_NODE_GET_STATE: + NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_state_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + *((ng_bt3c_node_state_ep *)(rsp->data)) = + sc->state; + break; + + case NGM_BT3C_NODE_SET_DEBUG: + if (msg->header.arglen != sizeof(ng_bt3c_node_debug_ep)) + error = EMSGSIZE; + else + sc->debug = + *((ng_bt3c_node_debug_ep *)(msg->data)); + break; + + case NGM_BT3C_NODE_GET_DEBUG: + NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_debug_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + *((ng_bt3c_node_debug_ep *)(rsp->data)) = + sc->debug; + break; + + case NGM_BT3C_NODE_GET_QLEN: + NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_qlen_ep), + M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + switch (((ng_bt3c_node_qlen_ep *)(msg->data))->queue) { + case NGM_BT3C_NODE_IN_QUEUE: + ((ng_bt3c_node_qlen_ep *)(rsp->data))->queue = + NGM_BT3C_NODE_IN_QUEUE; + ((ng_bt3c_node_qlen_ep *)(rsp->data))->qlen = + sc->inq.ifq_maxlen; + break; + + case NGM_BT3C_NODE_OUT_QUEUE: + ((ng_bt3c_node_qlen_ep *)(rsp->data))->queue = + NGM_BT3C_NODE_OUT_QUEUE; + ((ng_bt3c_node_qlen_ep *)(rsp->data))->qlen = + sc->outq.ifq_maxlen; + break; + + default: + NG_FREE_MSG(rsp); + error = EINVAL; + break; + } + break; + + case NGM_BT3C_NODE_SET_QLEN: + if (msg->header.arglen != sizeof(ng_bt3c_node_qlen_ep)){ + error = EMSGSIZE; + break; + } + + if (((ng_bt3c_node_qlen_ep *)(msg->data))->qlen <= 0) { + error = EINVAL; + break; + } + + switch (((ng_bt3c_node_qlen_ep *)(msg->data))->queue) { + case NGM_BT3C_NODE_IN_QUEUE: + sc->inq.ifq_maxlen = ((ng_bt3c_node_qlen_ep *) + (msg->data))->qlen; /* XXX */ + break; + + case NGM_BT3C_NODE_OUT_QUEUE: + sc->outq.ifq_maxlen = ((ng_bt3c_node_qlen_ep *) + (msg->data))->qlen; /* XXX */ + break; + + default: + error = EINVAL; + break; + } + break; + + case NGM_BT3C_NODE_GET_STAT: + NG_MKRESPONSE(rsp, msg, sizeof(ng_bt3c_node_stat_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + bcopy(&sc->stat, rsp->data, + sizeof(ng_bt3c_node_stat_ep)); + break; + + case NGM_BT3C_NODE_RESET_STAT: + NG_BT3C_STAT_RESET(sc->stat); + break; + + case NGM_BT3C_NODE_DOWNLOAD_FIRMWARE: + if (msg->header.arglen < + sizeof(ng_bt3c_firmware_block_ep)) + error = EMSGSIZE; + else + bt3c_download_firmware(sc, msg->data, + msg->header.arglen); + break; + + default: + error = EINVAL; + break; + } + break; + + default: + error = EINVAL; + break; + } + + NG_RESPOND_MSG(error, node, item, rsp); + NG_FREE_MSG(msg); + + return (error); +} /* ng_bt3c_rcvmsg */ + +/* + * Process data + */ + +static int +ng_bt3c_rcvdata(hook_p hook, item_p item) +{ + bt3c_softc_p sc = (bt3c_softc_p)NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + int error = 0; + + if (sc == NULL) { + error = EHOSTDOWN; + goto out; + } + + if (hook != sc->hook) { + error = EINVAL; + goto out; + } + + NGI_GET_M(item, m); + + IF_LOCK(&sc->outq); + if (_IF_QFULL(&sc->outq)) { + NG_BT3C_ERR(sc->dev, +"Outgoing queue is full. Dropping mbuf, len=%d\n", m->m_pkthdr.len); + + _IF_DROP(&sc->outq); + NG_BT3C_STAT_OERROR(sc->stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->outq, m); + IF_UNLOCK(&sc->outq); + + error = ng_send_fn(sc->node, NULL, bt3c_send, NULL, 0 /* new send */); +out: + NG_FREE_ITEM(item); + + return (error); +} /* ng_bt3c_rcvdata */ + +/**************************************************************************** + **************************************************************************** + ** PCMCIA driver specific + **************************************************************************** + ****************************************************************************/ + +/* + * PC-Card (PCMCIA) match routine + */ + +static int +bt3c_pccard_match(device_t dev) +{ + static struct pccard_product const bt3c_pccard_products[] = { + PCMCIA_CARD(3COM, 3CRWB609, 0), + { NULL, } + }; + + struct pccard_product const *pp = NULL; + + pp = pccard_product_lookup(dev, bt3c_pccard_products, + sizeof(bt3c_pccard_products[0]), NULL); + if (pp == NULL) + return (EIO); + + device_set_desc(dev, pp->pp_name); + + return (0); +} /* bt3c_pccacd_match */ + +/* + * PC-Card (PCMCIA) probe routine + * XXX FIXME + */ + +static int +bt3c_pccard_probe(device_t dev) +{ + return (0); +} /* bt3c_pccacd_probe */ + +/* + * PC-Card (PCMCIA) attach routine + */ + +static int +bt3c_pccard_attach(device_t dev) +{ + bt3c_softc_p sc = NULL; + + sc = (bt3c_softc_p) malloc(sizeof(*sc), M_BT3C, M_NOWAIT|M_ZERO); + if (sc == NULL) + return (ENOMEM); + + /* Allocate I/O ports */ + sc->iobase_rid = 0; + sc->iobase = bus_alloc_resource(dev, SYS_RES_IOPORT, &sc->iobase_rid, + 0, ~0, 8, RF_ACTIVE); + if (sc->iobase == NULL) { + device_printf(dev, "Could not allocate I/O ports\n"); + goto bad; + } + + /* Allocate IRQ */ + sc->irq_rid = 0; + sc->irq = bus_alloc_resource(dev, SYS_RES_IRQ, &sc->irq_rid, + 0, ~0, 1, RF_ACTIVE); + if (sc->irq == NULL) { + device_printf(dev, "Could not allocate IRQ\n"); + goto bad; + } + + sc->irq_cookie = NULL; + if (bus_setup_intr(dev, sc->irq, INTR_TYPE_TTY, bt3c_intr, sc, + &sc->irq_cookie) != 0) { + device_printf(dev, "Could not setup ISR\n"); + goto bad; + } + + /* Attach handler to TTY SWI thread */ + sc->ith = NULL; + if (swi_add(&tty_ithd, device_get_nameunit(dev), + bt3c_swi_intr, sc, SWI_TTY, 0, &sc->ith) < 0) { + device_printf(dev, "Could not setup SWI ISR\n"); + goto bad; + } + + /* Create Netgraph node */ + if (ng_make_node_common(&typestruct, &sc->node) != 0) { + device_printf(dev, "Could not create Netgraph node\n"); + sc->node = NULL; + goto bad; + } + + /* Name Netgraph node */ + if (ng_name_node(sc->node, device_get_nameunit(dev)) != 0) { + device_printf(dev, "Could not name Netgraph node\n"); + NG_NODE_UNREF(sc->node); + sc->node = NULL; + goto bad; + } + + sc->dev = dev; + sc->debug = NG_BT3C_WARN_LEVEL; + + sc->inq.ifq_maxlen = sc->outq.ifq_maxlen = BT3C_DEFAULTQLEN; + mtx_init(&sc->inq.ifq_mtx, "BT3C inq", NULL, MTX_DEF); + mtx_init(&sc->outq.ifq_mtx, "BT3C outq", NULL, MTX_DEF); + + sc->state = NG_BT3C_W4_PKT_IND; + sc->want = 1; + + NG_NODE_SET_PRIVATE(sc->node, sc); + device_set_softc(dev, sc); + + return (0); +bad: + if (sc->ith != NULL) { + ithread_remove_handler(sc->ith); + sc->ith = NULL; + } + + if (sc->irq != NULL) { + if (sc->irq_cookie != NULL) + bus_teardown_intr(dev, sc->irq, sc->irq_cookie); + + bus_release_resource(dev, SYS_RES_IRQ, + sc->irq_rid, sc->irq); + + sc->irq = NULL; + sc->irq_rid = 0; + } + + if (sc->iobase != NULL) { + bus_release_resource(dev, SYS_RES_IOPORT, + sc->iobase_rid, sc->iobase); + + sc->iobase = NULL; + sc->iobase_rid = 0; + } + + free(sc, M_BT3C); + + return (ENXIO); +} /* bt3c_pccacd_attach */ + +/* + * PC-Card (PCMCIA) detach routine + */ + +static int +bt3c_pccard_detach(device_t dev) +{ + bt3c_softc_p sc = (bt3c_softc_p) device_get_softc(dev); + + if (sc == NULL) + return (0); + + device_set_softc(dev, NULL); + + ithread_remove_handler(sc->ith); + sc->ith = NULL; + + bus_teardown_intr(dev, sc->irq, sc->irq_cookie); + bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid, sc->irq); + sc->irq_cookie = NULL; + sc->irq = NULL; + sc->irq_rid = 0; + + bus_release_resource(dev, SYS_RES_IOPORT, sc->iobase_rid, sc->iobase); + sc->iobase = NULL; + sc->iobase_rid = 0; + + if (sc->node != NULL) { + NG_NODE_SET_PRIVATE(sc->node, NULL); + ng_rmnode_self(sc->node); + sc->node = NULL; + } + + NG_FREE_M(sc->m); + IF_DRAIN(&sc->inq); + IF_DRAIN(&sc->outq); + + mtx_destroy(&sc->inq.ifq_mtx); + mtx_destroy(&sc->outq.ifq_mtx); + + bzero(sc, sizeof(*sc)); + free(sc, M_BT3C); + + return (0); +} /* bt3c_pccacd_detach */ + +/* + * Interrupt service routine's + */ + +static void +bt3c_intr(void *context) +{ + bt3c_softc_p sc = (bt3c_softc_p) context; + u_int16_t control, status; + + if (sc == NULL || sc->ith == NULL) { + printf("%s: bogus interrupt\n", NG_BT3C_NODE_TYPE); + return; + } + + bt3c_read_control(sc, control); + if ((control & 0x80) == 0) + return; + + bt3c_read(sc, 0x7001, status); + NG_BT3C_INFO(sc->dev, "control=%#x, status=%#x\n", control, status); + + if ((status & 0xff) == 0x7f || (status & 0xff) == 0xff) { + NG_BT3C_WARN(sc->dev, "Strange status=%#x\n", status); + return; + } + + /* Receive complete */ + if (status & 0x0001) + bt3c_receive(sc); + + /* Record status and schedule SWI */ + sc->status |= status; + swi_sched(sc->ith, 0); + + /* Complete interrupt */ + bt3c_write(sc, 0x7001, 0x0000); + bt3c_write_control(sc, control); +} /* bt3c_intr */ + +/* + * Receive data + */ + +static void +bt3c_receive(bt3c_softc_p sc) +{ + u_int16_t i, count, c; + + /* Receive data from the card */ + bt3c_read(sc, 0x7006, count); + NG_BT3C_INFO(sc->dev, "The card has %d characters\n", count); + + bt3c_set_address(sc, 0x7480); + + for (i = 0; i < count; i++) { + /* Allocate new mbuf if needed */ + if (sc->m == NULL) { + sc->state = NG_BT3C_W4_PKT_IND; + sc->want = 1; + + MGETHDR(sc->m, M_DONTWAIT, MT_DATA); + if (sc->m == NULL) { + NG_BT3C_ERR(sc->dev, "Could not get mbuf\n"); + NG_BT3C_STAT_IERROR(sc->stat); + + break; /* XXX lost of sync */ + } + + sc->m->m_len = sc->m->m_pkthdr.len = 0; + } + + /* Read and append character to mbuf */ + bt3c_read_data(sc, c); + if (bt3c_append(sc->m, c) != 0) { + NG_FREE_M(sc->m); + sc->state = NG_BT3C_W4_PKT_IND; + sc->want = 1; + + break; /* XXX lost of sync */ + } + + NG_BT3C_INFO(sc->dev, +"Got char %#x, want=%d, got=%d\n", c, sc->want, sc->m->m_pkthdr.len); + + if (sc->m->m_pkthdr.len < sc->want) + continue; /* wait for more */ + + switch (sc->state) { + /* Got packet indicator */ + case NG_BT3C_W4_PKT_IND: + NG_BT3C_INFO(sc->dev, +"Got packet indicator %#x\n", *mtod(sc->m, u_int8_t *)); + + sc->state = NG_BT3C_W4_PKT_HDR; + + /* + * Since packet indicator included in the packet + * header just set sc->want to sizeof(packet header). + */ + + switch (*mtod(sc->m, u_int8_t *)) { + case NG_HCI_ACL_DATA_PKT: + sc->want = sizeof(ng_hci_acldata_pkt_t); + break; + + case NG_HCI_SCO_DATA_PKT: + sc->want = sizeof(ng_hci_scodata_pkt_t); + break; + + case NG_HCI_EVENT_PKT: + sc->want = sizeof(ng_hci_event_pkt_t); + break; + + default: + NG_BT3C_ERR(sc->dev, +"Ignoring unknown packet type=%#x\n", *mtod(sc->m, u_int8_t *)); + + NG_BT3C_STAT_IERROR(sc->stat); + + NG_FREE_M(sc->m); + sc->state = NG_BT3C_W4_PKT_IND; + sc->want = 1; + break; + } + break; + + /* Got packet header */ + case NG_BT3C_W4_PKT_HDR: + sc->state = NG_BT3C_W4_PKT_DATA; + + switch (*mtod(sc->m, u_int8_t *)) { + case NG_HCI_ACL_DATA_PKT: + c = le16toh(mtod(sc->m, + ng_hci_acldata_pkt_t *)->length); + break; + + case NG_HCI_SCO_DATA_PKT: + c = mtod(sc->m, ng_hci_scodata_pkt_t*)->length; + break; + + case NG_HCI_EVENT_PKT: + c = mtod(sc->m, ng_hci_event_pkt_t *)->length; + break; + + default: + KASSERT(0, +("Invalid packet type=%#x\n", *mtod(sc->m, u_int8_t *))); + break; + } + + NG_BT3C_INFO(sc->dev, +"Got packet header, packet type=%#x, got so far %d, payload size=%d\n", + *mtod(sc->m, u_int8_t *), sc->m->m_pkthdr.len, + c); + + if (c > 0) { + sc->want += c; + break; + } + + /* else FALLTHROUGH and deliver frame */ + /* XXX is this true? should we deliver empty frame? */ + + /* Got packet data */ + case NG_BT3C_W4_PKT_DATA: + NG_BT3C_INFO(sc->dev, +"Got full packet, packet type=%#x, packet size=%d\n", + *mtod(sc->m, u_int8_t *), sc->m->m_pkthdr.len); + + NG_BT3C_STAT_BYTES_RECV(sc->stat, sc->m->m_pkthdr.len); + NG_BT3C_STAT_PCKTS_RECV(sc->stat); + + IF_LOCK(&sc->inq); + if (_IF_QFULL(&sc->inq)) { + NG_BT3C_ERR(sc->dev, +"Incoming queue is full. Dropping mbuf, len=%d\n", sc->m->m_pkthdr.len); + + _IF_DROP(&sc->inq); + NG_BT3C_STAT_IERROR(sc->stat); + + NG_FREE_M(sc->m); + } else { + _IF_ENQUEUE(&sc->inq, sc->m); + sc->m = NULL; + } + IF_UNLOCK(&sc->inq); + + sc->state = NG_BT3C_W4_PKT_IND; + sc->want = 1; + break; + + default: + KASSERT(0, +("Invalid node state=%d", sc->state)); + break; + } + } + + bt3c_write(sc, 0x7006, 0x0000); +} /* bt3c_receive */ + +/* + * Append character to the mbuf. + * XXX assumes mbuf has header + * XXX does not handle external mbuf's + * XXX always appends char to the end of chain + */ + +static int +bt3c_append(struct mbuf *m0, int c) +{ + struct mbuf *m = m0; + int len; + + if (m0->m_next == NULL) + len = MHLEN; + else { + len = MLEN; + + while (m->m_next != NULL) + m = m->m_next; + } + + if (m->m_len >= len) { + MGET(m->m_next, M_DONTWAIT, m0->m_type); + if (m->m_next == NULL) + return (ENOBUFS); + + m = m->m_next; + m->m_len = 0; + } + + m->m_data[m->m_len ++] = (char) c; + m0->m_pkthdr.len ++; + + return (0); +} /* bt3c_append */ + +/* + * SWI interrupt handler + * Netgraph part is handled via ng_send_fn() to avoid race with hook + * connection/disconnection + */ + +static void +bt3c_swi_intr(void *context) +{ + bt3c_softc_p sc = (bt3c_softc_p) context; + u_int16_t data; + + /* Receive complete */ + if (sc->status & 0x0001) { + sc->status &= ~0x0001; /* XXX is it safe? */ + + if (ng_send_fn(sc->node, NULL, &bt3c_forward, NULL, 0) != 0) + NG_BT3C_ALERT(sc->dev, "Could not forward frames!\n"); + } + + /* Send complete */ + if (sc->status & 0x0002) { + sc->status &= ~0x0002; /* XXX is it safe */ + + if (ng_send_fn(sc->node, NULL, &bt3c_send, NULL, 1) != 0) + NG_BT3C_ALERT(sc->dev, "Could not send frames!\n"); + } + + /* Antenna position */ + if (sc->status & 0x0020) { + sc->status &= ~0x0020; /* XXX is it safe */ + + bt3c_read(sc, 0x7002, data); + data &= 0x10; + + if (data) + sc->flags |= BT3C_ANTENNA_OUT; + else + sc->flags &= ~BT3C_ANTENNA_OUT; + + NG_BT3C_INFO(sc->dev, "Antenna %s\n", data? "OUT" : "IN"); + } +} /* bt3c_swi_intr */ + +/* + * Send all incoming frames to the upper layer + */ + +static void +bt3c_forward(node_p node, hook_p hook, void *arg1, int arg2) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node); + struct mbuf *m = NULL; + int error; + + if (sc == NULL) + return; + + if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) { + for (;;) { + IF_DEQUEUE(&sc->inq, m); + if (m == NULL) + break; + + NG_SEND_DATA_ONLY(error, sc->hook, m); + if (error != 0) + NG_BT3C_STAT_IERROR(sc->stat); + } + } else { + IF_LOCK(&sc->inq); + for (;;) { + _IF_DEQUEUE(&sc->inq, m); + if (m == NULL) + break; + + NG_BT3C_STAT_IERROR(sc->stat); + NG_FREE_M(m); + } + IF_UNLOCK(&sc->inq); + } +} /* bt3c_forward */ + +/* + * Send more data to the device. Must be called when node is locked + */ + +static void +bt3c_send(node_p node, hook_p hook, void *arg, int completed) +{ + bt3c_softc_p sc = (bt3c_softc_p) NG_NODE_PRIVATE(node); + struct mbuf *m = NULL; + int i, wrote, len; + + if (sc == NULL) + return; + + if (completed) + sc->flags &= ~BT3C_XMIT; + + if (sc->flags & BT3C_XMIT) + return; + + bt3c_set_address(sc, 0x7080); + + for (wrote = 0; wrote < BT3C_FIFO_SIZE; ) { + IF_DEQUEUE(&sc->outq, m); + if (m == NULL) + break; + + while (m != NULL) { + len = min((BT3C_FIFO_SIZE - wrote), m->m_len); + + for (i = 0; i < m->m_len; i++) + bt3c_write_data(sc, m->m_data[i]); + + wrote += len; + m->m_data += len; + m->m_len -= len; + + if (m->m_len > 0) + break; + + m = m_free(m); + } + + if (m != NULL) { + IF_PREPEND(&sc->outq, m); + break; + } + + NG_BT3C_STAT_PCKTS_SENT(sc->stat); + } + + if (wrote > 0) { + NG_BT3C_INFO(sc->dev, "Wrote %d bytes\n", wrote); + NG_BT3C_STAT_BYTES_SENT(sc->stat, wrote); + + bt3c_write(sc, 0x7005, wrote); + sc->flags |= BT3C_XMIT; + } +} /* bt3c_send */ + +/* + * Download chip firmware + */ + +static void +bt3c_download_firmware(bt3c_softc_p sc, char const *firmware, int firmware_size) +{ + ng_bt3c_firmware_block_ep const *block = NULL; + u_int16_t const *data = NULL; + int i, size; + u_int8_t c; + + /* Reset */ + device_printf(sc->dev, "Reseting the card...\n"); + bt3c_write(sc, 0x8040, 0x0404); + bt3c_write(sc, 0x8040, 0x0400); + DELAY(1); + + bt3c_write(sc, 0x8040, 0x0404); + DELAY(17); + + /* Download firmware */ + device_printf(sc->dev, "Starting firmware download process...\n"); + + for (size = 0; size < firmware_size; ) { + block = (ng_bt3c_firmware_block_ep const *)(firmware + size); + data = (u_int16_t const *)(block + 1); + + if (bootverbose) + device_printf(sc->dev, "Download firmware block, " \ + "address=%#08x, size=%d words, aligment=%d\n", + block->block_address, block->block_size, + block->block_alignment); + + bt3c_set_address(sc, block->block_address); + for (i = 0; i < block->block_size; i++) + bt3c_write_data(sc, data[i]); + + size += (sizeof(*block) + (block->block_size * 2) + + block->block_alignment); + } + + DELAY(17); + device_printf(sc->dev, "Firmware download process complete\n"); + + /* Boot */ + device_printf(sc->dev, "Starting the card...\n"); + bt3c_set_address(sc, 0x3000); + bt3c_read_control(sc, c); + bt3c_write_control(sc, (c | 0x40)); + DELAY(17); + + /* Clear registers */ + device_printf(sc->dev, "Clearing card registers...\n"); + bt3c_write(sc, 0x7006, 0x0000); + bt3c_write(sc, 0x7005, 0x0000); + bt3c_write(sc, 0x7001, 0x0000); + DELAY(1000); +} /* bt3c_download_firmware */ + +/**************************************************************************** + **************************************************************************** + ** Driver module + **************************************************************************** + ****************************************************************************/ + +/* + * PC-Card (PCMCIA) driver + */ + +static device_method_t bt3c_pccard_methods[] = { + /* Device interface */ + DEVMETHOD(device_probe, pccard_compat_probe), + DEVMETHOD(device_attach, pccard_compat_attach), + DEVMETHOD(device_detach, bt3c_pccard_detach), + + /* Card interface */ + DEVMETHOD(card_compat_match, bt3c_pccard_match), + DEVMETHOD(card_compat_probe, bt3c_pccard_probe), + DEVMETHOD(card_compat_attach, bt3c_pccard_attach), + { 0, 0 } +}; + +static driver_t bt3c_pccard_driver = { + NG_BT3C_NODE_TYPE, + bt3c_pccard_methods, + 0 +}; + +static devclass_t bt3c_devclass; + +DRIVER_MODULE(bt3c, pccard, bt3c_pccard_driver, bt3c_devclass, 0, 0); + diff --git a/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_var.h b/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_var.h new file mode 100644 index 0000000..89ac57c --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/bt3c/ng_bt3c_var.h @@ -0,0 +1,103 @@ +/* + * ng_bt3c_var.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_bt3c_var.h,v 1.1 2002/11/09 19:07:56 max Exp $ + * $FreeBSD$ + * + * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX + * + * Based on information obrained from: Jose Orlando Pereira <jop@di.uminho.pt> + * and disassembled w2k driver. + * + * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX + * + */ + +#ifndef _NG_BT3C_VAR_H_ +#define _NG_BT3C_VAR_H_ + +/* Debug printf's */ +#define NG_BT3C_ALERT if (sc->debug >= NG_BT3C_ALERT_LEVEL) device_printf +#define NG_BT3C_ERR if (sc->debug >= NG_BT3C_ERR_LEVEL) device_printf +#define NG_BT3C_WARN if (sc->debug >= NG_BT3C_WARN_LEVEL) device_printf +#define NG_BT3C_INFO if (sc->debug >= NG_BT3C_INFO_LEVEL) device_printf + +/* Device registers */ +#define BT3C_DATA_L 0x00 /* data low byte */ +#define BT3C_DATA_H 0x01 /* high byte */ +#define BT3C_ADDR_L 0x02 /* address low byte */ +#define BT3C_ADDR_H 0x03 /* high byte */ +#define BT3C_CONTROL 0x04 /* control */ + +#define BT3C_FIFO_SIZE 256 + +/* Device softc structure */ +struct bt3c_softc { + /* Device specific */ + device_t dev; /* pointer back to device */ + int iobase_rid; /* iobase RID */ + struct resource *iobase; /* iobase */ + int irq_rid; /* irq RID */ + struct resource *irq; /* irq */ + void *irq_cookie; /* irq cookie */ + + /* Netgraph specific */ + node_p node; /* pointer back to node */ + hook_p hook; /* hook */ + + ng_bt3c_node_debug_ep debug; /* debug level */ + u_int16_t flags; /* device flags */ +#define BT3C_ANTENNA_OUT (1 << 0) /* antena is out */ +#define BT3C_XMIT (1 << 1) /* xmit in progress */ + + ng_bt3c_node_state_ep state; /* receiving state */ + + ng_bt3c_node_stat_ep stat; /* statistic */ +#define NG_BT3C_STAT_PCKTS_SENT(s) (s).pckts_sent ++ +#define NG_BT3C_STAT_BYTES_SENT(s, n) (s).bytes_sent += (n) +#define NG_BT3C_STAT_PCKTS_RECV(s) (s).pckts_recv ++ +#define NG_BT3C_STAT_BYTES_RECV(s, n) (s).bytes_recv += (n) +#define NG_BT3C_STAT_OERROR(s) (s).oerrors ++ +#define NG_BT3C_STAT_IERROR(s) (s).ierrors ++ +#define NG_BT3C_STAT_RESET(s) bzero(&(s), sizeof((s))) + + u_int32_t status; /* from ISR */ + void *ith; /* ithread handler */ + + struct mbuf *m; /* current frame */ + u_int32_t want; /* # of chars we want */ + + struct ifqueue inq; /* queue of incoming mbuf's */ + struct ifqueue outq; /* queue of outgoing mbuf's */ +#define BT3C_DEFAULTQLEN 12 /* XXX max. size of out queue */ +}; + +typedef struct bt3c_softc bt3c_softc_t; +typedef struct bt3c_softc * bt3c_softc_p; + +#endif /* ndef _NG_BT3C_VAR_H_ */ + diff --git a/sys/netgraph/bluetooth/drivers/h4/TODO b/sys/netgraph/bluetooth/drivers/h4/TODO new file mode 100644 index 0000000..67cfbba --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/h4/TODO @@ -0,0 +1,13 @@ +# $FreeBSD$ +$Id: TODO,v 1.6 2002/06/27 09:50:17 max Exp $ + +FIXME/TODO list + +This is a list of open issues for H4 node + +1) Locking/SMP + + External code now uses ng_send_fn to inject data into Netgraph, but + i still use splXXX to lock tty level. this is wrong and should be + fixed! + diff --git a/sys/netgraph/bluetooth/drivers/h4/ng_h4.c b/sys/netgraph/bluetooth/drivers/h4/ng_h4.c new file mode 100644 index 0000000..650c6f4 --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/h4/ng_h4.c @@ -0,0 +1,1059 @@ +/* + * ng_h4.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_h4.c,v 1.25 2002/11/03 02:17:31 max Exp $ + * $FreeBSD$ + * + * Based on: + * --------- + * + * FreeBSD: src/sys/netgraph/ng_tty.c + * Author: Archie Cobbs <archie@freebsd.org> + * + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/conf.h> +#include <sys/endian.h> +#include <sys/errno.h> +#include <sys/fcntl.h> +#include <sys/ioccom.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/tty.h> +#include <sys/ttycom.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <netgraph/ng_parse.h> +#include <ng_bluetooth.h> +#include <ng_hci.h> +#include "ng_h4.h" +#include "ng_h4_var.h" +#include "ng_h4_prse.h" + +/***************************************************************************** + ***************************************************************************** + ** This node implements a Bluetooth HCI UART transport layer as per chapter + ** H4 of the Bluetooth Specification Book v1.1. It is a terminal line + ** discipline that is also a netgraph node. Installing this line discipline + ** on a terminal device instantiates a new netgraph node of this type, which + ** allows access to the device via the "hook" hook of the node. + ** + ** Once the line discipline is installed, you can find out the name of the + ** corresponding netgraph node via a NGIOCGINFO ioctl(). + ***************************************************************************** + *****************************************************************************/ + +/* MALLOC define */ +#ifndef NG_SEPARATE_MALLOC +MALLOC_DEFINE(M_NETGRAPH_H4, "netgraph_h4", "Netgraph Bluetooth H4 node"); +#else +#define M_NETGRAPH_H4 M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Line discipline methods */ +static int ng_h4_open (dev_t, struct tty *); +static int ng_h4_close (struct tty *, int); +static int ng_h4_read (struct tty *, struct uio *, int); +static int ng_h4_write (struct tty *, struct uio *, int); +static int ng_h4_input (int, struct tty *); +static int ng_h4_start (struct tty *); +static void ng_h4_start2 (node_p, hook_p, void *, int); +static int ng_h4_ioctl (struct tty *, u_long, caddr_t, + int, struct thread *); + +/* Line discipline descriptor */ +static struct linesw ng_h4_disc = { + ng_h4_open, /* open */ + ng_h4_close, /* close */ + ng_h4_read, /* read */ + ng_h4_write, /* write */ + ng_h4_ioctl, /* ioctl */ + ng_h4_input, /* input */ + ng_h4_start, /* start */ + ttymodem, /* modem */ + 0 /* hotchar (don't really care which one) */ +}; + +/* Netgraph methods */ +static ng_constructor_t ng_h4_constructor; +static ng_rcvmsg_t ng_h4_rcvmsg; +static ng_shutdown_t ng_h4_shutdown; +static ng_newhook_t ng_h4_newhook; +static ng_connect_t ng_h4_connect; +static ng_rcvdata_t ng_h4_rcvdata; +static ng_disconnect_t ng_h4_disconnect; + +/* Other stuff */ +static void ng_h4_timeout (node_p); +static void ng_h4_untimeout (node_p); +static void ng_h4_queue_timeout (void *); +static void ng_h4_process_timeout (node_p, hook_p, void *, int); +static int ng_h4_mod_event (module_t, int, void *); + +/* Netgraph node type descriptor */ +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_H4_NODE_TYPE, /* typename */ + ng_h4_mod_event, /* modevent */ + ng_h4_constructor, /* constructor */ + ng_h4_rcvmsg, /* control message */ + ng_h4_shutdown, /* destructor */ + ng_h4_newhook, /* new hook */ + NULL, /* find hook */ + ng_h4_connect, /* connect hook */ + ng_h4_rcvdata, /* data */ + ng_h4_disconnect, /* disconnect hook */ + ng_h4_cmdlist /* node command list */ +}; +NETGRAPH_INIT(h4, &typestruct); +MODULE_VERSION(ng_h4, NG_BLUETOOTH_VERSION); + +static int ng_h4_node = 0; + +/***************************************************************************** + ***************************************************************************** + ** Line discipline methods + ***************************************************************************** + *****************************************************************************/ + +/* + * Set our line discipline on the tty. + */ + +static int +ng_h4_open(dev_t dev, struct tty *tp) +{ + char name[NG_NODELEN + 1]; + ng_h4_info_p sc = NULL; + int s, error; + + /* Super-user only */ + error = suser(curthread); /* XXX */ + if (error != 0) + return (error); + + s = splnet(); /* XXX */ + spltty(); /* XXX */ + + /* Already installed? */ + if (tp->t_line == H4DISC) { + sc = (ng_h4_info_p) tp->t_sc; + if (sc != NULL && sc->tp == tp) + goto out; + } + + /* Initialize private struct */ + MALLOC(sc, ng_h4_info_p, sizeof(*sc), M_NETGRAPH_H4, M_WAITOK | M_ZERO); + if (sc == NULL) { + error = ENOMEM; + goto out; + } + + sc->tp = tp; + sc->debug = NG_H4_WARN_LEVEL; + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + + NG_BT_MBUFQ_INIT(&sc->outq, NG_H4_DEFAULTQLEN); + callout_handle_init(&sc->timo); + + /* Setup netgraph node */ + error = ng_make_node_common(&typestruct, &sc->node); + if (error != 0) { + bzero(sc, sizeof(*sc)); + FREE(sc, M_NETGRAPH_H4); + goto out; + } + + /* Assign node its name */ + snprintf(name, sizeof(name), "%s%d", typestruct.name, ng_h4_node ++); + + error = ng_name_node(sc->node, name); + if (error != 0) { + NG_H4_ALERT("%s: %s - node name exists?\n", __func__, name); + NG_NODE_UNREF(sc->node); + bzero(sc, sizeof(*sc)); + FREE(sc, M_NETGRAPH_H4); + goto out; + } + + /* Set back pointers */ + NG_NODE_SET_PRIVATE(sc->node, sc); + tp->t_sc = (caddr_t) sc; + + /* The node has to be a WRITER because data can change node status */ + NG_NODE_FORCE_WRITER(sc->node); + + /* + * Pre-allocate cblocks to the an appropriate amount. + * I'm not sure what is appropriate. + */ + + ttyflush(tp, FREAD | FWRITE); + clist_alloc_cblocks(&tp->t_canq, 0, 0); + clist_alloc_cblocks(&tp->t_rawq, 0, 0); + clist_alloc_cblocks(&tp->t_outq, + MLEN + NG_H4_HIWATER, MLEN + NG_H4_HIWATER); +out: + splx(s); /* XXX */ + + return (error); +} /* ng_h4_open */ + +/* + * Line specific close routine, called from device close routine + * and from ttioctl. This causes the node to be destroyed as well. + */ + +static int +ng_h4_close(struct tty *tp, int flag) +{ + ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; + int s; + + s = spltty(); /* XXX */ + + ttyflush(tp, FREAD | FWRITE); + clist_free_cblocks(&tp->t_outq); + tp->t_line = 0; + if (sc != NULL) { + tp->t_sc = NULL; + + if (sc->node != NULL) { + if (sc->flags & NG_H4_TIMEOUT) + ng_h4_untimeout(sc->node); + + NG_NODE_SET_PRIVATE(sc->node, NULL); + ng_rmnode_self(sc->node); + sc->node = NULL; + } + + NG_BT_MBUFQ_DESTROY(&sc->outq); + bzero(sc, sizeof(*sc)); + FREE(sc, M_NETGRAPH_H4); + } + + splx(s); /* XXX */ + + return (0); +} /* ng_h4_close */ + +/* + * Once the device has been turned into a node, we don't allow reading. + */ + +static int +ng_h4_read(struct tty *tp, struct uio *uio, int flag) +{ + return (EIO); +} /* ng_h4_read */ + +/* + * Once the device has been turned into a node, we don't allow writing. + */ + +static int +ng_h4_write(struct tty *tp, struct uio *uio, int flag) +{ + return (EIO); +} /* ng_h4_write */ + +/* + * We implement the NGIOCGINFO ioctl() defined in ng_message.h. + */ + +static int +ng_h4_ioctl(struct tty *tp, u_long cmd, caddr_t data, int flag, + struct thread *td) +{ + ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; + int s, error = 0; + + s = spltty(); /* XXX */ + + switch (cmd) { + case NGIOCGINFO: +#undef NI +#define NI(x) ((struct nodeinfo *)(x)) + + bzero(data, sizeof(*NI(data))); + + if (NG_NODE_HAS_NAME(sc->node)) + strncpy(NI(data)->name, NG_NODE_NAME(sc->node), + sizeof(NI(data)->name) - 1); + + strncpy(NI(data)->type, sc->node->nd_type->name, + sizeof(NI(data)->type) - 1); + + NI(data)->id = (u_int32_t) ng_node2ID(sc->node); + NI(data)->hooks = NG_NODE_NUMHOOKS(sc->node); + break; + + default: + error = ENOIOCTL; + break; + } + + splx(s); /* XXX */ + + return (error); +} /* ng_h4_ioctl */ + +/* + * Receive data coming from the device. We get one character at a time, which + * is kindof silly. + */ + +static int +ng_h4_input(int c, struct tty *tp) +{ + ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; + + if (sc == NULL || tp != sc->tp || + sc->node == NULL || NG_NODE_NOT_VALID(sc->node)) + return (0); + + /* Check for error conditions */ + if ((sc->tp->t_state & TS_CONNECTED) == 0) { + NG_H4_INFO("%s: %s - no carrier\n", __func__, + NG_NODE_NAME(sc->node)); + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + + return (0); /* XXX Loss of synchronization here! */ + } + + /* Check for framing error or overrun on this char */ + if (c & TTY_ERRORMASK) { + NG_H4_ERR("%s: %s - line error %#x, c=%#x\n", __func__, + NG_NODE_NAME(sc->node), c & TTY_ERRORMASK, + c & TTY_CHARMASK); + + NG_H4_STAT_IERROR(sc->stat); + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + + return (0); /* XXX Loss of synchronization here! */ + } + + NG_H4_STAT_BYTES_RECV(sc->stat, 1); + + /* Append char to mbuf */ + if (sc->got >= sizeof(sc->ibuf)) { + NG_H4_ALERT("%s: %s - input buffer overflow, c=%#x, got=%d\n", + __func__, NG_NODE_NAME(sc->node), c & TTY_CHARMASK, + sc->got); + + NG_H4_STAT_IERROR(sc->stat); + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + + return (0); /* XXX Loss of synchronization here! */ + } + + sc->ibuf[sc->got ++] = (c & TTY_CHARMASK); + + NG_H4_INFO("%s: %s - got char %#x, want=%d, got=%d\n", __func__, + NG_NODE_NAME(sc->node), c, sc->want, sc->got); + + if (sc->got < sc->want) + return (0); /* Wait for more */ + + switch (sc->state) { + /* Got packet indicator */ + case NG_H4_W4_PKT_IND: + NG_H4_INFO("%s: %s - got packet indicator %#x\n", __func__, + NG_NODE_NAME(sc->node), sc->ibuf[0]); + + sc->state = NG_H4_W4_PKT_HDR; + + /* + * Since packet indicator included in the packet header + * just set sc->want to sizeof(packet header). + */ + + switch (sc->ibuf[0]) { + case NG_HCI_ACL_DATA_PKT: + sc->want = sizeof(ng_hci_acldata_pkt_t); + break; + + case NG_HCI_SCO_DATA_PKT: + sc->want = sizeof(ng_hci_scodata_pkt_t); + break; + + case NG_HCI_EVENT_PKT: + sc->want = sizeof(ng_hci_event_pkt_t); + break; + + default: + NG_H4_WARN("%s: %s - ignoring unknown packet " \ + "type=%#x\n", __func__, NG_NODE_NAME(sc->node), + sc->ibuf[0]); + + NG_H4_STAT_IERROR(sc->stat); + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + break; + } + break; + + /* Got packet header */ + case NG_H4_W4_PKT_HDR: + sc->state = NG_H4_W4_PKT_DATA; + + switch (sc->ibuf[0]) { + case NG_HCI_ACL_DATA_PKT: + c = le16toh(((ng_hci_acldata_pkt_t *) + (sc->ibuf))->length); + break; + + case NG_HCI_SCO_DATA_PKT: + c = ((ng_hci_scodata_pkt_t *)(sc->ibuf))->length; + break; + + case NG_HCI_EVENT_PKT: + c = ((ng_hci_event_pkt_t *)(sc->ibuf))->length; + break; + + default: + KASSERT((0), ("Invalid packet type=%#x\n", + sc->ibuf[0])); + break; + } + + NG_H4_INFO("%s: %s - got packet header, packet type=%#x, " \ + "packet size=%d, payload size=%d\n", __func__, + NG_NODE_NAME(sc->node), sc->ibuf[0], sc->got, c); + + if (c > 0) { + sc->want += c; + + /* + * Try to prevent possible buffer overrun + * + * XXX I'm *really* confused here. It turns out + * that Xircom card sends us packets with length + * greater then 512 bytes! This is greater then + * our old receive buffer (ibuf) size. In the same + * time the card demands from us *not* to send + * packets greater then 192 bytes. Weird! How the + * hell i should know how big *receive* buffer + * should be? For now increase receiving buffer + * size to 1K and add the following check. + */ + + if (sc->want >= sizeof(sc->ibuf)) { + int b; + + NG_H4_ALERT("%s: %s - packet too big for " \ + "buffer, type=%#x, got=%d, want=%d, " \ + "length=%d\n", __func__, + NG_NODE_NAME(sc->node), sc->ibuf[0], + sc->got, sc->want, c); + + NG_H4_ALERT("Packet header:\n"); + for (b = 0; b < sc->got; b++) + NG_H4_ALERT("%#x ", sc->ibuf[b]); + NG_H4_ALERT("\n"); + + /* Reset state */ + NG_H4_STAT_IERROR(sc->stat); + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + } + + break; + } + + /* else FALLTHROUGH and deliver frame */ + /* XXX Is this true? Should we deliver empty frame? */ + + /* Got packet data */ + case NG_H4_W4_PKT_DATA: + NG_H4_INFO("%s: %s - got full packet, packet type=%#x, " \ + "packet size=%d\n", __func__, + NG_NODE_NAME(sc->node), sc->ibuf[0], sc->got); + + if (sc->hook != NULL && NG_HOOK_IS_VALID(sc->hook)) { + struct mbuf *m = NULL; + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m != NULL) { + m->m_pkthdr.len = 0; + + /* XXX m_copyback() is stupid */ + m->m_len = min(MHLEN, sc->got); + + m_copyback(m, 0, sc->got, sc->ibuf); + NG_SEND_DATA_ONLY(c, sc->hook, m); + } else { + NG_H4_ERR("%s: %s - could not get mbuf\n", + __func__, NG_NODE_NAME(sc->node)); + + NG_H4_STAT_IERROR(sc->stat); + } + } + + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + + NG_H4_STAT_PCKTS_RECV(sc->stat); + break; + + default: + KASSERT((0), ("Invalid H4 node state=%d", sc->state)); + break; + } + + return (0); +} /* ng_h4_input */ + +/* + * This is called when the device driver is ready for more output. Called from + * tty system. + */ + +static int +ng_h4_start(struct tty *tp) +{ + ng_h4_info_p sc = (ng_h4_info_p) tp->t_sc; + + if (sc == NULL || tp != sc->tp || + sc->node == NULL || NG_NODE_NOT_VALID(sc->node)) + return (0); + + return (ng_send_fn(sc->node, NULL, ng_h4_start2, NULL, 0)); +} /* ng_h4_start */ + +/* + * Device driver is ready for more output. Part 2. Called (via ng_send_fn) + * ng_h4_start() and from ng_h4_rcvdata() when a new mbuf is available for + * output. + */ + +static void +ng_h4_start2(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + struct mbuf *m = NULL; + int s, size; + + s = spltty(); /* XXX */ + +#if 0 + while (sc->tp->t_outq.c_cc < NG_H4_HIWATER) { /* XXX 2.2 specific ? */ +#else + while (1) { +#endif + /* Remove first mbuf from queue */ + NG_BT_MBUFQ_DEQUEUE(&sc->outq, m); + if (m == NULL) + break; + + /* Send as much of it as possible */ + while (m != NULL) { + size = m->m_len - b_to_q(mtod(m, u_char *), + m->m_len, &sc->tp->t_outq); + + NG_H4_STAT_BYTES_SENT(sc->stat, size); + + m->m_data += size; + m->m_len -= size; + if (m->m_len > 0) + break; /* device can't take no more */ + + m = m_free(m); + } + + /* Put remainder of mbuf chain (if any) back on queue */ + if (m != NULL) { + NG_BT_MBUFQ_PREPEND(&sc->outq, m); + break; + } + + /* Full packet has been sent */ + NG_H4_STAT_PCKTS_SENT(sc->stat); + } + + /* + * Call output process whether or not there is any output. We are + * being called in lieu of ttstart and must do what it would. + */ + + if (sc->tp->t_oproc != NULL) + (*sc->tp->t_oproc)(sc->tp); + + /* + * This timeout is needed for operation on a pseudo-tty, because the + * pty code doesn't call pppstart after it has drained the t_outq. + */ + + if (NG_BT_MBUFQ_LEN(&sc->outq) > 0 && (sc->flags & NG_H4_TIMEOUT) == 0) + ng_h4_timeout(node); + + splx(s); /* XXX */ +} /* ng_h4_start2 */ + +/***************************************************************************** + ***************************************************************************** + ** Netgraph node methods + ***************************************************************************** + *****************************************************************************/ + +/* + * Initialize a new node of this type. We only allow nodes to be created as + * a result of setting the line discipline on a tty, so always return an error + * if not. + */ + +static int +ng_h4_constructor(node_p node) +{ + return (EOPNOTSUPP); +} /* ng_h4_constructor */ + +/* + * Add a new hook. There can only be one. + */ + +static int +ng_h4_newhook(node_p node, hook_p hook, const char *name) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + + if (strcmp(name, NG_H4_HOOK) != 0) + return (EINVAL); + + if (sc->hook != NULL) + return (EISCONN); + + sc->hook = hook; + + return (0); +} /* ng_h4_newhook */ + +/* + * Connect hook. Just say yes. + */ + +static int +ng_h4_connect(hook_p hook) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + if (hook != sc->hook) { + sc->hook = NULL; + return (EINVAL); + } + + NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); + + return (0); +} /* ng_h4_connect */ + +/* + * Disconnect the hook + */ + +static int +ng_h4_disconnect(hook_p hook) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + /* + * We need to check for sc != NULL because we can be called from + * ng_h4_clsoe() via ng_rmnode_self() + */ + + if (sc != NULL) { + if (hook != sc->hook) + return (EINVAL); + + /* XXX do we have to untimeout and drain out queue? */ + if (sc->flags & NG_H4_TIMEOUT) + ng_h4_untimeout(NG_HOOK_NODE(hook)); + + NG_BT_MBUFQ_DRAIN(&sc->outq); + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + + sc->hook = NULL; + } + + return (0); +} /* ng_h4_disconnect */ + +/* + * Remove this node. The does the netgraph portion of the shutdown. + * This should only be called indirectly from ng_h4_close(). + */ + +static int +ng_h4_shutdown(node_p node) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + char name[NG_NODELEN + 1]; + + /* Let old node go */ + NG_NODE_SET_PRIVATE(node, NULL); + NG_NODE_UNREF(node); + + /* Check if device was closed */ + if (sc == NULL) + goto out; + + /* Setup new netgraph node */ + if (ng_make_node_common(&typestruct, &sc->node) != 0) { + printf("%s: Unable to create new node!\n", __func__); + sc->node = NULL; + goto out; + } + + /* Assign node its name */ + snprintf(name, sizeof(name), "%s%d", typestruct.name, ng_h4_node ++); + + if (ng_name_node(sc->node, name) != 0) { + printf("%s: %s - node name exists?\n", __func__, name); + NG_NODE_UNREF(sc->node); + sc->node = NULL; + goto out; + } + + /* The node has to be a WRITER because data can change node status */ + NG_NODE_FORCE_WRITER(sc->node); + NG_NODE_SET_PRIVATE(sc->node, sc); +out: + return (0); +} /* ng_h4_shutdown */ + +/* + * Receive incoming data from Netgraph system. Put it on our + * output queue and start output if necessary. + */ + +static int +ng_h4_rcvdata(hook_p hook, item_p item) +{ + ng_h4_info_p sc = (ng_h4_info_p)NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + int error = 0; + struct mbuf *m = NULL; + + if (sc == NULL) { + error = EHOSTDOWN; + goto out; + } + + if (hook != sc->hook) { + error = EINVAL; + goto out; + } + + NGI_GET_M(item, m); + + if (NG_BT_MBUFQ_FULL(&sc->outq)) { + NG_H4_ERR("%s: %s - dropping mbuf, len=%d\n", __func__, + NG_NODE_NAME(sc->node), m->m_pkthdr.len); + + NG_BT_MBUFQ_DROP(&sc->outq); + NG_H4_STAT_OERROR(sc->stat); + + NG_FREE_M(m); + error = ENOBUFS; + } else { + NG_H4_INFO("%s: %s - queue mbuf, len=%d\n", __func__, + NG_NODE_NAME(sc->node), m->m_pkthdr.len); + + NG_BT_MBUFQ_ENQUEUE(&sc->outq, m); + + /* + * We have lock on the node, so we can call ng_h4_start2() + * directly + */ + + ng_h4_start2(sc->node, NULL, NULL, 0); + } +out: + NG_FREE_ITEM(item); + + return (error); +} /* ng_h4_rcvdata */ + +/* + * Receive control message + */ + +static int +ng_h4_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NULL, *resp = NULL; + int error = 0; + + if (sc == NULL) { + error = EHOSTDOWN; + goto out; + } + + NGI_GET_MSG(item, msg); + + switch (msg->header.typecookie) { + case NGM_GENERIC_COOKIE: + switch (msg->header.cmd) { + case NGM_TEXT_STATUS: + NG_MKRESPONSE(resp, msg, NG_TEXTRESPONSE, M_NOWAIT); + if (resp == NULL) + error = ENOMEM; + else + snprintf(resp->data, NG_TEXTRESPONSE, + "Hook: %s\n" \ + "Flags: %#x\n" \ + "Debug: %d\n" \ + "State: %d\n" \ + "Queue: [have:%d,max:%d]\n" \ + "Input: [got:%d,want:%d]", + (sc->hook != NULL)? NG_H4_HOOK : "", + sc->flags, + sc->debug, + sc->state, + NG_BT_MBUFQ_LEN(&sc->outq), + sc->outq.maxlen, + sc->got, + sc->want); + break; + + default: + error = EINVAL; + break; + } + break; + + case NGM_H4_COOKIE: + switch (msg->header.cmd) { + case NGM_H4_NODE_RESET: + NG_BT_MBUFQ_DRAIN(&sc->outq); + sc->state = NG_H4_W4_PKT_IND; + sc->want = 1; + sc->got = 0; + break; + + case NGM_H4_NODE_GET_STATE: + NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_state_ep), + M_NOWAIT); + if (resp == NULL) + error = ENOMEM; + else + *((ng_h4_node_state_ep *)(resp->data)) = + sc->state; + break; + + case NGM_H4_NODE_GET_DEBUG: + NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_debug_ep), + M_NOWAIT); + if (resp == NULL) + error = ENOMEM; + else + *((ng_h4_node_debug_ep *)(resp->data)) = + sc->debug; + break; + + case NGM_H4_NODE_SET_DEBUG: + if (msg->header.arglen != sizeof(ng_h4_node_debug_ep)) + error = EMSGSIZE; + else + sc->debug = + *((ng_h4_node_debug_ep *)(msg->data)); + break; + + case NGM_H4_NODE_GET_QLEN: + NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_qlen_ep), + M_NOWAIT); + if (resp == NULL) + error = ENOMEM; + else + *((ng_h4_node_qlen_ep *)(resp->data)) = + sc->outq.maxlen; + break; + + case NGM_H4_NODE_SET_QLEN: + if (msg->header.arglen != sizeof(ng_h4_node_qlen_ep)) + error = EMSGSIZE; + else if (*((ng_h4_node_qlen_ep *)(msg->data)) <= 0) + error = EINVAL; + else + sc->outq.maxlen = + *((ng_h4_node_qlen_ep *)(msg->data)); + break; + + case NGM_H4_NODE_GET_STAT: + NG_MKRESPONSE(resp, msg, sizeof(ng_h4_node_stat_ep), + M_NOWAIT); + if (resp == NULL) + error = ENOMEM; + else + bcopy(&sc->stat, resp->data, + sizeof(ng_h4_node_stat_ep)); + break; + + case NGM_H4_NODE_RESET_STAT: + NG_H4_STAT_RESET(sc->stat); + break; + + default: + error = EINVAL; + break; + } + break; + + default: + error = EINVAL; + break; + } +out: + NG_RESPOND_MSG(error, node, item, resp); + NG_FREE_MSG(msg); + + return (error); +} /* ng_h4_rcvmsg */ + +/* + * Set timeout + */ + +static void +ng_h4_timeout(node_p node) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + + NG_NODE_REF(node); + sc->timo = timeout(ng_h4_queue_timeout, node, 1); + sc->flags |= NG_H4_TIMEOUT; +} /* ng_h4_timeout */ + +/* + * Unset timeout + */ + +static void +ng_h4_untimeout(node_p node) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + + sc->flags &= ~NG_H4_TIMEOUT; + untimeout(ng_h4_queue_timeout, node, sc->timo); + NG_NODE_UNREF(node); +} /* ng_h4_untimeout */ + +/* + * OK, timeout has happend, so queue function to process it + */ + +static void +ng_h4_queue_timeout(void *context) +{ + node_p node = (node_p) context; + + if (NG_NODE_IS_VALID(node)) + ng_send_fn(node, NULL, &ng_h4_process_timeout, NULL, 0); + + NG_NODE_UNREF(node); +} /* ng_h4_queue_timeout */ + +/* + * Timeout processing function. + * We still have data to output to the device, so try sending more. + */ + +static void +ng_h4_process_timeout(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_h4_info_p sc = (ng_h4_info_p) NG_NODE_PRIVATE(node); + + sc->flags &= ~NG_H4_TIMEOUT; + + /* + * We can call ng_h4_start2() directly here because we have lock + * on the node. + */ + + ng_h4_start2(node, NULL, NULL, 0); +} /* ng_h4_process_timeout */ + +/* + * Handle loading and unloading for this node type + */ + +static int +ng_h4_mod_event(module_t mod, int event, void *data) +{ + static int ng_h4_ldisc; + int s, error = 0; + + s = spltty(); /* XXX */ + + switch (event) { + case MOD_LOAD: + /* Register line discipline */ + ng_h4_ldisc = ldisc_register(H4DISC, &ng_h4_disc); + if (ng_h4_ldisc < 0) { + printf("%s: can't register H4 line discipline\n", + __func__); + error = EIO; + } + break; + + case MOD_UNLOAD: + /* Unregister line discipline */ + ldisc_deregister(ng_h4_ldisc); + break; + + default: + error = EOPNOTSUPP; + break; + } + + splx(s); /* XXX */ + + return (error); +} /* ng_h4_mod_event */ + diff --git a/sys/netgraph/bluetooth/drivers/h4/ng_h4_prse.h b/sys/netgraph/bluetooth/drivers/h4/ng_h4_prse.h new file mode 100644 index 0000000..a4ba75d --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/h4/ng_h4_prse.h @@ -0,0 +1,122 @@ +/* + * ng_h4_prse.h + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_h4_prse.h,v 1.6 2002/09/04 21:35:01 max Exp $ + * $FreeBSD$ + */ + +/*************************************************************************** + *************************************************************************** + ** ng_parse definitions for the H4 node + *************************************************************************** + ***************************************************************************/ + +#ifndef _NETGRAPH_H4_PRSE_H_ +#define _NETGRAPH_H4_PRSE_H_ 1 + +/* + * H4 node command list + */ + +/* Stat info */ +static const struct ng_parse_struct_field ng_h4_stat_type_fields[] = +{ + { "pckts_recv", &ng_parse_uint32_type, }, + { "bytes_recv", &ng_parse_uint32_type, }, + { "pckts_sent", &ng_parse_uint32_type, }, + { "bytes_sent", &ng_parse_uint32_type, }, + { "oerrors", &ng_parse_uint32_type, }, + { "ierrors", &ng_parse_uint32_type, }, + { NULL, } +}; +static const struct ng_parse_type ng_h4_stat_type = { + &ng_parse_struct_type, + &ng_h4_stat_type_fields +}; + +static const struct ng_cmdlist ng_h4_cmdlist[] = { + { + NGM_H4_COOKIE, + NGM_H4_NODE_RESET, + "reset", + NULL, + NULL + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_GET_STATE, + "get_state", + NULL, + &ng_parse_uint16_type + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_GET_DEBUG, + "get_debug", + NULL, + &ng_parse_uint16_type + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_SET_DEBUG, + "set_debug", + &ng_parse_uint16_type, + NULL + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_GET_QLEN, + "get_qlen", + NULL, + &ng_parse_int32_type + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_SET_QLEN, + "set_qlen", + &ng_parse_int32_type, + NULL + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_GET_STAT, + "get_stat", + NULL, + &ng_h4_stat_type + }, + { + NGM_H4_COOKIE, + NGM_H4_NODE_RESET_STAT, + "reset_stat", + NULL, + NULL + }, + { 0, } +}; + +#endif /* ndef _NETGRAPH_H4_PRSE_H_ */ + diff --git a/sys/netgraph/bluetooth/drivers/h4/ng_h4_var.h b/sys/netgraph/bluetooth/drivers/h4/ng_h4_var.h new file mode 100644 index 0000000..1b0d5b8 --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/h4/ng_h4_var.h @@ -0,0 +1,100 @@ +/* + * ng_h4_var.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_h4_var.h,v 1.14 2002/11/03 02:16:31 max Exp $ + * $FreeBSD$ + * + * Based on: + * --------- + * + * FreeBSD: src/sys/netgraph/ng_tty.h + * Author: Archie Cobbs <archie@freebsd.org> + */ + +#ifndef _NETGRAPH_H4_VAR_H_ +#define _NETGRAPH_H4_VAR_H_ 1 + +/* + * Malloc declaration + */ + +#ifndef NG_SEPARATE_MALLOC +MALLOC_DECLARE(M_NETGRAPH_H4); +#else +#define M_NETGRAPH_H4 M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* + * Debug + */ + +#define NG_H4_ALERT if (sc->debug >= NG_H4_ALERT_LEVEL) printf +#define NG_H4_ERR if (sc->debug >= NG_H4_ERR_LEVEL) printf +#define NG_H4_WARN if (sc->debug >= NG_H4_WARN_LEVEL) printf +#define NG_H4_INFO if (sc->debug >= NG_H4_INFO_LEVEL) printf + +#define NG_H4_HIWATER 256 /* High water mark on output */ + +/* + * Per-node private info + */ + +typedef struct ng_h4_info { + struct tty *tp; /* Terminal device */ + node_p node; /* Netgraph node */ + + u_int32_t flags; /* Flags */ +#define NG_H4_TIMEOUT (1 << 0) /* A timeout is pending */ + + ng_h4_node_debug_ep debug; /* Debug level */ + ng_h4_node_state_ep state; /* State */ + + ng_h4_node_stat_ep stat; +#define NG_H4_STAT_PCKTS_SENT(s) (s).pckts_sent ++ +#define NG_H4_STAT_BYTES_SENT(s, n) (s).bytes_sent += (n) +#define NG_H4_STAT_PCKTS_RECV(s) (s).pckts_recv ++ +#define NG_H4_STAT_BYTES_RECV(s, n) (s).bytes_recv += (n) +#define NG_H4_STAT_OERROR(s) (s).oerrors ++ +#define NG_H4_STAT_IERROR(s) (s).ierrors ++ +#define NG_H4_STAT_RESET(s) bzero(&(s), sizeof((s))) + + ng_bt_mbufq_t outq; /* Queue of outgoing mbuf's */ +#define NG_H4_DEFAULTQLEN 12 /* XXX max number of mbuf's in outq */ + +#define NG_H4_IBUF_SIZE 1024 /* XXX must be big enough to hold full + frame */ + u_int8_t ibuf[NG_H4_IBUF_SIZE]; /* Incoming data */ + u_int32_t got; /* Number of bytes we have received */ + u_int32_t want; /* Number of bytes we want to receive */ + + hook_p hook; /* Upstream hook */ + struct callout_handle timo; /* See man timeout(9) */ +} ng_h4_info_t; +typedef ng_h4_info_t * ng_h4_info_p; + +#endif /* _NETGRAPH_H4_VAR_H_ */ + diff --git a/sys/netgraph/bluetooth/drivers/ubt/TODO b/sys/netgraph/bluetooth/drivers/ubt/TODO new file mode 100644 index 0000000..aba45ed --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/ubt/TODO @@ -0,0 +1,30 @@ +# $FreeBSD$ +$Id: TODO,v 1.1.1.1 2002/06/09 20:21:47 max Exp $ + +1) SMP/Locking + + The code makes use of ng_send_fn() whenever possible. Just + need to verify and make sure i did it right + +2) Review USB ATTACH function + + It is a bit ugly now. Probably need a better way to discover + USB device configuration. + +2) Firmware upgrade + + According to Bluetooth spec device may present third interface + to perform firmware upgrade. 3Com USB Bluetooth dongle has + such interface. Need to implement set of Netgraph messages. + +3) Understand and fix isoc. USB transfers (SCO data) + + Currenty device reports that is got zero bytes and calls + isoc_in_complete callback over and over again. Why? + Also might need to setup at least two isoc. transfers in + both directions and switch them on the fly. Just to ensure + there at least one transfer at any time ready to run. + +4) Currently interrupt transfers are done as bulk-in transfers + + Need to check if that is allowed. diff --git a/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c new file mode 100644 index 0000000..982b939 --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt.c @@ -0,0 +1,2166 @@ +/* + * ng_ubt.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_ubt.c,v 1.1 2002/11/09 19:09:02 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/bus.h> +#include <sys/endian.h> +#include <sys/interrupt.h> +#include <sys/mbuf.h> +#include <sys/malloc.h> +#include <sys/kernel.h> + +#include <sys/socket.h> +#include <net/if.h> +#include <net/if_var.h> + +#include <dev/usb/usb.h> +#include <dev/usb/usbdi.h> +#include <dev/usb/usbdi_util.h> +#include <dev/usb/usbdivar.h> +#include <dev/usb/usbdevs.h> + +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <netgraph/ng_parse.h> +#include <ng_bluetooth.h> +#include <ng_hci.h> +#include "ng_ubt.h" +#include "ng_ubt_var.h" + +/* + * USB methods + */ + +USB_DECLARE_DRIVER(ubt); + +Static usbd_status ubt_request_start (ubt_softc_p, struct mbuf *); +Static void ubt_request_complete (usbd_xfer_handle, + usbd_private_handle, usbd_status); + +Static usbd_status ubt_intr_start (ubt_softc_p); +Static void ubt_intr_complete (usbd_xfer_handle, + usbd_private_handle, usbd_status); + +Static usbd_status ubt_bulk_in_start (ubt_softc_p); +Static void ubt_bulk_in_complete (usbd_xfer_handle, + usbd_private_handle, usbd_status); + +Static usbd_status ubt_bulk_out_start (ubt_softc_p, struct mbuf *); +Static void ubt_bulk_out_complete (usbd_xfer_handle, + usbd_private_handle, usbd_status); + +Static usbd_status ubt_isoc_in_start (ubt_softc_p); +Static void ubt_isoc_in_complete (usbd_xfer_handle, + usbd_private_handle, usbd_status); + +Static usbd_status ubt_isoc_out_start (ubt_softc_p, struct mbuf *); +Static void ubt_isoc_out_complete (usbd_xfer_handle, + usbd_private_handle, usbd_status); + +Static void ubt_swi_intr (void *); + +/* + * Netgraph methods + */ + +Static ng_constructor_t ng_ubt_constructor; +Static ng_shutdown_t ng_ubt_shutdown; +Static ng_newhook_t ng_ubt_newhook; +Static ng_connect_t ng_ubt_connect; +Static ng_disconnect_t ng_ubt_disconnect; +Static ng_rcvmsg_t ng_ubt_rcvmsg; +Static ng_rcvdata_t ng_ubt_rcvdata; +Static void ng_ubt_reset (ubt_softc_p); + +/* Queue length */ +Static const struct ng_parse_struct_field ng_ubt_node_qlen_type_fields[] = +{ + { "queue", &ng_parse_int32_type, }, + { "qlen", &ng_parse_int32_type, }, + { NULL, } +}; +Static const struct ng_parse_type ng_ubt_node_qlen_type = { + &ng_parse_struct_type, + &ng_ubt_node_qlen_type_fields +}; + +/* Stat info */ +Static const struct ng_parse_struct_field ng_ubt_node_stat_type_fields[] = +{ + { "pckts_recv", &ng_parse_uint32_type, }, + { "bytes_recv", &ng_parse_uint32_type, }, + { "pckts_sent", &ng_parse_uint32_type, }, + { "bytes_sent", &ng_parse_uint32_type, }, + { "oerrors", &ng_parse_uint32_type, }, + { "ierrors", &ng_parse_uint32_type, }, + { NULL, } +}; +Static const struct ng_parse_type ng_ubt_node_stat_type = { + &ng_parse_struct_type, + &ng_ubt_node_stat_type_fields +}; + +/* Netgraph node command list */ +Static const struct ng_cmdlist ng_ubt_cmdlist[] = { +{ + NGM_UBT_COOKIE, + NGM_UBT_NODE_SET_DEBUG, + "set_debug", + &ng_parse_uint16_type, + NULL +}, +{ + NGM_UBT_COOKIE, + NGM_UBT_NODE_GET_DEBUG, + "get_debug", + NULL, + &ng_parse_uint16_type +}, +{ + NGM_UBT_COOKIE, + NGM_UBT_NODE_SET_QLEN, + "set_qlen", + &ng_ubt_node_qlen_type, + NULL +}, +{ + NGM_UBT_COOKIE, + NGM_UBT_NODE_GET_QLEN, + "get_qlen", + &ng_ubt_node_qlen_type, + &ng_ubt_node_qlen_type +}, +{ + NGM_UBT_COOKIE, + NGM_UBT_NODE_GET_STAT, + "get_stat", + NULL, + &ng_ubt_node_stat_type +}, +{ + NGM_UBT_COOKIE, + NGM_UBT_NODE_RESET_STAT, + "reset_stat", + NULL, + NULL +}, +{ 0, } +}; + +/* Netgraph node type */ +Static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_UBT_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_ubt_constructor, /* constructor */ + ng_ubt_rcvmsg, /* control message */ + ng_ubt_shutdown, /* destructor */ + ng_ubt_newhook, /* new hook */ + NULL, /* find hook */ + ng_ubt_connect, /* connect hook */ + ng_ubt_rcvdata, /* data */ + ng_ubt_disconnect, /* disconnect hook */ + ng_ubt_cmdlist /* node command list */ +}; +NETGRAPH_INIT(ubt, &typestruct); + +/* + * Module + */ + +DRIVER_MODULE(ubt, uhub, ubt_driver, ubt_devclass, usbd_driver_load, 0); +MODULE_VERSION(ng_ubt, NG_BLUETOOTH_VERSION); + +/**************************************************************************** + **************************************************************************** + ** USB specific + **************************************************************************** + ****************************************************************************/ + +/* + * Probe for a USB Bluetooth device + */ + +USB_MATCH(ubt) +{ + Static struct usb_devno const ubt_devices[] = { + { USB_VENDOR_3COM, USB_PRODUCT_3COM_3CREB96 }, + { USB_VENDOR_MITSUMI, USB_PRODUCT_MITSUMI_BT_DONGLE }, + { USB_VENDOR_TDK, USB_PRODUCT_TDK_BT_DONGLE }, + { USB_VENDOR_MSI, USB_PRODUCT_MSI_BT_DONGLE }, + { USB_VENDOR_BROADCOM, USB_PRODUCT_DBW_120M_BT_DONGLE }, + { USB_VENDOR_EPOX, USB_PRODUCT_BT_DG02_DONGLE }, + { 0, 0 } + }; + + USB_MATCH_START(ubt, uaa); + + if (uaa->iface == NULL || + usb_lookup(ubt_devices, uaa->vendor, uaa->product) == NULL) + return (UMATCH_NONE); + + return (UMATCH_VENDOR_PRODUCT); +} /* USB_MATCH(ubt) */ + +/* + * Attach the device + */ + +USB_ATTACH(ubt) +{ + USB_ATTACH_START(ubt, sc, uaa); + usb_config_descriptor_t *cd = NULL; + usb_interface_descriptor_t *id = NULL; + usb_endpoint_descriptor_t *ed = NULL; + char devinfo[1024]; + usbd_status error; + int i, ai, alt_no, isoc_in, isoc_out, + isoc_isize, isoc_osize; + + /* Get USB device info */ + sc->sc_udev = uaa->device; + usbd_devinfo(sc->sc_udev, 0, devinfo); + USB_ATTACH_SETUP; + printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo); + + /* + * Initialize device softc structure + */ + + /* State */ + sc->sc_debug = NG_UBT_WARN_LEVEL; + sc->sc_flags = 0; + NG_UBT_STAT_RESET(sc->sc_stat); + + /* Interfaces */ + sc->sc_iface0 = sc->sc_iface1 = NULL; + + /* Input queue */ + bzero(&sc->sc_inq, sizeof(sc->sc_inq)); + sc->sc_inq.ifq_maxlen = UBT_DEFAULT_QLEN; + mtx_init(&sc->sc_inq.ifq_mtx, "UBT inq", NULL, MTX_DEF); + + /* Interrupt pipe */ + sc->sc_intr_ep = -1; + sc->sc_intr_pipe = NULL; + sc->sc_intr_xfer = NULL; + sc->sc_intr_buffer = NULL; + + /* Control pipe */ + sc->sc_ctrl_xfer = NULL; + sc->sc_ctrl_buffer = NULL; + bzero(&sc->sc_cmdq, sizeof(sc->sc_cmdq)); + sc->sc_cmdq.ifq_maxlen = UBT_DEFAULT_QLEN; + mtx_init(&sc->sc_cmdq.ifq_mtx, "UBT cmdq", NULL, MTX_DEF); + + /* Bulk-in pipe */ + sc->sc_bulk_in_ep = -1; + sc->sc_bulk_in_pipe = NULL; + sc->sc_bulk_in_xfer = NULL; + sc->sc_bulk_in_buffer = NULL; + + /* Bulk-out pipe */ + sc->sc_bulk_out_ep = -1; + sc->sc_bulk_out_pipe = NULL; + sc->sc_bulk_out_xfer = NULL; + sc->sc_bulk_out_buffer = NULL; + bzero(&sc->sc_aclq, sizeof(sc->sc_aclq)); + sc->sc_aclq.ifq_maxlen = UBT_DEFAULT_QLEN; + mtx_init(&sc->sc_aclq.ifq_mtx, "UBT aclq", NULL, MTX_DEF); + + /* Isoc-in pipe */ + sc->sc_isoc_in_ep = -1; + sc->sc_isoc_in_pipe = NULL; + sc->sc_isoc_in_xfer = NULL; + + /* Isoc-out pipe */ + sc->sc_isoc_out_ep = -1; + sc->sc_isoc_out_pipe = NULL; + sc->sc_isoc_out_xfer = NULL; + sc->sc_isoc_size = -1; + bzero(&sc->sc_scoq, sizeof(sc->sc_scoq)); + sc->sc_scoq.ifq_maxlen = UBT_DEFAULT_QLEN; + mtx_init(&sc->sc_scoq.ifq_mtx, "UBT scoq", NULL, MTX_DEF); + + /* Netgraph part */ + sc->sc_node = NULL; + sc->sc_hook = NULL; + + /* Attach SWI handler to TTY SWI thread */ + sc->sc_ith = NULL; + if (swi_add(&tty_ithd, USBDEVNAME(sc->sc_dev), + ubt_swi_intr, sc, SWI_TTY, 0, &sc->sc_ith) < 0) { + printf("%s: Could not setup SWI ISR\n", USBDEVNAME(sc->sc_dev)); + goto bad; + } + + /* + * XXX set configuration? + * + * Configure Bluetooth USB device. Discover all required USB interfaces + * and endpoints. + * + * USB device must present two interfaces: + * 1) Interface 0 that has 3 endpoints + * 1) Interrupt endpoint to receive HCI events + * 2) Bulk IN endpoint to receive ACL data + * 3) Bulk OUT endpoint to send ACL data + * + * 2) Interface 1 then has 2 endpoints + * 1) Isochronous IN endpoint to receive SCO data + * 2) Isochronous OUT endpoint to send SCO data + * + * Interface 1 (with isochronous endpoints) has several alternate + * configurations with different packet size. + */ + + /* + * Interface 0 + */ + + error = usbd_device2interface_handle(sc->sc_udev, 0, &sc->sc_iface0); + if (error || sc->sc_iface0 == NULL) { + printf("%s: Could not get interface 0 handle. %s (%d), " \ + "handle=%p\n", USBDEVNAME(sc->sc_dev), + usbd_errstr(error), error, sc->sc_iface0); + goto bad; + } + + id = usbd_get_interface_descriptor(sc->sc_iface0); + if (id == NULL) { + printf("%s: Could not get interface 0 descriptor\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + if (id->bInterfaceClass != UICLASS_WIRELESS_CONTROLLER || + id->bInterfaceSubClass != UISUBCLASS_RF_CONTROLLER || + id->bInterfaceProtocol != UIPROTO_BLUETOOTH) { + printf("%s: Interface 0 is not supported, " \ + "bInterfaceClass=%#x, bInterfaceSubClass=%#x, "\ + "bInterfaceProtocol=%#x\n", USBDEVNAME(sc->sc_dev), + id->bInterfaceClass, id->bInterfaceSubClass, + id->bInterfaceProtocol); + goto bad; + } + + for (i = 0; i < id->bNumEndpoints; i ++) { + ed = usbd_interface2endpoint_descriptor(sc->sc_iface0, i); + if (ed == NULL) { + printf("%s: Could not read endpoint descriptor for " \ + "interface 0, i=%d\n", USBDEVNAME(sc->sc_dev), + i); + goto bad; + } + + switch (UE_GET_XFERTYPE(ed->bmAttributes)) { + case UE_BULK: + if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) + sc->sc_bulk_in_ep = ed->bEndpointAddress; + else + sc->sc_bulk_out_ep = ed->bEndpointAddress; + break; + + case UE_INTERRUPT: + sc->sc_intr_ep = ed->bEndpointAddress; + break; + } + } + + /* Check if we got everything we wanted on Interface 0 */ + if (sc->sc_intr_ep == -1) { + printf("%s: Could not detect interrupt endpoint\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + if (sc->sc_bulk_in_ep == -1) { + printf("%s: Could not detect bulk-in endpoint\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + if (sc->sc_bulk_out_ep == -1) { + printf("%s: Could not detect bulk-out endpoint\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + printf("%s: Interface 0 endpoints: interrupt=%#x, bulk-in=%#x, " \ + "bulk-out=%#x\n", USBDEVNAME(sc->sc_dev), + sc->sc_intr_ep, sc->sc_bulk_in_ep, sc->sc_bulk_out_ep); + + /* + * Interface 1 + */ + + cd = usbd_get_config_descriptor(sc->sc_udev); + if (cd == NULL) { + printf("%s: Could not get device configuration descriptor\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + error = usbd_device2interface_handle(sc->sc_udev, 1, &sc->sc_iface1); + if (error || sc->sc_iface1 == NULL) { + printf("%s: Could not get interface 1 handle. %s (%d), " \ + "handle=%p\n", USBDEVNAME(sc->sc_dev), + usbd_errstr(error), error, sc->sc_iface1); + goto bad; + } + + id = usbd_get_interface_descriptor(sc->sc_iface1); + if (id == NULL) { + printf("%s: Could not get interface 1 descriptor\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + if (id->bInterfaceClass != UICLASS_WIRELESS_CONTROLLER || + id->bInterfaceSubClass != UISUBCLASS_RF_CONTROLLER || + id->bInterfaceProtocol != UIPROTO_BLUETOOTH) { + printf("%s: Interface 1 is not supported, " \ + "bInterfaceClass=%#x, bInterfaceSubClass=%#x, "\ + "bInterfaceProtocol=%#x\n", USBDEVNAME(sc->sc_dev), + id->bInterfaceClass, id->bInterfaceSubClass, + id->bInterfaceProtocol); + goto bad; + } + + /* + * Scan all alternate configurations for interface 1 + */ + + alt_no = -1; + + for (ai = 0; ai < usbd_get_no_alts(cd, 1); ai++) { + error = usbd_set_interface(sc->sc_iface1, ai); + if (error) { + printf("%s: [SCAN] Could not set alternate " \ + "configuration %d for interface 1. %s (%d)\n", + USBDEVNAME(sc->sc_dev), ai, usbd_errstr(error), + error); + goto bad; + } + id = usbd_get_interface_descriptor(sc->sc_iface1); + if (id == NULL) { + printf("%s: Could not get interface 1 descriptor for " \ + "alternate configuration %d\n", + USBDEVNAME(sc->sc_dev), ai); + goto bad; + } + + isoc_in = isoc_out = -1; + isoc_isize = isoc_osize = 0; + + for (i = 0; i < id->bNumEndpoints; i ++) { + ed = usbd_interface2endpoint_descriptor(sc->sc_iface1, i); + if (ed == NULL) { + printf("%s: Could not read endpoint " \ + "descriptor for interface 1, " \ + "alternate configuration %d, i=%d\n", + USBDEVNAME(sc->sc_dev), ai, i); + goto bad; + } + + if (UE_GET_XFERTYPE(ed->bmAttributes) != UE_ISOCHRONOUS) + continue; + + if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) { + isoc_in = ed->bEndpointAddress; + isoc_isize = UGETW(ed->wMaxPacketSize); + } else { + isoc_out = ed->bEndpointAddress; + isoc_osize = UGETW(ed->wMaxPacketSize); + } + } + + /* + * Make sure that configuration looks sane and if so + * update current settings + */ + + if (isoc_in != -1 && isoc_out != -1 && + isoc_isize > 0 && isoc_osize > 0 && + isoc_isize == isoc_osize && isoc_isize > sc->sc_isoc_size) { + sc->sc_isoc_in_ep = isoc_in; + sc->sc_isoc_out_ep = isoc_out; + sc->sc_isoc_size = isoc_isize; + alt_no = ai; + } + } + + /* Check if we got everything we wanted on Interface 0 */ + if (sc->sc_isoc_in_ep == -1) { + printf("%s: Could not detect isoc-in endpoint\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + if (sc->sc_isoc_out_ep == -1) { + printf("%s: Could not detect isoc-out endpoint\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + if (sc->sc_isoc_size <= 0) { + printf("%s: Invalid isoc. packet size=%d\n", + USBDEVNAME(sc->sc_dev), sc->sc_isoc_size); + goto bad; + } + + error = usbd_set_interface(sc->sc_iface1, alt_no); + if (error) { + printf("%s: Could not set alternate configuration " \ + "%d for interface 1. %s (%d)\n", USBDEVNAME(sc->sc_dev), + alt_no, usbd_errstr(error), error); + goto bad; + } + + /* Allocate USB transfer handles and buffers */ + sc->sc_ctrl_xfer = usbd_alloc_xfer(sc->sc_udev); + if (sc->sc_ctrl_xfer == NULL) { + printf("%s: Could not allocate control xfer handle\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_ctrl_buffer = usbd_alloc_buffer(sc->sc_ctrl_xfer, + UBT_CTRL_BUFFER_SIZE); + if (sc->sc_ctrl_buffer == NULL) { + printf("%s: Could not allocate control buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + sc->sc_intr_xfer = usbd_alloc_xfer(sc->sc_udev); + if (sc->sc_intr_xfer == NULL) { + printf("%s: Could not allocate interrupt xfer handle\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_intr_buffer = usbd_alloc_buffer(sc->sc_intr_xfer, + UBT_INTR_BUFFER_SIZE); + if (sc->sc_intr_buffer == NULL) { + printf("%s: Could not allocate interrupt buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + sc->sc_bulk_in_xfer = usbd_alloc_xfer(sc->sc_udev); + if (sc->sc_bulk_in_xfer == NULL) { + printf("%s: Could not allocate bulk-in xfer handle\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_bulk_in_buffer = usbd_alloc_buffer(sc->sc_bulk_in_xfer, + UBT_BULK_BUFFER_SIZE); + if (sc->sc_bulk_in_buffer == NULL) { + printf("%s: Could not allocate bulk-in buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + sc->sc_bulk_out_xfer = usbd_alloc_xfer(sc->sc_udev); + if (sc->sc_bulk_out_xfer == NULL) { + printf("%s: Could not allocate bulk-out xfer handle\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_bulk_out_buffer = usbd_alloc_buffer(sc->sc_bulk_out_xfer, + UBT_BULK_BUFFER_SIZE); + if (sc->sc_bulk_out_buffer == NULL) { + printf("%s: Could not allocate bulk-out buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + /* + * Allocate buffers for isoc. transfers + */ + + sc->sc_isoc_nframes = (UBT_ISOC_BUFFER_SIZE / sc->sc_isoc_size) + 1; + + sc->sc_isoc_in_xfer = usbd_alloc_xfer(sc->sc_udev); + if (sc->sc_isoc_in_xfer == NULL) { + printf("%s: Could not allocate isoc-in xfer handle\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_isoc_in_buffer = usbd_alloc_buffer(sc->sc_isoc_in_xfer, + sc->sc_isoc_nframes * sc->sc_isoc_size); + if (sc->sc_isoc_in_buffer == NULL) { + printf("%s: Could not allocate isoc-in buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_isoc_in_frlen = malloc(sizeof(u_int16_t) * sc->sc_isoc_nframes, + M_USBDEV, M_NOWAIT); + if (sc->sc_isoc_in_frlen == NULL) { + printf("%s: Could not allocate isoc-in frame sizes buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + sc->sc_isoc_out_xfer = usbd_alloc_xfer(sc->sc_udev); + if (sc->sc_isoc_out_xfer == NULL) { + printf("%s: Could not allocate isoc-out xfer handle\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_isoc_out_buffer = usbd_alloc_buffer(sc->sc_isoc_out_xfer, + sc->sc_isoc_nframes * sc->sc_isoc_size); + if (sc->sc_isoc_out_buffer == NULL) { + printf("%s: Could not allocate isoc-out buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + sc->sc_isoc_out_frlen = malloc(sizeof(u_int16_t) * sc->sc_isoc_nframes, + M_USBDEV, M_NOWAIT); + if (sc->sc_isoc_out_frlen == NULL) { + printf("%s: Could not allocate isoc-out frame sizes buffer\n", + USBDEVNAME(sc->sc_dev)); + goto bad; + } + + printf("%s: Interface 1 (alt.config %d) endpoints: isoc-in=%#x, " \ + "isoc-out=%#x; wMaxPacketSize=%d; nframes=%d, buffer size=%d\n", + USBDEVNAME(sc->sc_dev), alt_no, sc->sc_isoc_in_ep, + sc->sc_isoc_out_ep, sc->sc_isoc_size, sc->sc_isoc_nframes, + (sc->sc_isoc_nframes * sc->sc_isoc_size)); + + /* Create Netgraph node */ + if (ng_make_node_common(&typestruct, &sc->sc_node) != 0) { + printf("%s: Could not create Netgraph node\n", + USBDEVNAME(sc->sc_dev)); + sc->sc_node = NULL; + goto bad; + } + + /* Name node */ + if (ng_name_node(sc->sc_node, USBDEVNAME(sc->sc_dev)) != 0) { + printf("%s: Could not name Netgraph node\n", + USBDEVNAME(sc->sc_dev)); + NG_NODE_UNREF(sc->sc_node); + sc->sc_node = NULL; + goto bad; + } + + NG_NODE_SET_PRIVATE(sc->sc_node, sc); + + /* + * XXX Is that correct? + * Claim all interfaces on the device + */ + + for (i = 0; i < uaa->nifaces; i++) + uaa->ifaces[i] = NULL; + + USB_ATTACH_SUCCESS_RETURN; +bad: + ubt_detach(self); + + USB_ATTACH_ERROR_RETURN; +} /* USB_ATTACH(ubt) */ + +/* + * Detach the device + */ + +USB_DETACH(ubt) +{ + USB_DETACH_START(ubt, sc); + + ng_ubt_reset(sc); + + /* Destroy Netgraph node */ + if (sc->sc_node != NULL) { + NG_NODE_SET_PRIVATE(sc->sc_node, NULL); + ng_rmnode_self(sc->sc_node); + sc->sc_node = NULL; + } + + /* Destroy USB transfer handles */ + if (sc->sc_ctrl_xfer != NULL) { + usbd_free_xfer(sc->sc_ctrl_xfer); + sc->sc_ctrl_xfer = NULL; + } + + if (sc->sc_intr_xfer != NULL) { + usbd_free_xfer(sc->sc_intr_xfer); + sc->sc_intr_xfer = NULL; + } + + if (sc->sc_bulk_in_xfer != NULL) { + usbd_free_xfer(sc->sc_bulk_in_xfer); + sc->sc_bulk_in_xfer = NULL; + } + if (sc->sc_bulk_out_xfer != NULL) { + usbd_free_xfer(sc->sc_bulk_out_xfer); + sc->sc_bulk_out_xfer = NULL; + } + + if (sc->sc_isoc_in_xfer != NULL) { + usbd_free_xfer(sc->sc_isoc_in_xfer); + sc->sc_isoc_in_xfer = NULL; + } + if (sc->sc_isoc_out_xfer != NULL) { + usbd_free_xfer(sc->sc_isoc_out_xfer); + sc->sc_isoc_out_xfer = NULL; + } + + /* Destroy isoc. frame size buffers */ + if (sc->sc_isoc_in_frlen != NULL) { + free(sc->sc_isoc_in_frlen, M_USBDEV); + sc->sc_isoc_in_frlen = NULL; + } + if (sc->sc_isoc_out_frlen != NULL) { + free(sc->sc_isoc_out_frlen, M_USBDEV); + sc->sc_isoc_out_frlen = NULL; + } + + if (sc->sc_ith != NULL) { + ithread_remove_handler(sc->sc_ith); + sc->sc_ith = NULL; + } + + /* Destroy queues */ + IF_DRAIN(&sc->sc_cmdq); + IF_DRAIN(&sc->sc_aclq); + IF_DRAIN(&sc->sc_scoq); + IF_DRAIN(&sc->sc_inq); + + mtx_destroy(&sc->sc_cmdq.ifq_mtx); + mtx_destroy(&sc->sc_aclq.ifq_mtx); + mtx_destroy(&sc->sc_scoq.ifq_mtx); + mtx_destroy(&sc->sc_inq.ifq_mtx); + + return (0); +} /* USB_DETACH(ubt) */ + +/* + * Start USB control request (HCI command) + */ + +Static usbd_status +ubt_request_start(ubt_softc_p sc, struct mbuf *m) +{ + usb_device_request_t req; + usbd_status status = USBD_NORMAL_COMPLETION; + + IF_LOCK(&sc->sc_cmdq); + + if (m != NULL) { + if (_IF_QFULL(&sc->sc_cmdq)) { + NG_UBT_ERR( +"%s: %s - Dropping HCI command frame, len=%d. Queue full\n", + __func__, USBDEVNAME(sc->sc_dev), + m->m_pkthdr.len); + + _IF_DROP(&sc->sc_cmdq); + NG_UBT_STAT_OERROR(sc->sc_stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->sc_cmdq, m); + } else + sc->sc_flags &= ~UBT_CMD_XMIT; + + if (sc->sc_flags & UBT_CMD_XMIT) { + NG_UBT_INFO( +"%s: %s - Another control request is pending\n", + __func__, USBDEVNAME(sc->sc_dev)); + goto done; + } + + _IF_DEQUEUE(&sc->sc_cmdq, m); + if (m == NULL) { + NG_UBT_INFO( +"%s: %s - HCI command queue is empty\n", __func__, USBDEVNAME(sc->sc_dev)); + goto done; + } + + /* + * Check HCI command frame size and copy it back + * to linear USB transfer buffer. + */ + + if (m->m_pkthdr.len > UBT_CTRL_BUFFER_SIZE) + panic( +"%s: %s - HCI command frame too big, size=%d, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), UBT_CTRL_BUFFER_SIZE, + m->m_pkthdr.len); + + m_copydata(m, 0, m->m_pkthdr.len, sc->sc_ctrl_buffer); + + /* Initialize a USB control request and then schedule it */ + + bzero(&req, sizeof(req)); + req.bmRequestType = UBT_HCI_REQUEST; + USETW(req.wLength, m->m_pkthdr.len); + + NG_UBT_INFO( +"%s: %s - Sending control request, bmRequestType=%#x, wLength=%d\n", + __func__, USBDEVNAME(sc->sc_dev), req.bmRequestType, + UGETW(req.wLength)); + + usbd_setup_default_xfer( + sc->sc_ctrl_xfer, + sc->sc_udev, + (usbd_private_handle) sc, + USBD_DEFAULT_TIMEOUT, /* XXX */ + &req, + sc->sc_ctrl_buffer, + m->m_pkthdr.len, + USBD_NO_COPY, + ubt_request_complete); + + status = usbd_transfer(sc->sc_ctrl_xfer); + if (status && status != USBD_IN_PROGRESS) { + NG_UBT_ERR( +"%s: %s - Could not start control request. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), + usbd_errstr(status), status); + + _IF_DROP(&sc->sc_cmdq); /* XXX */ + NG_UBT_STAT_OERROR(sc->sc_stat); + + /* XXX FIXME: should we try to resubmit another request? */ + } else { + NG_UBT_INFO( +"%s: %s - Control request has been started\n", + __func__, USBDEVNAME(sc->sc_dev)); + + sc->sc_flags |= UBT_CMD_XMIT; + + status = USBD_NORMAL_COMPLETION; + } + + NG_FREE_M(m); +done: + IF_UNLOCK(&sc->sc_cmdq); + + return (status); +} /* ubt_request_start */ + +/* + * USB control request callback + */ + +Static void +ubt_request_complete(usbd_xfer_handle h, usbd_private_handle p, usbd_status s) +{ + ubt_softc_p sc = (ubt_softc_p) p; + + if (s == USBD_CANCELLED) { + NG_UBT_INFO( +"%s: %s - Control request cancelled\n", __func__, USBDEVNAME(sc->sc_dev)); + + return; + } + + if (s != USBD_NORMAL_COMPLETION) { + NG_UBT_ERR( +"%s: %s - Control request failed. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(s), s); + + if (s == USBD_STALLED) + usbd_clear_endpoint_stall_async(h->pipe); + + NG_UBT_STAT_OERROR(sc->sc_stat); + } else { + NG_UBT_INFO( +"%s: %s - Sent %d bytes to control pipe\n", + __func__, USBDEVNAME(sc->sc_dev), h->actlen); + + NG_UBT_STAT_BYTES_SENT(sc->sc_stat, h->actlen); + NG_UBT_STAT_PCKTS_SENT(sc->sc_stat); + } + + ubt_request_start(sc, NULL /* completed request */); +} /* ubt_request_complete */ + +/* + * Start interrupt transfer + */ + +Static usbd_status +ubt_intr_start(ubt_softc_p sc) +{ + usbd_status status; + + /* Initialize a USB transfer and then schedule it */ + usbd_setup_xfer( + sc->sc_intr_xfer, + sc->sc_intr_pipe, + (usbd_private_handle) sc, + sc->sc_intr_buffer, + UBT_INTR_BUFFER_SIZE, + USBD_SHORT_XFER_OK | USBD_NO_COPY, + USBD_NO_TIMEOUT, + ubt_intr_complete); + + status = usbd_transfer(sc->sc_intr_xfer); + if (status && status != USBD_IN_PROGRESS) { + NG_UBT_ERR( +"%s: %s - Failed to start intrerrupt transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + + return (status); + } + + return (USBD_NORMAL_COMPLETION); +} /* ubt_intr_start */ + +/* + * Process interrupt from USB device (We got data from interrupt pipe) + */ + +Static void +ubt_intr_complete(usbd_xfer_handle h, usbd_private_handle p, usbd_status s) +{ + ubt_softc_p sc = (ubt_softc_p) p; + struct mbuf *m = NULL; + ng_hci_event_pkt_t *hdr = NULL; + int off; + + if (s == USBD_CANCELLED) { + NG_UBT_INFO( +"%s: %s - Interrupt xfer cancelled\n", __func__, USBDEVNAME(sc->sc_dev)); + + return; + } + + if (s != USBD_NORMAL_COMPLETION) { + NG_UBT_WARN( +"%s: %s - Interrupt xfer failed. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(s), s); + + if (s == USBD_STALLED) + usbd_clear_endpoint_stall_async(sc->sc_intr_pipe); + + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + NG_UBT_STAT_BYTES_RECV(sc->sc_stat, h->actlen); + + NG_UBT_INFO( +"%s: %s - Got %d bytes from interrupt pipe\n", + __func__, USBDEVNAME(sc->sc_dev), h->actlen); + + if (h->actlen < sizeof(*hdr)) + goto done; + + /* Copy HCI event frame to mbuf */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + NG_UBT_ALERT( +"%s: %s - Could not allocate mbuf\n", __func__, USBDEVNAME(sc->sc_dev)); + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + /* + * Copy data from USB buffer into mbuf and check if we got + * full HCI event frame. Fix HCI event frame if required. + */ + + if (!(sc->sc_flags & UBT_HAVE_FRAME_TYPE)) { + off = 1; + *mtod(m, u_int8_t *) = NG_HCI_EVENT_PKT; + } else + off = 0; + + m->m_pkthdr.len = 0; + m->m_len = min(MHLEN, h->actlen + off); /* XXX m_copyback is stupid */ + m_copyback(m, off, h->actlen, sc->sc_intr_buffer); + + hdr = mtod(m, ng_hci_event_pkt_t *); + if (hdr->length == m->m_pkthdr.len - sizeof(*hdr)) { + NG_UBT_INFO( +"%s: %s - Got complete HCI event frame, pktlen=%d, length=%d\n", + __func__, USBDEVNAME(sc->sc_dev), m->m_pkthdr.len, + hdr->length); + + NG_UBT_STAT_PCKTS_RECV(sc->sc_stat); + + IF_LOCK(&sc->sc_inq); + if (_IF_QFULL(&sc->sc_inq)) { + NG_UBT_ERR( +"%s: %s -Incoming queue is full. Dropping mbuf, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), + m->m_pkthdr.len); + + _IF_DROP(&sc->sc_inq); + NG_UBT_STAT_IERROR(sc->sc_stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->sc_inq, m); + IF_UNLOCK(&sc->sc_inq); + + /* Schedule SWI */ + swi_sched(sc->sc_ith, 0); + } else { + NG_UBT_ERR( +"%s: %s - Invalid HCI event frame size, length=%d, pktlen=%d\n", + __func__, USBDEVNAME(sc->sc_dev), hdr->length, + m->m_pkthdr.len); + + NG_UBT_STAT_IERROR(sc->sc_stat); + NG_FREE_M(m); + } +done: + ubt_intr_start(sc); +} /* ubt_intr_complete */ + +/* + * Start bulk-in USB transfer (ACL data) + */ + +Static usbd_status +ubt_bulk_in_start(ubt_softc_p sc) +{ + usbd_status status; + + /* Initialize a bulk-in USB transfer and then schedule it */ + usbd_setup_xfer( + sc->sc_bulk_in_xfer, + sc->sc_bulk_in_pipe, + (usbd_private_handle) sc, + sc->sc_bulk_in_buffer, + UBT_BULK_BUFFER_SIZE, + USBD_SHORT_XFER_OK | USBD_NO_COPY, + USBD_NO_TIMEOUT, + ubt_bulk_in_complete); + + status = usbd_transfer(sc->sc_bulk_in_xfer); + if (status && status != USBD_IN_PROGRESS) { + NG_UBT_ERR( +"%s: %s - Failed to start bulk-in transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + + return (status); + } + + return (USBD_NORMAL_COMPLETION); +} /* ubt_bulk_in_start */ + +/* + * USB bulk-in transfer callback + */ + +Static void +ubt_bulk_in_complete(usbd_xfer_handle h, usbd_private_handle p, usbd_status s) +{ + ubt_softc_p sc = (ubt_softc_p) p; + struct mbuf *m = NULL; + ng_hci_acldata_pkt_t *hdr = NULL; + int len; + + if (s == USBD_CANCELLED) { + NG_UBT_INFO( +"%s: %s - Bulk-in xfer cancelled, pipe=%p\n", + __func__, USBDEVNAME(sc->sc_dev), sc->sc_bulk_in_pipe); + + return; + } + + if (s != USBD_NORMAL_COMPLETION) { + NG_UBT_WARN( +"%s: %s - Bulk-in xfer failed. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(s), s); + + if (s == USBD_STALLED) + usbd_clear_endpoint_stall_async(sc->sc_bulk_in_pipe); + + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + NG_UBT_STAT_BYTES_RECV(sc->sc_stat, h->actlen); + + NG_UBT_INFO( +"%s: %s - Got %d bytes from bulk-in pipe\n", + __func__, USBDEVNAME(sc->sc_dev), h->actlen); + + if (h->actlen < sizeof(*hdr)) + goto done; + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + NG_UBT_ALERT( +"%s: %s - Could not allocate mbuf\n", __func__, USBDEVNAME(sc->sc_dev)); + + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + /* + * Copy data from linear USB buffer into mbuf and check if we got + * full ACL data frame. Fix ACL data frame header if required. + */ + + if (!(sc->sc_flags & UBT_HAVE_FRAME_TYPE)) { + len = 1; + *mtod(m, u_int8_t *) = NG_HCI_ACL_DATA_PKT; + } else + len = 0; + + m->m_pkthdr.len = 0; + m->m_len = min(MHLEN, h->actlen + len); /* XXX m_copyback is stupid */ + m_copyback(m, len, h->actlen, sc->sc_bulk_in_buffer); + + hdr = mtod(m, ng_hci_acldata_pkt_t *); + len = le16toh(hdr->length); + + if (len == m->m_pkthdr.len - sizeof(*hdr)) { + NG_UBT_INFO( +"%s: %s - Got complete ACL data frame, pktlen=%d, length=%d\n", + __func__, USBDEVNAME(sc->sc_dev), m->m_pkthdr.len, + len); + + NG_UBT_STAT_PCKTS_RECV(sc->sc_stat); + + IF_LOCK(&sc->sc_inq); + if (_IF_QFULL(&sc->sc_inq)) { + NG_UBT_ERR( +"%s: %s -Incoming queue is full. Dropping mbuf, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), + m->m_pkthdr.len); + + _IF_DROP(&sc->sc_inq); + NG_UBT_STAT_IERROR(sc->sc_stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->sc_inq, m); + IF_UNLOCK(&sc->sc_inq); + + /* Schedule SWI */ + swi_sched(sc->sc_ith, 0); + } else { + NG_UBT_ERR( +"%s: %s - Invalid ACL frame size, length=%d, pktlen=%d\n", + __func__, USBDEVNAME(sc->sc_dev), len, + m->m_pkthdr.len); + + NG_UBT_STAT_IERROR(sc->sc_stat); + NG_FREE_M(m); + } +done: + ubt_bulk_in_start(sc); +} /* ubt_bulk_in_complete */ + +/* + * Start bulk-out USB transfer + */ + +Static usbd_status +ubt_bulk_out_start(ubt_softc_p sc, struct mbuf *m) +{ + usbd_status status = USBD_NORMAL_COMPLETION; + + IF_LOCK(&sc->sc_aclq); + + if (m != NULL) { + if (_IF_QFULL(&sc->sc_aclq)) { + NG_UBT_ERR( +"%s: %s - Dropping HCI ACL frame, len=%d. Queue full\n", + __func__, USBDEVNAME(sc->sc_dev), + m->m_pkthdr.len); + + _IF_DROP(&sc->sc_aclq); + NG_UBT_STAT_OERROR(sc->sc_stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->sc_aclq, m); + } else + sc->sc_flags &= ~UBT_ACL_XMIT; + + if (sc->sc_flags & UBT_ACL_XMIT) { + NG_UBT_INFO( +"%s: %s - Another bulk-out transfer is pending\n", + __func__, USBDEVNAME(sc->sc_dev)); + goto done; + } + + _IF_DEQUEUE(&sc->sc_aclq, m); + if (m == NULL) { + NG_UBT_INFO( +"%s: %s - ACL data queue is empty\n", __func__, USBDEVNAME(sc->sc_dev)); + goto done; + } + + /* + * Check ACL data frame size and copy it back to linear USB + * transfer buffer. + */ + + if (m->m_pkthdr.len > UBT_BULK_BUFFER_SIZE) + panic( +"%s: %s - ACL data frame too big, size=%d, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), UBT_BULK_BUFFER_SIZE, + m->m_pkthdr.len); + + m_copydata(m, 0, m->m_pkthdr.len, sc->sc_bulk_out_buffer); + + /* Initialize a bulk-out USB transfer and then schedule it */ + usbd_setup_xfer( + sc->sc_bulk_out_xfer, + sc->sc_bulk_out_pipe, + (usbd_private_handle) sc, + sc->sc_bulk_out_buffer, + m->m_pkthdr.len, + USBD_NO_COPY, + USBD_DEFAULT_TIMEOUT, /* XXX */ + ubt_bulk_out_complete); + + status = usbd_transfer(sc->sc_bulk_out_xfer); + if (status && status != USBD_IN_PROGRESS) { + NG_UBT_ERR( +"%s: %s - Could not start bulk-out transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + + _IF_DROP(&sc->sc_aclq); /* XXX */ + NG_UBT_STAT_OERROR(sc->sc_stat); + + /* XXX FIXME: should we try to start another transfer? */ + } else { + NG_UBT_INFO( +"%s: %s - Bulk-out transfer has been started, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), m->m_pkthdr.len); + + sc->sc_flags |= UBT_ACL_XMIT; + + status = USBD_NORMAL_COMPLETION; + } + + NG_FREE_M(m); +done: + IF_UNLOCK(&sc->sc_aclq); + + return (status); +} /* ubt_bulk_out_start */ + +/* + * USB bulk-out transfer callback + */ + +Static void +ubt_bulk_out_complete(usbd_xfer_handle h, usbd_private_handle p, usbd_status s) +{ + ubt_softc_p sc = (ubt_softc_p) p; + + if (s == USBD_CANCELLED) { + NG_UBT_INFO( +"%s: %s - Bulk-out xfer cancelled, pipe=%p\n", + __func__, USBDEVNAME(sc->sc_dev), + sc->sc_bulk_out_pipe); + + return; + } + + if (s != USBD_NORMAL_COMPLETION) { + NG_UBT_WARN( +"%s: %s - Bulk-out xfer failed. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(s), s); + + if (s == USBD_STALLED) + usbd_clear_endpoint_stall_async(sc->sc_bulk_out_pipe); + + NG_UBT_STAT_OERROR(sc->sc_stat); + } else { + NG_UBT_INFO( +"%s: %s - Sent %d bytes to bulk-out pipe\n", + __func__, USBDEVNAME(sc->sc_dev), h->actlen); + + NG_UBT_STAT_BYTES_SENT(sc->sc_stat, h->actlen); + NG_UBT_STAT_PCKTS_SENT(sc->sc_stat); + } + + ubt_bulk_out_start(sc, NULL /* completed request */); +} /* ubt_bulk_out_complete */ + +/* + * Start Isochronous-in USB transfer + */ + +Static usbd_status +ubt_isoc_in_start(ubt_softc_p sc) +{ + usbd_status status; + int i; + + /* Initialize a isoc-in USB transfer and then schedule it */ + + for (i = 0; i < sc->sc_isoc_nframes; i++) + sc->sc_isoc_in_frlen[i] = sc->sc_isoc_size; + + usbd_setup_isoc_xfer( + sc->sc_isoc_in_xfer, + sc->sc_isoc_in_pipe, + (usbd_private_handle) sc, + sc->sc_isoc_in_frlen, + sc->sc_isoc_nframes, + USBD_NO_COPY, /* XXX flags */ + ubt_isoc_in_complete); + + status = usbd_transfer(sc->sc_isoc_in_xfer); + if (status && status != USBD_IN_PROGRESS) { + NG_UBT_ERR( +"%s: %s - Failed to start isoc-in transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), + usbd_errstr(status), status); + + return (status); + } + + return (USBD_NORMAL_COMPLETION); +} /* ubt_isoc_in_start */ + +/* + * USB isochronous transfer callback + */ + +Static void +ubt_isoc_in_complete(usbd_xfer_handle h, usbd_private_handle p, usbd_status s) +{ + ubt_softc_p sc = (ubt_softc_p) p; + struct mbuf *m = NULL; + ng_hci_scodata_pkt_t *hdr = NULL; + u_int8_t *b = NULL; + int i; + + if (s == USBD_CANCELLED) { + NG_UBT_INFO( +"%s: %s - Isoc-in xfer cancelled, pipe=%p\n", + __func__, USBDEVNAME(sc->sc_dev), sc->sc_isoc_in_pipe); + + return; + } + + if (s != USBD_NORMAL_COMPLETION) { + NG_UBT_WARN( +"%s: %s - Isoc-in xfer failed. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(s), s); + + if (s == USBD_STALLED) + usbd_clear_endpoint_stall_async(sc->sc_isoc_in_pipe); + + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + NG_UBT_STAT_BYTES_RECV(sc->sc_stat, h->actlen); + + NG_UBT_INFO( +"%s: %s - Got %d bytes from isoc-in pipe\n", + __func__, USBDEVNAME(sc->sc_dev), h->actlen); + + if (h->actlen < sizeof(*hdr)) + goto done; + + /* Copy SCO data frame to mbuf */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + NG_UBT_ALERT( +"%s: %s - Could not allocate mbuf\n", + __func__, USBDEVNAME(sc->sc_dev)); + + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + /* Fix SCO data frame header if required */ + + if (sc->sc_flags & UBT_HAVE_FRAME_TYPE) { + m->m_pkthdr.len = m->m_len = 0; + } else { + *mtod(m, u_int8_t *) = NG_HCI_SCO_DATA_PKT; + m->m_pkthdr.len = m->m_len = 1; + } + + /* + * XXX FIXME: how do we know how many frames we have received? + * XXX use frlen for now. + * XXX is that correct? + */ + + b = (u_int8_t *) sc->sc_isoc_in_buffer; + + for (i = 0; i < sc->sc_isoc_nframes; i++) { + b += (i * sc->sc_isoc_size); + + if (sc->sc_isoc_in_frlen[i] > 0) + m_copyback(m, m->m_pkthdr.len, + sc->sc_isoc_in_frlen[i], b); + } + + NG_UBT_M_PULLUP(m, sizeof(*hdr)); + if (m == NULL) { + NG_UBT_STAT_IERROR(sc->sc_stat); + goto done; + } + + hdr = mtod(m, ng_hci_scodata_pkt_t *); + + if (hdr->length == m->m_pkthdr.len - sizeof(*hdr)) { + NG_UBT_INFO( +"%s: %s - Got complete SCO data frame, pktlen=%d, length=%d\n", + __func__, USBDEVNAME(sc->sc_dev), m->m_pkthdr.len, + hdr->length); + + NG_UBT_STAT_PCKTS_RECV(sc->sc_stat); + + IF_LOCK(&sc->sc_inq); + if (_IF_QFULL(&sc->sc_inq)) { + NG_UBT_ERR( +"%s: %s -Incoming queue is full. Dropping mbuf, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), + m->m_pkthdr.len); + + _IF_DROP(&sc->sc_inq); + NG_UBT_STAT_IERROR(sc->sc_stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->sc_inq, m); + IF_UNLOCK(&sc->sc_inq); + + /* Schedule SWI */ + swi_sched(sc->sc_ith, 0); + } else { + NG_UBT_ERR( +"%s: %s - Invalid SCO frame size, length=%d, pktlen=%d\n", + __func__, USBDEVNAME(sc->sc_dev), hdr->length, + m->m_pkthdr.len); + + NG_UBT_STAT_IERROR(sc->sc_stat); + NG_FREE_M(m); + } +done: + ubt_isoc_in_start(sc); +} /* ubt_bulk_in_complete */ + +/* + * Start isochronous-out USB transfer + */ + +Static usbd_status +ubt_isoc_out_start(ubt_softc_p sc, struct mbuf *m) +{ + u_int8_t *b = NULL; + int i, len, nframes; + usbd_status status = USBD_NORMAL_COMPLETION; + + IF_LOCK(&sc->sc_scoq); + + if (m != NULL) { + if (_IF_QFULL(&sc->sc_scoq)) { + NG_UBT_ERR( +"%s: %s - Dropping HCI SCO frame, len=%d. Queue full\n", + __func__, USBDEVNAME(sc->sc_dev), + m->m_pkthdr.len); + + _IF_DROP(&sc->sc_scoq); + NG_UBT_STAT_OERROR(sc->sc_stat); + + NG_FREE_M(m); + } else + _IF_ENQUEUE(&sc->sc_scoq, m); + } else + sc->sc_flags &= ~UBT_SCO_XMIT; + + if (sc->sc_flags & UBT_SCO_XMIT) { + NG_UBT_INFO( +"%s: %s - Another isoc-out transfer is pending\n", + __func__, USBDEVNAME(sc->sc_dev)); + goto done; + } + + _IF_DEQUEUE(&sc->sc_scoq, m); + if (m == NULL) { + NG_UBT_INFO( +"%s: %s - SCO data queue is empty\n", __func__, USBDEVNAME(sc->sc_dev)); + goto done; + } + + /* Copy entire SCO frame into USB transfer buffer and start transfer */ + + b = (u_int8_t *) sc->sc_isoc_out_buffer; + nframes = 0; + + for (i = 0; i < sc->sc_isoc_nframes; i++) { + b += (i * sc->sc_isoc_size); + + len = min(m->m_pkthdr.len, sc->sc_isoc_size); + if (len > 0) { + m_copydata(m, 0, len, b); + m_adj(m, len); + nframes ++; + } + + sc->sc_isoc_out_frlen[i] = len; + } + + if (m->m_pkthdr.len > 0) + panic( +"%s: %s - SCO data frame is too big, nframes=%d, size=%d, len=%d\n", + __func__, USBDEVNAME(sc->sc_dev), sc->sc_isoc_nframes, + sc->sc_isoc_size, m->m_pkthdr.len); + + NG_FREE_M(m); + + /* Initialize a isoc-out USB transfer and then schedule it */ + + usbd_setup_isoc_xfer( + sc->sc_isoc_out_xfer, + sc->sc_isoc_out_pipe, + (usbd_private_handle) sc, + sc->sc_isoc_out_frlen, + nframes, + USBD_NO_COPY, + ubt_isoc_out_complete); + + status = usbd_transfer(sc->sc_isoc_out_xfer); + if (status && status != USBD_IN_PROGRESS) { + NG_UBT_ERR( +"%s: %s - Could not start isoc-out transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + + _IF_DROP(&sc->sc_scoq); /* XXX */ + NG_UBT_STAT_OERROR(sc->sc_stat); + } else { + NG_UBT_INFO( +"%s: %s - Isoc-out transfer has been started, nframes=%d, size=%d\n", + __func__, USBDEVNAME(sc->sc_dev), nframes, + sc->sc_isoc_size); + + sc->sc_flags |= UBT_SCO_XMIT; + + status = USBD_NORMAL_COMPLETION; + } +done: + IF_UNLOCK(&sc->sc_scoq); + + return (status); +} /* ubt_isoc_out_start */ + +/* + * USB isoc-out. transfer callback + */ + +Static void +ubt_isoc_out_complete(usbd_xfer_handle h, usbd_private_handle p, usbd_status s) +{ + ubt_softc_p sc = (ubt_softc_p) p; + + if (s == USBD_CANCELLED) { + NG_UBT_INFO( +"%s: %s - Isoc-out xfer cancelled, pipe=%p\n", + __func__, USBDEVNAME(sc->sc_dev), + sc->sc_isoc_out_pipe); + + return; + } + + if (s != USBD_NORMAL_COMPLETION) { + NG_UBT_WARN( +"%s: %s - Isoc-out xfer failed. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(s), s); + + if (s == USBD_STALLED) + usbd_clear_endpoint_stall_async(sc->sc_isoc_out_pipe); + + NG_UBT_STAT_OERROR(sc->sc_stat); + } else { + NG_UBT_INFO( +"%s: %s - Sent %d bytes to isoc-out pipe\n", + __func__, USBDEVNAME(sc->sc_dev), h->actlen); + + NG_UBT_STAT_BYTES_SENT(sc->sc_stat, h->actlen); + NG_UBT_STAT_PCKTS_SENT(sc->sc_stat); + } + + ubt_isoc_out_start(sc, NULL /* completed request */); +} /* ubt_isoc_out_complete */ + +/* + * SWI interrupt handler + */ + +Static void +ubt_swi_intr(void *context) +{ + ubt_softc_p sc = (ubt_softc_p) context; + struct mbuf *m = NULL; + int error; + + if (sc->sc_hook != NULL && NG_HOOK_IS_VALID(sc->sc_hook)) { + for (;;) { + IF_DEQUEUE(&sc->sc_inq, m); + if (m == NULL) + break; + + NG_SEND_DATA_ONLY(error, sc->sc_hook, m); + if (error != 0) + NG_UBT_STAT_IERROR(sc->sc_stat); + } + } else { + IF_LOCK(&sc->sc_inq); + for (;;) { + _IF_DEQUEUE(&sc->sc_inq, m); + if (m == NULL) + break; + + NG_UBT_STAT_IERROR(sc->sc_stat); + NG_FREE_M(m); + } + IF_UNLOCK(&sc->sc_inq); + } +} /* ubt_swi_intr */ + +/**************************************************************************** + **************************************************************************** + ** Netgraph specific + **************************************************************************** + ****************************************************************************/ + +/* + * Netgraph node constructor. Do not allow to create node of this type. + */ + +Static int +ng_ubt_constructor(node_p node) +{ + return (EINVAL); +} /* ng_ubt_constructor */ + +/* + * Netgraph node destructor. Destroy node only when device has been detached + */ + +Static int +ng_ubt_shutdown(node_p node) +{ + ubt_softc_p sc = (ubt_softc_p) NG_NODE_PRIVATE(node); + + /* Let old node go */ + NG_NODE_SET_PRIVATE(node, NULL); + NG_NODE_UNREF(node); + + if (sc == NULL) + goto done; + + /* Create Netgraph node */ + if (ng_make_node_common(&typestruct, &sc->sc_node) != 0) { + printf("%s: Could not create Netgraph node\n", + USBDEVNAME(sc->sc_dev)); + sc->sc_node = NULL; + goto done; + } + + /* Name node */ + if (ng_name_node(sc->sc_node, USBDEVNAME(sc->sc_dev)) != 0) { + printf("%s: Could not name Netgraph node\n", + USBDEVNAME(sc->sc_dev)); + NG_NODE_UNREF(sc->sc_node); + sc->sc_node = NULL; + goto done; + } + + NG_NODE_SET_PRIVATE(sc->sc_node, sc); +done: + return (0); +} /* ng_ubt_shutdown */ + +/* + * Create new hook. There can only be one. + */ + +Static int +ng_ubt_newhook(node_p node, hook_p hook, char const *name) +{ + ubt_softc_p sc = (ubt_softc_p) NG_NODE_PRIVATE(node); + usbd_status status; + + if (strcmp(name, NG_UBT_HOOK) != 0) + return (EINVAL); + + if (sc->sc_hook != NULL) + return (EISCONN); + + sc->sc_hook = hook; + + /* Interrupt */ + status = usbd_open_pipe(sc->sc_iface0, sc->sc_intr_ep, + USBD_EXCLUSIVE_USE, &sc->sc_intr_pipe); + if (status) { + NG_UBT_ALERT( +"%s: %s - Could not open interrupt pipe. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } + + /* Bulk-in */ + status = usbd_open_pipe(sc->sc_iface0, sc->sc_bulk_in_ep, + USBD_EXCLUSIVE_USE, &sc->sc_bulk_in_pipe); + if (status) { + NG_UBT_ALERT( +"%s: %s - Could not open bulk-in pipe. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } + + /* Bulk-out */ + status = usbd_open_pipe(sc->sc_iface0, sc->sc_bulk_out_ep, + USBD_EXCLUSIVE_USE, &sc->sc_bulk_out_pipe); + if (status) { + NG_UBT_ALERT( +"%s: %s - Could not open bulk-out pipe. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } + +#if __broken__ /* XXX FIXME */ + /* Isoc-in */ + status = usbd_open_pipe(sc->sc_iface1, sc->sc_isoc_in_ep, + USBD_EXCLUSIVE_USE, &sc->sc_isoc_in_pipe); + if (status) { + NG_UBT_ALERT( +"%s: %s - Could not open isoc-in pipe. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } + + /* Isoc-out */ + status = usbd_open_pipe(sc->sc_iface1, sc->sc_isoc_out_ep, + USBD_EXCLUSIVE_USE, &sc->sc_isoc_out_pipe); + if (status) { + NG_UBT_ALERT( +"%s: %s - Could not open isoc-out pipe. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } +#endif /* __broken__ */ + + return (0); +fail: + ng_ubt_reset(sc); + sc->sc_hook = NULL; + + return (ENXIO); +} /* ng_ubt_newhook */ + +/* + * Connect hook. Start incoming USB transfers + */ + +Static int +ng_ubt_connect(hook_p hook) +{ + ubt_softc_p sc = (ubt_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + usbd_status status; + + /* Start intr transfer */ + status = ubt_intr_start(sc); + if (status != USBD_NORMAL_COMPLETION) { + NG_UBT_ALERT( +"%s: %s - Could not start interrupt transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } + + /* Start bulk-in transfer */ + status = ubt_bulk_in_start(sc); + if (status != USBD_NORMAL_COMPLETION) { + NG_UBT_ALERT( +"%s: %s - Could not start bulk-in transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } + +#if __broken__ /* XXX FIXME */ + /* Start isoc-in transfer */ + status = ubt_isoc_in_start(sc); + if (status != USBD_NORMAL_COMPLETION) { + NG_UBT_ALERT( +"%s: %s - Could not start isoc-in transfer. %s (%d)\n", + __func__, USBDEVNAME(sc->sc_dev), usbd_errstr(status), + status); + goto fail; + } +#endif /* __broken__ */ + + NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); + + return (0); +fail: + ng_ubt_reset(sc); + sc->sc_hook = NULL; + + return (ENXIO); +} /* ng_ubt_connect */ + +/* + * Disconnect hook + */ + +Static int +ng_ubt_disconnect(hook_p hook) +{ + ubt_softc_p sc = (ubt_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + if (sc != NULL) { + if (hook != sc->sc_hook) + return (EINVAL); + + ng_ubt_reset(sc); + sc->sc_hook = NULL; + } + + return (0); +} /* ng_ubt_disconnect */ + +/* + * Process control message + */ + +Static int +ng_ubt_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ubt_softc_p sc = (ubt_softc_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NULL, *rsp = NULL; + int error = 0, queue, qlen; + struct ifqueue *q = NULL; + + if (sc == NULL) { + NG_FREE_ITEM(item); + return (EHOSTDOWN); + } + + NGI_GET_MSG(item, msg); + + switch (msg->header.typecookie) { + case NGM_GENERIC_COOKIE: + switch (msg->header.cmd) { + case NGM_TEXT_STATUS: + NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + snprintf(rsp->data, NG_TEXTRESPONSE, + "Hook: %s\n" \ + "Flags: %#x\n" \ + "Debug: %d\n" \ + "CMD queue: [have:%d,max:%d]\n" \ + "ACL queue: [have:%d,max:%d]\n" \ + "SCO queue: [have:%d,max:%d]\n" \ + "Inp queue: [have:%d,max:%d]", + (sc->sc_hook != NULL)? NG_UBT_HOOK : "", + sc->sc_flags, + sc->sc_debug, + _IF_QLEN(&sc->sc_cmdq), /* XXX */ + sc->sc_cmdq.ifq_maxlen, /* XXX */ + _IF_QLEN(&sc->sc_aclq), /* XXX */ + sc->sc_aclq.ifq_maxlen, /* XXX */ + _IF_QLEN(&sc->sc_scoq), /* XXX */ + sc->sc_scoq.ifq_maxlen, /* XXX */ + _IF_QLEN(&sc->sc_inq), /* XXX */ + sc->sc_inq.ifq_maxlen /* XXX */ ); + break; + + default: + error = EINVAL; + break; + } + break; + + case NGM_UBT_COOKIE: + switch (msg->header.cmd) { + case NGM_UBT_NODE_SET_DEBUG: + if (msg->header.arglen != sizeof(ng_ubt_node_debug_ep)) + error = EMSGSIZE; + else + sc->sc_debug = + *((ng_ubt_node_debug_ep *)(msg->data)); + break; + + case NGM_UBT_NODE_GET_DEBUG: + NG_MKRESPONSE(rsp, msg, sizeof(ng_ubt_node_debug_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + *((ng_ubt_node_debug_ep *)(rsp->data)) = + sc->sc_debug; + break; + + case NGM_UBT_NODE_SET_QLEN: + if (msg->header.arglen != sizeof(ng_ubt_node_qlen_ep)) + error = EMSGSIZE; + else { + queue = ((ng_ubt_node_qlen_ep *) + (msg->data))->queue; + qlen = ((ng_ubt_node_qlen_ep *) + (msg->data))->qlen; + + if (qlen <= 0) { + error = EINVAL; + break; + } + + switch (queue) { + case NGM_UBT_NODE_QUEUE_IN: + q = &sc->sc_inq; + break; + + case NGM_UBT_NODE_QUEUE_CMD: + q = &sc->sc_cmdq; + break; + + case NGM_UBT_NODE_QUEUE_ACL: + q = &sc->sc_aclq; + break; + + case NGM_UBT_NODE_QUEUE_SCO: + q = &sc->sc_scoq; + break; + + default: + q = NULL; + error = EINVAL; + break; + } + + if (q != NULL) + q->ifq_maxlen = qlen; /* XXX */ + } + break; + + case NGM_UBT_NODE_GET_QLEN: + if (msg->header.arglen != sizeof(ng_ubt_node_qlen_ep)) { + error = EMSGSIZE; + break; + } + + queue = ((ng_ubt_node_qlen_ep *)(msg->data))->queue; + switch (queue) { + case NGM_UBT_NODE_QUEUE_IN: + q = &sc->sc_inq; + break; + + case NGM_UBT_NODE_QUEUE_CMD: + q = &sc->sc_cmdq; + break; + + case NGM_UBT_NODE_QUEUE_ACL: + q = &sc->sc_aclq; + break; + + case NGM_UBT_NODE_QUEUE_SCO: + q = &sc->sc_scoq; + break; + + default: + q = NULL; + error = EINVAL; + break; + } + + if (q != NULL) { + NG_MKRESPONSE(rsp, msg, + sizeof(ng_ubt_node_qlen_ep), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + ((ng_ubt_node_qlen_ep *)(rsp->data))->queue = + queue; + ((ng_ubt_node_qlen_ep *)(rsp->data))->qlen = + q->ifq_maxlen; /* XXX */ + } + break; + + case NGM_UBT_NODE_GET_STAT: + NG_MKRESPONSE(rsp, msg, sizeof(ng_ubt_node_stat_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + bcopy(&sc->sc_stat, rsp->data, + sizeof(ng_ubt_node_stat_ep)); + break; + + case NGM_UBT_NODE_RESET_STAT: + NG_UBT_STAT_RESET(sc->sc_stat); + break; + + default: + error = EINVAL; + break; + } + + default: + error = EINVAL; + break; + } + + NG_RESPOND_MSG(error, node, item, rsp); + NG_FREE_MSG(msg); + + return (error); +} /* ng_ubt_rcvmsg */ + +/* + * Process data + */ + +Static int +ng_ubt_rcvdata(hook_p hook, item_p item) +{ + ubt_softc_p sc = (ubt_softc_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + usbd_status (*f)(ubt_softc_p, struct mbuf *) = NULL; + int error = 0; + + if (sc == NULL) { + error = EHOSTDOWN; + goto done; + } + + if (hook != sc->sc_hook) { + error = EINVAL; + goto done; + } + + /* Deatch mbuf and get HCI frame type */ + NGI_GET_M(item, m); + + /* Process HCI frame */ + switch (*mtod(m, u_int8_t *)) { /* XXX call m_pullup ? */ + case NG_HCI_CMD_PKT: + f = ubt_request_start; + break; + + case NG_HCI_ACL_DATA_PKT: + f = ubt_bulk_out_start; + break; + +#if __broken__ /* XXX FIXME */ + case NG_HCI_SCO_DATA_PKT: + f = ubt_isoc_out_start; + break; +#endif /* __broken__ */ + + default: + NG_UBT_ERR( +"%s: %s - Dropping unknown/unsupported HCI frame, type=%d, pktlen=%d\n", + __func__, USBDEVNAME(sc->sc_dev), *mtod(m, u_int8_t *), + m->m_pkthdr.len); + + NG_FREE_M(m); + error = EINVAL; + + goto done; + /* NOT REACHED */ + } + + /* Loose frame type, if required */ + if (!(sc->sc_flags & UBT_NEED_FRAME_TYPE)) + m_adj(m, sizeof(u_int8_t)); + + if ((*f)(sc, m) != USBD_NORMAL_COMPLETION) + error = EIO; +done: + NG_FREE_ITEM(item); + + return (error); +} /* ng_ubt_rcvdata */ + +/* + * Abort transfers and close all USB pipes. + */ + +Static void +ng_ubt_reset(ubt_softc_p sc) +{ + /* Abort transfers and close all USB pipes */ + + /* Interrupt */ + if (sc->sc_intr_pipe != NULL) { + usbd_abort_pipe(sc->sc_intr_pipe); + usbd_close_pipe(sc->sc_intr_pipe); + sc->sc_intr_pipe = NULL; + } + + /* Bulk-in/out */ + if (sc->sc_bulk_in_pipe != NULL) { + usbd_abort_pipe(sc->sc_bulk_in_pipe); + usbd_close_pipe(sc->sc_bulk_in_pipe); + sc->sc_bulk_in_pipe = NULL; + } + if (sc->sc_bulk_out_pipe != NULL) { + usbd_abort_pipe(sc->sc_bulk_out_pipe); + usbd_close_pipe(sc->sc_bulk_out_pipe); + sc->sc_bulk_out_pipe = NULL; + } + + /* Isoc-in/out */ + if (sc->sc_isoc_in_pipe != NULL) { + usbd_abort_pipe(sc->sc_isoc_in_pipe); + usbd_close_pipe(sc->sc_isoc_in_pipe); + sc->sc_isoc_in_pipe = NULL; + } + if (sc->sc_isoc_out_pipe != NULL) { + usbd_abort_pipe(sc->sc_isoc_out_pipe); + usbd_close_pipe(sc->sc_isoc_out_pipe); + sc->sc_isoc_out_pipe = NULL; + } + + /* Cleanup queues */ + IF_DRAIN(&sc->sc_cmdq); + IF_DRAIN(&sc->sc_aclq); + IF_DRAIN(&sc->sc_scoq); + IF_DRAIN(&sc->sc_inq); +} /* ng_ubt_reset */ + diff --git a/sys/netgraph/bluetooth/drivers/ubt/ng_ubt_var.h b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt_var.h new file mode 100644 index 0000000..10b8911 --- /dev/null +++ b/sys/netgraph/bluetooth/drivers/ubt/ng_ubt_var.h @@ -0,0 +1,143 @@ +/* + * ng_ubt_var.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_ubt_var.h,v 1.1 2002/11/09 19:09:02 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NG_UBT_VAR_H_ +#define _NG_UBT_VAR_H_ + +/* pullup wrapper */ +#define NG_UBT_M_PULLUP(m, s) \ + do { \ + if ((m)->m_len < (s)) \ + (m) = m_pullup((m), (s)); \ + if ((m) == NULL) \ + NG_UBT_ALERT("%s: %s - m_pullup(%d) failed\n", \ + __func__, USBDEVNAME(sc->sc_dev), (s)); \ + } while (0) + +/* Debug printf's */ +#define NG_UBT_ALERT if (sc->sc_debug >= NG_UBT_ALERT_LEVEL) printf +#define NG_UBT_ERR if (sc->sc_debug >= NG_UBT_ERR_LEVEL) printf +#define NG_UBT_WARN if (sc->sc_debug >= NG_UBT_WARN_LEVEL) printf +#define NG_UBT_INFO if (sc->sc_debug >= NG_UBT_INFO_LEVEL) printf + +/* Bluetooth USB control request type */ +#define UBT_HCI_REQUEST 0x20 +#define UBT_DEFAULT_QLEN 12 + +/* USB device softc structure */ +struct ubt_softc { + /* State */ + ng_ubt_node_debug_ep sc_debug; /* debug level */ + u_int32_t sc_flags; /* device flags */ +#define UBT_NEED_FRAME_TYPE (1 << 0) /* device required frame type */ +#define UBT_HAVE_FRAME_TYPE UBT_NEED_FRAME_TYPE +#define UBT_CMD_XMIT (1 << 1) /* CMD xmit in progress */ +#define UBT_ACL_XMIT (1 << 2) /* ACL xmit in progress */ +#define UBT_SCO_XMIT (1 << 3) /* SCO xmit in progress */ + + ng_ubt_node_stat_ep sc_stat; /* statistic */ +#define NG_UBT_STAT_PCKTS_SENT(s) (s).pckts_sent ++ +#define NG_UBT_STAT_BYTES_SENT(s, n) (s).bytes_sent += (n) +#define NG_UBT_STAT_PCKTS_RECV(s) (s).pckts_recv ++ +#define NG_UBT_STAT_BYTES_RECV(s, n) (s).bytes_recv += (n) +#define NG_UBT_STAT_OERROR(s) (s).oerrors ++ +#define NG_UBT_STAT_IERROR(s) (s).ierrors ++ +#define NG_UBT_STAT_RESET(s) bzero(&(s), sizeof((s))) + + /* USB device specific */ + USBBASEDEVICE sc_dev; /* pointer back to USB device */ + usbd_device_handle sc_udev; /* USB device handle */ + + usbd_interface_handle sc_iface0; /* USB interface 0 */ + usbd_interface_handle sc_iface1; /* USB interface 1 */ + + struct ifqueue sc_inq; /* incoming queue */ + void *sc_ith; /* SWI interrupt handler */ + + /* Interrupt pipe (HCI events) */ + int sc_intr_ep; /* interrupt endpoint */ + usbd_pipe_handle sc_intr_pipe; /* interrupt pipe handle */ + usbd_xfer_handle sc_intr_xfer; /* intr xfer */ + u_int8_t *sc_intr_buffer; /* interrupt buffer */ +#define UBT_INTR_BUFFER_SIZE \ + (sizeof(ng_hci_event_pkt_t) + NG_HCI_EVENT_PKT_SIZE) + + /* Control pipe (HCI commands) */ + usbd_xfer_handle sc_ctrl_xfer; /* control xfer handle */ + void *sc_ctrl_buffer; /* control buffer */ + struct ifqueue sc_cmdq; /* HCI command queue */ +#define UBT_CTRL_BUFFER_SIZE \ + (sizeof(ng_hci_cmd_pkt_t) + NG_HCI_CMD_PKT_SIZE) + + /* Bulk in pipe (ACL data) */ + int sc_bulk_in_ep; /* bulk-in enpoint */ + usbd_pipe_handle sc_bulk_in_pipe; /* bulk-in pipe */ + usbd_xfer_handle sc_bulk_in_xfer; /* bulk-in xfer */ + void *sc_bulk_in_buffer; /* bulk-in buffer */ + + /* Bulk out pipe (ACL data) */ + int sc_bulk_out_ep; /* bulk-out endpoint */ + usbd_pipe_handle sc_bulk_out_pipe; /* bulk-out pipe */ + usbd_xfer_handle sc_bulk_out_xfer; /* bulk-out xfer */ + void *sc_bulk_out_buffer; /* bulk-out buffer */ + struct ifqueue sc_aclq; /* ACL data queue */ +#define UBT_BULK_BUFFER_SIZE \ + 512 /* XXX should be big enough to hold one frame */ + + /* Isoc. in pipe (SCO data) */ + int sc_isoc_in_ep; /* isoc-in endpoint */ + usbd_pipe_handle sc_isoc_in_pipe; /* isoc-in pipe */ + usbd_xfer_handle sc_isoc_in_xfer; /* isoc-in xfer */ + void *sc_isoc_in_buffer; /* isoc-in buffer */ + u_int16_t *sc_isoc_in_frlen; /* isoc-in. frame length */ + + /* Isoc. out pipe (ACL data) */ + int sc_isoc_out_ep; /* isoc-out endpoint */ + usbd_pipe_handle sc_isoc_out_pipe; /* isoc-out pipe */ + usbd_xfer_handle sc_isoc_out_xfer; /* isoc-out xfer */ + void *sc_isoc_out_buffer; /* isoc-in buffer */ + u_int16_t *sc_isoc_out_frlen; /* isoc-out. frame length */ + struct ifqueue sc_scoq; /* SCO data queue */ + + int sc_isoc_size; /* max. size of isoc. packet */ + u_int32_t sc_isoc_nframes; /* num. isoc. frames */ +#define UBT_ISOC_BUFFER_SIZE \ + (sizeof(ng_hci_scodata_pkt_t) + NG_HCI_SCO_PKT_SIZE) + + /* Netgraph specific */ + node_p sc_node; /* pointer back to node */ + hook_p sc_hook; /* upstream hook */ +}; +typedef struct ubt_softc ubt_softc_t; +typedef struct ubt_softc * ubt_softc_p; + +#endif /* ndef _NG_UBT_VAR_H_ */ + diff --git a/sys/netgraph/bluetooth/hci/TODO b/sys/netgraph/bluetooth/hci/TODO new file mode 100644 index 0000000..f277e7e --- /dev/null +++ b/sys/netgraph/bluetooth/hci/TODO @@ -0,0 +1,42 @@ +# $FreeBSD$ + +$Id: TODO,v 1.10 2002/09/06 21:03:57 max Exp $ + +FIXME/TODO list + +This is a list of open issues for HCI node + +1) Locking/SMP + + External code now uses ng_send_fn to inject data into Netgraph, so + it should be fine as long as Netgraph is SMP safe. Just need to + verify it. + +3) HCI QoS handling + + Some code exists, but i have no idea how it should work. Will + understand and fix later. I only have CSR based hardware and + it does not support QoS. + +4) Add proper handling for some HCI commands + + HCI testing commands is one example. Also might implement Host to + Host Controller flow control (not sure if it is required). + +5) Link security + + Manage link keys and PINs. Options: + + 1) manage keys inside HCI node/unit itself + 2) use user space daemon. + 3) Mix option 1 and option 2. + +6) Implement watchdog routine for HCI connections + + Some code exists, but it is not used + +7) Code cleanup + + Verify return codes from functions + Remove some waringns/errors + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_cmds.c b/sys/netgraph/bluetooth/hci/ng_hci_cmds.c new file mode 100644 index 0000000..5769ee5 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_cmds.c @@ -0,0 +1,887 @@ +/* + * ng_hci_cmds.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_cmds.c,v 1.22 2002/10/30 00:18:18 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_hci_var.h" +#include "ng_hci_cmds.h" +#include "ng_hci_evnt.h" +#include "ng_hci_ulpi.h" +#include "ng_hci_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** HCI commands processing module + ****************************************************************************** + ******************************************************************************/ + +#undef min +#define min(a, b) ((a) < (b))? (a) : (b) + +static int complete_command (ng_hci_unit_p, int, struct mbuf **); + +static int process_link_control_params + (ng_hci_unit_p, u_int16_t, struct mbuf *, struct mbuf *); +static int process_link_policy_params + (ng_hci_unit_p, u_int16_t, struct mbuf *, struct mbuf *); +static int process_hc_baseband_params + (ng_hci_unit_p, u_int16_t, struct mbuf *, struct mbuf *); +static int process_info_params + (ng_hci_unit_p, u_int16_t, struct mbuf *, struct mbuf *); +static int process_status_params + (ng_hci_unit_p, u_int16_t, struct mbuf *, struct mbuf *); +static int process_testing_params + (ng_hci_unit_p, u_int16_t, struct mbuf *, struct mbuf *); + +static int process_link_control_status + (ng_hci_unit_p, ng_hci_command_status_ep *, struct mbuf *); +static int process_link_policy_status + (ng_hci_unit_p, ng_hci_command_status_ep *, struct mbuf *); + +/* + * Send HCI command to the driver. + */ + +int +ng_hci_send_command(ng_hci_unit_p unit) +{ + struct mbuf *m0 = NULL, *m = NULL; + int free, error = 0; + + /* Check if other command is pending */ + if (unit->state & NG_HCI_UNIT_COMMAND_PENDING) + return (0); + + /* Check if unit can accept our command */ + NG_HCI_BUFF_CMD_GET(unit->buffer, free); + if (free == 0) + return (0); + + /* Check if driver hook is still ok */ + if (unit->drv == NULL || NG_HOOK_NOT_VALID(unit->drv)) { + NG_HCI_WARN( +"%s: %s - hook \"%s\" is not connected or valid\n", + __func__, NG_NODE_NAME(unit->node), NG_HCI_HOOK_DRV); + + NG_BT_MBUFQ_DRAIN(&unit->cmdq); + + return (ENOTCONN); + } + + /* + * Get first command from queue, give it to RAW hook then + * make copy of it and send it to the driver + */ + + m0 = NG_BT_MBUFQ_FIRST(&unit->cmdq); + if (m0 == NULL) + return (0); + + ng_hci_mtap(unit, m0); + + m = m_dup(m0, M_DONTWAIT); + if (m != NULL) + NG_SEND_DATA_ONLY(error, unit->drv, m); + else + error = ENOBUFS; + + if (error != 0) + NG_HCI_ERR( +"%s: %s - could not send HCI command, error=%d\n", + __func__, NG_NODE_NAME(unit->node), error); + + /* + * Even if we were not able to send command we still pretend + * that everything is OK and let timeout handle that. + */ + + NG_HCI_BUFF_CMD_USE(unit->buffer, 1); + NG_HCI_STAT_CMD_SENT(unit->stat); + NG_HCI_STAT_BYTES_SENT(unit->stat, m0->m_pkthdr.len); + + /* + * Note: ng_hci_command_timeout() will set + * NG_HCI_UNIT_COMMAND_PENDING flag + */ + + ng_hci_command_timeout(unit); + + return (0); +} /* ng_hci_send_command */ + +/* + * Process HCI Command_Compete event. Complete HCI command, and do post + * processing on the command parameters (cp) and command return parameters + * (e) if required (for example adjust state). + */ + +int +ng_hci_process_command_complete(ng_hci_unit_p unit, struct mbuf *e) +{ + ng_hci_command_compl_ep *ep = NULL; + struct mbuf *cp = NULL; + int error = 0; + + /* Get event packet and update command buffer info */ + NG_HCI_M_PULLUP(e, sizeof(*ep)); + if (e == NULL) + return (ENOBUFS); /* XXX this is bad */ + + ep = mtod(e, ng_hci_command_compl_ep *); + NG_HCI_BUFF_CMD_SET(unit->buffer, ep->num_cmd_pkts); + + /* Check for special NOOP command */ + if (ep->opcode == 0x0000) { + NG_FREE_M(e); + goto out; + } + + /* Try to match first command item in the queue */ + error = complete_command(unit, ep->opcode, &cp); + if (error != 0) { + NG_FREE_M(e); + goto out; + } + + /* + * Perform post processing on command parameters and return parameters + * do it only if status is OK (status == 0). Status is the first byte + * of any command return parameters. + */ + + ep->opcode = le16toh(ep->opcode); + m_adj(e, sizeof(*ep)); + + if (*mtod(e, u_int8_t *) == 0) { /* XXX m_pullup here? */ + switch (NG_HCI_OGF(ep->opcode)) { + case NG_HCI_OGF_LINK_CONTROL: + error = process_link_control_params(unit, + NG_HCI_OCF(ep->opcode), cp, e); + break; + + case NG_HCI_OGF_LINK_POLICY: + error = process_link_policy_params(unit, + NG_HCI_OCF(ep->opcode), cp, e); + break; + + case NG_HCI_OGF_HC_BASEBAND: + error = process_hc_baseband_params(unit, + NG_HCI_OCF(ep->opcode), cp, e); + break; + + case NG_HCI_OGF_INFO: + error = process_info_params(unit, + NG_HCI_OCF(ep->opcode), cp, e); + break; + + case NG_HCI_OGF_STATUS: + error = process_status_params(unit, + NG_HCI_OCF(ep->opcode), cp, e); + break; + + case NG_HCI_OGF_TESTING: + error = process_testing_params(unit, + NG_HCI_OCF(ep->opcode), cp, e); + break; + + case NG_HCI_OGF_BT_LOGO: + case NG_HCI_OGF_VENDOR: + NG_FREE_M(cp); + NG_FREE_M(e); + break; + + default: + NG_FREE_M(cp); + NG_FREE_M(e); + error = EINVAL; + break; + } + } else { + NG_HCI_ERR( +"%s: %s - HCI command failed, OGF=%#x, OCF=%#x, status=%#x\n", + __func__, NG_NODE_NAME(unit->node), + NG_HCI_OGF(ep->opcode), NG_HCI_OCF(ep->opcode), + *mtod(e, u_int8_t *)); + + NG_FREE_M(cp); + NG_FREE_M(e); + } +out: + ng_hci_send_command(unit); + + return (error); +} /* ng_hci_process_command_complete */ + +/* + * Process HCI Command_Status event. Check the status (mst) and do post + * processing (if required). + */ + +int +ng_hci_process_command_status(ng_hci_unit_p unit, struct mbuf *e) +{ + ng_hci_command_status_ep *ep = NULL; + struct mbuf *cp = NULL; + int error = 0; + + /* Update command buffer info */ + NG_HCI_M_PULLUP(e, sizeof(*ep)); + if (e == NULL) + return (ENOBUFS); /* XXX this is bad */ + + ep = mtod(e, ng_hci_command_status_ep *); + NG_HCI_BUFF_CMD_SET(unit->buffer, ep->num_cmd_pkts); + + /* Check for special NOOP command */ + if (ep->opcode == 0x0000) + goto out; + + /* Try to match first command item in the queue */ + error = complete_command(unit, ep->opcode, &cp); + if (error != 0) + goto out; + + /* + * Perform post processing on HCI Command_Status event + */ + + ep->opcode = le16toh(ep->opcode); + + switch (NG_HCI_OGF(ep->opcode)) { + case NG_HCI_OGF_LINK_CONTROL: + error = process_link_control_status(unit, ep, cp); + break; + + case NG_HCI_OGF_LINK_POLICY: + error = process_link_policy_status(unit, ep, cp); + break; + + case NG_HCI_OGF_BT_LOGO: + case NG_HCI_OGF_VENDOR: + NG_FREE_M(cp); + break; + + case NG_HCI_OGF_HC_BASEBAND: + case NG_HCI_OGF_INFO: + case NG_HCI_OGF_STATUS: + case NG_HCI_OGF_TESTING: + default: + NG_FREE_M(cp); + error = EINVAL; + break; + } +out: + NG_FREE_M(e); + ng_hci_send_command(unit); + + return (error); +} /* ng_hci_process_command_status */ + +/* + * Complete queued HCI command. + */ + +static int +complete_command(ng_hci_unit_p unit, int opcode, struct mbuf **cp) +{ + struct mbuf *m = NULL; + + /* Check unit state */ + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) { + NG_HCI_ALERT( +"%s: %s - no pending command, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), unit->state); + + return (EINVAL); + } + + /* Get first command in the queue */ + m = NG_BT_MBUFQ_FIRST(&unit->cmdq); + if (m == NULL) { + NG_HCI_ALERT( +"%s: %s - empty command queue?!\n", __func__, NG_NODE_NAME(unit->node)); + + return (EINVAL); + } + + /* + * Match command opcode, if does not match - do nothing and + * let timeout handle that. + */ + + if (mtod(m, ng_hci_cmd_pkt_t *)->opcode != opcode) { + NG_HCI_ALERT( +"%s: %s - command queue is out of sync\n", __func__, NG_NODE_NAME(unit->node)); + + return (EINVAL); + } + + /* + * Now we can remove command timeout, dequeue completed command + * and return command parameters. Note: ng_hci_command_untimeout() + * will drop NG_HCI_UNIT_COMMAND_PENDING flag. + */ + + ng_hci_command_untimeout(unit); + NG_BT_MBUFQ_DEQUEUE(&unit->cmdq, *cp); + m_adj(*cp, sizeof(ng_hci_cmd_pkt_t)); + + return (0); +} /* complete_command */ + +/* + * Process HCI command timeout + */ + +void +ng_hci_process_command_timeout(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) arg1; + struct mbuf *m = NULL; + u_int16_t opcode; + + if (unit->state & NG_HCI_UNIT_COMMAND_PENDING) { + NG_BT_MBUFQ_DEQUEUE(&unit->cmdq, m); + + if (m == NULL) { + KASSERT(0, +("%s: %s - command queue is out of sync!\n", + __func__, NG_NODE_NAME(unit->node))); + + return; + } + + opcode = le16toh(mtod(m, ng_hci_cmd_pkt_t *)->opcode); + NG_FREE_M(m); + + NG_HCI_ERR( +"%s: %s - unable to complete HCI command OGF=%#x, OCF=%#x. Timeout\n", + __func__, NG_NODE_NAME(unit->node), NG_HCI_OGF(opcode), + NG_HCI_OCF(opcode)); + + /* + * Try to send more commands + */ + + NG_HCI_BUFF_CMD_SET(unit->buffer, 1); + + unit->state &= ~NG_HCI_UNIT_COMMAND_PENDING; + ng_hci_send_command(unit); + } else + KASSERT(0, +("%s: %s - no pending command, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), unit->state)); +} /* ng_hci_process_command_timeout */ + +/* + * Process link command return parameters + */ + +static int +process_link_control_params(ng_hci_unit_p unit, u_int16_t ocf, + struct mbuf *mcp, struct mbuf *mrp) +{ + int error = 0; + + switch (ocf) { + case NG_HCI_OCF_INQUIRY_CANCEL: + case NG_HCI_OCF_PERIODIC_INQUIRY: + case NG_HCI_OCF_EXIT_PERIODIC_INQUIRY: + case NG_HCI_OCF_LINK_KEY_REP: + case NG_HCI_OCF_LINK_KEY_NEG_REP: + case NG_HCI_OCF_PIN_CODE_REP: + case NG_HCI_OCF_PIN_CODE_NEG_REP: + /* These do not need post processing */ + break; + + case NG_HCI_OCF_INQUIRY: + case NG_HCI_OCF_CREATE_CON: + case NG_HCI_OCF_DISCON: + case NG_HCI_OCF_ADD_SCO_CON: + case NG_HCI_OCF_ACCEPT_CON: + case NG_HCI_OCF_REJECT_CON: + case NG_HCI_OCF_CHANGE_CON_PKT_TYPE: + case NG_HCI_OCF_AUTH_REQ: + case NG_HCI_OCF_SET_CON_ENCRYPTION: + case NG_HCI_OCF_CHANGE_CON_LINK_KEY: + case NG_HCI_OCF_MASTER_LINK_KEY: + case NG_HCI_OCF_REMOTE_NAME_REQ: + case NG_HCI_OCF_READ_REMOTE_FEATURES: + case NG_HCI_OCF_READ_REMOTE_VER_INFO: + case NG_HCI_OCF_READ_CLOCK_OFFSET: + default: + + /* + * None of these command was supposed to generate + * Command_Complete event. Instead Command_Status event + * should have been generated and then appropriate event + * should have been sent to indicate the final result. + */ + + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + NG_FREE_M(mrp); + + return (error); +} /* process_link_control_params */ + +/* + * Process link policy command return parameters + */ + +static int +process_link_policy_params(ng_hci_unit_p unit, u_int16_t ocf, + struct mbuf *mcp, struct mbuf *mrp) +{ + int error = 0; + + switch (ocf){ + case NG_HCI_OCF_ROLE_DISCOVERY: { + ng_hci_role_discovery_rp *rp = NULL; + ng_hci_unit_con_t *con = NULL; + u_int16_t h; + + NG_HCI_M_PULLUP(mrp, sizeof(*rp)); + if (mrp != NULL) { + rp = mtod(mrp, ng_hci_role_discovery_rp *); + + h = NG_HCI_CON_HANDLE(le16toh(rp->con_handle)); + con = ng_hci_con_by_handle(unit, h); + if (con == NULL) { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + } else if (con->link_type != NG_HCI_LINK_ACL) { + NG_HCI_ALERT( +"%s: %s - invalid link type=%d\n", __func__, NG_NODE_NAME(unit->node), + con->link_type); + error = EINVAL; + } else + con->role = rp->role; + } else + error = ENOBUFS; + } break; + + case NG_HCI_OCF_READ_LINK_POLICY_SETTINGS: + case NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS: + /* These do not need post processing */ + break; + + case NG_HCI_OCF_HOLD_MODE: + case NG_HCI_OCF_SNIFF_MODE: + case NG_HCI_OCF_EXIT_SNIFF_MODE: + case NG_HCI_OCF_PARK_MODE: + case NG_HCI_OCF_EXIT_PARK_MODE: + case NG_HCI_OCF_QOS_SETUP: + case NG_HCI_OCF_SWITCH_ROLE: + default: + + /* + * None of these command was supposed to generate + * Command_Complete event. Instead Command_Status event + * should have been generated and then appropriate event + * should have been sent to indicate the final result. + */ + + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + NG_FREE_M(mrp); + + return (error); +} /* process_link_policy_params */ + +/* + * Process HC and baseband command return parameters + */ + +int +process_hc_baseband_params(ng_hci_unit_p unit, u_int16_t ocf, + struct mbuf *mcp, struct mbuf *mrp) +{ + int error = 0; + + switch (ocf) { + case NG_HCI_OCF_SET_EVENT_MASK: + case NG_HCI_OCF_SET_EVENT_FILTER: + case NG_HCI_OCF_FLUSH: /* XXX Do we need to handle that? */ + case NG_HCI_OCF_READ_PIN_TYPE: + case NG_HCI_OCF_WRITE_PIN_TYPE: + case NG_HCI_OCF_CREATE_NEW_UNIT_KEY: + case NG_HCI_OCF_WRITE_STORED_LINK_KEY: + case NG_HCI_OCF_WRITE_CON_ACCEPT_TIMO: + case NG_HCI_OCF_WRITE_PAGE_TIMO: + case NG_HCI_OCF_READ_SCAN_ENABLE: + case NG_HCI_OCF_WRITE_SCAN_ENABLE: + case NG_HCI_OCF_WRITE_PAGE_SCAN_ACTIVITY: + case NG_HCI_OCF_WRITE_INQUIRY_SCAN_ACTIVITY: + case NG_HCI_OCF_READ_AUTH_ENABLE: + case NG_HCI_OCF_WRITE_AUTH_ENABLE: + case NG_HCI_OCF_READ_ENCRYPTION_MODE: + case NG_HCI_OCF_WRITE_ENCRYPTION_MODE: + case NG_HCI_OCF_WRITE_VOICE_SETTINGS: + case NG_HCI_OCF_READ_NUM_BROADCAST_RETRANS: + case NG_HCI_OCF_WRITE_NUM_BROADCAST_RETRANS: + case NG_HCI_OCF_READ_HOLD_MODE_ACTIVITY: + case NG_HCI_OCF_WRITE_HOLD_MODE_ACTIVITY: + case NG_HCI_OCF_READ_SCO_FLOW_CONTROL: + case NG_HCI_OCF_WRITE_SCO_FLOW_CONTROL: + case NG_HCI_OCF_H2HC_FLOW_CONTROL: /* XXX Not supported this time */ + case NG_HCI_OCF_HOST_BUFFER_SIZE: + case NG_HCI_OCF_READ_IAC_LAP: + case NG_HCI_OCF_WRITE_IAC_LAP: + case NG_HCI_OCF_READ_PAGE_SCAN_PERIOD: + case NG_HCI_OCF_WRITE_PAGE_SCAN_PERIOD: + case NG_HCI_OCF_READ_PAGE_SCAN: + case NG_HCI_OCF_WRITE_PAGE_SCAN: + case NG_HCI_OCF_READ_LINK_SUPERVISION_TIMO: + case NG_HCI_OCF_WRITE_LINK_SUPERVISION_TIMO: + case NG_HCI_OCF_READ_SUPPORTED_IAC_NUM: + case NG_HCI_OCF_READ_STORED_LINK_KEY: + case NG_HCI_OCF_DELETE_STORED_LINK_KEY: + case NG_HCI_OCF_READ_CON_ACCEPT_TIMO: + case NG_HCI_OCF_READ_PAGE_TIMO: + case NG_HCI_OCF_READ_PAGE_SCAN_ACTIVITY: + case NG_HCI_OCF_READ_INQUIRY_SCAN_ACTIVITY: + case NG_HCI_OCF_READ_VOICE_SETTINGS: + case NG_HCI_OCF_READ_AUTO_FLUSH_TIMO: + case NG_HCI_OCF_WRITE_AUTO_FLUSH_TIMO: + case NG_HCI_OCF_READ_XMIT_LEVEL: + case NG_HCI_OCF_HOST_NUM_COMPL_PKTS: /* XXX Can get here? */ + case NG_HCI_OCF_CHANGE_LOCAL_NAME: + case NG_HCI_OCF_READ_LOCAL_NAME: + case NG_HCI_OCF_READ_UNIT_CLASS: + case NG_HCI_OCF_WRITE_UNIT_CLASS: + /* These do not need post processing */ + break; + + case NG_HCI_OCF_RESET: { + ng_hci_unit_con_p con = NULL; + int size; + + /* + * XXX + * + * After RESET command unit goes into standby mode + * and all operational state is lost. Host controller + * will revert to default values for all parameters. + * + * For now we shall terminate all connections and drop + * inited bit. After RESET unit must be re-initialized. + */ + + while (!LIST_EMPTY(&unit->con_list)) { + con = LIST_FIRST(&unit->con_list); + + /* Connection terminated by local host */ + ng_hci_lp_discon_ind(con, 0x16); + ng_hci_free_con(con); + } + + NG_HCI_BUFF_ACL_TOTAL(unit->buffer, size); + NG_HCI_BUFF_ACL_FREE(unit->buffer, size); + + NG_HCI_BUFF_SCO_TOTAL(unit->buffer, size); + NG_HCI_BUFF_SCO_FREE(unit->buffer, size); + + unit->state &= ~NG_HCI_UNIT_INITED; + } break; + + default: + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + NG_FREE_M(mrp); + + return (error); +} /* process_hc_baseband_params */ + +/* + * Process info command return parameters + */ + +static int +process_info_params(ng_hci_unit_p unit, u_int16_t ocf, struct mbuf *mcp, + struct mbuf *mrp) +{ + int error = 0, len; + + switch (ocf) { + case NG_HCI_OCF_READ_LOCAL_VER: + case NG_HCI_OCF_READ_COUNTRY_CODE: + break; + + case NG_HCI_OCF_READ_LOCAL_FEATURES: + m_adj(mrp, sizeof(u_int8_t)); + len = min(mrp->m_pkthdr.len, sizeof(unit->features)); + m_copydata(mrp, 0, len, (caddr_t) unit->features); + break; + + case NG_HCI_OCF_READ_BUFFER_SIZE: { + ng_hci_read_buffer_size_rp *rp = NULL; + + /* Do not update buffer descriptor if node was initialized */ + if ((unit->state & NG_HCI_UNIT_READY) == NG_HCI_UNIT_READY) + break; + + NG_HCI_M_PULLUP(mrp, sizeof(*rp)); + if (mrp != NULL) { + rp = mtod(mrp, ng_hci_read_buffer_size_rp *); + + NG_HCI_BUFF_ACL_SET( + unit->buffer, + le16toh(rp->num_acl_pkt), /* number */ + le16toh(rp->max_acl_size), /* size */ + le16toh(rp->num_acl_pkt) /* free */ + ); + + NG_HCI_BUFF_SCO_SET( + unit->buffer, + le16toh(rp->num_sco_pkt), /* number */ + rp->max_sco_size, /* size */ + le16toh(rp->num_sco_pkt) /* free */ + ); + + /* Let upper layers know */ + ng_hci_node_is_up(unit->node, unit->acl, NULL, 0); + ng_hci_node_is_up(unit->node, unit->sco, NULL, 0); + } else + error = ENOBUFS; + } break; + + case NG_HCI_OCF_READ_BDADDR: + /* Do not update BD_ADDR if node was initialized */ + if ((unit->state & NG_HCI_UNIT_READY) == NG_HCI_UNIT_READY) + break; + + m_adj(mrp, sizeof(u_int8_t)); + len = min(mrp->m_pkthdr.len, sizeof(unit->bdaddr)); + m_copydata(mrp, 0, len, (caddr_t) &unit->bdaddr); + + /* Let upper layers know */ + ng_hci_node_is_up(unit->node, unit->acl, NULL, 0); + ng_hci_node_is_up(unit->node, unit->sco, NULL, 0); + break; + + default: + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + NG_FREE_M(mrp); + + return (error); +} /* process_info_params */ + +/* + * Process status command return parameters + */ + +static int +process_status_params(ng_hci_unit_p unit, u_int16_t ocf, struct mbuf *mcp, + struct mbuf *mrp) +{ + int error = 0; + + switch (ocf) { + case NG_HCI_OCF_READ_FAILED_CONTACT_CNTR: + case NG_HCI_OCF_RESET_FAILED_CONTACT_CNTR: + case NG_HCI_OCF_GET_LINK_QUALITY: + case NG_HCI_OCF_READ_RSSI: + /* These do not need post processing */ + break; + + default: + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + NG_FREE_M(mrp); + + return (error); +} /* process_status_params */ + +/* + * Process testing command return parameters + */ + +int +process_testing_params(ng_hci_unit_p unit, u_int16_t ocf, struct mbuf *mcp, + struct mbuf *mrp) +{ + int error = 0; + + switch (ocf) { + + /* + * XXX FIXME + * We do not support these features at this time. However, + * HCI node could support this and do something smart. At least + * node can change unit state. + */ + + case NG_HCI_OCF_READ_LOOPBACK_MODE: + case NG_HCI_OCF_WRITE_LOOPBACK_MODE: + case NG_HCI_OCF_ENABLE_UNIT_UNDER_TEST: + break; + + default: + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + NG_FREE_M(mrp); + + return (error); +} /* process_testing_params */ + +/* + * Process link control command status + */ + +static int +process_link_control_status(ng_hci_unit_p unit, ng_hci_command_status_ep *ep, + struct mbuf *mcp) +{ + int error = 0; + + switch (NG_HCI_OCF(ep->opcode)) { + case NG_HCI_OCF_INQUIRY: + case NG_HCI_OCF_DISCON: /* XXX */ + case NG_HCI_OCF_REJECT_CON: /* XXX */ + case NG_HCI_OCF_CHANGE_CON_PKT_TYPE: + case NG_HCI_OCF_AUTH_REQ: + case NG_HCI_OCF_SET_CON_ENCRYPTION: + case NG_HCI_OCF_CHANGE_CON_LINK_KEY: + case NG_HCI_OCF_MASTER_LINK_KEY: + case NG_HCI_OCF_REMOTE_NAME_REQ: + case NG_HCI_OCF_READ_REMOTE_FEATURES: + case NG_HCI_OCF_READ_REMOTE_VER_INFO: + case NG_HCI_OCF_READ_CLOCK_OFFSET: + /* These do not need post processing */ + break; + + case NG_HCI_OCF_CREATE_CON: + break; + + case NG_HCI_OCF_ADD_SCO_CON: + break; + + case NG_HCI_OCF_ACCEPT_CON: + break; + + case NG_HCI_OCF_INQUIRY_CANCEL: + case NG_HCI_OCF_PERIODIC_INQUIRY: + case NG_HCI_OCF_EXIT_PERIODIC_INQUIRY: + case NG_HCI_OCF_LINK_KEY_REP: + case NG_HCI_OCF_LINK_KEY_NEG_REP: + case NG_HCI_OCF_PIN_CODE_REP: + case NG_HCI_OCF_PIN_CODE_NEG_REP: + default: + + /* + * None of these command was supposed to generate + * Command_Status event. Instead Command_Complete event + * should have been sent. + */ + + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + + return (error); +} /* process_link_control_status */ + +/* + * Process link policy command status + */ + +static int +process_link_policy_status(ng_hci_unit_p unit, ng_hci_command_status_ep *ep, + struct mbuf *mcp) +{ + int error = 0; + + switch (NG_HCI_OCF(ep->opcode)) { + case NG_HCI_OCF_HOLD_MODE: + case NG_HCI_OCF_SNIFF_MODE: + case NG_HCI_OCF_EXIT_SNIFF_MODE: + case NG_HCI_OCF_PARK_MODE: + case NG_HCI_OCF_EXIT_PARK_MODE: + case NG_HCI_OCF_SWITCH_ROLE: + /* These do not need post processing */ + break; + + case NG_HCI_OCF_QOS_SETUP: + break; + + case NG_HCI_OCF_ROLE_DISCOVERY: + case NG_HCI_OCF_READ_LINK_POLICY_SETTINGS: + case NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS: + default: + + /* + * None of these command was supposed to generate + * Command_Status event. Instead Command_Complete event + * should have been sent. + */ + + error = EINVAL; + break; + } + + NG_FREE_M(mcp); + + return (error); +} /* process_link_policy_status */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_cmds.h b/sys/netgraph/bluetooth/hci/ng_hci_cmds.h new file mode 100644 index 0000000..1123802 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_cmds.h @@ -0,0 +1,45 @@ +/* + * ng_hci_cmds.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_cmds.h,v 1.6 2002/09/04 21:36:51 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_HCI_CMDS_H_ +#define _NETGRAPH_HCI_CMDS_H_ 1 + +/* + * HCI command return parameters processing routines + */ + +int ng_hci_send_command (ng_hci_unit_p); +int ng_hci_process_command_complete (ng_hci_unit_p, struct mbuf *); +int ng_hci_process_command_status (ng_hci_unit_p, struct mbuf *); +void ng_hci_process_command_timeout (node_p, hook_p, void *, int); + +#endif /* ndef _NETGRAPH_HCI_CMDS_H_ */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_evnt.c b/sys/netgraph/bluetooth/hci/ng_hci_evnt.c new file mode 100644 index 0000000..9d81380 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_evnt.c @@ -0,0 +1,1085 @@ +/* + * ng_hci_evnt.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_evnt.c,v 1.18 2002/11/12 22:35:39 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_hci_var.h" +#include "ng_hci_cmds.h" +#include "ng_hci_evnt.h" +#include "ng_hci_ulpi.h" +#include "ng_hci_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** HCI event processing module + ****************************************************************************** + ******************************************************************************/ + +/* + * Event processing routines + */ + +static int inquiry_result (ng_hci_unit_p, struct mbuf *); +static int con_compl (ng_hci_unit_p, struct mbuf *); +static int con_req (ng_hci_unit_p, struct mbuf *); +static int discon_compl (ng_hci_unit_p, struct mbuf *); +static int read_remote_features_compl (ng_hci_unit_p, struct mbuf *); +static int qos_setup_compl (ng_hci_unit_p, struct mbuf *); +static int hardware_error (ng_hci_unit_p, struct mbuf *); +static int role_change (ng_hci_unit_p, struct mbuf *); +static int num_compl_pkts (ng_hci_unit_p, struct mbuf *); +static int mode_change (ng_hci_unit_p, struct mbuf *); +static int data_buffer_overflow (ng_hci_unit_p, struct mbuf *); +static int read_clock_offset_compl (ng_hci_unit_p, struct mbuf *); +static int qos_violation (ng_hci_unit_p, struct mbuf *); +static int page_scan_mode_change (ng_hci_unit_p, struct mbuf *); +static int page_scan_rep_mode_change (ng_hci_unit_p, struct mbuf *); +static int sync_con_queue (ng_hci_unit_p, ng_hci_unit_con_p, int); +static int send_data_packets (ng_hci_unit_p, int, int); + +/* + * Process HCI event packet + */ + +int +ng_hci_process_event(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_event_pkt_t *hdr = NULL; + int error = 0; + + /* Get event packet header */ + NG_HCI_M_PULLUP(event, sizeof(*hdr)); + if (event == NULL) + return (ENOBUFS); + + hdr = mtod(event, ng_hci_event_pkt_t *); + + NG_HCI_INFO( +"%s: %s - got HCI event=%#x, length=%d\n", + __func__, NG_NODE_NAME(unit->node), hdr->event, hdr->length); + + /* Get rid of event header and process event */ + m_adj(event, sizeof(*hdr)); + + switch (hdr->event) { + case NG_HCI_EVENT_INQUIRY_COMPL: +/* case NG_HCI_EVENT_MODE_CHANGE: */ + case NG_HCI_EVENT_RETURN_LINK_KEYS: + case NG_HCI_EVENT_PIN_CODE_REQ: + case NG_HCI_EVENT_LINK_KEY_REQ: + case NG_HCI_EVENT_LINK_KEY_NOTIFICATION: + case NG_HCI_EVENT_LOOPBACK_COMMAND: + case NG_HCI_EVENT_AUTH_COMPL: + case NG_HCI_EVENT_ENCRYPTION_CHANGE: + case NG_HCI_EVENT_CHANGE_CON_LINK_KEY_COMPL: + case NG_HCI_EVENT_MASTER_LINK_KEY_COMPL: + case NG_HCI_EVENT_FLUSH_OCCUR: /* XXX Do we have to handle it? */ +/* case NG_HCI_EVENT_ROLE_CHANGE: */ + case NG_HCI_EVENT_MAX_SLOT_CHANGE: + case NG_HCI_EVENT_CON_PKT_TYPE_CHANGED: + case NG_HCI_EVENT_BT_LOGO: + case NG_HCI_EVENT_VENDOR: + case NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL: + case NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL: + /* These do not need post processing */ + NG_FREE_M(event); + break; + + case NG_HCI_EVENT_INQUIRY_RESULT: + error = inquiry_result(unit, event); + break; + + case NG_HCI_EVENT_CON_COMPL: + error = con_compl(unit, event); + break; + + case NG_HCI_EVENT_CON_REQ: + error = con_req(unit, event); + break; + + case NG_HCI_EVENT_DISCON_COMPL: + error = discon_compl(unit, event); + break; + + case NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL: + error = read_remote_features_compl(unit, event); + break; + + case NG_HCI_EVENT_QOS_SETUP_COMPL: + error = qos_setup_compl(unit, event); + break; + + case NG_HCI_EVENT_COMMAND_COMPL: + error = ng_hci_process_command_complete(unit, event); + break; + + case NG_HCI_EVENT_COMMAND_STATUS: + error = ng_hci_process_command_status(unit, event); + break; + + case NG_HCI_EVENT_HARDWARE_ERROR: + error = hardware_error(unit, event); + break; + + case NG_HCI_EVENT_ROLE_CHANGE: + error = role_change(unit, event); + break; + + case NG_HCI_EVENT_NUM_COMPL_PKTS: + error = num_compl_pkts(unit, event); + break; + + case NG_HCI_EVENT_MODE_CHANGE: + error = mode_change(unit, event); + break; + + case NG_HCI_EVENT_DATA_BUFFER_OVERFLOW: + error = data_buffer_overflow(unit, event); + break; + + case NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL: + error = read_clock_offset_compl(unit, event); + break; + + case NG_HCI_EVENT_QOS_VIOLATION: + error = qos_violation(unit, event); + break; + + case NG_HCI_EVENT_PAGE_SCAN_MODE_CHANGE: + error = page_scan_mode_change(unit, event); + break; + + case NG_HCI_EVENT_PAGE_SCAN_REP_MODE_CHANGE: + error = page_scan_rep_mode_change(unit, event); + break; + + default: + NG_FREE_M(event); + error = EINVAL; + break; + } + + return (error); +} /* ng_hci_process_event */ + +/* + * Send ACL and/or SCO data to the unit driver + */ + +void +ng_hci_send_data(ng_hci_unit_p unit) +{ + int count; + + /* Send ACL data */ + NG_HCI_BUFF_ACL_AVAIL(unit->buffer, count); + + NG_HCI_INFO( +"%s: %s - sending ACL data packets, count=%d\n", + __func__, NG_NODE_NAME(unit->node), count); + + if (count > 0) { + count = send_data_packets(unit, NG_HCI_LINK_ACL, count); + NG_HCI_STAT_ACL_SENT(unit->stat, count); + NG_HCI_BUFF_ACL_USE(unit->buffer, count); + } + + /* Send SCO data */ + NG_HCI_BUFF_SCO_AVAIL(unit->buffer, count); + + NG_HCI_INFO( +"%s: %s - sending SCO data packets, count=%d\n", + __func__, NG_NODE_NAME(unit->node), count); + + if (count > 0) { + count = send_data_packets(unit, NG_HCI_LINK_SCO, count); + NG_HCI_STAT_SCO_SENT(unit->stat, count); + NG_HCI_BUFF_SCO_USE(unit->buffer, count); + } +} /* ng_hci_send_data */ + +/* + * Send data packets to the lower layer. + */ + +static int +send_data_packets(ng_hci_unit_p unit, int link_type, int limit) +{ + ng_hci_unit_con_p con = NULL, winner = NULL; + item_p item = NULL; + int min_pending, total_sent, sent, error, v; + + for (total_sent = 0; limit > 0; ) { + min_pending = 0x0fffffff; + winner = NULL; + + /* + * Find the connection that has has data to send + * and the smallest number of pending packets + */ + + LIST_FOREACH(con, &unit->con_list, next) { + if (con->link_type != link_type) + continue; + if (NG_BT_ITEMQ_LEN(&con->conq) == 0) + continue; + + if (con->pending < min_pending) { + winner = con; + min_pending = con->pending; + } + } + + if (winner == NULL) + break; + + /* + * OK, we have a winner now send as much packets as we can + * Count the number of packets we have sent and then sync + * winner connection queue. + */ + + for (sent = 0; limit > 0; limit --, total_sent ++, sent ++) { + NG_BT_ITEMQ_DEQUEUE(&winner->conq, item); + if (item == NULL) + break; + + NG_HCI_INFO( +"%s: %s - sending data packet, handle=%d, len=%d\n", + __func__, NG_NODE_NAME(unit->node), + winner->con_handle, NGI_M(item)->m_pkthdr.len); + + /* Check if driver hook still there */ + v = (unit->drv != NULL && NG_HOOK_IS_VALID(unit->drv)); + if (!v || (unit->state & NG_HCI_UNIT_READY) != + NG_HCI_UNIT_READY) { + NG_HCI_ERR( +"%s: %s - could not send data. Hook \"%s\" is %svalid, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), + NG_HCI_HOOK_DRV, ((v)? "" : "not "), + unit->state); + + NG_FREE_ITEM(item); + error = ENOTCONN; + } else { + v = NGI_M(item)->m_pkthdr.len; + + /* Give packet to raw hook */ + ng_hci_mtap(unit, NGI_M(item)); + + /* ... and forward item to the driver */ + NG_FWD_ITEM_HOOK(error, item, unit->drv); + } + + if (error != 0) { + NG_HCI_ERR( +"%s: %s - could not send data packet, handle=%d, error=%d\n", + __func__, NG_NODE_NAME(unit->node), + winner->con_handle, error); + break; + } + + winner->pending ++; + NG_HCI_STAT_BYTES_SENT(unit->stat, v); + } + + /* + * Sync connection queue for the winner + */ + + sync_con_queue(unit, winner, sent); + } + + return (total_sent); +} /* send_data_packets */ + +/* + * Send flow control messages to the upper layer + */ + +static int +sync_con_queue(ng_hci_unit_p unit, ng_hci_unit_con_p con, int completed) +{ + hook_p hook = NULL; + struct ng_mesg *msg = NULL; + ng_hci_sync_con_queue_ep *state = NULL; + int error; + + hook = (con->link_type == NG_HCI_LINK_ACL)? unit->acl : unit->sco; + if (hook == NULL || NG_HOOK_NOT_VALID(hook)) + return (ENOTCONN); + + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_SYNC_CON_QUEUE, + sizeof(*state), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + state = (ng_hci_sync_con_queue_ep *)(msg->data); + state->con_handle = con->con_handle; + state->completed = completed; + + NG_SEND_MSG_HOOK(error, unit->node, msg, hook, NULL); + + return (error); +} /* sync_con_queue */ + +/* Inquiry result event */ +static int +inquiry_result(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_inquiry_result_ep *ep = NULL; + ng_hci_neighbor_p n = NULL; + bdaddr_t bdaddr; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_inquiry_result_ep *); + m_adj(event, sizeof(*ep)); + + for (; ep->num_responses > 0; ep->num_responses --) { + /* Get remote unit address */ + m_copydata(event, 0, sizeof(bdaddr), (caddr_t) &bdaddr); + m_adj(event, sizeof(bdaddr)); + + /* Lookup entry in the cache */ + n = ng_hci_get_neighbor(unit, &bdaddr); + if (n == NULL) { + /* Create new entry */ + n = ng_hci_new_neighbor(unit); + if (n == NULL) { + error = ENOMEM; + break; + } + } else + getmicrotime(&n->updated); + + bcopy(&bdaddr, &n->bdaddr, sizeof(n->bdaddr)); + + /* XXX call m_pullup here? */ + + n->page_scan_rep_mode = *mtod(event, u_int8_t *); + m_adj(event, sizeof(u_int8_t)); + + /* page_scan_period_mode */ + m_adj(event, sizeof(u_int8_t)); + + n->page_scan_mode = *mtod(event, u_int8_t *); + m_adj(event, sizeof(u_int8_t)); + + /* class */ + m_adj(event, NG_HCI_CLASS_SIZE); + + /* clock offset */ + m_copydata(event, 0, sizeof(n->clock_offset), + (caddr_t) &n->clock_offset); + n->clock_offset = le16toh(n->clock_offset); + } + + NG_FREE_M(event); + + return (error); +} /* inquiry_result */ + +/* Connection complete event */ +static int +con_compl(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_con_compl_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_con_compl_ep *); + + /* + * Find the first connection descriptor that matches the following: + * + * 1) con->link_type == ep->link_type + * 2) con->state == NG_HCI_CON_W4_CONN_COMPLETE + * 3) con->bdaddr == ep->bdaddr + */ + + LIST_FOREACH(con, &unit->con_list, next) + if (con->link_type == ep->link_type && + con->state == NG_HCI_CON_W4_CONN_COMPLETE && + bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0) + break; + + /* + * Two possible cases: + * + * 1) We have found connection descriptor. That means upper layer has + * requested this connection via LP_CON_REQ message + * + * 2) We do not have connection descriptor. That means upper layer + * nas not requested this connection or (less likely) we gave up + * on this connection (timeout). The most likely scenario is that + * we have received Create_Connection/Add_SCO_Connection command + * from the RAW hook + */ + + if (con == NULL) { + if (ep->status != 0) + goto out; + + con = ng_hci_new_con(unit, ep->link_type); + if (con == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr)); + } else + ng_hci_con_untimeout(con); + + /* + * Update connection descriptor and send notification + * to the upper layers. + */ + + con->con_handle = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + con->encryption_mode = ep->encryption_mode; + + ng_hci_lp_con_cfm(con, ep->status); + + /* Adjust connection state */ + if (ep->status != 0) + ng_hci_free_con(con); + else { + con->state = NG_HCI_CON_OPEN; + + /* + * Change link policy for the ACL connections. Enable all + * supported link modes. Enable Role switch as well if + * device supports it. + */ + + if (ep->link_type == NG_HCI_LINK_ACL) { + struct __link_policy { + ng_hci_cmd_pkt_t hdr; + ng_hci_write_link_policy_settings_cp cp; + } __attribute__ ((packed)) *lp; + struct mbuf *m; + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m != NULL) { + m->m_pkthdr.len = m->m_len = sizeof(*lp); + lp = mtod(m, struct __link_policy *); + + lp->hdr.type = NG_HCI_CMD_PKT; + lp->hdr.opcode = htole16(NG_HCI_OPCODE( + NG_HCI_OGF_LINK_POLICY, + NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS)); + lp->hdr.length = sizeof(lp->cp); + + lp->cp.con_handle = ep->con_handle; + + lp->cp.settings = 0; + if (unit->features[0] & NG_HCI_LMP_SWITCH) + lp->cp.settings |= 0x1; + if (unit->features[0] & NG_HCI_LMP_HOLD_MODE) + lp->cp.settings |= 0x2; + if (unit->features[0] & NG_HCI_LMP_SNIFF_MODE) + lp->cp.settings |= 0x4; + if (unit->features[1] & NG_HCI_LMP_PARK_MODE) + lp->cp.settings |= 0x8; + + lp->cp.settings &= unit->link_policy_mask; + lp->cp.settings = htole16(lp->cp.settings); + + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + ng_hci_send_command(unit); + } + } + } +out: + NG_FREE_M(event); + + return (error); +} /* com_compl */ + +/* Connection request event */ +static int +con_req(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_con_req_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_con_req_ep *); + + /* + * Find the first connection descriptor that matches the following: + * + * 1) con->link_type == ep->link_type + * + * 2) con->state == NG_HCI_CON_W4_LP_CON_RSP || + * con->state == NG_HCI_CON_W4_CONN_COMPL + * + * 3) con->bdaddr == ep->bdaddr + * + * Possible cases: + * + * 1) We do not have connection descriptor. This is simple. Create + * new fresh connection descriptor and send notification to the + * appropriate upstream hook (based on link_type). + * + * 2) We found connection handle. This is more complicated. + * + * 2.1) ACL links + * + * Since only one ACL link can exist between each pair of + * units then we have a race. Our upper layer has requested + * an ACL connection to the remote unit, but we did not send + * command yet. At the same time the remote unit has requested + * an ACL connection from us. In this case we will ignore + * Connection_Request event. This probably will cause connect + * failure on both units. + * + * 2.2) SCO links + * + * The spec on page 45 says : + * + * "The master can support up to three SCO links to the same + * slave or to different slaves. A slave can support up to + * three SCO links from the same master, or two SCO links if + * the links originate from different masters." + * + * The only problem is how to handle multiple SCO links between + * matster and slave. For now we will assume that multiple SCO + * links MUST be opened one after another. + */ + + LIST_FOREACH(con, &unit->con_list, next) + if (con->link_type == ep->link_type && + (con->state == NG_HCI_CON_W4_LP_CON_RSP || + con->state == NG_HCI_CON_W4_CONN_COMPLETE) && + bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0) + break; + + if (con == NULL) { + con = ng_hci_new_con(unit, ep->link_type); + if (con != NULL) { + bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr)); + + con->state = NG_HCI_CON_W4_LP_CON_RSP; + ng_hci_con_timeout(con); + + error = ng_hci_lp_con_ind(con, ep->uclass); + if (error != 0) + ng_hci_free_con(con); + } else + error = ENOMEM; + } + + NG_FREE_M(event); + + return (error); +} /* con_req */ + +/* Disconnect complete event */ +static int +discon_compl(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_discon_compl_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + int error = 0; + u_int16_t h; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_discon_compl_ep *); + + /* + * XXX + * Do we have to send notification if ep->status != 0? + * For now we will send notification for both ACL and SCO connections + * ONLY if ep->status == 0. + */ + + if (ep->status == 0) { + h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + con = ng_hci_con_by_handle(unit, h); + if (con != NULL) { + error = ng_hci_lp_discon_ind(con, ep->reason); + ng_hci_free_con(con); + } else { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + } + } + + NG_FREE_M(event); + + return (error); +} /* discon_compl */ + +/* Read remote feature complete event */ +static int +read_remote_features_compl(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_read_remote_features_compl_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + ng_hci_neighbor_p n = NULL; + u_int16_t h; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_read_remote_features_compl_ep *); + + if (ep->status == 0) { + /* Check if we have this connection handle */ + h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + con = ng_hci_con_by_handle(unit, h); + if (con == NULL) { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + goto out; + } + + /* Update cache entry */ + n = ng_hci_get_neighbor(unit, &con->bdaddr); + if (n == NULL) { + n = ng_hci_new_neighbor(unit); + if (n == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr)); + } else + getmicrotime(&n->updated); + + bcopy(ep->features, n->features, sizeof(n->features)); + } else + NG_HCI_ERR( +"%s: %s - failed to read remote unit features, status=%d\n", + __func__, NG_NODE_NAME(unit->node), ep->status); +out: + NG_FREE_M(event); + + return (error); +} /* read_remote_features_compl */ + +/* QoS setup complete event */ +static int +qos_setup_compl(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_qos_setup_compl_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + u_int16_t h; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_qos_setup_compl_ep *); + + /* Check if we have this connection handle */ + h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + con = ng_hci_con_by_handle(unit, h); + if (con == NULL) { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + } else if (con->link_type != NG_HCI_LINK_ACL) { + NG_HCI_ALERT( +"%s: %s - invalid link type=%d, handle=%d\n", + __func__, NG_NODE_NAME(unit->node), con->link_type, h); + error = EINVAL; + } else if (con->state != NG_HCI_CON_OPEN) { + NG_HCI_ALERT( +"%s: %s - invalid connection state=%d, handle=%d\n", + __func__, NG_NODE_NAME(unit->node), + con->state, h); + error = EINVAL; + } else /* Notify upper layer */ + error = ng_hci_lp_qos_cfm(con, ep->status); + + NG_FREE_M(event); + + return (error); +} /* qos_setup_compl */ + +/* Hardware error event */ +static int +hardware_error(ng_hci_unit_p unit, struct mbuf *event) +{ + NG_HCI_ALERT( +"%s: %s - hardware error %#x\n", + __func__, NG_NODE_NAME(unit->node), *mtod(event, u_int8_t *)); + + NG_FREE_M(event); + + return (0); +} /* hardware_error */ + +/* Role change event */ +static int +role_change(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_role_change_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_role_change_ep *); + + if (ep->status == 0) { + /* XXX shoud we also change "role" for SCO connections? */ + con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, NG_HCI_LINK_ACL); + if (con != NULL) + con->role = ep->role; + else + NG_HCI_ALERT( +"%s: %s - ACL connection does not exist, bdaddr=%x:%x:%x:%x:%x:%x\n", + __func__, NG_NODE_NAME(unit->node), + ep->bdaddr.b[5], ep->bdaddr.b[4], + ep->bdaddr.b[3], ep->bdaddr.b[2], + ep->bdaddr.b[1], ep->bdaddr.b[0]); + } else + NG_HCI_ERR( +"%s: %s - failed to change role, status=%d, bdaddr=%x:%x:%x:%x:%x:%x\n", + __func__, NG_NODE_NAME(unit->node), ep->status, + ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3], + ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]); + + NG_FREE_M(event); + + return (0); +} /* role_change */ + +/* Number of completed packets event */ +static int +num_compl_pkts(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_num_compl_pkts_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + u_int16_t h, p; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_num_compl_pkts_ep *); + m_adj(event, sizeof(*ep)); + + for (; ep->num_con_handles > 0; ep->num_con_handles --) { + /* Get connection handle */ + m_copydata(event, 0, sizeof(h), (caddr_t) &h); + m_adj(event, sizeof(h)); + h = NG_HCI_CON_HANDLE(le16toh(h)); + + /* Get number of completed packets */ + m_copydata(event, 0, sizeof(p), (caddr_t) &p); + m_adj(event, sizeof(p)); + p = le16toh(p); + + /* Check if we have this connection handle */ + con = ng_hci_con_by_handle(unit, h); + if (con != NULL) { + con->pending -= p; + if (con->pending < 0) { + NG_HCI_WARN( +"%s: %s - pending packet counter is out of sync! " \ +"handle=%d, pending=%d, ncp=%d\n", __func__, NG_NODE_NAME(unit->node), + con->con_handle, con->pending, p); + + con->pending = 0; + } + + /* Update buffer descriptor */ + if (con->link_type == NG_HCI_LINK_ACL) + NG_HCI_BUFF_ACL_FREE(unit->buffer, p); + else + NG_HCI_BUFF_SCO_FREE(unit->buffer, p); + } else + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + } + + NG_FREE_M(event); + + /* Send more data */ + ng_hci_send_data(unit); + + return (0); +} /* num_compl_pkts */ + +/* Mode change event */ +static int +mode_change(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_mode_change_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_mode_change_ep *); + + if (ep->status == 0) { + u_int16_t h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + + con = ng_hci_con_by_handle(unit, h); + if (con == NULL) { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + } else if (con->link_type != NG_HCI_LINK_ACL) { + NG_HCI_ALERT( +"%s: %s - invalid link type=%d\n", + __func__, NG_NODE_NAME(unit->node), + con->link_type); + error = EINVAL; + } else + con->mode = ep->unit_mode; + } else + NG_HCI_ERR( +"%s: %s - failed to change mode, status=%d\n", + __func__, NG_NODE_NAME(unit->node), ep->status); + + NG_FREE_M(event); + + return (error); +} /* mode_change */ + +/* Data buffer overflow event */ +static int +data_buffer_overflow(ng_hci_unit_p unit, struct mbuf *event) +{ + NG_HCI_ALERT( +"%s: %s - %s data buffer overflow\n", + __func__, NG_NODE_NAME(unit->node), + (*mtod(event, u_int8_t *) == NG_HCI_LINK_ACL)? "ACL" : "SCO"); + + NG_FREE_M(event); + + return (0); +} /* data_buffer_overflow */ + +/* Read clock offset complete event */ +static int +read_clock_offset_compl(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_read_clock_offset_compl_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + ng_hci_neighbor_p n = NULL; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_read_clock_offset_compl_ep *); + + if (ep->status == 0) { + u_int16_t h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + + con = ng_hci_con_by_handle(unit, h); + if (con == NULL) { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + goto out; + } + + /* Update cache entry */ + n = ng_hci_get_neighbor(unit, &con->bdaddr); + if (n == NULL) { + n = ng_hci_new_neighbor(unit); + if (n == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&con->bdaddr, &n->bdaddr, sizeof(n->bdaddr)); + } else + getmicrotime(&n->updated); + + n->clock_offset = le16toh(ep->clock_offset); + } else + NG_HCI_ERR( +"%s: %s - failed to Read Remote Clock Offset, status=%d\n", + __func__, NG_NODE_NAME(unit->node), ep->status); +out: + NG_FREE_M(event); + + return (error); +} /* read_clock_offset_compl */ + +/* QoS violation event */ +static int +qos_violation(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_qos_violation_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + u_int16_t h; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_qos_violation_ep *); + + /* Check if we have this connection handle */ + h = NG_HCI_CON_HANDLE(le16toh(ep->con_handle)); + con = ng_hci_con_by_handle(unit, h); + if (con == NULL) { + NG_HCI_ALERT( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), h); + error = ENOENT; + } else if (con->link_type != NG_HCI_LINK_ACL) { + NG_HCI_ALERT( +"%s: %s - invalid link type=%d\n", + __func__, NG_NODE_NAME(unit->node), con->link_type); + error = EINVAL; + } else if (con->state != NG_HCI_CON_OPEN) { + NG_HCI_ALERT( +"%s: %s - invalid connection state=%d, handle=%d\n", + __func__, NG_NODE_NAME(unit->node), con->state, h); + error = EINVAL; + } else /* Notify upper layer */ + error = ng_hci_lp_qos_ind(con); + + NG_FREE_M(event); + + return (error); +} /* qos_violation */ + +/* Page scan mode change event */ +static int +page_scan_mode_change(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_page_scan_mode_change_ep *ep = NULL; + ng_hci_neighbor_p n = NULL; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_page_scan_mode_change_ep *); + + /* Update cache entry */ + n = ng_hci_get_neighbor(unit, &ep->bdaddr); + if (n == NULL) { + n = ng_hci_new_neighbor(unit); + if (n == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr)); + } else + getmicrotime(&n->updated); + + n->page_scan_mode = ep->page_scan_mode; +out: + NG_FREE_M(event); + + return (error); +} /* page_scan_mode_change */ + +/* Page scan repetition mode change event */ +static int +page_scan_rep_mode_change(ng_hci_unit_p unit, struct mbuf *event) +{ + ng_hci_page_scan_rep_mode_change_ep *ep = NULL; + ng_hci_neighbor_p n = NULL; + int error = 0; + + NG_HCI_M_PULLUP(event, sizeof(*ep)); + if (event == NULL) + return (ENOBUFS); + + ep = mtod(event, ng_hci_page_scan_rep_mode_change_ep *); + + /* Update cache entry */ + n = ng_hci_get_neighbor(unit, &ep->bdaddr); + if (n == NULL) { + n = ng_hci_new_neighbor(unit); + if (n == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&ep->bdaddr, &n->bdaddr, sizeof(n->bdaddr)); + } else + getmicrotime(&n->updated); + + n->page_scan_rep_mode = ep->page_scan_rep_mode; +out: + NG_FREE_M(event); + + return (error); +} /* page_scan_rep_mode_change */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_evnt.h b/sys/netgraph/bluetooth/hci/ng_hci_evnt.h new file mode 100644 index 0000000..706d7b0 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_evnt.h @@ -0,0 +1,43 @@ +/* + * ng_hci_evnt.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_evnt.h,v 1.4 2002/09/04 21:36:51 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_HCI_EVNT_H_ +#define _NETGRAPH_HCI_EVNT_H_ 1 + +/* + * HCI events processing routines + */ + +int ng_hci_process_event (ng_hci_unit_p, struct mbuf *); +void ng_hci_send_data (ng_hci_unit_p); + +#endif /* ndef _NETGRAPH_HCI_EVNT_H_ */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_main.c b/sys/netgraph/bluetooth/hci/ng_hci_main.c new file mode 100644 index 0000000..c3c77fc --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_main.c @@ -0,0 +1,1063 @@ +/* + * ng_hci_main.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_main.c,v 1.28 2002/11/12 22:35:40 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <netgraph/ng_parse.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_hci_var.h" +#include "ng_hci_prse.h" +#include "ng_hci_cmds.h" +#include "ng_hci_evnt.h" +#include "ng_hci_ulpi.h" +#include "ng_hci_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** This node implements Bluetooth Host Controller Interface (HCI) + ****************************************************************************** + ******************************************************************************/ + +/* MALLOC define */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DEFINE(M_NETGRAPH_HCI, "netgraph_hci", "Netgraph Bluetooth HCI node"); +#else +#define M_NETGRAPH_HCI M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Netgraph node methods */ +static ng_constructor_t ng_hci_constructor; +static ng_shutdown_t ng_hci_shutdown; +static ng_newhook_t ng_hci_newhook; +static ng_connect_t ng_hci_connect; +static ng_disconnect_t ng_hci_disconnect; +static ng_rcvmsg_t ng_hci_default_rcvmsg; +static ng_rcvmsg_t ng_hci_upper_rcvmsg; +static ng_rcvdata_t ng_hci_drv_rcvdata; +static ng_rcvdata_t ng_hci_acl_rcvdata; +static ng_rcvdata_t ng_hci_sco_rcvdata; +static ng_rcvdata_t ng_hci_raw_rcvdata; + +/* Netgraph node type descriptor */ +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_HCI_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_hci_constructor, /* constructor */ + ng_hci_default_rcvmsg, /* control message */ + ng_hci_shutdown, /* destructor */ + ng_hci_newhook, /* new hook */ + NULL, /* findhook */ + ng_hci_connect, /* connect hook */ + ng_hci_drv_rcvdata, /* data */ + ng_hci_disconnect, /* disconnect hook */ + ng_hci_cmdlist /* node command list */ +}; +NETGRAPH_INIT(hci, &typestruct); +MODULE_VERSION(ng_hci, NG_BLUETOOTH_VERSION); +MODULE_DEPEND(ng_hci, ng_bluetooth, NG_BLUETOOTH_VERSION, + NG_BLUETOOTH_VERSION, NG_BLUETOOTH_VERSION); + +/***************************************************************************** + ***************************************************************************** + ** Netgraph methods implementation + ***************************************************************************** + *****************************************************************************/ + +/* + * Create new instance of HCI node (new unit) + */ + +static int +ng_hci_constructor(node_p node) +{ + ng_hci_unit_p unit = NULL; + + MALLOC(unit, ng_hci_unit_p, sizeof(*unit), M_NETGRAPH_HCI, + M_NOWAIT | M_ZERO); + if (unit == NULL) + return (ENOMEM); + + unit->node = node; + unit->debug = NG_HCI_WARN_LEVEL; + + unit->link_policy_mask = 0xffff; /* Enable all supported modes */ + unit->packet_mask = 0xffff; /* Enable all packet types */ + + /* + * Set default buffer info + * + * One HCI command + * One ACL packet with max. size of 17 bytes (1 DM1 packet) + * One SCO packet with max. size of 10 bytes (1 HV1 packet) + */ + + NG_HCI_BUFF_CMD_SET(unit->buffer, 1); + NG_HCI_BUFF_ACL_SET(unit->buffer, 1, 17, 1); + NG_HCI_BUFF_SCO_SET(unit->buffer, 1, 10, 1); + + /* Init command queue & command timeout handler */ + callout_handle_init(&unit->cmd_timo); + NG_BT_MBUFQ_INIT(&unit->cmdq, NG_HCI_CMD_QUEUE_LEN); + + /* Init lists */ + LIST_INIT(&unit->con_list); + LIST_INIT(&unit->neighbors); + + /* + * This node has to be a WRITER because both data and messages + * can change node state. + */ + + NG_NODE_FORCE_WRITER(node); + NG_NODE_SET_PRIVATE(node, unit); + + return (0); +} /* ng_hci_constructor */ + +/* + * Destroy the node + */ + +static int +ng_hci_shutdown(node_p node) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node); + + NG_NODE_SET_PRIVATE(node, NULL); + NG_NODE_UNREF(node); + + unit->node = NULL; + ng_hci_unit_clean(unit, 0x16 /* Connection terminated by local host */); + + NG_BT_MBUFQ_DESTROY(&unit->cmdq); + + bzero(unit, sizeof(*unit)); + FREE(unit, M_NETGRAPH_HCI); + + return (0); +} /* ng_hci_shutdown */ + +/* + * Give our OK for a hook to be added. Unit driver is connected to the driver + * (NG_HCI_HOOK_DRV) hook. Upper layer protocols are connected to appropriate + * (NG_HCI_HOOK_ACL or NG_HCI_HOOK_SCO) hooks. + */ + +static int +ng_hci_newhook(node_p node, hook_p hook, char const *name) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node); + hook_p *h = NULL; + + if (strcmp(name, NG_HCI_HOOK_DRV) == 0) + h = &unit->drv; + else if (strcmp(name, NG_HCI_HOOK_ACL) == 0) + h = &unit->acl; + else if (strcmp(name, NG_HCI_HOOK_SCO) == 0) + h = &unit->sco; + else if (strcmp(name, NG_HCI_HOOK_RAW) == 0) + h = &unit->raw; + else + return (EINVAL); + + if (*h != NULL) + return (EISCONN); + + *h = hook; + + return (0); +} /* ng_hci_newhook */ + +/* + * Give our final OK to connect hook + */ + +static int +ng_hci_connect(hook_p hook) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + if (hook != unit->drv) { + if (hook == unit->acl) { + NG_HOOK_SET_RCVMSG(hook, ng_hci_upper_rcvmsg); + NG_HOOK_SET_RCVDATA(hook, ng_hci_acl_rcvdata); + } else if (hook == unit->sco) { + NG_HOOK_SET_RCVMSG(hook, ng_hci_upper_rcvmsg); + NG_HOOK_SET_RCVDATA(hook, ng_hci_sco_rcvdata); + } else + NG_HOOK_SET_RCVDATA(hook, ng_hci_raw_rcvdata); + + /* Send delayed notification to the upper layers */ + if (hook != unit->raw) + ng_send_fn(unit->node, hook, ng_hci_node_is_up, NULL,0); + } else + unit->state |= NG_HCI_UNIT_CONNECTED; + + return (0); +} /* ng_hci_connect */ + +/* + * Disconnect the hook + */ + +static int +ng_hci_disconnect(hook_p hook) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + + if (hook == unit->acl) + unit->acl = NULL; + else if (hook == unit->sco) + unit->sco = NULL; + else if (hook == unit->raw) + unit->raw = NULL; + else if (hook == unit->drv) { + unit->drv = NULL; + + /* Connection terminated by local host */ + ng_hci_unit_clean(unit, 0x16); + unit->state &= ~(NG_HCI_UNIT_CONNECTED|NG_HCI_UNIT_INITED); + } else + return (EINVAL); + + /* Shutdown when all hooks are disconnected */ + if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) && + (NG_NODE_IS_VALID(NG_HOOK_NODE(hook)))) + ng_rmnode_self(NG_HOOK_NODE(hook)); + + return (0); +} /* ng_hci_disconnect */ + +/* + * Default control message processing routine. Control message could be: + * + * 1) GENERIC Netgraph messages + * + * 2) Control message directed to the node itself. + */ + +static int +ng_hci_default_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NULL, *rsp = NULL; + int error = 0; + + NGI_GET_MSG(item, msg); + + switch (msg->header.typecookie) { + case NGM_GENERIC_COOKIE: + switch (msg->header.cmd) { + case NGM_TEXT_STATUS: { + int cmd_avail, + acl_total, acl_avail, acl_size, + sco_total, sco_avail, sco_size; + + NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + NG_HCI_BUFF_CMD_GET(unit->buffer, cmd_avail); + + NG_HCI_BUFF_ACL_AVAIL(unit->buffer, acl_avail); + NG_HCI_BUFF_ACL_TOTAL(unit->buffer, acl_total); + NG_HCI_BUFF_ACL_SIZE(unit->buffer, acl_size); + + NG_HCI_BUFF_SCO_AVAIL(unit->buffer, sco_avail); + NG_HCI_BUFF_SCO_TOTAL(unit->buffer, sco_total); + NG_HCI_BUFF_SCO_SIZE(unit->buffer, sco_size); + + snprintf(rsp->data, NG_TEXTRESPONSE, + "bdaddr %x:%x:%x:%x:%x:%x\n" \ + "Hooks %s %s %s %s\n" \ + "State %#x\n" \ + "Queue cmd:%d\n" \ + "Buffer cmd:%d,acl:%d,%d,%d,sco:%d,%d,%d", + unit->bdaddr.b[5], unit->bdaddr.b[4], + unit->bdaddr.b[3], unit->bdaddr.b[2], + unit->bdaddr.b[1], unit->bdaddr.b[0], + (unit->drv != NULL)? NG_HCI_HOOK_DRV : "", + (unit->acl != NULL)? NG_HCI_HOOK_ACL : "", + (unit->sco != NULL)? NG_HCI_HOOK_SCO : "", + (unit->raw != NULL)? NG_HCI_HOOK_RAW : "", + unit->state, + NG_BT_MBUFQ_LEN(&unit->cmdq), + cmd_avail, + acl_avail, acl_total, acl_size, + sco_avail, sco_total, sco_size); + } break; + + default: + error = EINVAL; + break; + } + break; + + case NGM_HCI_COOKIE: + switch (msg->header.cmd) { + /* Get current node state */ + case NGM_HCI_NODE_GET_STATE: + NG_MKRESPONSE(rsp, msg, sizeof(unit->state), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + *((ng_hci_node_state_ep *)(rsp->data)) = unit->state; + break; + + /* Turn INITED bit - node initialized */ + case NGM_HCI_NODE_INIT: + if (bcmp(&unit->bdaddr, NG_HCI_BDADDR_ANY, + sizeof(bdaddr_t)) == 0) { + error = ENXIO; + break; + } + + unit->state |= NG_HCI_UNIT_INITED; + + ng_hci_node_is_up(unit->node, unit->acl, NULL, 0); + ng_hci_node_is_up(unit->node, unit->sco, NULL, 0); + break; + + /* Get node debug level */ + case NGM_HCI_NODE_GET_DEBUG: + NG_MKRESPONSE(rsp, msg, sizeof(unit->debug), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + *((ng_hci_node_debug_ep *)(rsp->data)) = unit->debug; + break; + + /* Set node debug level */ + case NGM_HCI_NODE_SET_DEBUG: + if (msg->header.arglen != sizeof(ng_hci_node_debug_ep)){ + error = EMSGSIZE; + break; + } + + unit->debug = *((ng_hci_node_debug_ep *)(msg->data)); + break; + + /* Get buffer info */ + case NGM_HCI_NODE_GET_BUFFER: { + ng_hci_node_buffer_ep *ep = NULL; + + NG_MKRESPONSE(rsp, msg, sizeof(ng_hci_node_buffer_ep), + M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + ep = (ng_hci_node_buffer_ep *)(rsp->data); + + NG_HCI_BUFF_CMD_GET(unit->buffer, ep->cmd_free); + NG_HCI_BUFF_ACL_AVAIL(unit->buffer, ep->acl_free); + NG_HCI_BUFF_ACL_TOTAL(unit->buffer, ep->acl_pkts); + NG_HCI_BUFF_ACL_SIZE(unit->buffer, ep->acl_size); + NG_HCI_BUFF_SCO_AVAIL(unit->buffer, ep->sco_free); + NG_HCI_BUFF_SCO_TOTAL(unit->buffer, ep->sco_pkts); + NG_HCI_BUFF_SCO_SIZE(unit->buffer, ep->sco_size); + } break; + + /* Get BDADDR */ + case NGM_HCI_NODE_GET_BDADDR: + NG_MKRESPONSE(rsp, msg, sizeof(bdaddr_t), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + bcopy(&unit->bdaddr, rsp->data, sizeof(bdaddr_t)); + break; + + /* Get features */ + case NGM_HCI_NODE_GET_FEATURES: + NG_MKRESPONSE(rsp,msg,sizeof(unit->features),M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + bcopy(&unit->features,rsp->data,sizeof(unit->features)); + break; + + /* Get stat */ + case NGM_HCI_NODE_GET_STAT: + NG_MKRESPONSE(rsp, msg, sizeof(unit->stat), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + bcopy(&unit->stat, rsp->data, sizeof(unit->stat)); + break; + + /* Reset stat */ + case NGM_HCI_NODE_RESET_STAT: + NG_HCI_STAT_RESET(unit->stat); + break; + + /* Clean up neighbors list */ + case NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE: + ng_hci_flush_neighbor_cache(unit); + break; + + /* Get neighbor cache entries */ + case NGM_HCI_NODE_GET_NEIGHBOR_CACHE: { + ng_hci_neighbor_p n = NULL; + ng_hci_node_get_neighbor_cache_ep *e1 = NULL; + ng_hci_node_neighbor_cache_entry_ep *e2 = NULL; + int s = 0; + + /* Look for the fresh entries in the cache */ + for (n = LIST_FIRST(&unit->neighbors); n != NULL; ) { + ng_hci_neighbor_p nn = LIST_NEXT(n, next); + + if (ng_hci_neighbor_stale(n)) + ng_hci_free_neighbor(n); + else + s ++; + + n = nn; + } + if (s > NG_HCI_MAX_NEIGHBOR_NUM) + s = NG_HCI_MAX_NEIGHBOR_NUM; + + /* Prepare response */ + NG_MKRESPONSE(rsp, msg, sizeof(*e1) + s * sizeof(*e2), + M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + e1 = (ng_hci_node_get_neighbor_cache_ep *)(rsp->data); + e2 = (ng_hci_node_neighbor_cache_entry_ep *)(e1 + 1); + + e1->num_entries = s; + + LIST_FOREACH(n, &unit->neighbors, next) { + e2->page_scan_rep_mode = n->page_scan_rep_mode; + e2->page_scan_mode = n->page_scan_mode; + e2->clock_offset = n->clock_offset; + bcopy(&n->bdaddr, &e2->bdaddr, + sizeof(e2->bdaddr)); + bcopy(&n->features, &e2->features, + sizeof(e2->features)); + + e2 ++; + if (--s <= 0) + break; + } + } break; + + /* Get connection list */ + case NGM_HCI_NODE_GET_CON_LIST: { + ng_hci_unit_con_p c = NULL; + ng_hci_node_con_list_ep *e1 = NULL; + ng_hci_node_con_ep *e2 = NULL; + int s = 0; + + /* Count number of connections in the list */ + LIST_FOREACH(c, &unit->con_list, next) + s ++; + if (s > NG_HCI_MAX_CON_NUM) + s = NG_HCI_MAX_CON_NUM; + + /* Prepare response */ + NG_MKRESPONSE(rsp, msg, sizeof(*e1) + s * sizeof(*e2), + M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + e1 = (ng_hci_node_con_list_ep *)(rsp->data); + e2 = (ng_hci_node_con_ep *)(e1 + 1); + + e1->num_connections = s; + + LIST_FOREACH(c, &unit->con_list, next) { + e2->link_type = c->link_type; + e2->encryption_mode= c->encryption_mode; + e2->mode = c->mode; + e2->role = c->role; + + e2->state = c->state; + + e2->pending = c->pending; + e2->queue_len = NG_BT_ITEMQ_LEN(&c->conq); + + e2->con_handle = c->con_handle; + bcopy(&c->bdaddr, &e2->bdaddr, + sizeof(e2->bdaddr)); + + + e2 ++; + if (--s <= 0) + break; + } + } break; + + /* Get link policy settings mask */ + case NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK: + NG_MKRESPONSE(rsp, msg, sizeof(unit->link_policy_mask), + M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + *((ng_hci_node_link_policy_mask_ep *)(rsp->data)) = + unit->link_policy_mask; + break; + + /* Set link policy settings mask */ + case NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK: + if (msg->header.arglen != + sizeof(ng_hci_node_link_policy_mask_ep)) { + error = EMSGSIZE; + break; + } + + unit->link_policy_mask = + *((ng_hci_node_link_policy_mask_ep *) + (msg->data)); + break; + + /* Get packet mask */ + case NGM_HCI_NODE_GET_PACKET_MASK: + NG_MKRESPONSE(rsp, msg, sizeof(unit->packet_mask), + M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + *((ng_hci_node_packet_mask_ep *)(rsp->data)) = + unit->packet_mask; + break; + + /* Set packet mask */ + case NGM_HCI_NODE_SET_PACKET_MASK: + if (msg->header.arglen != + sizeof(ng_hci_node_packet_mask_ep)) { + error = EMSGSIZE; + break; + } + + unit->packet_mask = + *((ng_hci_node_packet_mask_ep *)(msg->data)); + break; + + default: + error = EINVAL; + break; + } + break; + + default: + error = EINVAL; + break; + } + + /* NG_RESPOND_MSG should take care of "item" and "rsp" */ + NG_RESPOND_MSG(error, node, item, rsp); + NG_FREE_MSG(msg); + + return (error); +} /* ng_hci_default_rcvmsg */ + +/* + * Process control message from upstream hooks (ACL and SCO). + * Handle LP_xxx messages here, give everything else to default routine. + */ + +static int +ng_hci_upper_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node); + int error = 0; + + switch (NGI_MSG(item)->header.typecookie) { + case NGM_HCI_COOKIE: + switch (NGI_MSG(item)->header.cmd) { + case NGM_HCI_LP_CON_REQ: + error = ng_hci_lp_con_req(unit, item, lasthook); + break; + + case NGM_HCI_LP_DISCON_REQ: /* XXX not defined by specs */ + error = ng_hci_lp_discon_req(unit, item, lasthook); + break; + + case NGM_HCI_LP_CON_RSP: + error = ng_hci_lp_con_rsp(unit, item, lasthook); + break; + + case NGM_HCI_LP_QOS_REQ: + error = ng_hci_lp_qos_req(unit, item, lasthook); + break; + + default: + error = ng_hci_default_rcvmsg(node, item, lasthook); + break; + } + break; + + default: + error = ng_hci_default_rcvmsg(node, item, lasthook); + break; + } + + return (error); +} /* ng_hci_upper_rcvmsg */ + +/* + * Process data packet from the driver hook. + * We expect HCI events, ACL or SCO data packets. + */ + +static int +ng_hci_drv_rcvdata(hook_p hook, item_p item) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + int error = 0; + + /* Process packet */ + m = NGI_M(item); /* item still has mbuf, just peeking */ + m->m_flags |= M_PROTO1; /* mark as incoming packet */ + + NG_HCI_STAT_BYTES_RECV(unit->stat, m->m_pkthdr.len); + + /* Give copy packet to RAW hook */ + ng_hci_mtap(unit, m); + + /* + * XXX XXX XXX + * Lower layer drivers MUST NOT send mbuf chain with empty mbuf at + * the beginning of the chain. HCI layer WILL NOT call m_pullup() here. + */ + + switch (*mtod(m, u_int8_t *)) { + case NG_HCI_ACL_DATA_PKT: + NG_HCI_STAT_ACL_RECV(unit->stat); + + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY || + unit->acl == NULL || NG_HOOK_NOT_VALID(unit->acl)) { + NG_HCI_WARN( +"%s: %s - could not forward HCI ACL data packet, state=%#x, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), + unit->state, unit->acl); + + NG_FREE_ITEM(item); + } else + NG_FWD_ITEM_HOOK(error, item, unit->acl); + break; + + case NG_HCI_SCO_DATA_PKT: + NG_HCI_STAT_SCO_RECV(unit->stat); + + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY || + unit->sco == NULL || NG_HOOK_NOT_VALID(unit->sco)) { + NG_HCI_WARN( +"%s: %s - could not forward HCI SCO data packet, state=%#x, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), + unit->state, unit->sco); + + NG_FREE_ITEM(item); + } else + NG_FWD_ITEM_HOOK(error, item, unit->sco); + break; + + case NG_HCI_EVENT_PKT: + NG_HCI_STAT_EVNT_RECV(unit->stat); + + /* Detach mbuf, discard item and process event */ + NGI_GET_M(item, m); + NG_FREE_ITEM(item); + + error = ng_hci_process_event(unit, m); + break; + + default: + NG_HCI_ALERT( +"%s: %s - got unknown HCI packet type=%#x\n", + __func__, NG_NODE_NAME(unit->node), + *mtod(m, u_int8_t *)); + + NG_FREE_ITEM(item); + + error = EINVAL; + break; + } + + return (error); +} /* ng_hci_drv_rcvdata */ + +/* + * Process data packet from ACL upstream hook. + * We expect valid HCI ACL data packets. + */ + +static int +ng_hci_acl_rcvdata(hook_p hook, item_p item) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + ng_hci_unit_con_p con = NULL; + u_int16_t con_handle; + int size, error = 0; + + NG_HCI_BUFF_ACL_SIZE(unit->buffer, size); + + /* Check packet */ + NGI_GET_M(item, m); + + if (*mtod(m, u_int8_t *) != NG_HCI_ACL_DATA_PKT) { + NG_HCI_ALERT( +"%s: %s - invalid HCI data packet type=%#x\n", + __func__, NG_NODE_NAME(unit->node), + *mtod(m, u_int8_t *)); + + error = EINVAL; + goto drop; + } + + if (m->m_pkthdr.len < sizeof(ng_hci_acldata_pkt_t) || + m->m_pkthdr.len > sizeof(ng_hci_acldata_pkt_t) + size) { + NG_HCI_ALERT( +"%s: %s - invalid HCI ACL data packet, len=%d, mtu=%d\n", + __func__, NG_NODE_NAME(unit->node), + m->m_pkthdr.len, size); + + error = EMSGSIZE; + goto drop; + } + + NG_HCI_M_PULLUP(m, sizeof(ng_hci_acldata_pkt_t)); + if (m == NULL) { + error = ENOBUFS; + goto drop; + } + + con_handle = NG_HCI_CON_HANDLE(le16toh( + mtod(m, ng_hci_acldata_pkt_t *)->con_handle)); + size = le16toh(mtod(m, ng_hci_acldata_pkt_t *)->length); + + if (m->m_pkthdr.len != sizeof(ng_hci_acldata_pkt_t) + size) { + NG_HCI_ALERT( +"%s: %s - invalid HCI ACL data packet size, len=%d, length=%d\n", + __func__, NG_NODE_NAME(unit->node), + m->m_pkthdr.len, size); + + error = EMSGSIZE; + goto drop; + } + + /* Queue packet */ + con = ng_hci_con_by_handle(unit, con_handle); + if (con == NULL) { + NG_HCI_ERR( +"%s: %s - unexpected HCI ACL data packet. Connection does not exists, " \ +"con_handle=%d\n", __func__, NG_NODE_NAME(unit->node), con_handle); + + error = ENOENT; + goto drop; + } + + if (con->link_type != NG_HCI_LINK_ACL) { + NG_HCI_ERR( +"%s: %s - unexpected HCI ACL data packet. Not ACL link, con_handle=%d, " \ +"link_type=%d\n", __func__, NG_NODE_NAME(unit->node), + con_handle, con->link_type); + + error = EINVAL; + goto drop; + } + + if (con->state != NG_HCI_CON_OPEN) { + NG_HCI_ERR( +"%s: %s - unexpected HCI ACL data packet. Invalid connection state=%d, " \ +"con_handle=%d\n", __func__, NG_NODE_NAME(unit->node), + con->state, con_handle); + + error = EHOSTDOWN; + goto drop; + } + + if (NG_BT_ITEMQ_FULL(&con->conq)) { + NG_HCI_ALERT( +"%s: %s - dropping HCI ACL data packet, con_handle=%d, len=%d, queue_len=%d\n", + __func__, NG_NODE_NAME(unit->node), con_handle, + m->m_pkthdr.len, NG_BT_ITEMQ_LEN(&con->conq)); + + NG_BT_ITEMQ_DROP(&con->conq); + + error = ENOBUFS; + goto drop; + } + + /* Queue item and schedule data transfer */ + NGI_M(item) = m; + NG_BT_ITEMQ_ENQUEUE(&con->conq, item); + item = NULL; + m = NULL; + + ng_hci_send_data(unit); +drop: + if (item != NULL) + NG_FREE_ITEM(item); + + NG_FREE_M(m); /* NG_FREE_M() checks for m != NULL */ + + return (error); +} /* ng_hci_acl_rcvdata */ + +/* + * Process data packet from SCO upstream hook. + * We expect valid HCI SCO data packets + */ + +static int +ng_hci_sco_rcvdata(hook_p hook, item_p item) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + ng_hci_unit_con_p con = NULL; + u_int16_t con_handle; + int size, error = 0; + + NG_HCI_BUFF_SCO_SIZE(unit->buffer, size); + + /* Check packet */ + NGI_GET_M(item, m); + + if (*mtod(m, u_int8_t *) != NG_HCI_SCO_DATA_PKT) { + NG_HCI_ALERT( +"%s: %s - invalid HCI data packet type=%#x\n", + __func__, NG_NODE_NAME(unit->node), + *mtod(m, u_int8_t *)); + + error = EINVAL; + goto drop; + } + + if (m->m_pkthdr.len < sizeof(ng_hci_scodata_pkt_t) || + m->m_pkthdr.len > sizeof(ng_hci_scodata_pkt_t) + size) { + NG_HCI_ALERT( +"%s: %s - invalid HCI SCO data packet, len=%d, mtu=%d\n", + __func__, NG_NODE_NAME(unit->node), + m->m_pkthdr.len, size); + + error = EMSGSIZE; + goto drop; + } + + NG_HCI_M_PULLUP(m, sizeof(ng_hci_scodata_pkt_t)); + if (m == NULL) { + error = ENOBUFS; + goto drop; + } + + con_handle = NG_HCI_CON_HANDLE(le16toh( + mtod(m, ng_hci_scodata_pkt_t *)->con_handle)); + size = mtod(m, ng_hci_scodata_pkt_t *)->length; + + if (m->m_pkthdr.len != sizeof(ng_hci_scodata_pkt_t) + size) { + NG_HCI_ALERT( +"%s: %s - invalid HCI SCO data packet size, len=%d, length=%d\n", + __func__, NG_NODE_NAME(unit->node), + m->m_pkthdr.len, size); + + error = EMSGSIZE; + goto drop; + } + + /* Queue packet */ + con = ng_hci_con_by_handle(unit, con_handle); + if (con == NULL) { + NG_HCI_ERR( +"%s: %s - unexpected HCI SCO data packet. Connection does not exists, " \ +"con_handle=%d\n", __func__, NG_NODE_NAME(unit->node), con_handle); + + error = ENOENT; + goto drop; + } + + if (con->link_type != NG_HCI_LINK_SCO) { + NG_HCI_ERR( +"%s: %s - unexpected HCI SCO data packet. Not SCO link, con_handle=%d, " \ +"link_type=%d\n", __func__, NG_NODE_NAME(unit->node), + con_handle, con->link_type); + + error = EINVAL; + goto drop; + } + + if (con->state != NG_HCI_CON_OPEN) { + NG_HCI_ERR( +"%s: %s - unexpected HCI SCO data packet. Invalid connection state=%d, " \ +"con_handle=%d\n", __func__, NG_NODE_NAME(unit->node), + con->state, con_handle); + + error = EHOSTDOWN; + goto drop; + } + + if (NG_BT_ITEMQ_FULL(&con->conq)) { + NG_HCI_ALERT( +"%s: %s - dropping HCI SCO data packet, con_handle=%d, len=%d, queue_len=%d\n", + __func__, NG_NODE_NAME(unit->node), con_handle, + m->m_pkthdr.len, NG_BT_ITEMQ_LEN(&con->conq)); + + NG_BT_ITEMQ_DROP(&con->conq); + + error = ENOBUFS; + goto drop; + } + + /* Queue item and schedule data transfer */ + NGI_M(item) = m; + NG_BT_ITEMQ_ENQUEUE(&con->conq, item); + item = NULL; + m = NULL; + + ng_hci_send_data(unit); +drop: + if (item != NULL) + NG_FREE_ITEM(item); + + NG_FREE_M(m); /* NG_FREE_M() checks for m != NULL */ + + return (error); +} /* ng_hci_sco_rcvdata */ + +/* + * Process data packet from uptream RAW hook. + * We expect valid HCI command packets. + */ + +static int +ng_hci_raw_rcvdata(hook_p hook, item_p item) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + int error = 0; + + NGI_GET_M(item, m); + NG_FREE_ITEM(item); + + /* Check packet */ + if (*mtod(m, u_int8_t *) != NG_HCI_CMD_PKT) { + NG_HCI_ALERT( +"%s: %s - invalid HCI command packet type=%#x\n", + __func__, NG_NODE_NAME(unit->node), + *mtod(m, u_int8_t *)); + + error = EINVAL; + goto drop; + } + + if (m->m_pkthdr.len < sizeof(ng_hci_cmd_pkt_t)) { + NG_HCI_ALERT( +"%s: %s - invalid HCI command packet len=%d\n", + __func__, NG_NODE_NAME(unit->node), m->m_pkthdr.len); + + error = EMSGSIZE; + goto drop; + } + + NG_HCI_M_PULLUP(m, sizeof(ng_hci_cmd_pkt_t)); + if (m == NULL) { + error = ENOBUFS; + goto drop; + } + + if (m->m_pkthdr.len != + mtod(m, ng_hci_cmd_pkt_t *)->length + sizeof(ng_hci_cmd_pkt_t)) { + NG_HCI_ALERT( +"%s: %s - invalid HCI command packet size, len=%d, length=%d\n", + __func__, NG_NODE_NAME(unit->node), m->m_pkthdr.len, + mtod(m, ng_hci_cmd_pkt_t *)->length); + + error = EMSGSIZE; + goto drop; + } + + if (mtod(m, ng_hci_cmd_pkt_t *)->opcode == 0) { + NG_HCI_ALERT( +"%s: %s - invalid HCI command opcode\n", + __func__, NG_NODE_NAME(unit->node)); + + error = EINVAL; + goto drop; + } + + if (NG_BT_MBUFQ_FULL(&unit->cmdq)) { + NG_HCI_ALERT( +"%s: %s - dropping HCI command packet, len=%d, queue_len=%d\n", + __func__, NG_NODE_NAME(unit->node), m->m_pkthdr.len, + NG_BT_MBUFQ_LEN(&unit->cmdq)); + + NG_BT_MBUFQ_DROP(&unit->cmdq); + + error = ENOBUFS; + goto drop; + } + + /* Queue and send command */ + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + m = NULL; + + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + error = ng_hci_send_command(unit); +drop: + NG_FREE_M(m); /* NG_FREE_M() checks for m != NULL */ + + return (error); +} /* ng_hci_raw_rcvdata */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_misc.c b/sys/netgraph/bluetooth/hci/ng_hci_misc.c new file mode 100644 index 0000000..ba92f89 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_misc.c @@ -0,0 +1,556 @@ +/* + * ng_hci_misc.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_misc.c,v 1.18 2002/10/30 00:18:19 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_hci_var.h" +#include "ng_hci_cmds.h" +#include "ng_hci_evnt.h" +#include "ng_hci_ulpi.h" +#include "ng_hci_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** Utility routines + ****************************************************************************** + ******************************************************************************/ + +static void ng_hci_command_queue_timeout (void *); +static void ng_hci_con_queue_timeout (void *); +static void ng_hci_con_queue_watchdog_timeout (void *); + +/* + * Give packet to RAW hook + * Assumes input mbuf is read only. + */ + +void +ng_hci_mtap(ng_hci_unit_p unit, struct mbuf *m0) +{ + struct mbuf *m = NULL; + int error = 0; + + if (unit->raw != NULL && NG_HOOK_IS_VALID(unit->raw)) { + m = m_dup(m0, M_DONTWAIT); + if (m != NULL) + NG_SEND_DATA_ONLY(error, unit->raw, m); + + if (error != 0) + NG_HCI_INFO( +"%s: %s - Could not forward packet, error=%d\n", + __func__, NG_NODE_NAME(unit->node), error); + } +} /* ng_hci_mtap */ + +/* + * Send notification to the upper layer's + */ + +void +ng_hci_node_is_up(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_hci_unit_p unit = NULL; + struct ng_mesg *msg = NULL; + ng_hci_node_up_ep *ep = NULL; + int error; + + if (node == NULL || NG_NODE_NOT_VALID(node) || + hook == NULL || NG_HOOK_NOT_VALID(hook)) + return; + + unit = (ng_hci_unit_p) NG_NODE_PRIVATE(node); + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY) + return; + + if (hook != unit->acl && hook != unit->sco) + return; + + NG_MKMESSAGE(msg,NGM_HCI_COOKIE,NGM_HCI_NODE_UP,sizeof(*ep),M_NOWAIT); + if (msg != NULL) { + ep = (ng_hci_node_up_ep *)(msg->data); + + if (hook == unit->acl) { + NG_HCI_BUFF_ACL_SIZE(unit->buffer, ep->pkt_size); + NG_HCI_BUFF_ACL_TOTAL(unit->buffer, ep->num_pkts); + } else { + NG_HCI_BUFF_SCO_SIZE(unit->buffer, ep->pkt_size); + NG_HCI_BUFF_SCO_TOTAL(unit->buffer, ep->num_pkts); + } + + bcopy(&unit->bdaddr, &ep->bdaddr, sizeof(ep->bdaddr)); + + NG_SEND_MSG_HOOK(error, node, msg, hook, NULL); + } else + error = ENOMEM; + + if (error != 0) + NG_HCI_INFO( +"%s: %s - failed to send NODE_UP message to hook \"%s\", error=%d\n", + __func__, NG_NODE_NAME(unit->node), + NG_HOOK_NAME(hook), error); +} /* ng_hci_node_is_up */ + +/* + * Clean unit (helper) + */ + +void +ng_hci_unit_clean(ng_hci_unit_p unit, int reason) +{ + int size; + + /* Drain command queue */ + if (unit->state & NG_HCI_UNIT_COMMAND_PENDING) + ng_hci_command_untimeout(unit); + + NG_BT_MBUFQ_DRAIN(&unit->cmdq); + NG_HCI_BUFF_CMD_SET(unit->buffer, 1); + + /* Clean up connection list */ + while (!LIST_EMPTY(&unit->con_list)) { + ng_hci_unit_con_p con = LIST_FIRST(&unit->con_list); + + /* + * Notify upper layer protocol and destroy connection + * descriptor. Do not really care about the result. + */ + + ng_hci_lp_discon_ind(con, reason); + ng_hci_free_con(con); + } + + NG_HCI_BUFF_ACL_TOTAL(unit->buffer, size); + NG_HCI_BUFF_ACL_FREE(unit->buffer, size); + + NG_HCI_BUFF_SCO_TOTAL(unit->buffer, size); + NG_HCI_BUFF_SCO_FREE(unit->buffer, size); + + /* Clean up neighbors list */ + ng_hci_flush_neighbor_cache(unit); +} /* ng_hci_unit_clean */ + +/* + * Allocate and link new unit neighbor cache entry + */ + +ng_hci_neighbor_p +ng_hci_new_neighbor(ng_hci_unit_p unit) +{ + ng_hci_neighbor_p n = NULL; + + MALLOC(n, ng_hci_neighbor_p, sizeof(*n), M_NETGRAPH_HCI, + M_NOWAIT | M_ZERO); + if (n != NULL) { + getmicrotime(&n->updated); + LIST_INSERT_HEAD(&unit->neighbors, n, next); + } + + return (n); +} /* ng_hci_new_neighbor */ + +/* + * Free unit neighbor cache entry + */ + +void +ng_hci_free_neighbor(ng_hci_neighbor_p n) +{ + LIST_REMOVE(n, next); + bzero(n, sizeof(*n)); + FREE(n, M_NETGRAPH_HCI); +} /* ng_hci_free_neighbor */ + +/* + * Flush neighbor cache + */ + +void +ng_hci_flush_neighbor_cache(ng_hci_unit_p unit) +{ + while (!LIST_EMPTY(&unit->neighbors)) + ng_hci_free_neighbor(LIST_FIRST(&unit->neighbors)); +} /* ng_hci_flush_neighbor_cache */ + +/* + * Lookup unit in neighbor cache + */ + +ng_hci_neighbor_p +ng_hci_get_neighbor(ng_hci_unit_p unit, bdaddr_p bdaddr) +{ + ng_hci_neighbor_p n = NULL; + + for (n = LIST_FIRST(&unit->neighbors); n != NULL; ) { + ng_hci_neighbor_p nn = LIST_NEXT(n, next); + + if (!ng_hci_neighbor_stale(n)) { + if (bcmp(&n->bdaddr, bdaddr, sizeof(*bdaddr)) == 0) + break; + } else + ng_hci_free_neighbor(n); /* remove old entry */ + + n = nn; + } + + return (n); +} /* ng_hci_get_neighbor */ + +/* + * Check if neighbor entry is stale + */ + +int +ng_hci_neighbor_stale(ng_hci_neighbor_p n) +{ + struct timeval now; + + getmicrotime(&now); + + return (now.tv_sec - n->updated.tv_sec > bluetooth_hci_max_neighbor_age()); +} /* ng_hci_neighbor_stale */ + +/* + * Allocate and link new connection descriptor + */ + +ng_hci_unit_con_p +ng_hci_new_con(ng_hci_unit_p unit, int link_type) +{ + ng_hci_unit_con_p con = NULL; + int num_pkts; + + MALLOC(con, ng_hci_unit_con_p, sizeof(*con), M_NETGRAPH_HCI, + M_NOWAIT | M_ZERO); + if (con != NULL) { + con->unit = unit; + con->state = NG_HCI_CON_CLOSED; + con->link_type = link_type; + + if (con->link_type == NG_HCI_LINK_ACL) + NG_HCI_BUFF_ACL_TOTAL(unit->buffer, num_pkts); + else + NG_HCI_BUFF_SCO_TOTAL(unit->buffer, num_pkts); + + NG_BT_ITEMQ_INIT(&con->conq, num_pkts); + + callout_handle_init(&con->con_timo); + callout_handle_init(&con->watchdog_timo); + + LIST_INSERT_HEAD(&unit->con_list, con, next); + } + + return (con); +} /* ng_hci_new_con */ + +/* + * Free connection descriptor + */ + +void +ng_hci_free_con(ng_hci_unit_con_p con) +{ + LIST_REMOVE(con, next); + + /* Remove all timeouts (if any) */ + if (con->flags & NG_HCI_CON_TIMEOUT_PENDING) + ng_hci_con_untimeout(con); + + if (con->flags & NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING) + ng_hci_con_watchdog_untimeout(con); + + /* + * If we have pending packets then assume that Host Controller has + * flushed these packets and we can free them too + */ + + if (con->link_type == NG_HCI_LINK_ACL) + NG_HCI_BUFF_ACL_FREE(con->unit->buffer, con->pending); + else + NG_HCI_BUFF_SCO_FREE(con->unit->buffer, con->pending); + + NG_BT_ITEMQ_DESTROY(&con->conq); + + bzero(con, sizeof(*con)); + FREE(con, M_NETGRAPH_HCI); +} /* ng_hci_free_con */ + +/* + * Lookup connection for given unit and connection handle. + */ + +ng_hci_unit_con_p +ng_hci_con_by_handle(ng_hci_unit_p unit, int con_handle) +{ + ng_hci_unit_con_p con = NULL; + + LIST_FOREACH(con, &unit->con_list, next) + if (con->con_handle == con_handle) + break; + + return (con); +} /* ng_hci_con_by_handle */ + +/* + * Lookup connection for given unit, link type and remove unit address + */ + +ng_hci_unit_con_p +ng_hci_con_by_bdaddr(ng_hci_unit_p unit, bdaddr_p bdaddr, int link_type) +{ + ng_hci_unit_con_p con = NULL; + + LIST_FOREACH(con, &unit->con_list, next) + if (con->link_type == link_type && + bcmp(&con->bdaddr, bdaddr, sizeof(bdaddr_t)) == 0) + break; + + return (con); +} /* ng_hci_con_by_bdaddr */ + +/* + * Set HCI command timeout + */ + +void +ng_hci_command_timeout(ng_hci_unit_p unit) +{ + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) { + NG_NODE_REF(unit->node); + unit->state |= NG_HCI_UNIT_COMMAND_PENDING; + unit->cmd_timo = timeout(ng_hci_command_queue_timeout, unit, + bluetooth_hci_command_timeout()); + } else + KASSERT(0, +("%s: %s - Duplicated command timeout!\n", __func__, NG_NODE_NAME(unit->node))); +} /* ng_hci_command_timeout */ + +/* + * Unset HCI command timeout + */ + +void +ng_hci_command_untimeout(ng_hci_unit_p unit) +{ + if (unit->state & NG_HCI_UNIT_COMMAND_PENDING) { + unit->state &= ~NG_HCI_UNIT_COMMAND_PENDING; + untimeout(ng_hci_command_queue_timeout, unit, unit->cmd_timo); + NG_NODE_UNREF(unit->node); + } else + KASSERT(0, +("%s: %s - No command timeout!\n", __func__, NG_NODE_NAME(unit->node))); +} /* ng_hci_command_untimeout */ + +/* + * OK timeout has happend, so queue timeout processing function + */ + +static void +ng_hci_command_queue_timeout(void *context) +{ + ng_hci_unit_p unit = (ng_hci_unit_p) context; + node_p node = unit->node; + + if (NG_NODE_IS_VALID(node)) + ng_send_fn(node,NULL,&ng_hci_process_command_timeout,unit,0); + + NG_NODE_UNREF(node); +} /* ng_hci_command_queue_timeout */ + +/* + * Set HCI connection timeout + */ + +void +ng_hci_con_timeout(ng_hci_unit_con_p con) +{ + if (!(con->flags & NG_HCI_CON_TIMEOUT_PENDING)) { + NG_NODE_REF(con->unit->node); + con->flags |= NG_HCI_CON_TIMEOUT_PENDING; + con->con_timo = timeout(ng_hci_con_queue_timeout, con, + bluetooth_hci_connect_timeout()); + } else + KASSERT(0, +("%s: %s - Duplicated connection timeout!\n", + __func__, NG_NODE_NAME(con->unit->node))); +} /* ng_hci_con_timeout */ + +/* + * Unset HCI connection timeout + */ + +void +ng_hci_con_untimeout(ng_hci_unit_con_p con) +{ + if (con->flags & NG_HCI_CON_TIMEOUT_PENDING) { + con->flags &= ~NG_HCI_CON_TIMEOUT_PENDING; + untimeout(ng_hci_con_queue_timeout, con, con->con_timo); + NG_NODE_UNREF(con->unit->node); + } else + KASSERT(0, +("%s: %s - No connection timeout!\n", __func__, NG_NODE_NAME(con->unit->node))); +} /* ng_hci_con_untimeout */ + +/* + * OK timeout has happend, so queue timeout processing function + */ + +static void +ng_hci_con_queue_timeout(void *context) +{ + ng_hci_unit_con_p con = (ng_hci_unit_con_p) context; + node_p node = con->unit->node; + + if (NG_NODE_IS_VALID(node)) + ng_send_fn(node, NULL, &ng_hci_process_con_timeout, con, 0); + + NG_NODE_UNREF(node); +} /* ng_hci_con_queue_timeout */ + +/* + * Set HCI connection watchdog timeout + */ + +void +ng_hci_con_watchdog_timeout(ng_hci_unit_con_p con) +{ + if (!(con->flags & NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING)) { + NG_NODE_REF(con->unit->node); + con->flags |= NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING; + con->watchdog_timo = timeout(ng_hci_con_queue_watchdog_timeout, + con, bluetooth_hci_watchdog_timeout()); + } else + KASSERT(0, +("%s: %s - Duplicated connection watchdog timeout!\n", + __func__, NG_NODE_NAME(con->unit->node))); +} /* ng_hci_con_watchdog_timeout */ + +/* + * Unset HCI connection watchdog timeout + */ + +void +ng_hci_con_watchdog_untimeout(ng_hci_unit_con_p con) +{ + if (con->flags & NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING) { + con->flags &= ~NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING; + untimeout(ng_hci_con_queue_watchdog_timeout, con, + con->watchdog_timo); + NG_NODE_UNREF(con->unit->node); + } else + KASSERT(0, +("%s: %s - No connection watchdog timeout!\n", + __func__, NG_NODE_NAME(con->unit->node))); +} /* ng_hci_con_watchdog_untimeout */ + +/* + * OK timeout has happend, so queue timeout processing function + */ + +static void +ng_hci_con_queue_watchdog_timeout(void *context) +{ + ng_hci_unit_con_p con = (ng_hci_unit_con_p) context; + node_p node = con->unit->node; + + if (NG_NODE_IS_VALID(node)) + ng_send_fn(node, NULL, &ng_hci_process_con_watchdog_timeout, + con, 0); + + NG_NODE_UNREF(node); +} /* ng_hci_con_queue_watchdog_timeout */ + +#if 0 +/* + * Convert numeric error code/reason to a string + */ + +char const * const +ng_hci_str_error(u_int16_t code) +{ +#define LAST_ERROR_CODE ((sizeof(s)/sizeof(s[0]))-1) + static char const * const s[] = { + /* 0x00 */ "No error", + /* 0x01 */ "Unknown HCI command", + /* 0x02 */ "No connection", + /* 0x03 */ "Hardware failure", + /* 0x04 */ "Page timeout", + /* 0x05 */ "Authentication failure", + /* 0x06 */ "Key missing", + /* 0x07 */ "Memory full", + /* 0x08 */ "Connection timeout", + /* 0x09 */ "Max number of connections", + /* 0x0a */ "Max number of SCO connections to a unit", + /* 0x0b */ "ACL connection already exists", + /* 0x0c */ "Command disallowed", + /* 0x0d */ "Host rejected due to limited resources", + /* 0x0e */ "Host rejected due to securiity reasons", + /* 0x0f */ "Host rejected due to remote unit is a personal unit", + /* 0x10 */ "Host timeout", + /* 0x11 */ "Unsupported feature or parameter value", + /* 0x12 */ "Invalid HCI command parameter", + /* 0x13 */ "Other end terminated connection: User ended connection", + /* 0x14 */ "Other end terminated connection: Low resources", + /* 0x15 */ "Other end terminated connection: About to power off", + /* 0x16 */ "Connection terminated by local host", + /* 0x17 */ "Repeated attempts", + /* 0x18 */ "Pairing not allowed", + /* 0x19 */ "Unknown LMP PDU", + /* 0x1a */ "Unsupported remote feature", + /* 0x1b */ "SCO offset rejected", + /* 0x1c */ "SCO interval rejected", + /* 0x1d */ "SCO air mode rejected", + /* 0x1e */ "Invalid LMP parameters", + /* 0x1f */ "Unspecified error", + /* 0x20 */ "Unsupported LMP parameter value", + /* 0x21 */ "Role change not allowed", + /* 0x22 */ "LMP response timeout", + /* 0x23 */ "LMP error transaction collision", + /* 0x24 */ "LMP PSU not allowed", + /* 0x25 */ "Encryption mode not acceptable", + /* 0x26 */ "Unit key used", + /* 0x27 */ "QoS is not supported", + /* 0x28 */ "Instant passed", + /* 0x29 */ "Paring with unit key not supported", + /* SHOULD ALWAYS BE LAST */ "Unknown error" + }; + + return ((code >= LAST_ERROR_CODE)? s[LAST_ERROR_CODE] : s[code]); +} /* ng_hci_str_error */ +#endif + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_misc.h b/sys/netgraph/bluetooth/hci/ng_hci_misc.h new file mode 100644 index 0000000..862d7db --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_misc.h @@ -0,0 +1,58 @@ +/* + * ng_hci_misc.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_misc.h,v 1.8 2002/09/04 21:36:52 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_HCI_MISC_H_ +#define _NETGRAPH_HCI_MISC_H_ 1 + +void ng_hci_mtap (ng_hci_unit_p, struct mbuf *); +void ng_hci_node_is_up (node_p, hook_p, void *, int); +void ng_hci_unit_clean (ng_hci_unit_p, int); + +ng_hci_neighbor_p ng_hci_new_neighbor (ng_hci_unit_p); +void ng_hci_free_neighbor (ng_hci_neighbor_p); +void ng_hci_flush_neighbor_cache (ng_hci_unit_p); +ng_hci_neighbor_p ng_hci_get_neighbor (ng_hci_unit_p, bdaddr_p); +int ng_hci_neighbor_stale (ng_hci_neighbor_p); + +ng_hci_unit_con_p ng_hci_new_con (ng_hci_unit_p, int); +void ng_hci_free_con (ng_hci_unit_con_p); +ng_hci_unit_con_p ng_hci_con_by_handle (ng_hci_unit_p, int); +ng_hci_unit_con_p ng_hci_con_by_bdaddr (ng_hci_unit_p, bdaddr_p, int); + +void ng_hci_command_timeout (ng_hci_unit_p); +void ng_hci_command_untimeout (ng_hci_unit_p); +void ng_hci_con_timeout (ng_hci_unit_con_p); +void ng_hci_con_untimeout (ng_hci_unit_con_p); +void ng_hci_con_watchdog_timeout (ng_hci_unit_con_p); +void ng_hci_con_watchdog_untimeout (ng_hci_unit_con_p); + +#endif /* ndef _NETGRAPH_HCI_MISC_H_ */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_prse.h b/sys/netgraph/bluetooth/hci/ng_hci_prse.h new file mode 100644 index 0000000..4c4bd6e --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_prse.h @@ -0,0 +1,203 @@ +/* + * ng_hci_prse.h + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_prse.h,v 1.9 2002/11/12 22:35:40 max Exp $ + * $FreeBSD$ + */ + +/*************************************************************************** + *************************************************************************** + ** ng_parse definitions for the HCI node + *************************************************************************** + ***************************************************************************/ + +#ifndef _NETGRAPH_HCI_PRSE_H_ +#define _NETGRAPH_HCI_PRSE_H_ 1 + +/* BDADDR */ +static const struct ng_parse_fixedarray_info ng_hci_bdaddr_type_info = { + &ng_parse_uint8_type, + NG_HCI_BDADDR_SIZE +}; +static const struct ng_parse_type ng_hci_bdaddr_type = { + &ng_parse_fixedarray_type, + &ng_hci_bdaddr_type_info +}; + +/* Features */ +static const struct ng_parse_fixedarray_info ng_hci_features_type_info = { + &ng_parse_uint8_type, + NG_HCI_FEATURES_SIZE +}; +static const struct ng_parse_type ng_hci_features_type = { + &ng_parse_fixedarray_type, + &ng_hci_features_type_info +}; + +/* Buffer info */ +static const struct ng_parse_struct_field ng_hci_buffer_type_fields[] = +{ + { "cmd_free", &ng_parse_uint8_type, }, + { "sco_size", &ng_parse_uint8_type, }, + { "sco_pkts", &ng_parse_uint16_type, }, + { "sco_free", &ng_parse_uint16_type, }, + { "acl_size", &ng_parse_uint16_type, }, + { "acl_pkts", &ng_parse_uint16_type, }, + { "acl_free", &ng_parse_uint16_type, }, + { NULL, } +}; +static const struct ng_parse_type ng_hci_buffer_type = { + &ng_parse_struct_type, + &ng_hci_buffer_type_fields +}; + +/* Stat info */ +static const struct ng_parse_struct_field ng_hci_stat_type_fields[] = +{ + { "cmd_sent", &ng_parse_uint32_type, }, + { "evnt_recv", &ng_parse_uint32_type, }, + { "acl_recv", &ng_parse_uint32_type, }, + { "acl_sent", &ng_parse_uint32_type, }, + { "sco_recv", &ng_parse_uint32_type, }, + { "sco_sent", &ng_parse_uint32_type, }, + { "bytes_recv", &ng_parse_uint32_type, }, + { "bytes_sent", &ng_parse_uint32_type, }, + { NULL, } +}; +static const struct ng_parse_type ng_hci_stat_type = { + &ng_parse_struct_type, + &ng_hci_stat_type_fields +}; + +/* + * HCI node command list + */ + +static const struct ng_cmdlist ng_hci_cmdlist[] = { + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_STATE, + "get_state", + NULL, + &ng_parse_uint16_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_INIT, + "init", + NULL, + NULL + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_DEBUG, + "get_debug", + NULL, + &ng_parse_uint16_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_SET_DEBUG, + "set_debug", + &ng_parse_uint16_type, + NULL + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_BUFFER, + "get_buff_info", + NULL, + &ng_hci_buffer_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_BDADDR, + "get_bdaddr", + NULL, + &ng_hci_bdaddr_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_FEATURES, + "get_features", + NULL, + &ng_hci_features_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_STAT, + "get_stat", + NULL, + &ng_hci_stat_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_RESET_STAT, + "reset_stat", + NULL, + NULL + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE, + "flush_ncache", + NULL, + NULL + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK, + "get_lm_mask", + NULL, + &ng_parse_uint16_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK, + "set_lm_mask", + &ng_parse_uint16_type, + NULL + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_PACKET_MASK, + "get_pkt_mask", + NULL, + &ng_parse_uint16_type + }, + { + NGM_HCI_COOKIE, + NGM_HCI_NODE_SET_PACKET_MASK, + "set_pkt_mask", + &ng_parse_uint16_type, + NULL + }, + { 0, } +}; + +#endif /* ndef _NETGRAPH_HCI_PRSE_H_ */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_ulpi.c b/sys/netgraph/bluetooth/hci/ng_hci_ulpi.c new file mode 100644 index 0000000..97a0ea8 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_ulpi.c @@ -0,0 +1,1280 @@ +/* + * ng_hci_ulpi.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_ulpi.c,v 1.14 2002/11/12 22:35:40 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_hci_var.h" +#include "ng_hci_cmds.h" +#include "ng_hci_evnt.h" +#include "ng_hci_ulpi.h" +#include "ng_hci_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** Upper Layer Protocol Interface module + ****************************************************************************** + ******************************************************************************/ + +static int ng_hci_lp_acl_con_req (ng_hci_unit_p, item_p, hook_p); +static int ng_hci_lp_sco_con_req (ng_hci_unit_p, item_p, hook_p); + +/* + * Process LP_ConnectReq event from the upper layer protocol + */ + +int +ng_hci_lp_con_req(ng_hci_unit_p unit, item_p item, hook_p hook) +{ + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY) { + NG_HCI_WARN( +"%s: %s - unit is not ready, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), unit->state); + + NG_FREE_ITEM(item); + + return (ENXIO); + } + + if (NGI_MSG(item)->header.arglen != sizeof(ng_hci_lp_con_req_ep)) { + NG_HCI_ALERT( +"%s: %s - invalid LP_ConnectReq message size=%d\n", + __func__, NG_NODE_NAME(unit->node), + NGI_MSG(item)->header.arglen); + + NG_FREE_ITEM(item); + + return (EMSGSIZE); + } + + if (((ng_hci_lp_con_req_ep *)(NGI_MSG(item)->data))->link_type == NG_HCI_LINK_ACL) + return (ng_hci_lp_acl_con_req(unit, item, hook)); + + if (hook != unit->sco) { + NG_HCI_WARN( +"%s: %s - LP_ConnectReq for SCO connection came from wrong hook=%p\n", + __func__, NG_NODE_NAME(unit->node), hook); + + NG_FREE_ITEM(item); + + return (EINVAL); + } + + return (ng_hci_lp_sco_con_req(unit, item, hook)); +} /* ng_hci_lp_con_req */ + +/* + * Request to create new ACL connection + */ + +static int +ng_hci_lp_acl_con_req(ng_hci_unit_p unit, item_p item, hook_p hook) +{ + struct acl_con_req { + ng_hci_cmd_pkt_t hdr; + ng_hci_create_con_cp cp; + } __attribute__ ((packed)) *req = NULL; + ng_hci_lp_con_req_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + ng_hci_neighbor_t *n = NULL; + struct mbuf *m = NULL; + int error = 0; + + ep = (ng_hci_lp_con_req_ep *)(NGI_MSG(item)->data); + + /* + * Only one ACL connection can exist between each pair of units. + * So try to find ACL connection descriptor (in any state) that + * has requested remote BD_ADDR. + * + * Two cases: + * + * 1) We do not have connection to the remote unit. This is simple. + * Just create new connection descriptor and send HCI command to + * create new connection. + * + * 2) We do have connection descriptor. We need to check connection + * state: + * + * 2.1) NG_HCI_CON_CLOSED mean we are in the process of closing + * connection to the remote unit. We will reject connection + * request until connection is closed. + * + * 2.2) NG_HCI_CON_W4_LP_CON_RSP means that we are in the middle of + * accepting connection from the remote unit. This is a race + * condition. We will ignore this message. + * + * 2.3) NG_HCI_CON_W4_CONN_COMPLETE means that upper layer already + * requested connection or we just accepted it. In any case + * all we need to do here is set appropriate notification bit + * and wait. + * + * 2.4) NG_HCI_CON_OPEN means connection is open. Just reply back + * and let upper layer know that we have connection already. + */ + + con = ng_hci_con_by_bdaddr(unit, &ep->bdaddr, NG_HCI_LINK_ACL); + if (con != NULL) { + switch (con->state) { + case NG_HCI_CON_CLOSED: + error = EBUSY; + break; + + case NG_HCI_CON_W4_LP_CON_RSP: /* XXX */ + error = EALREADY; + break; + + case NG_HCI_CON_W4_CONN_COMPLETE: + if (hook == unit->acl) + con->flags |= NG_HCI_CON_NOTIFY_ACL; + else + con->flags |= NG_HCI_CON_NOTIFY_SCO; + break; + + case NG_HCI_CON_OPEN: { + struct ng_mesg *msg = NULL; + ng_hci_lp_con_cfm_ep *cfm = NULL; + + if (hook != NULL && NG_HOOK_IS_VALID(hook)) { + NGI_GET_MSG(item, msg); + NG_FREE_MSG(msg); + + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, + NGM_HCI_LP_CON_CFM, sizeof(*cfm), + M_NOWAIT); + if (msg != NULL) { + cfm = (ng_hci_lp_con_cfm_ep *)msg->data; + cfm->status = 0; + cfm->link_type = con->link_type; + cfm->con_handle = con->con_handle; + bcopy(&con->bdaddr, &cfm->bdaddr, + sizeof(cfm->bdaddr)); + + /* + * This will forward item back to + * sender and set item to NULL + */ + + _NGI_MSG(item) = msg; + NG_FWD_ITEM_HOOK(error, item, hook); + } else + error = ENOMEM; + } else + NG_HCI_INFO( +"%s: %s - Source hook is not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), + hook); + } break; + + default: + KASSERT(0, +("%s: %s - Invalid connection state=%d\n", + __func__, NG_NODE_NAME(unit->node),con->state)); + + error = EINVAL; + break; + } + + goto out; + } + + /* + * If we got here then we need to create new ACL connection descriptor + * and submit HCI command. First create new connection desriptor, set + * bdaddr and notification flags. + */ + + con = ng_hci_new_con(unit, NG_HCI_LINK_ACL); + if (con == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&ep->bdaddr, &con->bdaddr, sizeof(con->bdaddr)); + + /* + * Create HCI command + */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + ng_hci_free_con(con); + error = ENOBUFS; + goto out; + } + + m->m_pkthdr.len = m->m_len = sizeof(*req); + req = mtod(m, struct acl_con_req *); + req->hdr.type = NG_HCI_CMD_PKT; + req->hdr.length = sizeof(req->cp); + req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_CREATE_CON)); + + bcopy(&ep->bdaddr, &req->cp.bdaddr, sizeof(req->cp.bdaddr)); + + req->cp.pkt_type = (NG_HCI_PKT_DM1|NG_HCI_PKT_DH1); + if (unit->features[0] & NG_HCI_LMP_3SLOT) + req->cp.pkt_type |= (NG_HCI_PKT_DM3|NG_HCI_PKT_DH3); + if (unit->features[0] & NG_HCI_LMP_5SLOT) + req->cp.pkt_type |= (NG_HCI_PKT_DM5|NG_HCI_PKT_DH5); + + req->cp.pkt_type &= unit->packet_mask; + if (req->cp.pkt_type == 0) + req->cp.pkt_type = (NG_HCI_PKT_DM1|NG_HCI_PKT_DH1); + + req->cp.pkt_type = htole16(req->cp.pkt_type); + + if (unit->features[0] & NG_HCI_LMP_SWITCH) + req->cp.accept_role_switch = 1; + else + req->cp.accept_role_switch = 0; + + /* + * We may speed up connect by specifying valid parameters. + * So check the neighbor cache. + */ + + n = ng_hci_get_neighbor(unit, &ep->bdaddr); + if (n == NULL) { + req->cp.page_scan_rep_mode = 0; + req->cp.page_scan_mode = 0; + req->cp.clock_offset = 0; + } else { + req->cp.page_scan_rep_mode = n->page_scan_rep_mode; + req->cp.page_scan_mode = n->page_scan_mode; + req->cp.clock_offset = htole16(n->clock_offset); + } + + /* + * Adust connection state + */ + + if (hook == unit->acl) + con->flags |= NG_HCI_CON_NOTIFY_ACL; + else + con->flags |= NG_HCI_CON_NOTIFY_SCO; + + con->state = NG_HCI_CON_W4_CONN_COMPLETE; + ng_hci_con_timeout(con); + + /* + * Queue and send HCI command + */ + + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + error = ng_hci_send_command(unit); +out: + if (item != NULL) + NG_FREE_ITEM(item); + + return (error); +} /* ng_hci_lp_acl_con_req */ + +/* + * Request to create new SCO connection + */ + +static int +ng_hci_lp_sco_con_req(ng_hci_unit_p unit, item_p item, hook_p hook) +{ + struct sco_con_req { + ng_hci_cmd_pkt_t hdr; + ng_hci_add_sco_con_cp cp; + } __attribute__ ((packed)) *req = NULL; + ng_hci_lp_con_req_ep *ep = NULL; + ng_hci_unit_con_p acl_con = NULL, sco_con = NULL; + struct mbuf *m = NULL; + int error = 0; + + ep = (ng_hci_lp_con_req_ep *)(NGI_MSG(item)->data); + + /* + * SCO connection without ACL link + * + * If upper layer requests SCO connection and there is no open ACL + * connection to the desired remote unit, we will reject the request. + */ + + LIST_FOREACH(acl_con, &unit->con_list, next) + if (acl_con->link_type == NG_HCI_LINK_ACL && + acl_con->state == NG_HCI_CON_OPEN && + bcmp(&acl_con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0) + break; + + if (acl_con == NULL) { + NG_HCI_INFO( +"%s: %s - No open ACL connection to bdaddr=%x:%x:%x:%x:%x:%x\n", + __func__, NG_NODE_NAME(unit->node), + ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3], + ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]); + + error = ENOENT; + goto out; + } + + /* + * Multiple SCO connections can exist between the same pair of units. + * We assume that multiple SCO connections have to be opened one after + * another. + * + * Try to find SCO connection descriptor that matches the following: + * + * 1) sco_con->link_type == NG_HCI_LINK_SCO + * + * 2) sco_con->state == NG_HCI_CON_W4_LP_CON_RSP || + * sco_con->state == NG_HCI_CON_W4_CONN_COMPLETE + * + * 3) sco_con->bdaddr == ep->bdaddr + * + * Two cases: + * + * 1) We do not have connection descriptor. This is simple. Just + * create new connection and submit Add_SCO_Connection command. + * + * 2) We do have connection descriptor. We need to check the state. + * + * 2.1) NG_HCI_CON_W4_LP_CON_RSP means we in the middle of accepting + * connection from the remote unit. This is a race condition and + * we will ignore the request. + * + * 2.2) NG_HCI_CON_W4_CONN_COMPLETE means upper layer already requested + * connection or we just accepted it. + * + * XXX FIXME what to do with connection(s) in CLOSED state? + */ + + LIST_FOREACH(sco_con, &unit->con_list, next) + if (sco_con->link_type == NG_HCI_LINK_SCO && + (sco_con->state == NG_HCI_CON_W4_LP_CON_RSP || + sco_con->state == NG_HCI_CON_W4_CONN_COMPLETE) && + bcmp(&sco_con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0) + break; + + if (sco_con != NULL) { + switch (sco_con->state) { + case NG_HCI_CON_W4_LP_CON_RSP: /* XXX */ + error = EALREADY; + break; + + case NG_HCI_CON_W4_CONN_COMPLETE: + sco_con->flags |= NG_HCI_CON_NOTIFY_SCO; + break; + + default: + KASSERT(0, +("%s: %s - Inavalid connection state=%d\n", + __func__, NG_NODE_NAME(unit->node), + sco_con->state)); + + error = EINVAL; + break; + } + + goto out; + } + + /* + * If we got here then we need to create new SCO connection descriptor + * and submit HCI command. + */ + + sco_con = ng_hci_new_con(unit, NG_HCI_LINK_SCO); + if (sco_con == NULL) { + error = ENOMEM; + goto out; + } + + bcopy(&ep->bdaddr, &sco_con->bdaddr, sizeof(sco_con->bdaddr)); + + /* + * Create HCI command + */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + ng_hci_free_con(sco_con); + error = ENOBUFS; + goto out; + } + + m->m_pkthdr.len = m->m_len = sizeof(*req); + req = mtod(m, struct sco_con_req *); + req->hdr.type = NG_HCI_CMD_PKT; + req->hdr.length = sizeof(req->cp); + req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_ADD_SCO_CON)); + + req->cp.con_handle = htole16(acl_con->con_handle); + + req->cp.pkt_type = NG_HCI_PKT_HV1; + if (unit->features[1] & NG_HCI_LMP_HV2_PKT) + req->cp.pkt_type |= NG_HCI_PKT_HV2; + if (unit->features[1] & NG_HCI_LMP_HV3_PKT) + req->cp.pkt_type |= NG_HCI_PKT_HV3; + + req->cp.pkt_type &= unit->packet_mask; + if (req->cp.pkt_type == 0) + req->cp.pkt_type = NG_HCI_PKT_HV1; + + req->cp.pkt_type = htole16(req->cp.pkt_type); + + /* + * Adust connection state + */ + + sco_con->flags |= NG_HCI_CON_NOTIFY_SCO; + + sco_con->state = NG_HCI_CON_W4_CONN_COMPLETE; + ng_hci_con_timeout(sco_con); + + /* + * Queue and send HCI command + */ + + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + error = ng_hci_send_command(unit); +out: + NG_FREE_ITEM(item); + + return (error); +} /* ng_hci_lp_sco_con_req */ + +/* + * Process LP_DisconnectReq event from the upper layer protocol + * + * XXX XXX XXX + * + * NOTE: This is NOT defined by Bluetooth specification (why?) But i think + * this might be useful (at least for testing), so please do not depend on + * this interface. + */ + +int +ng_hci_lp_discon_req(ng_hci_unit_p unit, item_p item, hook_p hook) +{ + struct discon_req { + ng_hci_cmd_pkt_t hdr; + ng_hci_discon_cp cp; + } __attribute__ ((packed)) *req = NULL; + ng_hci_lp_discon_req_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + struct mbuf *m = NULL; + int error = 0; + + /* Check if unit is ready */ + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY) { + NG_HCI_WARN( +"%s: %s - unit is not ready, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), unit->state); + + error = ENXIO; + goto out; + } + + if (NGI_MSG(item)->header.arglen != sizeof(*ep)) { + NG_HCI_ALERT( +"%s: %s - invalid LP_DisconnectReq message size=%d\n", + __func__, NG_NODE_NAME(unit->node), + NGI_MSG(item)->header.arglen); + + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_discon_req_ep *)(NGI_MSG(item)->data); + + con = ng_hci_con_by_handle(unit, ep->con_handle); + if (con == NULL) { + NG_HCI_ERR( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), ep->con_handle); + + error = ENOENT; + goto out; + } + + if (con->state != NG_HCI_CON_OPEN) { + NG_HCI_ERR( +"%s: %s - invalid connection state=%d, handle=%d\n", + __func__, NG_NODE_NAME(unit->node), con->state, + ep->con_handle); + + error = EINVAL; + goto out; + } + + /* + * Create HCI command + */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + error = ENOBUFS; + goto out; + } + + m->m_pkthdr.len = m->m_len = sizeof(*req); + req = mtod(m, struct discon_req *); + req->hdr.type = NG_HCI_CMD_PKT; + req->hdr.length = sizeof(req->cp); + req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_DISCON)); + + req->cp.con_handle = htole16(ep->con_handle); + req->cp.reason = ep->reason; + + /* + * Adjust connection state + */ + + con->state = NG_HCI_CON_CLOSED; + ng_hci_con_timeout(con); + + /* + * Queue and send HCI command + */ + + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + error = ng_hci_send_command(unit); +out: + NG_FREE_ITEM(item); + + return (error); +} /* ng_hci_lp_discon_req */ + +/* + * Send LP_ConnectCfm event to the upper layer protocol + */ + +int +ng_hci_lp_con_cfm(ng_hci_unit_con_p con, int status) +{ + ng_hci_unit_p unit = con->unit; + struct ng_mesg *msg = NULL; + ng_hci_lp_con_cfm_ep *ep = NULL; + int error; + + /* + * Check who wants to be notified. For ACL links both ACL and SCO + * upstream hooks will be notified (if required). For SCO links + * only SCO upstream hook will receive notification + */ + + if (con->link_type == NG_HCI_LINK_ACL && + con->flags & NG_HCI_CON_NOTIFY_ACL) { + if (unit->acl != NULL && NG_HOOK_IS_VALID(unit->acl)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_CFM, + sizeof(*ep), M_NOWAIT); + if (msg != NULL) { + ep = (ng_hci_lp_con_cfm_ep *) msg->data; + ep->status = status; + ep->link_type = con->link_type; + ep->con_handle = con->con_handle; + bcopy(&con->bdaddr, &ep->bdaddr, + sizeof(ep->bdaddr)); + + NG_SEND_MSG_HOOK(error, unit->node, msg, + unit->acl, NULL); + } + } else + NG_HCI_INFO( +"%s: %s - ACL hook not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->acl); + + con->flags &= ~NG_HCI_CON_NOTIFY_ACL; + } + + if (con->flags & NG_HCI_CON_NOTIFY_SCO) { + if (unit->sco != NULL && NG_HOOK_IS_VALID(unit->sco)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_CFM, + sizeof(*ep), M_NOWAIT); + if (msg != NULL) { + ep = (ng_hci_lp_con_cfm_ep *) msg->data; + ep->status = status; + ep->link_type = con->link_type; + ep->con_handle = con->con_handle; + bcopy(&con->bdaddr, &ep->bdaddr, + sizeof(ep->bdaddr)); + + NG_SEND_MSG_HOOK(error, unit->node, msg, + unit->sco, NULL); + } + } else + NG_HCI_INFO( +"%s: %s - SCO hook not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->acl); + + con->flags &= ~NG_HCI_CON_NOTIFY_SCO; + } + + return (0); +} /* ng_hci_lp_con_cfm */ + +/* + * Send LP_ConnectInd event to the upper layer protocol + */ + +int +ng_hci_lp_con_ind(ng_hci_unit_con_p con, u_int8_t *uclass) +{ + ng_hci_unit_p unit = con->unit; + struct ng_mesg *msg = NULL; + ng_hci_lp_con_ind_ep *ep = NULL; + hook_p hook = NULL; + int error = 0; + + /* + * Connection_Request event is generated for specific link type. + * Use link_type to select upstream hook. + */ + + if (con->link_type == NG_HCI_LINK_ACL) + hook = unit->acl; + else + hook = unit->sco; + + if (hook != NULL && NG_HOOK_IS_VALID(hook)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_IND, + sizeof(*ep), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + ep = (ng_hci_lp_con_ind_ep *)(msg->data); + ep->link_type = con->link_type; + bcopy(uclass, ep->uclass, sizeof(ep->uclass)); + bcopy(&con->bdaddr, &ep->bdaddr, sizeof(ep->bdaddr)); + + NG_SEND_MSG_HOOK(error, unit->node, msg, hook, NULL); + } else { + NG_HCI_WARN( +"%s: %s - Upstream hook is not connected or not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), hook); + + error = ENOTCONN; + } + + return (error); +} /* ng_hci_lp_con_ind */ + +/* + * Process LP_ConnectRsp event from the upper layer protocol + */ + +int +ng_hci_lp_con_rsp(ng_hci_unit_p unit, item_p item, hook_p hook) +{ + struct con_rsp_req { + ng_hci_cmd_pkt_t hdr; + union { + ng_hci_accept_con_cp acc; + ng_hci_reject_con_cp rej; + } __attribute__ ((packed)) cp; + } __attribute__ ((packed)) *req = NULL; + ng_hci_lp_con_rsp_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + struct mbuf *m = NULL; + int error = 0; + + /* Check if unit is ready */ + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY) { + NG_HCI_WARN( +"%s: %s - unit is not ready, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), unit->state); + + error = ENXIO; + goto out; + } + + if (NGI_MSG(item)->header.arglen != sizeof(*ep)) { + NG_HCI_ALERT( +"%s: %s - invalid LP_ConnectRsp message size=%d\n", + __func__, NG_NODE_NAME(unit->node), + NGI_MSG(item)->header.arglen); + + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_con_rsp_ep *)(NGI_MSG(item)->data); + + /* + * Here we have to deal with race. Upper layers might send conflicting + * requests. One might send Accept and other Reject. We will not try + * to solve all the problems, so first request will always win. + * + * Try to find connection that matches the following: + * + * 1) con->link_type == ep->link_type + * + * 2) con->state == NG_HCI_CON_W4_LP_CON_RSP || + * con->state == NG_HCI_CON_W4_CONN_COMPLETE + * + * 3) con->bdaddr == ep->bdaddr + * + * Two cases: + * + * 1) We do not have connection descriptor. Could be bogus request or + * we have rejected connection already. + * + * 2) We do have connection descriptor. Then we need to check state: + * + * 2.1) NG_HCI_CON_W4_LP_CON_RSP means upper layer has requested + * connection and it is a first response from the upper layer. + * if "status == 0" (Accept) then we will send Accept_Connection + * command and change connection state to W4_CONN_COMPLETE, else + * send reject and delete connection. + * + * 2.2) NG_HCI_CON_W4_CONN_COMPLETE means that we already accepted + * connection. If "status == 0" we just need to link request + * and wait, else ignore Reject request. + */ + + LIST_FOREACH(con, &unit->con_list, next) + if (con->link_type == ep->link_type && + (con->state == NG_HCI_CON_W4_LP_CON_RSP || + con->state == NG_HCI_CON_W4_CONN_COMPLETE) && + bcmp(&con->bdaddr, &ep->bdaddr, sizeof(bdaddr_t)) == 0) + break; + + if (con == NULL) { + /* Reject for non-existing connection is fine */ + error = (ep->status == 0)? ENOENT : 0; + goto out; + } + + /* + * Remove connection timeout and check connection state + */ + + ng_hci_con_untimeout(con); + + switch (con->state) { + case NG_HCI_CON_W4_LP_CON_RSP: + + /* + * Create HCI command + */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + error = ENOBUFS; + goto out; + } + + req = mtod(m, struct con_rsp_req *); + req->hdr.type = NG_HCI_CMD_PKT; + + if (ep->status == 0) { + req->hdr.length = sizeof(req->cp.acc); + req->hdr.opcode = htole16(NG_HCI_OPCODE( + NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_ACCEPT_CON)); + + bcopy(&ep->bdaddr, &req->cp.acc.bdaddr, + sizeof(req->cp.acc.bdaddr)); + + /* + * XXX should be configurable? + * + * We are accepting connection, so if we support role + * switch then set role to NG_HCI_ROLE_MASTER and let + * LM peform role switch. Otherwise it is probably + * makes sense to remain slave. In this case LM WILL + * NOT perform role switch. + */ + + if (unit->features[0] & NG_HCI_LMP_SWITCH) + req->cp.acc.role = NG_HCI_ROLE_MASTER; + else + req->cp.acc.role = NG_HCI_ROLE_SLAVE; + + /* + * Adjust connection state + */ + + if (hook == unit->acl) + con->flags |= NG_HCI_CON_NOTIFY_ACL; + else + con->flags |= NG_HCI_CON_NOTIFY_SCO; + + con->state = NG_HCI_CON_W4_CONN_COMPLETE; + ng_hci_con_timeout(con); + } else { + req->hdr.length = sizeof(req->cp.rej); + req->hdr.opcode = htole16(NG_HCI_OPCODE( + NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_REJECT_CON)); + + bcopy(&ep->bdaddr, &req->cp.rej.bdaddr, + sizeof(req->cp.rej.bdaddr)); + + req->cp.rej.reason = ep->status; + + /* + * Free connection descritor + * Item will be deleted just before return. + */ + + ng_hci_free_con(con); + } + + m->m_pkthdr.len = m->m_len = sizeof(req->hdr) + req->hdr.length; + + /* Queue and send HCI command */ + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + error = ng_hci_send_command(unit); + break; + + case NG_HCI_CON_W4_CONN_COMPLETE: + if (ep->status == 0) { + if (hook == unit->acl) + con->flags |= NG_HCI_CON_NOTIFY_ACL; + else + con->flags |= NG_HCI_CON_NOTIFY_SCO; + } else + error = EPERM; + break; + + default: + KASSERT(0, +("%s: %s - Invalid connection state=%d\n", + __func__, NG_NODE_NAME(unit->node), con->state)); + + error = EINVAL; + break; + } +out: + NG_FREE_ITEM(item); + + return (error); +} /* ng_hci_lp_con_rsp */ + +/* + * Send LP_DisconnectInd to the upper layer protocol + */ + +int +ng_hci_lp_discon_ind(ng_hci_unit_con_p con, int reason) +{ + ng_hci_unit_p unit = con->unit; + struct ng_mesg *msg = NULL; + ng_hci_lp_discon_ind_ep *ep = NULL; + int error = 0; + + /* + * Disconnect_Complete event is generated for specific connection + * handle. For ACL connection handles both ACL and SCO upstream + * hooks will receive notification. For SCO connection handles + * only SCO upstream hook will receive notification. + */ + + if (con->link_type == NG_HCI_LINK_ACL) { + if (unit->acl != NULL && NG_HOOK_IS_VALID(unit->acl)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, + NGM_HCI_LP_DISCON_IND, sizeof(*ep), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + ep = (ng_hci_lp_discon_ind_ep *) msg->data; + ep->reason = reason; + ep->link_type = con->link_type; + ep->con_handle = con->con_handle; + + NG_SEND_MSG_HOOK(error,unit->node,msg,unit->acl,NULL); + } else + NG_HCI_INFO( +"%s: %s - ACL hook is not connected or not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->acl); + } + + if (unit->sco != NULL && NG_HOOK_IS_VALID(unit->sco)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_DISCON_IND, + sizeof(*ep), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + ep = (ng_hci_lp_discon_ind_ep *) msg->data; + ep->reason = reason; + ep->link_type = con->link_type; + ep->con_handle = con->con_handle; + + NG_SEND_MSG_HOOK(error, unit->node, msg, unit->sco, NULL); + } else + NG_HCI_INFO( +"%s: %s - SCO hook is not connected or not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->sco); + + return (0); +} /* ng_hci_lp_discon_ind */ + +/* + * Process LP_QoSReq action from the upper layer protocol + */ + +int +ng_hci_lp_qos_req(ng_hci_unit_p unit, item_p item, hook_p hook) +{ + struct qos_setup_req { + ng_hci_cmd_pkt_t hdr; + ng_hci_qos_setup_cp cp; + } __attribute__ ((packed)) *req = NULL; + ng_hci_lp_qos_req_ep *ep = NULL; + ng_hci_unit_con_p con = NULL; + struct mbuf *m = NULL; + int error = 0; + + /* Check if unit is ready */ + if ((unit->state & NG_HCI_UNIT_READY) != NG_HCI_UNIT_READY) { + NG_HCI_WARN( +"%s: %s - unit is not ready, state=%#x\n", + __func__, NG_NODE_NAME(unit->node), unit->state); + + error = ENXIO; + goto out; + } + + if (NGI_MSG(item)->header.arglen != sizeof(*ep)) { + NG_HCI_ALERT( +"%s: %s - invalid LP_QoSSetupReq message size=%d\n", + __func__, NG_NODE_NAME(unit->node), + NGI_MSG(item)->header.arglen); + + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_qos_req_ep *)(NGI_MSG(item)->data); + + con = ng_hci_con_by_handle(unit, ep->con_handle); + if (con == NULL) { + NG_HCI_ERR( +"%s: %s - invalid connection handle=%d\n", + __func__, NG_NODE_NAME(unit->node), ep->con_handle); + + error = EINVAL; + goto out; + } + + if (con->link_type != NG_HCI_LINK_ACL) { + NG_HCI_ERR("%s: %s - invalid link type=%d\n", + __func__, NG_NODE_NAME(unit->node), con->link_type); + + error = EINVAL; + goto out; + } + + if (con->state != NG_HCI_CON_OPEN) { + NG_HCI_ERR( +"%s: %s - invalid connection state=%d, handle=%d\n", + __func__, NG_NODE_NAME(unit->node), con->state, + con->con_handle); + + error = EINVAL; + goto out; + } + + /* + * Create HCI command + */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) { + error = ENOBUFS; + goto out; + } + + m->m_pkthdr.len = m->m_len = sizeof(*req); + req = mtod(m, struct qos_setup_req *); + req->hdr.type = NG_HCI_CMD_PKT; + req->hdr.length = sizeof(req->cp); + req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LINK_POLICY, + NG_HCI_OCF_QOS_SETUP)); + + req->cp.con_handle = htole16(ep->con_handle); + req->cp.flags = ep->flags; + req->cp.service_type = ep->service_type; + req->cp.token_rate = htole32(ep->token_rate); + req->cp.peak_bandwidth = htole32(ep->peak_bandwidth); + req->cp.latency = htole32(ep->latency); + req->cp.delay_variation = htole32(ep->delay_variation); + + /* + * Adjust connection state + */ + + if (hook == unit->acl) + con->flags |= NG_HCI_CON_NOTIFY_ACL; + else + con->flags |= NG_HCI_CON_NOTIFY_SCO; + + /* + * Queue and send HCI command + */ + + NG_BT_MBUFQ_ENQUEUE(&unit->cmdq, m); + if (!(unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + error = ng_hci_send_command(unit); +out: + NG_FREE_ITEM(item); + + return (error); +} /* ng_hci_lp_qos_req */ + +/* + * Send LP_QoSCfm event to the upper layer protocol + */ + +int +ng_hci_lp_qos_cfm(ng_hci_unit_con_p con, int status) +{ + ng_hci_unit_p unit = con->unit; + struct ng_mesg *msg = NULL; + ng_hci_lp_qos_cfm_ep *ep = NULL; + int error; + + if (con->flags & NG_HCI_CON_NOTIFY_ACL) { + if (unit->acl != NULL && NG_HOOK_IS_VALID(unit->acl)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_QOS_CFM, + sizeof(*ep), M_NOWAIT); + if (msg != NULL) { + ep = (ng_hci_lp_qos_cfm_ep *) msg->data; + ep->status = status; + ep->con_handle = con->con_handle; + + NG_SEND_MSG_HOOK(error, unit->node, msg, + unit->acl, NULL); + } + } else + NG_HCI_INFO( +"%s: %s - ACL hook not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->acl); + + con->flags &= ~NG_HCI_CON_NOTIFY_ACL; + } + + if (con->flags & NG_HCI_CON_NOTIFY_SCO) { + if (unit->sco != NULL && NG_HOOK_IS_VALID(unit->sco)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_QOS_CFM, + sizeof(*ep), M_NOWAIT); + if (msg != NULL) { + ep = (ng_hci_lp_qos_cfm_ep *) msg->data; + ep->status = status; + ep->con_handle = con->con_handle; + + NG_SEND_MSG_HOOK(error, unit->node, msg, + unit->sco, NULL); + } + } else + NG_HCI_INFO( +"%s: %s - SCO hook not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->sco); + + con->flags &= ~NG_HCI_CON_NOTIFY_SCO; + } + + return (0); +} /* ng_hci_lp_qos_cfm */ + +/* + * Send LP_QoSViolationInd event to the upper layer protocol + */ + +int +ng_hci_lp_qos_ind(ng_hci_unit_con_p con) +{ + ng_hci_unit_p unit = con->unit; + struct ng_mesg *msg = NULL; + ng_hci_lp_qos_ind_ep *ep = NULL; + int error; + + /* + * QoS Violation can only be generated for ACL connection handles. + * Both ACL and SCO upstream hooks will receive notification. + */ + + if (unit->acl != NULL && NG_HOOK_IS_VALID(unit->acl)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_QOS_IND, + sizeof(*ep), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + ep = (ng_hci_lp_qos_ind_ep *) msg->data; + ep->con_handle = con->con_handle; + + NG_SEND_MSG_HOOK(error, unit->node, msg, unit->acl, NULL); + } else + NG_HCI_INFO( +"%s: %s - ACL hook is not connected or not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->acl); + + if (unit->sco != NULL && NG_HOOK_IS_VALID(unit->sco)) { + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_QOS_IND, + sizeof(*ep), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + ep = (ng_hci_lp_qos_ind_ep *) msg->data; + ep->con_handle = con->con_handle; + + NG_SEND_MSG_HOOK(error, unit->node, msg, unit->sco, NULL); + } else + NG_HCI_INFO( +"%s: %s - SCO hook is not connected or not valid, hook=%p\n", + __func__, NG_NODE_NAME(unit->node), unit->sco); + + return (0); +} /* ng_hci_lp_qos_ind */ + +/* + * Process connection timeout + */ + +void +ng_hci_process_con_timeout(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_hci_unit_con_p con = (ng_hci_unit_con_p) arg1; + + KASSERT((con->flags & NG_HCI_CON_TIMEOUT_PENDING), +("%s: %s - No connection timeout!\n", __func__, NG_NODE_NAME(node))); + + con->flags &= ~NG_HCI_CON_TIMEOUT_PENDING; + + /* + * We expect to receive connection timeout in one of the following + * states: + * + * 1) NG_HCI_CON_CLOSED means that upper layer has requested disconnect + * via LP_DISCON_REQ and we have not received Disconnect_Complete + * event. In this case we will send LP_DISCON_IND to upper layer. + * + * 2) NG_HCI_CON_W4_LP_CON_RSP means that upper layer has not responded + * to our LP_CON_IND. Do nothing and destroy connection. Remote peer + * most likely already gave up on us. + * + * 3) NG_HCI_CON_W4_CONN_COMPLETE means upper layer requested connection + * (or we in the process of accepting it) and baseband has timedout + * on us. Inform upper layers and send LP_CON_CFM. + */ + + switch (con->state) { + case NG_HCI_CON_CLOSED: + ng_hci_lp_discon_ind(con, 0x16); + break; + + case NG_HCI_CON_W4_LP_CON_RSP: + break; + + case NG_HCI_CON_W4_CONN_COMPLETE: + ng_hci_lp_con_cfm(con, 0xee); + break; + + default: + KASSERT(0, +("%s: %s - Invalid connection state=%d\n", + __func__, NG_NODE_NAME(node), con->state)); + break; + } + + ng_hci_free_con(con); +} /* ng_hci_process_con_timeout */ + +/* + * Process connection watchdog timeout + */ + +void +ng_hci_process_con_watchdog_timeout(node_p node, hook_p hook, + void *arg1, int arg2) +{ + ng_hci_unit_con_p con = (ng_hci_unit_con_p) arg1; + struct discon_req { + ng_hci_cmd_pkt_t hdr; + ng_hci_discon_cp cp; + } __attribute__ ((packed)) *req = NULL; + struct mbuf *m = NULL; + + KASSERT((con->state == NG_HCI_CON_OPEN), +("%s: %s - invalid connection state=%d, handle=%d\n", + __func__, NG_NODE_NAME(node), con->state, con->con_handle)); + + KASSERT((con->flags & NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING), +("%s: %s - No connection watchdog timeout!\n", + __func__, NG_NODE_NAME(node))); + + con->flags &= ~NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING; + + /* + * Create HCI command + */ + + MGETHDR(m, M_DONTWAIT, MT_DATA); + if (m == NULL) + return; /* XXX this is bad */ + + m->m_pkthdr.len = m->m_len = sizeof(*req); + req = mtod(m, struct discon_req *); + req->hdr.type = NG_HCI_CMD_PKT; + req->hdr.length = sizeof(req->cp); + req->hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_DISCON)); + + req->cp.con_handle = htole16(con->con_handle); + req->cp.reason = 0x13; /* User ended connection */ + + /* + * Queue and send HCI command + */ + + NG_BT_MBUFQ_ENQUEUE(&con->unit->cmdq, m); + if (!(con->unit->state & NG_HCI_UNIT_COMMAND_PENDING)) + ng_hci_send_command(con->unit); + + /* + * Send LP_DISCON_IND to the upper layers + * Connection terminated by local host + */ + + ng_hci_lp_discon_ind(con, 0x16); + ng_hci_free_con(con); +} /* ng_hci_process_con_watchdog_timeout */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_ulpi.h b/sys/netgraph/bluetooth/hci/ng_hci_ulpi.h new file mode 100644 index 0000000..9f4e0ef --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_ulpi.h @@ -0,0 +1,53 @@ +/* + * ng_hci_ulpi.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_ulpi.h,v 1.4 2002/09/04 21:36:52 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_HCI_ULPI_H_ +#define _NETGRAPH_HCI_ULPI_H_ + +/* + * LP_xxx event handlers + */ + +int ng_hci_lp_con_req (ng_hci_unit_p, item_p, hook_p); +int ng_hci_lp_discon_req (ng_hci_unit_p, item_p, hook_p); +int ng_hci_lp_con_cfm (ng_hci_unit_con_p, int); +int ng_hci_lp_con_ind (ng_hci_unit_con_p, u_int8_t *); +int ng_hci_lp_con_rsp (ng_hci_unit_p, item_p, hook_p); +int ng_hci_lp_discon_ind (ng_hci_unit_con_p, int); +int ng_hci_lp_qos_req (ng_hci_unit_p, item_p, hook_p); +int ng_hci_lp_qos_cfm (ng_hci_unit_con_p, int); +int ng_hci_lp_qos_ind (ng_hci_unit_con_p); + +void ng_hci_process_con_timeout (node_p, hook_p, void *, int); +void ng_hci_process_con_watchdog_timeout (node_p, hook_p, void *, int); + +#endif /* ndef _NETGRAPH_HCI_ULPI_H_ */ + diff --git a/sys/netgraph/bluetooth/hci/ng_hci_var.h b/sys/netgraph/bluetooth/hci/ng_hci_var.h new file mode 100644 index 0000000..43940a9 --- /dev/null +++ b/sys/netgraph/bluetooth/hci/ng_hci_var.h @@ -0,0 +1,217 @@ +/* + * ng_hci_var.h + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci_var.h,v 1.14 2002/11/12 22:35:40 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_HCI_VAR_H_ +#define _NETGRAPH_HCI_VAR_H_ 1 + +/* MALLOC decalation */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DECLARE(M_NETGRAPH_HCI); +#else +#define M_NETGRAPH_HCI M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Debug */ +#define NG_HCI_ALERT if (unit->debug >= NG_HCI_ALERT_LEVEL) printf +#define NG_HCI_ERR if (unit->debug >= NG_HCI_ERR_LEVEL) printf +#define NG_HCI_WARN if (unit->debug >= NG_HCI_WARN_LEVEL) printf +#define NG_HCI_INFO if (unit->debug >= NG_HCI_INFO_LEVEL) printf + +/* Wrapper around m_pullup */ +#define NG_HCI_M_PULLUP(m, s) \ + do { \ + if ((m)->m_len < (s)) \ + (m) = m_pullup((m), (s)); \ + if ((m) == NULL) \ + NG_HCI_ALERT("%s: %s - m_pullup(%d) failed\n", \ + __func__, NG_NODE_NAME(unit->node), (s)); \ + } while (0) + +/* + * Unit hardware buffer descriptor + */ + +typedef struct ng_hci_unit_buff { + u_int8_t cmd_free; /* space available (cmds) */ + + u_int8_t sco_size; /* max. size of one packet */ + u_int16_t sco_pkts; /* size of buffer (packets) */ + u_int16_t sco_free; /* space available (packets)*/ + + u_int16_t acl_size; /* max. size of one packet */ + u_int16_t acl_pkts; /* size of buffer (packets) */ + u_int16_t acl_free; /* space available (packets)*/ +} ng_hci_unit_buff_t; + +/* + * These macro's must be used everywhere in the code. So if extra locking + * is required later, it can be added without much troubles. + */ + +#define NG_HCI_BUFF_CMD_SET(b, v) (b).cmd_free = (v) +#define NG_HCI_BUFF_CMD_GET(b, v) (v) = (b).cmd_free +#define NG_HCI_BUFF_CMD_USE(b, v) (b).cmd_free -= (v) + +#define NG_HCI_BUFF_ACL_USE(b, v) (b).acl_free -= (v) +#define NG_HCI_BUFF_ACL_FREE(b, v) \ + do { \ + (b).acl_free += (v); \ + if ((b).acl_free > (b).acl_pkts) \ + (b).acl_free = (b).acl_pkts; \ + } while (0) +#define NG_HCI_BUFF_ACL_AVAIL(b, v) (v) = (b).acl_free +#define NG_HCI_BUFF_ACL_TOTAL(b, v) (v) = (b).acl_pkts +#define NG_HCI_BUFF_ACL_SIZE(b, v) (v) = (b).acl_size +#define NG_HCI_BUFF_ACL_SET(b, n, s, f) \ + do { \ + (b).acl_free = (f); \ + (b).acl_size = (s); \ + (b).acl_pkts = (n); \ + } while (0) + +#define NG_HCI_BUFF_SCO_USE(b, v) (b).sco_free -= (v) +#define NG_HCI_BUFF_SCO_FREE(b, v) \ + do { \ + (b).sco_free += (v); \ + if ((b).sco_free > (b).sco_pkts) \ + (b).sco_free = (b).sco_pkts; \ + } while (0) +#define NG_HCI_BUFF_SCO_AVAIL(b, v) (v) = (b).sco_free +#define NG_HCI_BUFF_SCO_TOTAL(b, v) (v) = (b).sco_pkts +#define NG_HCI_BUFF_SCO_SIZE(b, v) (v) = (b).sco_size +#define NG_HCI_BUFF_SCO_SET(b, n, s, f) \ + do { \ + (b).sco_free = (f); \ + (b).sco_size = (s); \ + (b).sco_pkts = (n); \ + } while (0) + +/* + * Unit (Node private) + */ + +struct ng_hci_unit_con; +struct ng_hci_neighbor; + +typedef struct ng_hci_unit { + node_p node; /* node ptr */ + + ng_hci_node_debug_ep debug; /* debug level */ + ng_hci_node_state_ep state; /* unit state */ + + bdaddr_t bdaddr; /* unit address */ + u_int8_t features[NG_HCI_FEATURES_SIZE]; + /* LMP features */ + + ng_hci_node_link_policy_mask_ep link_policy_mask; /* link policy mask */ + ng_hci_node_packet_mask_ep packet_mask; /* packet mask */ + + ng_hci_node_stat_ep stat; /* statistic */ +#define NG_HCI_STAT_CMD_SENT(s) (s).cmd_sent ++ +#define NG_HCI_STAT_EVNT_RECV(s) (s).evnt_recv ++ +#define NG_HCI_STAT_ACL_SENT(s, n) (s).acl_sent += (n) +#define NG_HCI_STAT_ACL_RECV(s) (s).acl_recv ++ +#define NG_HCI_STAT_SCO_SENT(s, n) (s).sco_sent += (n) +#define NG_HCI_STAT_SCO_RECV(s) (s).sco_recv ++ +#define NG_HCI_STAT_BYTES_SENT(s, b) (s).bytes_sent += (b) +#define NG_HCI_STAT_BYTES_RECV(s, b) (s).bytes_recv += (b) +#define NG_HCI_STAT_RESET(s) bzero(&(s), sizeof((s))) + + ng_hci_unit_buff_t buffer; /* buffer info */ + + struct callout_handle cmd_timo; /* command timeout */ + ng_bt_mbufq_t cmdq; /* command queue */ +#define NG_HCI_CMD_QUEUE_LEN 12 /* max. size of cmd q */ + + hook_p drv; /* driver hook */ + hook_p acl; /* upstream hook */ + hook_p sco; /* upstream hook */ + hook_p raw; /* upstream hook */ + + LIST_HEAD(, ng_hci_unit_con) con_list; /* connections */ + LIST_HEAD(, ng_hci_neighbor) neighbors; /* unit neighbors */ +} ng_hci_unit_t; +typedef ng_hci_unit_t * ng_hci_unit_p; + +/* + * Unit connection descriptor + */ + +typedef struct ng_hci_unit_con { + ng_hci_unit_p unit; /* pointer back */ + + u_int16_t state; /* con. state */ + u_int16_t flags; /* con. flags */ +#define NG_HCI_CON_TIMEOUT_PENDING (1 << 0) +#define NG_HCI_CON_WATCHDOG_TIMEOUT_PENDING (1 << 1) +#define NG_HCI_CON_NOTIFY_ACL (1 << 2) +#define NG_HCI_CON_NOTIFY_SCO (1 << 3) + + bdaddr_t bdaddr; /* remote address */ + u_int16_t con_handle; /* con. handle */ + + u_int8_t link_type; /* ACL or SCO */ + u_int8_t encryption_mode; /* none, p2p, ... */ + u_int8_t mode; /* ACTIVE, HOLD ... */ + u_int8_t role; /* MASTER/SLAVE */ + + struct callout_handle con_timo; /* con. timeout */ + struct callout_handle watchdog_timo; /* watch dog */ + + int pending; /* # of data pkts */ + ng_bt_itemq_t conq; /* con. queue */ + + LIST_ENTRY(ng_hci_unit_con) next; /* next */ +} ng_hci_unit_con_t; +typedef ng_hci_unit_con_t * ng_hci_unit_con_p; + +/* + * Unit's neighbor descriptor. + * Neighbor is a remote unit that responded to our inquiry. + */ + +typedef struct ng_hci_neighbor { + struct timeval updated; /* entry was updated */ + + bdaddr_t bdaddr; /* address */ + u_int8_t features[NG_HCI_FEATURES_SIZE]; + /* LMP features */ + + u_int8_t page_scan_rep_mode; /* PS rep. mode */ + u_int8_t page_scan_mode; /* page scan mode */ + u_int16_t clock_offset; /* clock offset */ + + LIST_ENTRY(ng_hci_neighbor) next; +} ng_hci_neighbor_t; +typedef ng_hci_neighbor_t * ng_hci_neighbor_p; + +#endif /* ndef _NETGRAPH_HCI_VAR_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_bluetooth.h b/sys/netgraph/bluetooth/include/ng_bluetooth.h new file mode 100644 index 0000000..238da42 --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_bluetooth.h @@ -0,0 +1,232 @@ +/* + * bluetooth.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_bluetooth.h,v 1.1.1.1 2002/09/04 21:47:41 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_BLUETOOTH_H_ +#define _NETGRAPH_BLUETOOTH_H_ 1 + +/* + * Version of the stack + */ + +#define NG_BLUETOOTH_VERSION 1 + +/* + * Declare the base of the Bluetooth sysctl hierarchy, + * but only if this file cares about sysctl's + */ + +#ifdef SYSCTL_DECL +SYSCTL_DECL(_net_bluetooth); +SYSCTL_DECL(_net_bluetooth_hci); +SYSCTL_DECL(_net_bluetooth_l2cap); +#endif /* SYSCTL_DECL */ + +/* + * Mbuf qeueue and useful mbufq macros. We do not use ifqueue because we + * do not need mutex and other locking stuff + */ + +struct mbuf; + +struct ng_bt_mbufq { + struct mbuf *head; /* first item in the queue */ + struct mbuf *tail; /* last item in the queue */ + u_int32_t len; /* number of items in the queue */ + u_int32_t maxlen; /* maximal number of items in the queue */ + u_int32_t drops; /* number if dropped items */ +}; +typedef struct ng_bt_mbufq ng_bt_mbufq_t; +typedef struct ng_bt_mbufq * ng_bt_mbufq_p; + +#define NG_BT_MBUFQ_INIT(q, _maxlen) \ + do { \ + (q)->head = NULL; \ + (q)->tail = NULL; \ + (q)->len = 0; \ + (q)->maxlen = (_maxlen); \ + (q)->drops = 0; \ + } while (0) + +#define NG_BT_MBUFQ_DESTROY(q) \ + do { \ + NG_BT_MBUFQ_DRAIN((q)); \ + } while (0) + +#define NG_BT_MBUFQ_FIRST(q) (q)->head + +#define NG_BT_MBUFQ_LEN(q) (q)->len + +#define NG_BT_MBUFQ_FULL(q) (q)->len >= (q)->maxlen + +#define NG_BT_MBUFQ_DROP(q) (q)->drops ++ + +#define NG_BT_MBUFQ_ENQUEUE(q, i) \ + do { \ + (i)->m_nextpkt = NULL; \ + \ + if ((q)->tail == NULL) \ + (q)->head = (i); \ + else \ + (q)->tail->m_nextpkt = (i); \ + \ + (q)->tail = (i); \ + (q)->len ++; \ + } while (0) + +#define NG_BT_MBUFQ_DEQUEUE(q, i) \ + do { \ + (i) = (q)->head; \ + if ((i) != NULL) { \ + (q)->head = (q)->head->m_nextpkt; \ + if ((q)->head == NULL) \ + (q)->tail = NULL; \ + \ + (q)->len --; \ + (i)->m_nextpkt = NULL; \ + } \ + } while (0) + +#define NG_BT_MBUFQ_PREPEND(q, i) \ + do { \ + (i)->m_nextpkt = (q)->head; \ + if ((q)->tail == NULL) \ + (q)->tail = (i); \ + \ + (q)->head = (i); \ + (q)->len ++; \ + } while (0) + +#define NG_BT_MBUFQ_DRAIN(q) \ + do { \ + struct mbuf *m = NULL; \ + \ + for (;;) { \ + NG_BT_MBUFQ_DEQUEUE((q), m); \ + if (m == NULL) \ + break; \ + \ + NG_FREE_M(m); \ + } \ + } while (0) + +/* + * Netgraph item queue and useful itemq macros + */ + +struct ng_item; + +struct ng_bt_itemq { + struct ng_item *head; /* first item in the queue */ + struct ng_item *tail; /* last item in the queue */ + u_int32_t len; /* number of items in the queue */ + u_int32_t maxlen; /* maximal number of items in the queue */ + u_int32_t drops; /* number if dropped items */ +}; +typedef struct ng_bt_itemq ng_bt_itemq_t; +typedef struct ng_bt_itemq * ng_bt_itemq_p; + +#define NG_BT_ITEMQ_INIT(q, _maxlen) NG_BT_MBUFQ_INIT((q), (_maxlen)) + +#define NG_BT_ITEMQ_DESTROY(q) \ + do { \ + NG_BT_ITEMQ_DRAIN((q)); \ + } while (0) + +#define NG_BT_ITEMQ_FIRST(q) NG_BT_MBUFQ_FIRST((q)) + +#define NG_BT_ITEMQ_LEN(q) NG_BT_MBUFQ_LEN((q)) + +#define NG_BT_ITEMQ_FULL(q) NG_BT_MBUFQ_FULL((q)) + +#define NG_BT_ITEMQ_DROP(q) NG_BT_MBUFQ_DROP((q)) + +#define NG_BT_ITEMQ_ENQUEUE(q, i) \ + do { \ + (i)->el_next = NULL; \ + \ + if ((q)->tail == NULL) \ + (q)->head = (i); \ + else \ + (q)->tail->el_next = (i); \ + \ + (q)->tail = (i); \ + (q)->len ++; \ + } while (0) + +#define NG_BT_ITEMQ_DEQUEUE(q, i) \ + do { \ + (i) = (q)->head; \ + if ((i) != NULL) { \ + (q)->head = (q)->head->el_next; \ + if ((q)->head == NULL) \ + (q)->tail = NULL; \ + \ + (q)->len --; \ + (i)->el_next = NULL; \ + } \ + } while (0) + +#define NG_BT_ITEMQ_PREPEND(q, i) \ + do { \ + (i)->el_next = (q)->head; \ + if ((q)->tail == NULL) \ + (q)->tail = (i); \ + \ + (q)->head = (i); \ + (q)->len ++; \ + } while (0) + +#define NG_BT_ITEMQ_DRAIN(q) \ + do { \ + struct ng_item *i = NULL; \ + \ + for (;;) { \ + NG_BT_ITEMQ_DEQUEUE((q), i); \ + if (i == NULL) \ + break; \ + \ + NG_FREE_ITEM(i); \ + } \ + } while (0) + +/* + * Get Bluetooth stack sysctl globals + */ + +u_int32_t bluetooth_hci_command_timeout (void); +u_int32_t bluetooth_hci_connect_timeout (void); +u_int32_t bluetooth_hci_watchdog_timeout (void); +u_int32_t bluetooth_hci_max_neighbor_age (void); +u_int32_t bluetooth_l2cap_rtx_timeout (void); +u_int32_t bluetooth_l2cap_ertx_timeout (void); + +#endif /* _NETGRAPH_BLUETOOTH_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_bt3c.h b/sys/netgraph/bluetooth/include/ng_bt3c.h new file mode 100644 index 0000000..6030b81 --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_bt3c.h @@ -0,0 +1,114 @@ +/* + * ng_bt3c.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_bt3c.h,v 1.2 2002/11/12 00:51:45 max Exp $ + * $FreeBSD$ + * + * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX + * + * Based on information obrained from: Jose Orlando Pereira <jop@di.uminho.pt> + * and disassembled w2k driver. + * + * XXX XXX XX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX XXX + * + */ + +#ifndef _NG_BT3C_H_ +#define _NG_BT3C_H_ + +/* XXX FIME: does not belong here. Move to pccarddevs.h later */ +#define PCMCIA_PRODUCT_3COM_3CRWB609 0x0040 +#define PCMCIA_STR_3COM_3CRWB609 "3Com Bluetooth PC Card 3CRWB60-A" +#define PCMCIA_CIS_3COM_3CRWB609 { NULL, NULL, NULL, NULL } + +/************************************************************************** + ************************************************************************** + ** Netgraph node hook name, type name and type cookie and commands + ************************************************************************** + **************************************************************************/ + +#define NG_BT3C_NODE_TYPE "btccc" /* XXX can't use bt3c in pccard.conf */ +#define NG_BT3C_HOOK "hook" + +#define NGM_BT3C_COOKIE 1014752016 + +/* Debug levels */ +#define NG_BT3C_ALERT_LEVEL 1 +#define NG_BT3C_ERR_LEVEL 2 +#define NG_BT3C_WARN_LEVEL 3 +#define NG_BT3C_INFO_LEVEL 4 + +/* Node states */ +#define NG_BT3C_W4_PKT_IND 1 /* wait for packet indicator */ +#define NG_BT3C_W4_PKT_HDR 2 /* wait for packet header */ +#define NG_BT3C_W4_PKT_DATA 3 /* wait for packet data */ + +/************************************************************************** + ************************************************************************** + ** BT3C node command/event parameters + ************************************************************************** + **************************************************************************/ + +#define NGM_BT3C_NODE_GET_STATE 1 /* get node state */ +typedef u_int16_t ng_bt3c_node_state_ep; + +#define NGM_BT3C_NODE_SET_DEBUG 2 /* set debug level */ +#define NGM_BT3C_NODE_GET_DEBUG 3 /* get debug level */ +typedef u_int16_t ng_bt3c_node_debug_ep; + +#define NGM_BT3C_NODE_GET_QLEN 4 /* get queue length */ +#define NGM_BT3C_NODE_SET_QLEN 5 /* set queue length */ +typedef struct { + int32_t queue; /* queue index */ +#define NGM_BT3C_NODE_IN_QUEUE 1 /* incoming queue */ +#define NGM_BT3C_NODE_OUT_QUEUE 2 /* outgoing queue */ + + int32_t qlen; /* queue length */ +} ng_bt3c_node_qlen_ep; + +#define NGM_BT3C_NODE_GET_STAT 6 /* get statistic */ +typedef struct { + u_int32_t pckts_recv; /* # of packets received */ + u_int32_t bytes_recv; /* # of bytes received */ + u_int32_t pckts_sent; /* # of packets sent */ + u_int32_t bytes_sent; /* # of bytes sent */ + u_int32_t oerrors; /* # of output errors */ + u_int32_t ierrors; /* # of input errors */ +} ng_bt3c_node_stat_ep; + +#define NGM_BT3C_NODE_RESET_STAT 7 /* reset statistic */ + +#define NGM_BT3C_NODE_DOWNLOAD_FIRMWARE 8 /* download firmware */ + +typedef struct { + u_int32_t block_address; + u_int16_t block_size; /* in words */ + u_int16_t block_alignment; /* in bytes */ +} ng_bt3c_firmware_block_ep; + +#endif /* ndef _NG_BT3C_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_btsocket.h b/sys/netgraph/bluetooth/include/ng_btsocket.h new file mode 100644 index 0000000..5ace3fa --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_btsocket.h @@ -0,0 +1,319 @@ +/* + * ng_btsocket.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket.h,v 1.7 2002/11/12 22:31:39 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_BTSOCKET_H_ +#define _NETGRAPH_BTSOCKET_H_ 1 + +/* + * XXX FIXME: does not belong here, move to sys/socket.h later and fix AF_MAX + */ + +#define AF_BLUETOOTH 36 /* Address family */ +#define PF_BLUETOOTH AF_BLUETOOTH /* Protocol family */ + +/* + * XXX FIXME: does not belong here, move to other places later + */ + +#define BLUETOOTH_PROTO_HCI 134 /* HCI protocol number */ +#define BLUETOOTH_PROTO_L2CAP 135 /* L2CAP protocol number */ + +/* + * XXX FIXME: probably does not belong here + * Bluetooth version of struct sockaddr for raw HCI sockets + */ + +struct sockaddr_hci { + u_char hci_len; /* total length */ + u_char hci_family; /* address family */ + char hci_node[16]; /* address (size == NG_NODELEN + 1) */ +}; + +/* Raw HCI socket options */ +#define SOL_HCI_RAW 0x0802 /* socket options level */ + +#define SO_HCI_RAW_FILTER 1 /* get/set filter on socket */ +#define SO_HCI_RAW_DIRECTION 2 /* turn on/off direction info */ +#define SCM_HCI_RAW_DIRECTION SO_HCI_RAW_DIRECTION /* cmsg_type */ + +/* + * Raw HCI socket filter. + * + * For packet mask use (1 << (HCI packet indicator - 1)) + * For event mask use (1 << (Event - 1)) + */ + +struct ng_btsocket_hci_raw_filter { + bitstr_t bit_decl(packet_mask, 32); + bitstr_t bit_decl(event_mask, (NG_HCI_EVENT_MASK_SIZE * 8)); +}; + +/* + * Raw HCI sockets ioctl's + */ + +/* Get state */ +struct ng_btsocket_hci_raw_node_state { + char hci_node[16]; + ng_hci_node_state_ep state; +}; +#define SIOC_HCI_RAW_NODE_GET_STATE \ + _IOWR('b', NGM_HCI_NODE_GET_STATE, \ + struct ng_btsocket_hci_raw_node_state) + +/* Initialize */ +struct ng_btsocket_hci_raw_node_init { + char hci_node[16]; +}; +#define SIOC_HCI_RAW_NODE_INIT \ + _IOWR('b', NGM_HCI_NODE_INIT, \ + struct ng_btsocket_hci_raw_node_init) + +/* Get/Set debug level */ +struct ng_btsocket_hci_raw_node_debug { + char hci_node[16]; + ng_hci_node_debug_ep debug; +}; +#define SIOC_HCI_RAW_NODE_GET_DEBUG \ + _IOWR('b', NGM_HCI_NODE_GET_DEBUG, \ + struct ng_btsocket_hci_raw_node_debug) +#define SIOC_HCI_RAW_NODE_SET_DEBUG \ + _IOWR('b', NGM_HCI_NODE_SET_DEBUG, \ + struct ng_btsocket_hci_raw_node_debug) + +/* Get buffer info */ +struct ng_btsocket_hci_raw_node_buffer { + char hci_node[16]; + ng_hci_node_buffer_ep buffer; +}; +#define SIOC_HCI_RAW_NODE_GET_BUFFER \ + _IOWR('b', NGM_HCI_NODE_GET_BUFFER, \ + struct ng_btsocket_hci_raw_node_buffer) + +/* Get BD_ADDR */ +struct ng_btsocket_hci_raw_node_bdaddr { + char hci_node[16]; + bdaddr_t bdaddr; +}; +#define SIOC_HCI_RAW_NODE_GET_BDADDR \ + _IOWR('b', NGM_HCI_NODE_GET_BDADDR, \ + struct ng_btsocket_hci_raw_node_bdaddr) + +/* Get features */ +struct ng_btsocket_hci_raw_node_features { + char hci_node [16]; + u_int8_t features[NG_HCI_FEATURES_SIZE]; +}; +#define SIOC_HCI_RAW_NODE_GET_FEATURES \ + _IOWR('b', NGM_HCI_NODE_GET_FEATURES, \ + struct ng_btsocket_hci_raw_node_features) + +/* Get stat */ +struct ng_btsocket_hci_raw_node_stat { + char hci_node[16]; + ng_hci_node_stat_ep stat; +}; +#define SIOC_HCI_RAW_NODE_GET_STAT \ + _IOWR('b', NGM_HCI_NODE_GET_STAT, \ + struct ng_btsocket_hci_raw_node_stat) + +/* Reset stat */ +struct ng_btsocket_hci_raw_node_reset_stat { + char hci_node[16]; +}; +#define SIOC_HCI_RAW_NODE_RESET_STAT \ + _IOWR('b', NGM_HCI_NODE_RESET_STAT, \ + struct ng_btsocket_hci_raw_node_reset_stat) + +/* Flush neighbor cache */ +struct ng_btsocket_hci_raw_node_flush_neighbor_cache { + char hci_node[16]; +}; +#define SIOC_HCI_RAW_NODE_FLUSH_NEIGHBOR_CACHE \ + _IOWR('b', NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE, \ + struct ng_btsocket_hci_raw_node_flush_neighbor_cache) + +/* Get neighbor cache */ +struct ng_btsocket_hci_raw_node_neighbor_cache { + char hci_node[16]; + u_int32_t num_entries; + ng_hci_node_neighbor_cache_entry_ep *entries; +}; +#define SIOC_HCI_RAW_NODE_GET_NEIGHBOR_CACHE \ + _IOWR('b', NGM_HCI_NODE_GET_NEIGHBOR_CACHE, \ + struct ng_btsocket_hci_raw_node_neighbor_cache) + +/* Get connection list */ +struct ng_btsocket_hci_raw_con_list { + char hci_node[16]; + u_int32_t num_connections; + ng_hci_node_con_ep *connections; +}; +#define SIOC_HCI_RAW_NODE_GET_CON_LIST \ + _IOWR('b', NGM_HCI_NODE_GET_CON_LIST, \ + struct ng_btsocket_hci_raw_con_list) + +/* Get/Set link policy settings mask */ +struct ng_btsocket_hci_raw_node_link_policy_mask { + char hci_node[16]; + ng_hci_node_link_policy_mask_ep policy_mask; +}; +#define SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK \ + _IOWR('b', NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK, \ + struct ng_btsocket_hci_raw_node_link_policy_mask) +#define SIOC_HCI_RAW_NODE_SET_LINK_POLICY_MASK \ + _IOWR('b', NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK, \ + struct ng_btsocket_hci_raw_node_link_policy_mask) + +/* Get/Set packet mask */ +struct ng_btsocket_hci_raw_node_packet_mask { + char hci_node[16]; + ng_hci_node_packet_mask_ep packet_mask; +}; +#define SIOC_HCI_RAW_NODE_GET_PACKET_MASK \ + _IOWR('b', NGM_HCI_NODE_GET_PACKET_MASK, \ + struct ng_btsocket_hci_raw_node_packet_mask) +#define SIOC_HCI_RAW_NODE_SET_PACKET_MASK \ + _IOWR('b', NGM_HCI_NODE_SET_PACKET_MASK, \ + struct ng_btsocket_hci_raw_node_packet_mask) + +/* + * XXX FIXME: probably does not belong here + * Bluetooth version of struct sockaddr for L2CAP sockets (RAW and SEQPACKET) + */ + +struct sockaddr_l2cap { + u_char l2cap_len; /* total length */ + u_char l2cap_family; /* address family */ + u_int16_t l2cap_psm; /* PSM (Protocol/Service Multiplexor) */ + bdaddr_t l2cap_bdaddr; /* address */ +}; + +/* L2CAP socket options */ +#define SOL_L2CAP 0x1609 /* socket option level */ + +#define SO_L2CAP_IMTU 1 /* get/set incoming MTU */ +#define SO_L2CAP_OMTU 2 /* get outgoing (peer incoming) MTU */ +#define SO_L2CAP_IFLOW 3 /* get incoming flow spec. */ +#define SO_L2CAP_OFLOW 4 /* get/set outgoing flow spec. */ +#define SO_L2CAP_FLUSH 5 /* get/set flush timeout */ + +/* + * Raw L2CAP sockets ioctl's + */ + +/* Ping */ +struct ng_btsocket_l2cap_raw_ping { + bdaddr_t bdaddr[2]; +#define echo_src bdaddr[0] +#define echo_dst bdaddr[1] + u_int32_t result; + u_int32_t echo_size; + u_int8_t *echo_data; +}; +#define SIOC_L2CAP_L2CA_PING \ + _IOWR('b', NGM_L2CAP_L2CA_PING, \ + struct ng_btsocket_l2cap_raw_ping) + +/* Get info */ +struct ng_btsocket_l2cap_raw_get_info { + bdaddr_t bdaddr[2]; +#define info_src bdaddr[0] +#define info_dst bdaddr[1] + u_int32_t result; + u_int32_t info_type; + u_int32_t info_size; + u_int8_t *info_data; +}; +#define SIOC_L2CAP_L2CA_GET_INFO \ + _IOWR('b', NGM_L2CAP_L2CA_GET_INFO, \ + struct ng_btsocket_l2cap_raw_get_info) + +/* Get flags */ +struct ng_btsocket_l2cap_raw_node_flags { + bdaddr_t src; + ng_l2cap_node_flags_ep flags; +}; +#define SIOC_L2CAP_NODE_GET_FLAGS \ + _IOWR('b', NGM_L2CAP_NODE_GET_FLAGS, \ + struct ng_btsocket_l2cap_raw_node_flags) + +/* Get/Set debug level */ +struct ng_btsocket_l2cap_raw_node_debug { + bdaddr_t src; + ng_l2cap_node_debug_ep debug; +}; +#define SIOC_L2CAP_NODE_GET_DEBUG \ + _IOWR('b', NGM_L2CAP_NODE_GET_DEBUG, \ + struct ng_btsocket_l2cap_raw_node_debug) +#define SIOC_L2CAP_NODE_SET_DEBUG \ + _IOWR('b', NGM_L2CAP_NODE_SET_DEBUG, \ + struct ng_btsocket_l2cap_raw_node_debug) + +/* Get connection list */ +struct ng_btsocket_l2cap_raw_con_list { + bdaddr_t src; + u_int32_t num_connections; + ng_l2cap_node_con_ep *connections; +}; +#define SIOC_L2CAP_NODE_GET_CON_LIST \ + _IOWR('b', NGM_L2CAP_NODE_GET_CON_LIST, \ + struct ng_btsocket_l2cap_raw_con_list) + +/* Get channel list */ +struct ng_btsocket_l2cap_raw_chan_list { + bdaddr_t src; + u_int32_t num_channels; + ng_l2cap_node_chan_ep *channels; +}; +#define SIOC_L2CAP_NODE_GET_CHAN_LIST \ + _IOWR('b', NGM_L2CAP_NODE_GET_CHAN_LIST, \ + struct ng_btsocket_l2cap_raw_chan_list) + +/* + * Netgraph node type name and cookie + */ + +#define NG_BTSOCKET_HCI_RAW_NODE_TYPE "btsock_hci_raw" +#define NG_BTSOCKET_L2CAP_RAW_NODE_TYPE "btsock_l2c_raw" +#define NG_BTSOCKET_L2CAP_NODE_TYPE "btsock_l2c" + +/* + * Debug levels + */ + +#define NG_BTSOCKET_ALERT_LEVEL 1 +#define NG_BTSOCKET_ERR_LEVEL 2 +#define NG_BTSOCKET_WARN_LEVEL 3 +#define NG_BTSOCKET_INFO_LEVEL 4 + +#endif /* _NETGRAPH_BTSOCKET_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_btsocket_hci_raw.h b/sys/netgraph/bluetooth/include/ng_btsocket_hci_raw.h new file mode 100644 index 0000000..399e8ac --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_btsocket_hci_raw.h @@ -0,0 +1,85 @@ +/* + * ng_btsocket_hci_raw.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket_hci_raw.h,v 1.2 2002/09/16 19:46:02 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_BTSOCKET_HCI_RAW_H_ +#define _NETGRAPH_BTSOCKET_HCI_RAW_H_ 1 + +#define NG_BTSOCKET_HCI_RAW_SENDSPACE (4 * 1024) +#define NG_BTSOCKET_HCI_RAW_RECVSPACE (4 * 1024) + +/* + * Bluetooth raw HCI socket PCB + */ + +struct ng_btsocket_hci_raw_pcb { + struct socket *so; /* socket */ + int flags; /* flags */ +#define NG_BTSOCKET_HCI_RAW_DIRECTION (1 << 0) + struct sockaddr_hci addr; /* local address */ + struct ng_btsocket_hci_raw_filter filter; /* filter */ + u_int32_t token; /* message token */ + struct ng_mesg *msg; /* message */ + LIST_ENTRY(ng_btsocket_hci_raw_pcb) next; /* link to next */ +}; +typedef struct ng_btsocket_hci_raw_pcb ng_btsocket_hci_raw_pcb_t; +typedef struct ng_btsocket_hci_raw_pcb * ng_btsocket_hci_raw_pcb_p; + +#define so2hci_raw_pcb(so) \ + ((struct ng_btsocket_hci_raw_pcb *)((so)->so_pcb)) + +/* + * Bluetooth raw HCI socket methods + */ + +#ifdef _KERNEL + +void ng_btsocket_hci_raw_init (void); +int ng_btsocket_hci_raw_abort (struct socket *); +int ng_btsocket_hci_raw_attach (struct socket *, int, struct thread *); +int ng_btsocket_hci_raw_bind (struct socket *, struct sockaddr *, + struct thread *); +int ng_btsocket_hci_raw_connect (struct socket *, struct sockaddr *, + struct thread *); +int ng_btsocket_hci_raw_control (struct socket *, u_long, caddr_t, + struct ifnet *, struct thread *); +int ng_btsocket_hci_raw_ctloutput (struct socket *, struct sockopt *); +int ng_btsocket_hci_raw_detach (struct socket *); +int ng_btsocket_hci_raw_disconnect (struct socket *); +int ng_btsocket_hci_raw_peeraddr (struct socket *, struct sockaddr **); +int ng_btsocket_hci_raw_send (struct socket *, int, struct mbuf *, + struct sockaddr *, struct mbuf *, + struct thread *); +int ng_btsocket_hci_raw_sockaddr (struct socket *, struct sockaddr **); + +#endif /* _KERNEL */ + +#endif /* ndef _NETGRAPH_BTSOCKET_HCI_RAW_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_btsocket_l2cap.h b/sys/netgraph/bluetooth/include/ng_btsocket_l2cap.h new file mode 100644 index 0000000..cfae52e --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_btsocket_l2cap.h @@ -0,0 +1,200 @@ +/* + * ng_btsocket_l2cap.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket_l2cap.h,v 1.3 2002/09/22 18:23:31 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_BTSOCKET_L2CAP_H_ +#define _NETGRAPH_BTSOCKET_L2CAP_H_ 1 + +/* + * L2CAP routing entry + */ + +struct ng_hook; +struct ng_message; + +struct ng_btsocket_l2cap_rtentry { + bdaddr_t src; /* source BD_ADDR */ + struct ng_hook *hook; /* downstream hook */ + LIST_ENTRY(ng_btsocket_l2cap_rtentry) next; /* linkt to next */ +}; +typedef struct ng_btsocket_l2cap_rtentry ng_btsocket_l2cap_rtentry_t; +typedef struct ng_btsocket_l2cap_rtentry * ng_btsocket_l2cap_rtentry_p; + +/***************************************************************************** + ***************************************************************************** + ** SOCK_RAW L2CAP sockets ** + ***************************************************************************** + *****************************************************************************/ + +#define NG_BTSOCKET_L2CAP_RAW_SENDSPACE NG_L2CAP_MTU_DEFAULT +#define NG_BTSOCKET_L2CAP_RAW_RECVSPACE NG_L2CAP_MTU_DEFAULT + +/* + * Bluetooth raw L2CAP socket PCB + */ + +struct ng_btsocket_l2cap_raw_pcb { + struct socket *so; /* socket */ + + bdaddr_t src; /* source address */ + ng_btsocket_l2cap_rtentry_p rt; /* routing info */ + + u_int32_t token; /* message token */ + struct ng_mesg *msg; /* message */ + + LIST_ENTRY(ng_btsocket_l2cap_raw_pcb) next; /* link to next PCB */ +}; +typedef struct ng_btsocket_l2cap_raw_pcb ng_btsocket_l2cap_raw_pcb_t; +typedef struct ng_btsocket_l2cap_raw_pcb * ng_btsocket_l2cap_raw_pcb_p; + +#define so2l2cap_raw_pcb(so) \ + ((struct ng_btsocket_l2cap_raw_pcb *)((so)->so_pcb)) + +/* + * Bluetooth raw L2CAP socket methods + */ + +#ifdef _KERNEL + +void ng_btsocket_l2cap_raw_init (void); +int ng_btsocket_l2cap_raw_abort (struct socket *); +int ng_btsocket_l2cap_raw_attach (struct socket *, int, struct thread *); +int ng_btsocket_l2cap_raw_bind (struct socket *, struct sockaddr *, + struct thread *); +int ng_btsocket_l2cap_raw_connect (struct socket *, struct sockaddr *, + struct thread *); +int ng_btsocket_l2cap_raw_control (struct socket *, u_long, caddr_t, + struct ifnet *, struct thread *); +int ng_btsocket_l2cap_raw_detach (struct socket *); +int ng_btsocket_l2cap_raw_disconnect (struct socket *); +int ng_btsocket_l2cap_raw_peeraddr (struct socket *, struct sockaddr **); +int ng_btsocket_l2cap_raw_send (struct socket *, int, struct mbuf *, + struct sockaddr *, struct mbuf *, + struct thread *); +int ng_btsocket_l2cap_raw_sockaddr (struct socket *, struct sockaddr **); + +#endif /* _KERNEL */ + +/***************************************************************************** + ***************************************************************************** + ** SOCK_SEQPACKET L2CAP sockets ** + ***************************************************************************** + *****************************************************************************/ + +#define NG_BTSOCKET_L2CAP_SENDSPACE NG_L2CAP_MTU_DEFAULT /* (64 * 1024) */ +#define NG_BTSOCKET_L2CAP_RECVSPACE (64 * 1024) + +/* + * Bluetooth L2CAP socket PCB + */ + +struct ng_btsocket_l2cap_pcb { + struct socket *so; /* Pointer to socket */ + + bdaddr_t src; /* Source address */ + bdaddr_t dst; /* Destination address */ + + u_int16_t psm; /* PSM */ + u_int16_t cid; /* Local channel ID */ + + u_int16_t flags; /* socket flags */ +#define NG_BTSOCKET_L2CAP_CLIENT (1 << 0) /* socket is client */ +#define NG_BTSOCKET_L2CAP_TIMO (1 << 1) /* timeout pending */ + + u_int8_t state; /* socket state */ +#define NG_BTSOCKET_L2CAP_CLOSED 0 /* socket closed */ +#define NG_BTSOCKET_L2CAP_CONNECTING 1 /* wait for connect */ +#define NG_BTSOCKET_L2CAP_CONFIGURING 2 /* wait for config */ +#define NG_BTSOCKET_L2CAP_OPEN 3 /* socket open */ +#define NG_BTSOCKET_L2CAP_DISCONNECTING 4 /* wait for disconnect */ + + u_int8_t cfg_state; /* config state */ +#define NG_BTSOCKET_L2CAP_CFG_IN (1 << 0) /* incoming path done */ +#define NG_BTSOCKET_L2CAP_CFG_OUT (1 << 1) /* outgoing path done */ +#define NG_BTSOCKET_L2CAP_CFG_BOTH \ + (NG_BTSOCKET_L2CAP_CFG_IN | NG_BTSOCKET_L2CAP_CFG_OUT) + +#define NG_BTSOCKET_L2CAP_CFG_IN_SENT (1 << 2) /* L2CAP ConfigReq sent */ +#define NG_BTSOCKET_L2CAP_CFG_OUT_SENT (1 << 3) /* ---/--- */ + + u_int16_t imtu; /* Incoming MTU */ + ng_l2cap_flow_t iflow; /* Input flow spec */ + + u_int16_t omtu; /* Outgoing MTU */ + ng_l2cap_flow_t oflow; /* Outgoing flow spec */ + + u_int16_t flush_timo; /* flush timeout */ + u_int16_t link_timo; /* link timeout */ + + struct callout_handle timo; /* timeout */ + + u_int32_t token; /* message token */ + ng_btsocket_l2cap_rtentry_p rt; /* routing info */ + + struct mtx pcb_mtx; /* pcb mutex */ + + LIST_ENTRY(ng_btsocket_l2cap_pcb) next; /* link to next PCB */ +}; +typedef struct ng_btsocket_l2cap_pcb ng_btsocket_l2cap_pcb_t; +typedef struct ng_btsocket_l2cap_pcb * ng_btsocket_l2cap_pcb_p; + +#define so2l2cap_pcb(so) \ + ((struct ng_btsocket_l2cap_pcb *)((so)->so_pcb)) + +/* + * Bluetooth L2CAP socket methods + */ + +#ifdef _KERNEL + +void ng_btsocket_l2cap_init (void); +int ng_btsocket_l2cap_abort (struct socket *); +int ng_btsocket_l2cap_accept (struct socket *, struct sockaddr **); +int ng_btsocket_l2cap_attach (struct socket *, int, struct thread *); +int ng_btsocket_l2cap_bind (struct socket *, struct sockaddr *, + struct thread *); +int ng_btsocket_l2cap_connect (struct socket *, struct sockaddr *, + struct thread *); +int ng_btsocket_l2cap_control (struct socket *, u_long, caddr_t, + struct ifnet *, struct thread *); +int ng_btsocket_l2cap_ctloutput (struct socket *, struct sockopt *); +int ng_btsocket_l2cap_detach (struct socket *); +int ng_btsocket_l2cap_disconnect (struct socket *); +int ng_btsocket_l2cap_listen (struct socket *, struct thread *); +int ng_btsocket_l2cap_peeraddr (struct socket *, struct sockaddr **); +int ng_btsocket_l2cap_send (struct socket *, int, struct mbuf *, + struct sockaddr *, struct mbuf *, + struct thread *); +int ng_btsocket_l2cap_sockaddr (struct socket *, struct sockaddr **); + +#endif /* _KERNEL */ + +#endif /* _NETGRAPH_BTSOCKET_L2CAP_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_h4.h b/sys/netgraph/bluetooth/include/ng_h4.h new file mode 100644 index 0000000..8f6f849 --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_h4.h @@ -0,0 +1,118 @@ +/* + * ng_h4.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_h4.h,v 1.5 2002/06/27 09:50:18 max Exp $ + * $FreeBSD$ + * + * Based on: + * --------- + * + * FreeBSD: src/sys/netgraph/ng_tty.h + * Author: Archie Cobbs <archie@freebsd.org> + */ + +/* + * This file contains everything that application needs to know about + * Bluetooth HCI UART transport layer as per chapter H4 of the Bluetooth + * Specification Book v1.1. + * + * This file can be included by both kernel and userland applications. + */ + +#ifndef _NETGRAPH_H4_H_ +#define _NETGRAPH_H4_H_ 1 + +/* + * H4 line discipline + * XXX FIXME: does not belong here. Move to "ttycom.h" later + */ + +#define H4DISC 7 + +/************************************************************************** + ************************************************************************** + ** Netgraph node hook name, type name and type cookie and commands + ************************************************************************** + **************************************************************************/ + +/* Hook name */ +#define NG_H4_HOOK "hook" + +/* Node type name and magic cookie */ +#define NG_H4_NODE_TYPE "h4" +#define NGM_H4_COOKIE 1013899512 + +/* Node states */ +#define NG_H4_W4_PKT_IND 1 /* Waiting for packet indicator */ +#define NG_H4_W4_PKT_HDR 2 /* Waiting for packet header */ +#define NG_H4_W4_PKT_DATA 3 /* Waiting for packet data */ + +/* Debug levels */ +#define NG_H4_ALERT_LEVEL 1 +#define NG_H4_ERR_LEVEL 2 +#define NG_H4_WARN_LEVEL 3 +#define NG_H4_INFO_LEVEL 4 + +/************************************************************************** + ************************************************************************** + ** H4 node command/event parameters + ************************************************************************** + **************************************************************************/ + +/* Reset node */ +#define NGM_H4_NODE_RESET 1 + +/* Get node state (see states above) */ +#define NGM_H4_NODE_GET_STATE 2 +typedef u_int16_t ng_h4_node_state_ep; + +/* Get/Set node debug level (see levels above) */ +#define NGM_H4_NODE_GET_DEBUG 3 +#define NGM_H4_NODE_SET_DEBUG 4 +typedef u_int16_t ng_h4_node_debug_ep; + +/* Get/Set max queue length for the node */ +#define NGM_H4_NODE_GET_QLEN 5 +#define NGM_H4_NODE_SET_QLEN 6 +typedef int32_t ng_h4_node_qlen_ep; + +/* Get node statistic */ +#define NGM_H4_NODE_GET_STAT 7 +typedef struct { + u_int32_t pckts_recv; /* # of packets received */ + u_int32_t bytes_recv; /* # of bytes received */ + u_int32_t pckts_sent; /* # of packets sent */ + u_int32_t bytes_sent; /* # of bytes sent */ + u_int32_t oerrors; /* # of output errors */ + u_int32_t ierrors; /* # of input errors */ +} ng_h4_node_stat_ep; + +/* Reset node statistic */ +#define NGM_H4_NODE_RESET_STAT 8 + +#endif /* _NETGRAPH_H4_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_hci.h b/sys/netgraph/bluetooth/include/ng_hci.h new file mode 100644 index 0000000..c4b1aba --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_hci.h @@ -0,0 +1,1651 @@ +/* + * ng_hci.h + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_hci.h,v 1.13 2002/11/12 22:35:39 max Exp $ + * $FreeBSD$ + */ + +/* + * This file contains everything that application needs to know about + * Host Controller Interface (HCI). All information was obtained from + * Bluetooth Specification Book v1.1. + * + * This file can be included by both kernel and userland applications. + * + * NOTE: Here and after Bluetooth device is called a "unit". Bluetooth + * specification refers to both devices and units. They are the + * same thing (i think), so to be consistent word "unit" will be + * used. + */ + +#ifndef _NETGRAPH_HCI_H_ +#define _NETGRAPH_HCI_H_ 1 + +/************************************************************************** + ************************************************************************** + ** Netgraph node hook name, type name and type cookie and commands + ************************************************************************** + **************************************************************************/ + +/* Node type name and type cookie */ +#define NG_HCI_NODE_TYPE "hci" +#define NGM_HCI_COOKIE 1000774184 + +/* Netgraph node hook names */ +#define NG_HCI_HOOK_DRV "drv" /* Driver <-> HCI */ +#define NG_HCI_HOOK_ACL "acl" /* HCI <-> Upper */ +#define NG_HCI_HOOK_SCO "sco" /* HCI <-> Upper */ +#define NG_HCI_HOOK_RAW "raw" /* HCI <-> Upper */ + +/************************************************************************** + ************************************************************************** + ** Common defines and types (HCI) + ************************************************************************** + **************************************************************************/ + +/* All sizes are in bytes */ +#define NG_HCI_BDADDR_SIZE 6 /* unit address */ +#define NG_HCI_LAP_SIZE 3 /* unit LAP */ +#define NG_HCI_KEY_SIZE 16 /* link key */ +#define NG_HCI_PIN_SIZE 16 /* link PIN */ +#define NG_HCI_EVENT_MASK_SIZE 8 /* event mask */ +#define NG_HCI_CLASS_SIZE 3 /* unit class */ +#define NG_HCI_FEATURES_SIZE 8 /* LMP features */ +#define NG_HCI_UNIT_NAME_SIZE 248 /* unit name size */ + +/* HCI specification */ +#define NG_HCI_SPEC_V10 0x00 /* v1.0 */ +#define NG_HCI_SPEC_V11 0x01 /* v1.1 */ +/* 0x02 - 0xFF - reserved for future use */ + +/* LMP features */ +/* ------------------- byte 0 --------------------*/ +#define NG_HCI_LMP_3SLOT 0x01 +#define NG_HCI_LMP_5SLOT 0x02 +#define NG_HCI_LMP_ENCRYPTION 0x04 +#define NG_HCI_LMP_SLOT_OFFSET 0x08 +#define NG_HCI_LMP_TIMING_ACCURACY 0x10 +#define NG_HCI_LMP_SWITCH 0x20 +#define NG_HCI_LMP_HOLD_MODE 0x40 +#define NG_HCI_LMP_SNIFF_MODE 0x80 +/* ------------------- byte 1 --------------------*/ +#define NG_HCI_LMP_PARK_MODE 0x01 +#define NG_HCI_LMP_RSSI 0x02 +#define NG_HCI_LMP_CHANNEL_QUALITY 0x04 +#define NG_HCI_LMP_SCO_LINK 0x08 +#define NG_HCI_LMP_HV2_PKT 0x10 +#define NG_HCI_LMP_HV3_PKT 0x20 +#define NG_HCI_LMP_ULAW_LOG 0x40 +#define NG_HCI_LMP_ALAW_LOG 0x80 +/* ------------------- byte 2 --------------------*/ +#define NG_HCI_LMP_CVSD 0x01 +#define NG_HCI_LMP_PAGING_SCHEME 0x02 +#define NG_HCI_LMP_POWER_CONTROL 0x04 +#define NG_HCI_LMP_TRANSPARENT_SCO 0x08 +#define NG_HCI_LMP_FLOW_CONTROL_LAG0 0x10 +#define NG_HCI_LMP_FLOW_CONTROL_LAG1 0x20 +#define NG_HCI_LMP_FLOW_CONTROL_LAG2 0x40 + +/* Link types */ +#define NG_HCI_LINK_SCO 0x00 /* Voice */ +#define NG_HCI_LINK_ACL 0x01 /* Data */ +/* 0x02 - 0xFF - reserved for future use */ + +/* Packet types */ + /* 0x0001 - 0x0004 - reserved for future use */ +#define NG_HCI_PKT_DM1 0x0008 /* ACL link */ +#define NG_HCI_PKT_DH1 0x0010 /* ACL link */ +#define NG_HCI_PKT_HV1 0x0020 /* SCO link */ +#define NG_HCI_PKT_HV2 0x0040 /* SCO link */ +#define NG_HCI_PKT_HV3 0x0080 /* SCO link */ + /* 0x0100 - 0x0200 - reserved for future use */ +#define NG_HCI_PKT_DM3 0x0400 /* ACL link */ +#define NG_HCI_PKT_DH3 0x0800 /* ACL link */ + /* 0x1000 - 0x2000 - reserved for future use */ +#define NG_HCI_PKT_DM5 0x4000 /* ACL link */ +#define NG_HCI_PKT_DH5 0x8000 /* ACL link */ + +/* + * Connection modes/Unit modes + * + * This is confusing. It means that one of the units change its mode + * for the specific connection. For example one connection was put on + * hold (but i could be wrong :) + */ + +#define NG_HCI_UNIT_MODE_ACTIVE 0x00 +#define NG_HCI_UNIT_MODE_HOLD 0x01 +#define NG_HCI_UNIT_MODE_SNIFF 0x02 +#define NG_HCI_UNIT_MODE_PARK 0x03 +/* 0x04 - 0xFF - reserved for future use */ + +/* Page scan modes */ +#define NG_HCI_MANDATORY_PAGE_SCAN_MODE 0x00 +#define NG_HCI_OPTIONAL_PAGE_SCAN_MODE1 0x01 +#define NG_HCI_OPTIONAL_PAGE_SCAN_MODE2 0x02 +#define NG_HCI_OPTIONAL_PAGE_SCAN_MODE3 0x03 +/* 0x04 - 0xFF - reserved for future use */ + +/* Page scan repetition modes */ +#define NG_HCI_SCAN_REP_MODE0 0x00 +#define NG_HCI_SCAN_REP_MODE1 0x01 +#define NG_HCI_SCAN_REP_MODE2 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Page scan period modes */ +#define NG_HCI_PAGE_SCAN_PERIOD_MODE0 0x00 +#define NG_HCI_PAGE_SCAN_PERIOD_MODE1 0x01 +#define NG_HCI_PAGE_SCAN_PERIOD_MODE2 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Scan enable */ +#define NG_HCI_NO_SCAN_ENABLE 0x00 +#define NG_HCI_INQUIRY_ENABLE_PAGE_DISABLE 0x01 +#define NG_HCI_INQUIRY_DISABLE_PAGE_ENABLE 0x02 +#define NG_HCI_INQUIRY_ENABLE_PAGE_ENABLE 0x03 +/* 0x04 - 0xFF - reserved for future use */ + +/* Hold mode activities */ +#define NG_HCI_HOLD_MODE_NO_CHANGE 0x00 +#define NG_HCI_HOLD_MODE_SUSPEND_PAGE_SCAN 0x01 +#define NG_HCI_HOLD_MODE_SUSPEND_INQUIRY_SCAN 0x02 +#define NG_HCI_HOLD_MODE_SUSPEND_PERIOD_INQUIRY 0x04 +/* 0x08 - 0x80 - reserved for future use */ + +/* Connection roles */ +#define NG_HCI_ROLE_MASTER 0x00 +#define NG_HCI_ROLE_SLAVE 0x01 +/* 0x02 - 0xFF - reserved for future use */ + +/* Key flags */ +#define NG_HCI_USE_SEMI_PERMANENT_LINK_KEYS 0x00 +#define NG_HCI_USE_TEMPORARY_LINK_KEY 0x01 +/* 0x02 - 0xFF - reserved for future use */ + +/* Pin types */ +#define NG_HCI_PIN_TYPE_VARIABLE 0x00 +#define NG_HCI_PIN_TYPE_FIXED 0x01 + +/* Link key types */ +#define NG_HCI_LINK_KEY_TYPE_COMBINATION_KEY 0x00 +#define NG_HCI_LINK_KEY_TYPE_LOCAL_UNIT_KEY 0x01 +#define NG_HCI_LINK_KEY_TYPE_REMOTE_UNIT_KEY 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Encryption modes */ +#define NG_HCI_ENCRYPTION_MODE_NONE 0x00 +#define NG_HCI_ENCRYPTION_MODE_P2P 0x01 +#define NG_HCI_ENCRYPTION_MODE_ALL 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Quality of service types */ +#define NG_HCI_SERVICE_TYPE_NO_TRAFFIC 0x00 +#define NG_HCI_SERVICE_TYPE_BEST_EFFORT 0x01 +#define NG_HCI_SERVICE_TYPE_GUARANTEED 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Link policy settings */ +#define NG_HCI_LINK_POLICY_DISABLE_ALL_LM_MODES 0x0000 +#define NG_HCI_LINK_POLICY_ENABLE_ROLE_SWITCH 0x0001 /* Master/Slave switch */ +#define NG_HCI_LINK_POLICY_ENABLE_HOLD_MODE 0x0002 +#define NG_HCI_LINK_POLICY_ENABLE_SNIFF_MODE 0x0004 +#define NG_HCI_LINK_POLICY_ENABLE_PARK_MODE 0x0008 +/* 0x0010 - 0x8000 - reserved for future use */ + +/* Event masks */ +#define NG_HCI_EVMSK_ALL 0x00000000ffffffff +#define NG_HCI_EVMSK_NONE 0x0000000000000000 +#define NG_HCI_EVMSK_INQUIRY_COMPL 0x0000000000000001 +#define NG_HCI_EVMSK_INQUIRY_RESULT 0x0000000000000002 +#define NG_HCI_EVMSK_CON_COMPL 0x0000000000000004 +#define NG_HCI_EVMSK_CON_REQ 0x0000000000000008 +#define NG_HCI_EVMSK_DISCON_COMPL 0x0000000000000010 +#define NG_HCI_EVMSK_AUTH_COMPL 0x0000000000000020 +#define NG_HCI_EVMSK_REMOTE_NAME_REQ_COMPL 0x0000000000000040 +#define NG_HCI_EVMSK_ENCRYPTION_CHANGE 0x0000000000000080 +#define NG_HCI_EVMSK_CHANGE_CON_LINK_KEY_COMPL 0x0000000000000100 +#define NG_HCI_EVMSK_MASTER_LINK_KEY_COMPL 0x0000000000000200 +#define NG_HCI_EVMSK_READ_REMOTE_FEATURES_COMPL 0x0000000000000400 +#define NG_HCI_EVMSK_READ_REMOTE_VER_INFO_COMPL 0x0000000000000800 +#define NG_HCI_EVMSK_QOS_SETUP_COMPL 0x0000000000001000 +#define NG_HCI_EVMSK_COMMAND_COMPL 0x0000000000002000 +#define NG_HCI_EVMSK_COMMAND_STATUS 0x0000000000004000 +#define NG_HCI_EVMSK_HARDWARE_ERROR 0x0000000000008000 +#define NG_HCI_EVMSK_FLUSH_OCCUR 0x0000000000010000 +#define NG_HCI_EVMSK_ROLE_CHANGE 0x0000000000020000 +#define NG_HCI_EVMSK_NUM_COMPL_PKTS 0x0000000000040000 +#define NG_HCI_EVMSK_MODE_CHANGE 0x0000000000080000 +#define NG_HCI_EVMSK_RETURN_LINK_KEYS 0x0000000000100000 +#define NG_HCI_EVMSK_PIN_CODE_REQ 0x0000000000200000 +#define NG_HCI_EVMSK_LINK_KEY_REQ 0x0000000000400000 +#define NG_HCI_EVMSK_LINK_KEY_NOTIFICATION 0x0000000000800000 +#define NG_HCI_EVMSK_LOOPBACK_COMMAND 0x0000000001000000 +#define NG_HCI_EVMSK_DATA_BUFFER_OVERFLOW 0x0000000002000000 +#define NG_HCI_EVMSK_MAX_SLOT_CHANGE 0x0000000004000000 +#define NG_HCI_EVMSK_READ_CLOCK_OFFSET_COMLETE 0x0000000008000000 +#define NG_HCI_EVMSK_CON_PKT_TYPE_CHANGED 0x0000000010000000 +#define NG_HCI_EVMSK_QOS_VIOLATION 0x0000000020000000 +#define NG_HCI_EVMSK_PAGE_SCAN_MODE_CHANGE 0x0000000040000000 +#define NG_HCI_EVMSK_PAGE_SCAN_REP_MODE_CHANGE 0x0000000080000000 +/* 0x0000000100000000 - 0x8000000000000000 - reserved for future use */ + +/* Filter types */ +#define NG_HCI_FILTER_TYPE_NONE 0x00 +#define NG_HCI_FILTER_TYPE_INQUIRY_RESULT 0x01 +#define NG_HCI_FILTER_TYPE_CON_SETUP 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Filter condition types for NG_HCI_FILTER_TYPE_INQUIRY_RESULT */ +#define NG_HCI_FILTER_COND_INQUIRY_NEW_UNIT 0x00 +#define NG_HCI_FILTER_COND_INQUIRY_UNIT_CLASS 0x01 +#define NG_HCI_FILTER_COND_INQUIRY_BDADDR 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Filter condition types for NG_HCI_FILTER_TYPE_CON_SETUP */ +#define NG_HCI_FILTER_COND_CON_ANY_UNIT 0x00 +#define NG_HCI_FILTER_COND_CON_UNIT_CLASS 0x01 +#define NG_HCI_FILTER_COND_CON_BDADDR 0x02 +/* 0x03 - 0xFF - reserved for future use */ + +/* Xmit level types */ +#define NG_HCI_XMIT_LEVEL_CURRENT 0x00 +#define NG_HCI_XMIT_LEVEL_MAXIMUM 0x01 +/* 0x02 - 0xFF - reserved for future use */ + +/* Host to Host Controller flow control */ +#define NG_HCI_H2HC_FLOW_CONTROL_NONE 0x00 +#define NG_HCI_H2HC_FLOW_CONTROL_ACL 0x01 +#define NG_HCI_H2HC_FLOW_CONTROL_SCO 0x02 +#define NG_HCI_H2HC_FLOW_CONTROL_BOTH 0x03 /* ACL and SCO */ +/* 0x04 - 0xFF - reserved future use */ + +/* Country codes */ +#define NG_HCI_COUNTRY_CODE_NAM_EUR_JP 0x00 +#define NG_HCI_COUNTRY_CODE_FRANCE 0x01 +/* 0x02 - 0xFF - reserved future use */ + +/* Loopback modes */ +#define NG_HCI_LOOPBACK_NONE 0x00 +#define NG_HCI_LOOPBACK_LOCAL 0x01 +#define NG_HCI_LOOPBACK_REMOTE 0x02 +/* 0x03 - 0xFF - reserved future use */ + +/************************************************************************** + ************************************************************************** + ** Link level defines, headers and types + ************************************************************************** + **************************************************************************/ + +/* + * Macro(s) to combine OpCode and extract OGF (OpCode Group Field) + * and OCF (OpCode Command Field) from OpCode. + */ + +#define NG_HCI_OPCODE(gf,cf) ((((gf) & 0x3f) << 10) | ((cf) & 0x3ff)) +#define NG_HCI_OCF(op) ((op) & 0x3ff) +#define NG_HCI_OGF(op) (((op) >> 10) & 0x3f) + +/* + * Marco(s) to extract/combine connection handle, BC (Broadcast) and + * PB (Packet boundary) flags. + */ + +#define NG_HCI_CON_HANDLE(h) ((h) & 0x0fff) +#define NG_HCI_PB_FLAG(h) (((h) & 0x3000) >> 12) +#define NG_HCI_BC_FLAG(h) (((h) & 0xc000) >> 14) +#define NG_HCI_MK_CON_HANDLE(h, pb, bc) \ + (((h) & 0x0fff) | (((pb) & 3) << 12) | (((bc) & 3) << 14)) + +/* PB flag values */ + /* 00 - reserved for future use */ +#define NG_HCI_PACKET_FRAGMENT 0x1 +#define NG_HCI_PACKET_START 0x2 + /* 11 - reserved for future use */ + +/* BC flag values */ +#define NG_HCI_POINT2POINT 0x0 /* only Host controller to Host */ +#define NG_HCI_BROADCAST_ACTIVE 0x1 /* both directions */ +#define NG_HCI_BROADCAST_PICONET 0x2 /* both directions */ + /* 11 - reserved for future use */ + +/* HCI command packet header */ +#define NG_HCI_CMD_PKT 0x01 +#define NG_HCI_CMD_PKT_SIZE 0xff /* without header */ +typedef struct { + u_int8_t type; /* MUST be 0x1 */ + u_int16_t opcode; /* OpCode */ + u_int8_t length; /* parameter(s) length in bytes */ +} __attribute__ ((packed)) ng_hci_cmd_pkt_t; + +/* ACL data packet header */ +#define NG_HCI_ACL_DATA_PKT 0x02 +#define NG_HCI_ACL_PKT_SIZE 0xffff /* without header */ +typedef struct { + u_int8_t type; /* MUST be 0x2 */ + u_int16_t con_handle; /* connection handle + PB + BC flags */ + u_int16_t length; /* payload length in bytes */ +} __attribute__ ((packed)) ng_hci_acldata_pkt_t; + +/* SCO data packet header */ +#define NG_HCI_SCO_DATA_PKT 0x03 +#define NG_HCI_SCO_PKT_SIZE 0xff /* without header */ +typedef struct { + u_int8_t type; /* MUST be 0x3 */ + u_int16_t con_handle; /* connection handle + reserved bits */ + u_int8_t length; /* payload length in bytes */ +} __attribute__ ((packed)) ng_hci_scodata_pkt_t; + +/* HCI event packet header */ +#define NG_HCI_EVENT_PKT 0x04 +#define NG_HCI_EVENT_PKT_SIZE 0xff /* without header */ +typedef struct { + u_int8_t type; /* MUST be 0x4 */ + u_int8_t event; /* event */ + u_int8_t length; /* parameter(s) length in bytes */ +} __attribute__ ((packed)) ng_hci_event_pkt_t; + +/* Bluetooth unit address */ +typedef struct { + u_int8_t b[NG_HCI_BDADDR_SIZE]; +} __attribute__ ((packed)) bdaddr_t; +typedef bdaddr_t * bdaddr_p; + +/* Any BD_ADDR. Note: This is actually 7 bytes (count '\0' terminator) */ +#define NG_HCI_BDADDR_ANY ((bdaddr_p) "\000\000\000\000\000\000") + +/* HCI status return parameter */ +typedef struct { + u_int8_t status; /* 0x00 - success */ +} __attribute__ ((packed)) ng_hci_status_rp; + +/************************************************************************** + ************************************************************************** + ** Upper layer protocol interface. LP_xxx event parameters + ************************************************************************** + **************************************************************************/ + +/* Connection Request Event */ +#define NGM_HCI_LP_CON_REQ 1 /* Upper -> HCI */ +typedef struct { + u_int16_t link_type; /* type of connection */ + bdaddr_t bdaddr; /* remote unit address */ +} ng_hci_lp_con_req_ep; + +/* + * XXX XXX XXX + * + * NOTE: This request is not defined by Bluetooth specification, + * but i find it useful :) + */ +#define NGM_HCI_LP_DISCON_REQ 2 /* Upper -> HCI */ +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t reason; /* reason to disconnect (only low byte) */ +} ng_hci_lp_discon_req_ep; + +/* Connection Confirmation Event */ +#define NGM_HCI_LP_CON_CFM 3 /* HCI -> Upper */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t link_type; /* link type */ + u_int16_t con_handle; /* con_handle */ + bdaddr_t bdaddr; /* remote unit address */ +} ng_hci_lp_con_cfm_ep; + +/* Connection Indication Event */ +#define NGM_HCI_LP_CON_IND 4 /* HCI -> Upper */ +typedef struct { + u_int8_t link_type; /* link type */ + u_int8_t uclass[NG_HCI_CLASS_SIZE]; /* unit class */ + bdaddr_t bdaddr; /* remote unit address */ +} ng_hci_lp_con_ind_ep; + +/* Connection Response Event */ +#define NGM_HCI_LP_CON_RSP 5 /* Upper -> HCI */ +typedef struct { + u_int8_t status; /* 0x00 - accept connection */ + u_int8_t link_type; /* link type */ + bdaddr_t bdaddr; /* remote unit address */ +} ng_hci_lp_con_rsp_ep; + +/* Disconnection Indication Event */ +#define NGM_HCI_LP_DISCON_IND 6 /* HCI -> Upper */ +typedef struct { + u_int8_t reason; /* reason to disconnect (only low byte) */ + u_int8_t link_type; /* link type */ + u_int16_t con_handle; /* connection handle */ +} ng_hci_lp_discon_ind_ep; + +/* QoS Setup Request Event */ +#define NGM_HCI_LP_QOS_REQ 7 /* Upper -> HCI */ +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int8_t flags; /* reserved */ + u_int8_t service_type; /* service type */ + u_int32_t token_rate; /* bytes/sec */ + u_int32_t peak_bandwidth; /* bytes/sec */ + u_int32_t latency; /* msec */ + u_int32_t delay_variation; /* msec */ +} ng_hci_lp_qos_req_ep; + +/* QoS Conformition Event */ +#define NGM_HCI_LP_QOS_CFM 8 /* HCI -> Upper */ +typedef struct { + u_int16_t status; /* 0x00 - success (only low byte) */ + u_int16_t con_handle; /* connection handle */ +} ng_hci_lp_qos_cfm_ep; + +/* QoS Violation Indication Event */ +#define NGM_HCI_LP_QOS_IND 9 /* HCI -> Upper */ +typedef struct { + u_int16_t con_handle; /* connection handle */ +} ng_hci_lp_qos_ind_ep; + +/************************************************************************** + ************************************************************************** + ** HCI node command/event parameters + ************************************************************************** + **************************************************************************/ + +/* Debug levels */ +#define NG_HCI_ALERT_LEVEL 1 +#define NG_HCI_ERR_LEVEL 2 +#define NG_HCI_WARN_LEVEL 3 +#define NG_HCI_INFO_LEVEL 4 + +/* Unit states */ +#define NG_HCI_UNIT_CONNECTED (1 << 0) +#define NG_HCI_UNIT_INITED (1 << 1) +#define NG_HCI_UNIT_READY (NG_HCI_UNIT_CONNECTED|NG_HCI_UNIT_INITED) +#define NG_HCI_UNIT_COMMAND_PENDING (1 << 2) + +/* Connection state */ +#define NG_HCI_CON_CLOSED 0 /* connection closed */ +#define NG_HCI_CON_W4_LP_CON_RSP 1 /* wait for LP_ConnectRsp */ +#define NG_HCI_CON_W4_CONN_COMPLETE 2 /* wait for Connection_Complete evt */ +#define NG_HCI_CON_OPEN 3 /* connection open */ + +/* Get HCI node (unit) state (see states above) */ +#define NGM_HCI_NODE_GET_STATE 100 /* HCI -> User */ +typedef u_int16_t ng_hci_node_state_ep; + +/* Turn on "inited" bit */ +#define NGM_HCI_NODE_INIT 101 /* User -> HCI */ +/* No parameters */ + +/* Get/Set node debug level (see debug levels above) */ +#define NGM_HCI_NODE_GET_DEBUG 102 /* HCI -> User */ +#define NGM_HCI_NODE_SET_DEBUG 103 /* User -> HCI */ +typedef u_int16_t ng_hci_node_debug_ep; + +/* Get node buffer info */ +#define NGM_HCI_NODE_GET_BUFFER 104 /* HCI -> User */ +typedef struct { + u_int8_t cmd_free; /* number of free command packets */ + u_int8_t sco_size; /* max. size of SCO packet */ + u_int16_t sco_pkts; /* number of SCO packets */ + u_int16_t sco_free; /* number of free SCO packets */ + u_int16_t acl_size; /* max. size of ACL packet */ + u_int16_t acl_pkts; /* number of ACL packets */ + u_int16_t acl_free; /* number of free ACL packets */ +} ng_hci_node_buffer_ep; + +/* Get BDADDR */ +#define NGM_HCI_NODE_GET_BDADDR 105 /* HCI -> User */ +/* bdaddr_t -- BDADDR */ + +/* Get features */ +#define NGM_HCI_NODE_GET_FEATURES 106 /* HCI -> User */ +/* features[NG_HCI_FEATURES_SIZE] -- features */ + +#define NGM_HCI_NODE_GET_STAT 107 /* HCI -> User */ +typedef struct { + u_int32_t cmd_sent; /* number of HCI commands sent */ + u_int32_t evnt_recv; /* number of HCI events received */ + u_int32_t acl_recv; /* number of ACL packets received */ + u_int32_t acl_sent; /* number of ACL packets sent */ + u_int32_t sco_recv; /* number of SCO packets received */ + u_int32_t sco_sent; /* number of SCO packets sent */ + u_int32_t bytes_recv; /* total number of bytes received */ + u_int32_t bytes_sent; /* total number of bytes sent */ +} ng_hci_node_stat_ep; + +#define NGM_HCI_NODE_RESET_STAT 108 /* User -> HCI */ +/* No parameters */ + +#define NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE 109 /* User -> HCI */ + +#define NGM_HCI_NODE_GET_NEIGHBOR_CACHE 110 /* HCI -> User */ +typedef struct { + u_int32_t num_entries; /* number of entries */ +} ng_hci_node_get_neighbor_cache_ep; + +typedef struct { + u_int16_t page_scan_rep_mode; /* page rep scan mode */ + u_int16_t page_scan_mode; /* page scan mode */ + u_int16_t clock_offset; /* clock offset */ + bdaddr_t bdaddr; /* bdaddr */ + u_int8_t features[NG_HCI_FEATURES_SIZE]; /* features */ +} ng_hci_node_neighbor_cache_entry_ep; + +#define NG_HCI_MAX_NEIGHBOR_NUM \ + ((0xffff - sizeof(ng_hci_node_get_neighbor_cache_ep))/sizeof(ng_hci_node_neighbor_cache_entry_ep)) + +#define NGM_HCI_NODE_GET_CON_LIST 111 /* HCI -> User */ +typedef struct { + u_int32_t num_connections; /* number of connections */ +} ng_hci_node_con_list_ep; + +typedef struct { + u_int8_t link_type; /* ACL or SCO */ + u_int8_t encryption_mode; /* none, p2p, ... */ + u_int8_t mode; /* ACTIVE, HOLD ... */ + u_int8_t role; /* MASTER/SLAVE */ + u_int16_t state; /* connection state */ + u_int16_t reserved; /* place holder */ + u_int16_t pending; /* number of pending packets */ + u_int16_t queue_len; /* number of packets in queue */ + u_int16_t con_handle; /* connection handle */ + bdaddr_t bdaddr; /* remote bdaddr */ +} ng_hci_node_con_ep; + +#define NG_HCI_MAX_CON_NUM \ + ((0xffff - sizeof(ng_hci_node_con_list_ep))/sizeof(ng_hci_node_con_ep)) + +#define NGM_HCI_NODE_UP 112 /* HCI -> Upper */ +typedef struct { + u_int16_t pkt_size; /* max. ACL/SCO packet size (w/out header) */ + u_int16_t num_pkts; /* ACL/SCO packet queue size */ + u_int16_t reserved; /* place holder */ + bdaddr_t bdaddr; /* bdaddr */ +} ng_hci_node_up_ep; + +#define NGM_HCI_SYNC_CON_QUEUE 113 /* HCI -> Upper */ +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t completed; /* number of completed packets */ +} ng_hci_sync_con_queue_ep; + +#define NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK 114 /* HCI -> User */ +#define NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK 115 /* User -> HCI */ +typedef u_int16_t ng_hci_node_link_policy_mask_ep; + +#define NGM_HCI_NODE_GET_PACKET_MASK 116 /* HCI -> User */ +#define NGM_HCI_NODE_SET_PACKET_MASK 117 /* User -> HCI */ +typedef u_int16_t ng_hci_node_packet_mask_ep; + +/************************************************************************** + ************************************************************************** + ** Link control commands and return parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_LINK_CONTROL 0x01 /* OpCode Group Field */ + +#define NG_HCI_OCF_INQUIRY 0x0001 +typedef struct { + u_int8_t lap[NG_HCI_LAP_SIZE]; /* LAP */ + u_int8_t inquiry_length; /* (N x 1.28) sec */ + u_int8_t num_responses; /* Max. # of responses before halted */ +} __attribute__ ((packed)) ng_hci_inquiry_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_INQUIRY_CANCEL 0x0002 +/* No command parameter(s) */ +typedef ng_hci_status_rp ng_hci_inquiry_cancel_rp; + +#define NG_HCI_OCF_PERIODIC_INQUIRY 0x0003 +typedef struct { + u_int16_t max_period_length; /* Max. and min. amount of time */ + u_int16_t min_period_length; /* between consecutive inquiries */ + u_int8_t lap[NG_HCI_LAP_SIZE]; /* LAP */ + u_int8_t inquiry_length; /* (inquiry_length * 1.28) sec */ + u_int8_t num_responses; /* Max. # of responses */ +} __attribute__ ((packed)) ng_hci_periodic_inquiry_cp; + +typedef ng_hci_status_rp ng_hci_periodic_inquiry_rp; + +#define NG_HCI_OCF_EXIT_PERIODIC_INQUIRY 0x0004 +/* No command parameter(s) */ +typedef ng_hci_status_rp ng_hci_exit_periodic_inquiry_rp; + +#define NG_HCI_OCF_CREATE_CON 0x0005 +typedef struct { + bdaddr_t bdaddr; /* destination address */ + u_int16_t pkt_type; /* packet type */ + u_int8_t page_scan_rep_mode; /* page scan repetition mode */ + u_int8_t page_scan_mode; /* page scan mode */ + u_int16_t clock_offset; /* clock offset */ + u_int8_t accept_role_switch; /* accept role switch? 0x00 - no */ +} __attribute__ ((packed)) ng_hci_create_con_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_DISCON 0x0006 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int8_t reason; /* reason to disconnect */ +} __attribute__ ((packed)) ng_hci_discon_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_ADD_SCO_CON 0x0007 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t pkt_type; /* packet type */ +} __attribute__ ((packed)) ng_hci_add_sco_con_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_ACCEPT_CON 0x0009 +typedef struct { + bdaddr_t bdaddr; /* address of unit to be connected */ + u_int8_t role; /* connection role */ +} __attribute__ ((packed)) ng_hci_accept_con_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_REJECT_CON 0x000a +typedef struct { + bdaddr_t bdaddr; /* remote address */ + u_int8_t reason; /* reason to reject */ +} __attribute__ ((packed)) ng_hci_reject_con_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_LINK_KEY_REP 0x000b +typedef struct { + bdaddr_t bdaddr; /* remote address */ + u_int8_t key[NG_HCI_KEY_SIZE]; /* key */ +} __attribute__ ((packed)) ng_hci_link_key_rep_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* unit address */ +} __attribute__ ((packed)) ng_hci_link_key_rep_rp; + +#define NG_HCI_OCF_LINK_KEY_NEG_REP 0x000c +typedef struct { + bdaddr_t bdaddr; /* remote address */ +} __attribute__ ((packed)) ng_hci_link_key_neg_rep_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* unit address */ +} __attribute__ ((packed)) ng_hci_link_key_neg_rep_rp; + +#define NG_HCI_OCF_PIN_CODE_REP 0x000d +typedef struct { + bdaddr_t bdaddr; /* remote address */ + u_int8_t pin_size; /* pin code length (in bytes) */ + u_int8_t pin[NG_HCI_PIN_SIZE]; /* pin code */ +} __attribute__ ((packed)) ng_hci_pin_code_rep_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* unit address */ +} __attribute__ ((packed)) ng_hci_pin_code_rep_rp; + +#define NG_HCI_OCF_PIN_CODE_NEG_REP 0x000e +typedef struct { + bdaddr_t bdaddr; /* remote address */ +} __attribute__ ((packed)) ng_hci_pin_code_neg_rep_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* unit address */ +} __attribute__ ((packed)) ng_hci_pin_code_neg_rep_rp; + +#define NG_HCI_OCF_CHANGE_CON_PKT_TYPE 0x000f +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t pkt_type; /* packet type */ +} __attribute__ ((packed)) ng_hci_change_con_pkt_type_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_AUTH_REQ 0x0011 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_auth_req_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_SET_CON_ENCRYPTION 0x0013 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int8_t encryption_enable; /* 0x00 - disable, 0x01 - enable */ +} __attribute__ ((packed)) ng_hci_set_con_encryption_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_CHANGE_CON_LINK_KEY 0x0015 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_change_con_link_key_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_MASTER_LINK_KEY 0x0017 +typedef struct { + u_int8_t key_flag; /* key flag */ +} __attribute__ ((packed)) ng_hci_master_link_key_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_REMOTE_NAME_REQ 0x0019 +typedef struct { + bdaddr_t bdaddr; /* remote address */ + u_int8_t page_scan_rep_mode; /* page scan repetition mode */ + u_int8_t page_scan_mode; /* page scan mode */ + u_int16_t clock_offset; /* clock offset */ +} __attribute__ ((packed)) ng_hci_remote_name_req_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_READ_REMOTE_FEATURES 0x001b +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_remote_features_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_READ_REMOTE_VER_INFO 0x001d +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_remote_ver_info_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_READ_CLOCK_OFFSET 0x001f +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_clock_offset_cp; +/* No return parameter(s) */ + +/************************************************************************** + ************************************************************************** + ** Link policy commands and return parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_LINK_POLICY 0x02 /* OpCode Group Field */ + +#define NG_HCI_OCF_HOLD_MODE 0x0001 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t max_interval; /* (max_interval * 0.625) msec */ + u_int16_t min_interval; /* (max_interval * 0.625) msec */ +} __attribute__ ((packed)) ng_hci_hold_mode_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_SNIFF_MODE 0x0003 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t max_interval; /* (max_interval * 0.625) msec */ + u_int16_t min_interval; /* (max_interval * 0.625) msec */ + u_int16_t attempt; /* (2 * attempt - 1) * 0.625 msec */ + u_int16_t timeout; /* (2 * attempt - 1) * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_sniff_mode_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_EXIT_SNIFF_MODE 0x0004 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_exit_sniff_mode_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_PARK_MODE 0x0005 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t max_interval; /* (max_interval * 0.625) msec */ + u_int16_t min_interval; /* (max_interval * 0.625) msec */ +} __attribute__ ((packed)) ng_hci_park_mode_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_EXIT_PARK_MODE 0x0006 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_exit_park_mode_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_QOS_SETUP 0x0007 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int8_t flags; /* reserved for future use */ + u_int8_t service_type; /* service type */ + u_int32_t token_rate; /* bytes per second */ + u_int32_t peak_bandwidth; /* bytes per second */ + u_int32_t latency; /* microseconds */ + u_int32_t delay_variation; /* microseconds */ +} __attribute__ ((packed)) ng_hci_qos_setup_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_ROLE_DISCOVERY 0x0009 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_role_discovery_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int8_t role; /* role for the connection handle */ +} __attribute__ ((packed)) ng_hci_role_discovery_rp; + +#define NG_HCI_OCF_SWITCH_ROLE 0x000b +typedef struct { + bdaddr_t bdaddr; /* remote address */ + u_int8_t role; /* new local role */ +} __attribute__ ((packed)) ng_hci_switch_role_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_READ_LINK_POLICY_SETTINGS 0x000c +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_link_policy_settings_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int16_t settings; /* link policy settings */ +} __attribute__ ((packed)) ng_hci_read_link_policy_settings_rp; + +#define NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS 0x000d +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t settings; /* link policy settings */ +} __attribute__ ((packed)) ng_hci_write_link_policy_settings_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_write_link_policy_settings_rp; + +/************************************************************************** + ************************************************************************** + ** Host controller and baseband commands and return parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_HC_BASEBAND 0x03 /* OpCode Group Field */ + +#define NG_HCI_OCF_SET_EVENT_MASK 0x0001 +typedef struct { + u_int8_t event_mask[NG_HCI_EVENT_MASK_SIZE]; /* event_mask */ +} __attribute__ ((packed)) ng_hci_set_event_mask_cp; + +typedef ng_hci_status_rp ng_hci_set_event_mask_rp; + +#define NG_HCI_OCF_RESET 0x0003 +/* No command parameter(s) */ +typedef ng_hci_status_rp ng_hci_reset_rp; + +#define NG_HCI_OCF_SET_EVENT_FILTER 0x0005 +typedef struct { + u_int8_t filter_type; /* filter type */ + u_int8_t filter_condition_type; /* filter condition type */ + u_int8_t condition[0]; /* conditions - variable size */ +} __attribute__ ((packed)) ng_hci_set_event_filter_cp; + +typedef ng_hci_status_rp ng_hci_set_event_filter_rp; + +#define NG_HCI_OCF_FLUSH 0x0008 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_flush_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_flush_rp; + +#define NG_HCI_OCF_READ_PIN_TYPE 0x0009 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t pin_type; /* PIN type */ +} __attribute__ ((packed)) ng_hci_read_pin_type_rp; + +#define NG_HCI_OCF_WRITE_PIN_TYPE 0x000a +typedef struct { + u_int8_t pin_type; /* PIN type */ +} __attribute__ ((packed)) ng_hci_write_pin_type_cp; + +typedef ng_hci_status_rp ng_hci_write_pin_type_rp; + +#define NG_HCI_OCF_CREATE_NEW_UNIT_KEY 0x000b +/* No command parameter(s) */ +typedef ng_hci_status_rp ng_hci_create_new_unit_key_rp; + +#define NG_HCI_OCF_READ_STORED_LINK_KEY 0x000d +typedef struct { + bdaddr_t bdaddr; /* address */ + u_int8_t read_all; /* read all keys? 0x01 - yes */ +} __attribute__ ((packed)) ng_hci_read_stored_link_key_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t max_num_keys; /* Max. number of keys */ + u_int16_t num_keys_read; /* Number of stored keys */ +} __attribute__ ((packed)) ng_hci_read_stored_link_key_rp; + +#define NG_HCI_OCF_WRITE_STORED_LINK_KEY 0x0011 +typedef struct { + u_int8_t num_keys_write; /* # of keys to write */ +/* these are repeated "num_keys_write" times + bdaddr_t bdaddr; --- remote address(es) + u_int8_t key[NG_HCI_KEY_SIZE]; --- key(s) */ +} __attribute__ ((packed)) ng_hci_write_stored_link_key_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t num_keys_written; /* # of keys successfully written */ +} __attribute__ ((packed)) ng_hci_write_stored_link_key_rp; + +#define NG_HCI_OCF_DELETE_STORED_LINK_KEY 0x0012 +typedef struct { + bdaddr_t bdaddr; /* address */ + u_int8_t delete_all; /* delete all keys? 0x01 - yes */ +} __attribute__ ((packed)) ng_hci_delete_stored_link_key_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t num_keys_deleted; /* Number of keys deleted */ +} __attribute__ ((packed)) ng_hci_delete_stored_link_key_rp; + +#define NG_HCI_OCF_CHANGE_LOCAL_NAME 0x0013 +typedef struct { + char name[NG_HCI_UNIT_NAME_SIZE]; /* new unit name */ +} __attribute__ ((packed)) ng_hci_change_local_name_cp; + +typedef ng_hci_status_rp ng_hci_change_local_name_rp; + +#define NG_HCI_OCF_READ_LOCAL_NAME 0x0014 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + char name[NG_HCI_UNIT_NAME_SIZE]; /* unit name */ +} __attribute__ ((packed)) ng_hci_read_local_name_rp; + +#define NG_HCI_OCF_READ_CON_ACCEPT_TIMO 0x0015 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t timeout; /* (timeout * 0.625) msec */ +} __attribute__ ((packed)) ng_hci_read_con_accept_timo_rp; + +#define NG_HCI_OCF_WRITE_CON_ACCEPT_TIMO 0x0016 +typedef struct { + u_int16_t timeout; /* (timeout * 0.625) msec */ +} __attribute__ ((packed)) ng_hci_write_con_accept_timo_cp; + +typedef ng_hci_status_rp ng_hci_write_con_accept_timo_rp; + +#define NG_HCI_OCF_READ_PAGE_TIMO 0x0017 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t timeout; /* (timeout * 0.625) msec */ +} __attribute__ ((packed)) ng_hci_read_page_timo_rp; + +#define NG_HCI_OCF_WRITE_PAGE_TIMO 0x0018 +typedef struct { + u_int16_t timeout; /* (timeout * 0.625) msec */ +} __attribute__ ((packed)) ng_hci_write_page_timo_cp; + +typedef ng_hci_status_rp ng_hci_write_page_timo_rp; + +#define NG_HCI_OCF_READ_SCAN_ENABLE 0x0019 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t scan_enable; /* Scan enable */ +} __attribute__ ((packed)) ng_hci_read_scan_enable_rp; + +#define NG_HCI_OCF_WRITE_SCAN_ENABLE 0x001a +typedef struct { + u_int8_t scan_enable; /* Scan enable */ +} __attribute__ ((packed)) ng_hci_write_scan_enable_cp; + +typedef ng_hci_status_rp ng_hci_write_scan_enable_rp; + +#define NG_HCI_OCF_READ_PAGE_SCAN_ACTIVITY 0x001b +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t page_scan_interval; /* interval * 0.625 msec */ + u_int16_t page_scan_window; /* window * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_read_page_scan_activity_rp; + +#define NG_HCI_OCF_WRITE_PAGE_SCAN_ACTIVITY 0x001c +typedef struct { + u_int16_t page_scan_interval; /* interval * 0.625 msec */ + u_int16_t page_scan_window; /* window * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_write_page_scan_activity_cp; + +typedef ng_hci_status_rp ng_hci_write_page_scan_activity_rp; + +#define NG_HCI_OCF_READ_INQUIRY_SCAN_ACTIVITY 0x001d +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t inquiry_scan_interval; /* interval * 0.625 msec */ + u_int16_t inquiry_scan_window; /* window * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_read_inquiry_scan_activity_rp; + +#define NG_HCI_OCF_WRITE_INQUIRY_SCAN_ACTIVITY 0x001e +typedef struct { + u_int16_t inquiry_scan_interval; /* interval * 0.625 msec */ + u_int16_t inquiry_scan_window; /* window * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_write_inquiry_scan_activity_cp; + +typedef ng_hci_status_rp ng_hci_write_inquiry_scan_activity_rp; + +#define NG_HCI_OCF_READ_AUTH_ENABLE 0x001f +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t auth_enable; /* 0x01 - enabled */ +} __attribute__ ((packed)) ng_hci_read_auth_enable_rp; + +#define NG_HCI_OCF_WRITE_AUTH_ENABLE 0x0020 +typedef struct { + u_int8_t auth_enable; /* 0x01 - enabled */ +} __attribute__ ((packed)) ng_hci_write_auth_enable_cp; + +typedef ng_hci_status_rp ng_hci_write_auth_enable_rp; + +#define NG_HCI_OCF_READ_ENCRYPTION_MODE 0x0021 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t encryption_mode; /* encryption mode */ +} __attribute__ ((packed)) ng_hci_read_encryption_mode_rp; + +#define NG_HCI_OCF_WRITE_ENCRYPTION_MODE 0x0022 +typedef struct { + u_int8_t encryption_mode; /* encryption mode */ +} __attribute__ ((packed)) ng_hci_write_encryption_mode_cp; + +typedef ng_hci_status_rp ng_hci_write_encryption_mode_rp; + +#define NG_HCI_OCF_READ_UNIT_CLASS 0x0023 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t uclass[NG_HCI_CLASS_SIZE]; /* unit class */ +} __attribute__ ((packed)) ng_hci_read_unit_class_rp; + +#define NG_HCI_OCF_WRITE_UNIT_CLASS 0x0024 +typedef struct { + u_int8_t uclass[NG_HCI_CLASS_SIZE]; /* unit class */ +} __attribute__ ((packed)) ng_hci_write_unit_class_cp; + +typedef ng_hci_status_rp ng_hci_write_unit_class_rp; + +#define NG_HCI_OCF_READ_VOICE_SETTINGS 0x0025 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t settings; /* voice settings */ +} __attribute__ ((packed)) ng_hci_read_voice_settings_rp; + +#define NG_HCI_OCF_WRITE_VOICE_SETTINGS 0x0026 +typedef struct { + u_int16_t settings; /* voice settings */ +} __attribute__ ((packed)) ng_hci_write_voice_settings_cp; + +typedef ng_hci_status_rp ng_hci_write_voice_settings_rp; + +#define NG_HCI_OCF_READ_AUTO_FLUSH_TIMO 0x0027 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_auto_flush_timo_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int16_t timeout; /* 0x00 - no flush, timeout * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_read_auto_flush_timo_rp; + +#define NG_HCI_OCF_WRITE_AUTO_FLUSH_TIMO 0x0028 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t timeout; /* 0x00 - no flush, timeout * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_write_auto_flush_timo_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_write_auto_flush_timo_rp; + +#define NG_HCI_OCF_READ_NUM_BROADCAST_RETRANS 0x0029 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t counter; /* number of broadcast retransmissions */ +} __attribute__ ((packed)) ng_hci_read_num_broadcast_retrans_rp; + +#define NG_HCI_OCF_WRITE_NUM_BROADCAST_RETRANS 0x002a +typedef struct { + u_int8_t counter; /* number of broadcast retransmissions */ +} __attribute__ ((packed)) ng_hci_write_num_broadcast_retrans_cp; + +typedef ng_hci_status_rp ng_hci_write_num_broadcast_retrans_rp; + +#define NG_HCI_OCF_READ_HOLD_MODE_ACTIVITY 0x002b +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t hold_mode_activity; /* Hold mode activities */ +} __attribute__ ((packed)) ng_hci_read_hold_mode_activity_rp; + +#define NG_HCI_OCF_WRITE_HOLD_MODE_ACTIVITY 0x002c +typedef struct { + u_int8_t hold_mode_activity; /* Hold mode activities */ +} __attribute__ ((packed)) ng_hci_write_hold_mode_activity_cp; + +typedef ng_hci_status_rp ng_hci_write_hold_mode_activity_rp; + +#define NG_HCI_OCF_READ_XMIT_LEVEL 0x002d +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int8_t type; /* Xmit level type */ +} __attribute__ ((packed)) ng_hci_read_xmit_level_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + char level; /* -30 <= level <= 30 dBm */ +} __attribute__ ((packed)) ng_hci_read_xmit_level_rp; + +#define NG_HCI_OCF_READ_SCO_FLOW_CONTROL 0x002e +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t flow_control; /* 0x00 - disabled */ +} __attribute__ ((packed)) ng_hci_read_sco_flow_control_rp; + +#define NG_HCI_OCF_WRITE_SCO_FLOW_CONTROL 0x002f +typedef struct { + u_int8_t flow_control; /* 0x00 - disabled */ +} __attribute__ ((packed)) ng_hci_write_sco_flow_control_cp; + +typedef ng_hci_status_rp ng_hci_write_sco_flow_control_rp; + +#define NG_HCI_OCF_H2HC_FLOW_CONTROL 0x0031 +typedef struct { + u_int8_t h2hc_flow; /* Host to Host controller flow control */ +} __attribute__ ((packed)) ng_hci_h2hc_flow_control_cp; + +typedef ng_hci_status_rp ng_hci_h2hc_flow_control_rp; + +#define NG_HCI_OCF_HOST_BUFFER_SIZE 0x0033 +typedef struct { + u_int16_t max_acl_size; /* Max. size of ACL packet (bytes) */ + u_int8_t max_sco_size; /* Max. size of SCO packet (bytes) */ + u_int16_t num_acl_pkt; /* Max. number of ACL packets */ + u_int16_t num_sco_pkt; /* Max. number of SCO packets */ +} __attribute__ ((packed)) ng_hci_host_buffer_size_cp; + +typedef ng_hci_status_rp ng_hci_host_buffer_size_rp; + +#define NG_HCI_OCF_HOST_NUM_COMPL_PKTS 0x0035 +typedef struct { + u_int8_t num_con_handles; /* # of connection handles */ +/* these are repeated "num_con_handles" times + u_int16_t con_handle; --- connection handle(s) + u_int16_t compl_pkt; --- # of completed packets */ +} __attribute__ ((packed)) ng_hci_host_num_compl_pkts_cp; +/* No return parameter(s) */ + +#define NG_HCI_OCF_READ_LINK_SUPERVISION_TIMO 0x0036 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_link_supervision_timo_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int16_t timeout; /* Link supervision timeout * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_read_link_supervision_timo_rp; + +#define NG_HCI_OCF_WRITE_LINK_SUPERVISION_TIMO 0x0037 +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int16_t timeout; /* Link supervision timeout * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_write_link_supervision_timo_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_write_link_supervision_timo_rp; + +#define NG_HCI_OCF_READ_SUPPORTED_IAC_NUM 0x0038 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t num_iac; /* # of supported IAC during scan */ +} __attribute__ ((packed)) ng_hci_read_supported_iac_num_rp; + +#define NG_HCI_OCF_READ_IAC_LAP 0x0039 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t num_iac; /* # of IAC */ +/* these are repeated "num_iac" times + u_int8_t laps[NG_HCI_LAP_SIZE]; --- LAPs */ +} __attribute__ ((packed)) ng_hci_read_iac_lap_rp; + +#define NG_HCI_OCF_WRITE_IAC_LAP 0x003a +typedef struct { + u_int8_t num_iac; /* # of IAC */ +/* these are repeated "num_iac" times + u_int8_t laps[NG_HCI_LAP_SIZE]; --- LAPs */ +} __attribute__ ((packed)) ng_hci_write_iac_lap_cp; + +typedef ng_hci_status_rp ng_hci_write_iac_lap_rp; + +#define NG_HCI_OCF_READ_PAGE_SCAN_PERIOD 0x003b +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t page_scan_period_mode; /* Page scan period mode */ +} __attribute__ ((packed)) ng_hci_read_page_scan_period_rp; + +#define NG_HCI_OCF_WRITE_PAGE_SCAN_PERIOD 0x003c +typedef struct { + u_int8_t page_scan_period_mode; /* Page scan period mode */ +} __attribute__ ((packed)) ng_hci_write_page_scan_period_cp; + +typedef ng_hci_status_rp ng_hci_write_page_scan_period_rp; + +#define NG_HCI_OCF_READ_PAGE_SCAN 0x003d +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t page_scan_mode; /* Page scan mode */ +} __attribute__ ((packed)) ng_hci_read_page_scan_rp; + +#define NG_HCI_OCF_WRITE_PAGE_SCAN 0x003e +typedef struct { + u_int8_t page_scan_mode; /* Page scan mode */ +} __attribute__ ((packed)) ng_hci_write_page_scan_cp; + +typedef ng_hci_status_rp ng_hci_write_page_scan_rp; + +/************************************************************************** + ************************************************************************** + ** Informational commands and return parameters + ** All commands in this category do not accept any parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_INFO 0x04 /* OpCode Group Field */ + +#define NG_HCI_OCF_READ_LOCAL_VER 0x0001 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t hci_version; /* HCI version */ + u_int16_t hci_revision; /* HCI revision */ + u_int8_t lmp_version; /* LMP version */ + u_int16_t manufacturer; /* Hardware manufacturer name */ + u_int16_t lmp_subversion; /* LMP sub-version */ +} __attribute__ ((packed)) ng_hci_read_local_ver_rp; + +#define NG_HCI_OCF_READ_LOCAL_FEATURES 0x0003 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t features[NG_HCI_FEATURES_SIZE]; /* LMP features bitmsk*/ +} __attribute__ ((packed)) ng_hci_read_local_features_rp; + +#define NG_HCI_OCF_READ_BUFFER_SIZE 0x0005 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t max_acl_size; /* Max. size of ACL packet (bytes) */ + u_int8_t max_sco_size; /* Max. size of SCO packet (bytes) */ + u_int16_t num_acl_pkt; /* Max. number of ACL packets */ + u_int16_t num_sco_pkt; /* Max. number of SCO packets */ +} __attribute__ ((packed)) ng_hci_read_buffer_size_rp; + +#define NG_HCI_OCF_READ_COUNTRY_CODE 0x0007 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t country_code; /* 0x00 - NAM, EUR, JP; 0x01 - France */ +} __attribute__ ((packed)) ng_hci_read_country_code_rp; + +#define NG_HCI_OCF_READ_BDADDR 0x0009 +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* unit address */ +} __attribute__ ((packed)) ng_hci_read_bdaddr_rp; + +/************************************************************************** + ************************************************************************** + ** Status commands and return parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_STATUS 0x05 /* OpCode Group Field */ + +#define NG_HCI_OCF_READ_FAILED_CONTACT_CNTR 0x0001 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_failed_contact_cntr_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int16_t counter; /* number of consecutive failed contacts */ +} __attribute__ ((packed)) ng_hci_read_failed_contact_cntr_rp; + +#define NG_HCI_OCF_RESET_FAILED_CONTACT_CNTR 0x0002 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_reset_failed_contact_cntr_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_reset_failed_contact_cntr_rp; + +#define NG_HCI_OCF_GET_LINK_QUALITY 0x0003 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_get_link_quality_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int8_t quality; /* higher value means better quality */ +} __attribute__ ((packed)) ng_hci_get_link_quality_rp; + +#define NG_HCI_OCF_READ_RSSI 0x0005 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_read_rssi_cp; + +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + char rssi; /* -127 <= rssi <= 127 dB */ +} __attribute__ ((packed)) ng_hci_read_rssi_rp; + +/************************************************************************** + ************************************************************************** + ** Testing commands and return parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_TESTING 0x06 /* OpCode Group Field */ + +#define NG_HCI_OCF_READ_LOOPBACK_MODE 0x0001 +/* No command parameter(s) */ +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int8_t lbmode; /* loopback mode */ +} __attribute__ ((packed)) ng_hci_read_loopback_mode_rp; + +#define NG_HCI_OCF_WRITE_LOOPBACK_MODE 0x0002 +typedef struct { + u_int8_t lbmode; /* loopback mode */ +} __attribute__ ((packed)) ng_hci_write_loopback_mode_cp; + +typedef ng_hci_status_rp ng_hci_write_loopback_mode_rp; + +#define NG_HCI_OCF_ENABLE_UNIT_UNDER_TEST 0x0003 +/* No command parameter(s) */ +typedef ng_hci_status_rp ng_hci_enable_unit_under_test_rp; + +/************************************************************************** + ************************************************************************** + ** Special HCI OpCode group field values + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_OGF_BT_LOGO 0x3e + +#define NG_HCI_OGF_VENDOR 0x3f + +/************************************************************************** + ************************************************************************** + ** Events and event parameters + ************************************************************************** + **************************************************************************/ + +#define NG_HCI_EVENT_INQUIRY_COMPL 0x01 +typedef struct { + u_int8_t status; /* 0x00 - success */ +} __attribute__ ((packed)) ng_hci_inquiry_compl_ep; + +#define NG_HCI_EVENT_INQUIRY_RESULT 0x02 +typedef struct { + u_int8_t num_responses; /* number of responses */ +/* these are repeated "num_responses" times + bdaddr_t bdaddr; --- unit address(es) + u_int8_t page_scan_rep_mode; --- page scan rep. mode(s) + u_int8_t page_scan_period_mode; --- page scan period mode(s) + u_int8_t page_scan_mode; --- page scan mode(s) + u_int8_t uclass[NG_HCI_CLASS_SIZE]; --- unit class(es) + u_int16_t clock_offset; --- clock offset(s) */ +} __attribute__ ((packed)) ng_hci_inquiry_result_ep; + +#define NG_HCI_EVENT_CON_COMPL 0x03 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ + bdaddr_t bdaddr; /* remote unit address */ + u_int8_t link_type; /* Link type */ + u_int8_t encryption_mode; /* Encryption mode */ +} __attribute__ ((packed)) ng_hci_con_compl_ep; + +#define NG_HCI_EVENT_CON_REQ 0x04 +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ + u_int8_t uclass[NG_HCI_CLASS_SIZE]; /* remote unit class */ + u_int8_t link_type; /* link type */ +} __attribute__ ((packed)) ng_hci_con_req_ep; + +#define NG_HCI_EVENT_DISCON_COMPL 0x05 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int8_t reason; /* reason to disconnect */ +} __attribute__ ((packed)) ng_hci_discon_compl_ep; + +#define NG_HCI_EVENT_AUTH_COMPL 0x06 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_auth_compl_ep; + +#define NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL 0x7 +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* remote unit address */ + char name[NG_HCI_UNIT_NAME_SIZE]; /* remote unit name */ +} __attribute__ ((packed)) ng_hci_remote_name_req_compl_ep; + +#define NG_HCI_EVENT_ENCRYPTION_CHANGE 0x08 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ + u_int8_t encryption_enable; /* 0x00 - disable */ +} __attribute__ ((packed)) ng_hci_encryption_change_ep; + +#define NG_HCI_EVENT_CHANGE_CON_LINK_KEY_COMPL 0x09 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ +} __attribute__ ((packed)) ng_hci_change_con_link_key_compl_ep; + +#define NG_HCI_EVENT_MASTER_LINK_KEY_COMPL 0x0a +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ + u_int8_t key_flag; /* Key flag */ +} __attribute__ ((packed)) ng_hci_master_link_key_compl_ep; + +#define NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL 0x0b +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ + u_int8_t features[NG_HCI_FEATURES_SIZE]; /* LMP features bitmsk*/ +} __attribute__ ((packed)) ng_hci_read_remote_features_compl_ep; + +#define NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL 0x0c +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ + u_int8_t lmp_version; /* LMP version */ + u_int16_t manufacturer; /* Hardware manufacturer name */ + u_int16_t lmp_subversion; /* LMP sub-version */ +} __attribute__ ((packed)) ng_hci_read_remote_ver_info_compl_ep; + +#define NG_HCI_EVENT_QOS_SETUP_COMPL 0x0d +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int8_t flags; /* reserved for future use */ + u_int8_t service_type; /* service type */ + u_int32_t token_rate; /* bytes per second */ + u_int32_t peak_bandwidth; /* bytes per second */ + u_int32_t latency; /* microseconds */ + u_int32_t delay_variation; /* microseconds */ +} __attribute__ ((packed)) ng_hci_qos_setup_compl_ep; + +#define NG_HCI_EVENT_COMMAND_COMPL 0x0e +typedef struct { + u_int8_t num_cmd_pkts; /* # of HCI command packets */ + u_int16_t opcode; /* command OpCode */ + /* command return parameters (if any) */ +} __attribute__ ((packed)) ng_hci_command_compl_ep; + +#define NG_HCI_EVENT_COMMAND_STATUS 0x0f +typedef struct { + u_int8_t status; /* 0x00 - pending */ + u_int8_t num_cmd_pkts; /* # of HCI command packets */ + u_int16_t opcode; /* command OpCode */ +} __attribute__ ((packed)) ng_hci_command_status_ep; + +#define NG_HCI_EVENT_HARDWARE_ERROR 0x10 +typedef struct { + u_int8_t hardware_code; /* hardware error code */ +} __attribute__ ((packed)) ng_hci_hardware_error_ep; + +#define NG_HCI_EVENT_FLUSH_OCCUR 0x11 +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_flush_occur_ep; + +#define NG_HCI_EVENT_ROLE_CHANGE 0x12 +typedef struct { + u_int8_t status; /* 0x00 - success */ + bdaddr_t bdaddr; /* address of remote unit */ + u_int8_t role; /* new connection role */ +} __attribute__ ((packed)) ng_hci_role_change_ep; + +#define NG_HCI_EVENT_NUM_COMPL_PKTS 0x13 +typedef struct { + u_int8_t num_con_handles; /* # of connection handles */ +/* these are repeated "num_con_handles" times + u_int16_t con_handle; --- connection handle(s) + u_int16_t compl_pkt; --- # of completed packets */ +} __attribute__ ((packed)) ng_hci_num_compl_pkts_ep; + +#define NG_HCI_EVENT_MODE_CHANGE 0x14 +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int8_t unit_mode; /* remote unit mode */ + u_int16_t interval; /* interval * 0.625 msec */ +} __attribute__ ((packed)) ng_hci_mode_change_ep; + +#define NG_HCI_EVENT_RETURN_LINK_KEYS 0x15 +typedef struct { + u_int8_t num_keys; /* # of keys */ +/* these are repeated "num_keys" times + bdaddr_t bdaddr; --- remote address(es) + u_int8_t key[NG_HCI_KEY_SIZE]; --- key(s) */ +} __attribute__ ((packed)) ng_hci_return_link_keys_ep; + +#define NG_HCI_EVENT_PIN_CODE_REQ 0x16 +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ +} __attribute__ ((packed)) ng_hci_pin_code_req_ep; + +#define NG_HCI_EVENT_LINK_KEY_REQ 0x17 +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ +} __attribute__ ((packed)) ng_hci_link_key_req_ep; + +#define NG_HCI_EVENT_LINK_KEY_NOTIFICATION 0x18 +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ + u_int8_t key[NG_HCI_KEY_SIZE]; /* link key */ + u_int8_t key_type; /* type of the key */ +} __attribute__ ((packed)) ng_hci_link_key_notification_ep; + +#define NG_HCI_EVENT_LOOPBACK_COMMAND 0x19 +typedef struct { + u_int8_t command[0]; /* Command packet */ +} __attribute__ ((packed)) ng_hci_loopback_command_ep; + +#define NG_HCI_EVENT_DATA_BUFFER_OVERFLOW 0x1a +typedef struct { + u_int8_t link_type; /* Link type */ +} __attribute__ ((packed)) ng_hci_data_buffer_overflow_ep; + +#define NG_HCI_EVENT_MAX_SLOT_CHANGE 0x1b +typedef struct { + u_int16_t con_handle; /* connection handle */ + u_int8_t lmp_max_slots; /* Max. # of slots allowed */ +} __attribute__ ((packed)) ng_hci_max_slot_change_ep; + +#define NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL 0x1c +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* Connection handle */ + u_int16_t clock_offset; /* Clock offset */ +} __attribute__ ((packed)) ng_hci_read_clock_offset_compl_ep; + +#define NG_HCI_EVENT_CON_PKT_TYPE_CHANGED 0x1d +typedef struct { + u_int8_t status; /* 0x00 - success */ + u_int16_t con_handle; /* connection handle */ + u_int16_t pkt_type; /* packet type */ +} __attribute__ ((packed)) ng_hci_con_pkt_type_changed_ep; + +#define NG_HCI_EVENT_QOS_VIOLATION 0x1e +typedef struct { + u_int16_t con_handle; /* connection handle */ +} __attribute__ ((packed)) ng_hci_qos_violation_ep; + +#define NG_HCI_EVENT_PAGE_SCAN_MODE_CHANGE 0x1f +typedef struct { + bdaddr_t bdaddr; /* destination address */ + u_int8_t page_scan_mode; /* page scan mode */ +} __attribute__ ((packed)) ng_hci_page_scan_mode_change_ep; + +#define NG_HCI_EVENT_PAGE_SCAN_REP_MODE_CHANGE 0x20 +typedef struct { + bdaddr_t bdaddr; /* destination address */ + u_int8_t page_scan_rep_mode; /* page scan repetition mode */ +} __attribute__ ((packed)) ng_hci_page_scan_rep_mode_change_ep; + +#define NG_HCI_EVENT_BT_LOGO 0xfe + +#define NG_HCI_EVENT_VENDOR 0xff + +#endif /* ndef _NETGRAPH_HCI_H_ */ diff --git a/sys/netgraph/bluetooth/include/ng_l2cap.h b/sys/netgraph/bluetooth/include/ng_l2cap.h new file mode 100644 index 0000000..e277c21 --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_l2cap.h @@ -0,0 +1,655 @@ +/* + * ng_l2cap.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap.h,v 1.13 2002/09/08 23:35:51 max Exp $ + * $FreeBSD$ + */ + +/* + * This file contains everything that application needs to know about + * Link Layer Control and Adaptation Protocol (L2CAP). All information + * was obtained from Bluetooth Specification Book v1.1. + * + * This file can be included by both kernel and userland applications. + */ + +#ifndef _NETGRAPH_L2CAP_H_ +#define _NETGRAPH_L2CAP_H_ + +/************************************************************************** + ************************************************************************** + ** Netgraph node hook name, type name and type cookie and commands + ************************************************************************** + **************************************************************************/ + +/* Netgraph node hook names */ +#define NG_L2CAP_HOOK_HCI "hci" /* HCI <-> L2CAP */ +#define NG_L2CAP_HOOK_L2C "l2c" /* L2CAP <-> Upper */ +#define NG_L2CAP_HOOK_CTL "ctl" /* L2CAP <-> User */ + +/* Node type name and type cookie */ +#define NG_L2CAP_NODE_TYPE "l2cap" +#define NGM_L2CAP_COOKIE 1000774185 + +/************************************************************************** + ************************************************************************** + ** Common defines and types (L2CAP) + ************************************************************************** + **************************************************************************/ + +/* + * Channel IDs are assigned relative to the instance of L2CAP node, i.e. + * relative to the unit. So the total number of channels that unit can have + * open at the same time is 0xffff - 0x0040 = 0xffbf (65471). This number + * does not depend on number of connections. + */ + +#define NG_L2CAP_NULL_CID 0x0000 /* DO NOT USE THIS CID */ +#define NG_L2CAP_SIGNAL_CID 0x0001 /* signaling channel ID */ +#define NG_L2CAP_CLT_CID 0x0002 /* connectionless channel ID */ + /* 0x0003 - 0x003f Reserved */ +#define NG_L2CAP_FIRST_CID 0x0040 /* dynamically alloc. (start) */ +#define NG_L2CAP_LAST_CID 0xffff /* dynamically alloc. (end) */ + +/* L2CAP MTU */ +#define NG_L2CAP_MTU_MINIMUM 48 +#define NG_L2CAP_MTU_DEFAULT 672 +#define NG_L2CAP_MTU_MAXIMUM 0xffff + +/* L2CAP flush and link timeouts */ +#define NG_L2CAP_FLUSH_TIMO_DEFAULT 0xffff /* always retransmit */ +#define NG_L2CAP_LINK_TIMO_DEFAULT 0xffff + +/* L2CAP Command Reject reasons */ +#define NG_L2CAP_REJ_NOT_UNDERSTOOD 0x0000 +#define NG_L2CAP_REJ_MTU_EXCEEDED 0x0001 +#define NG_L2CAP_REJ_INVALID_CID 0x0002 +/* 0x0003 - 0xffff - reserved for future use */ + +/* Protocol/Service Multioplexor (PSM) values */ +#define NG_L2CAP_PSM_ANY 0x0000 /* Any/Invalid PSM */ +#define NG_L2CAP_PSM_SDP 0x0001 /* Service Discovery Protocol */ +#define NG_L2CAP_PSM_RFCOMM 0x0003 /* RFCOMM protocol */ +#define NG_L2CAP_PSM_TCP 0x0005 /* Telephony Control Protocol */ +/* 0x0006 - 0x1000 - reserved for future use */ + +/* L2CAP Connection response command result codes */ +#define NG_L2CAP_SUCCESS 0x0000 +#define NG_L2CAP_PENDING 0x0001 +#define NG_L2CAP_PSM_NOT_SUPPORTED 0x0002 +#define NG_L2CAP_SEQUIRY_BLOCK 0x0003 +#define NG_L2CAP_NO_RESOURCES 0x0004 +#define NG_L2CAP_TIMEOUT 0xeeee +#define NG_L2CAP_UNKNOWN 0xffff +/* 0x0005 - 0xffff - reserved for future use */ + +/* L2CAP Connection response status codes */ +#define NG_L2CAP_NO_INFO 0x0000 +#define NG_L2CAP_AUTH_PENDING 0x0001 +#define NG_L2CAP_AUTZ_PENDING 0x0002 +/* 0x0003 - 0xffff - reserved for future use */ + +/* L2CAP Configuration response result codes */ +#define NG_L2CAP_UNACCEPTABLE_PARAMS 0x0001 +#define NG_L2CAP_REJECT 0x0002 +#define NG_L2CAP_UNKNOWN_OPTION 0x0003 +/* 0x0003 - 0xffff - reserved for future use */ + +/* L2CAP Configuration options */ +#define NG_L2CAP_OPT_CFLAG_BIT 0x0001 +#define NG_L2CAP_OPT_CFLAG(flags) ((flags) & NG_L2CAP_OPT_CFLAG_BIT) +#define NG_L2CAP_OPT_HINT_BIT 0x80 +#define NG_L2CAP_OPT_HINT(type) ((type) & NG_L2CAP_OPT_HINT_BIT) +#define NG_L2CAP_OPT_HINT_MASK 0x7f +#define NG_L2CAP_OPT_MTU 0x01 +#define NG_L2CAP_OPT_MTU_SIZE sizeof(u_int16_t) +#define NG_L2CAP_OPT_FLUSH_TIMO 0x02 +#define NG_L2CAP_OPT_FLUSH_TIMO_SIZE sizeof(u_int16_t) +#define NG_L2CAP_OPT_QOS 0x03 +#define NG_L2CAP_OPT_QOS_SIZE sizeof(ng_l2cap_flow_t) +/* 0x4 - 0xff - reserved for future use */ + +/* L2CAP Information request type codes */ +#define NG_L2CAP_CONNLESS_MTU 0x0001 +/* 0x0002 - 0xffff - reserved for future use */ + +/* L2CAP Information response codes */ +#define NG_L2CAP_NOT_SUPPORTED 0x0001 +/* 0x0002 - 0xffff - reserved for future use */ + +/* L2CAP flow control */ +typedef struct { + u_int8_t flags; /* reserved for future use */ + u_int8_t service_type; /* service type */ + u_int32_t token_rate; /* bytes per second */ + u_int32_t token_bucket_size; /* bytes */ + u_int32_t peak_bandwidth; /* bytes per second */ + u_int32_t latency; /* microseconds */ + u_int32_t delay_variation; /* microseconds */ +} __attribute__ ((packed)) ng_l2cap_flow_t; +typedef ng_l2cap_flow_t * ng_l2cap_flow_p; + +/************************************************************************** + ************************************************************************** + ** Link level defines, headers and types + ************************************************************************** + **************************************************************************/ + +/* L2CAP header */ +typedef struct { + u_int16_t length; /* payload size */ + u_int16_t dcid; /* destination channel ID */ +} __attribute__ ((packed)) ng_l2cap_hdr_t; + +/* L2CAP ConnectionLess Traffic (CLT) (if destination cid == 0x2) */ +typedef struct { + u_int16_t psm; /* Protocol/Service Multiplexor */ +} __attribute__ ((packed)) ng_l2cap_clt_hdr_t; + +#define NG_L2CAP_CLT_MTU_MAXIMUM \ + (NG_L2CAP_MTU_MAXIMUM - sizeof(ng_l2cap_clt_hdr_t)) + +/* L2CAP command header */ +typedef struct { + u_int8_t code; /* command OpCode */ + u_int8_t ident; /* identifier to match request and response */ + u_int16_t length; /* command parameters length */ +} __attribute__ ((packed)) ng_l2cap_cmd_hdr_t; + +/* L2CAP Command Reject */ +#define NG_L2CAP_CMD_REJ 0x01 +typedef struct { + u_int16_t reason; /* reason to reject command */ +/* u_int8_t data[]; -- optional data (depends on reason) */ +} __attribute__ ((packed)) ng_l2cap_cmd_rej_cp; + +/* CommandReject data */ +typedef union { + /* NG_L2CAP_REJ_MTU_EXCEEDED */ + struct { + u_int16_t mtu; /* actual signaling MTU */ + } __attribute__ ((packed)) mtu; + /* NG_L2CAP_REJ_INVALID_CID */ + struct { + u_int16_t scid; /* local CID */ + u_int16_t dcid; /* remote CID */ + } __attribute__ ((packed)) cid; +} ng_l2cap_cmd_rej_data_t; +typedef ng_l2cap_cmd_rej_data_t * ng_l2cap_cmd_rej_data_p; + +/* L2CAP Connection Request */ +#define NG_L2CAP_CON_REQ 0x02 +typedef struct { + u_int16_t psm; /* Protocol/Service Multiplexor (PSM) */ + u_int16_t scid; /* source channel ID */ +} __attribute__ ((packed)) ng_l2cap_con_req_cp; + +/* L2CAP Connection Response */ +#define NG_L2CAP_CON_RSP 0x03 +typedef struct { + u_int16_t dcid; /* destination channel ID */ + u_int16_t scid; /* source channel ID */ + u_int16_t result; /* 0x00 - success */ + u_int16_t status; /* more info if result != 0x00 */ +} __attribute__ ((packed)) ng_l2cap_con_rsp_cp; + +/* L2CAP Configuration Request */ +#define NG_L2CAP_CFG_REQ 0x04 +typedef struct { + u_int16_t dcid; /* destination channel ID */ + u_int16_t flags; /* flags */ +/* u_int8_t options[] -- options */ +} __attribute__ ((packed)) ng_l2cap_cfg_req_cp; + +/* L2CAP Configuration Response */ +#define NG_L2CAP_CFG_RSP 0x05 +typedef struct { + u_int16_t scid; /* source channel ID */ + u_int16_t flags; /* flags */ + u_int16_t result; /* 0x00 - success */ +/* u_int8_t options[] -- options */ +} __attribute__ ((packed)) ng_l2cap_cfg_rsp_cp; + +/* L2CAP configuration option */ +typedef struct { + u_int8_t type; + u_int8_t length; +/* u_int8_t value[] -- option value (depends on type) */ +} __attribute__ ((packed)) ng_l2cap_cfg_opt_t; +typedef ng_l2cap_cfg_opt_t * ng_l2cap_cfg_opt_p; + +/* L2CAP configuration option value */ +typedef union { + u_int16_t mtu; /* NG_L2CAP_OPT_MTU */ + u_int16_t flush_timo; /* NG_L2CAP_OPT_FLUSH_TIMO */ + ng_l2cap_flow_t flow; /* NG_L2CAP_OPT_QOS */ +} ng_l2cap_cfg_opt_val_t; +typedef ng_l2cap_cfg_opt_val_t * ng_l2cap_cfg_opt_val_p; + +/* L2CAP Disconnect Request */ +#define NG_L2CAP_DISCON_REQ 0x06 +typedef struct { + u_int16_t dcid; /* destination channel ID */ + u_int16_t scid; /* source channel ID */ +} __attribute__ ((packed)) ng_l2cap_discon_req_cp; + +/* L2CAP Disconnect Response */ +#define NG_L2CAP_DISCON_RSP 0x07 +typedef ng_l2cap_discon_req_cp ng_l2cap_discon_rsp_cp; + +/* L2CAP Echo Request */ +#define NG_L2CAP_ECHO_REQ 0x08 +/* No command parameters, only optional data */ + +/* L2CAP Echo Response */ +#define NG_L2CAP_ECHO_RSP 0x09 +#define NG_L2CAP_MAX_ECHO_SIZE \ + (NG_L2CAP_MTU_MAXIMUM - sizeof(ng_l2cap_cmd_hdr_t)) +/* No command parameters, only optional data */ + +/* L2CAP Information Request */ +#define NG_L2CAP_INFO_REQ 0x0a +typedef struct { + u_int16_t type; /* requested information type */ +} __attribute__ ((packed)) ng_l2cap_info_req_cp; + +/* L2CAP Information Response */ +#define NG_L2CAP_INFO_RSP 0x0b +typedef struct { + u_int16_t type; /* requested information type */ + u_int16_t result; /* 0x00 - success */ +/* u_int8_t info[] -- info data (depends on type) + * + * NG_L2CAP_CONNLESS_MTU - 2 bytes connectionless MTU + */ +} __attribute__ ((packed)) ng_l2cap_info_rsp_cp; + +typedef union { + /* NG_L2CAP_CONNLESS_MTU */ + struct { + u_int16_t mtu; + } __attribute__ ((packed)) mtu; +} ng_l2cap_info_rsp_data_t; +typedef ng_l2cap_info_rsp_data_t * ng_l2cap_info_rsp_data_p; + +/************************************************************************** + ************************************************************************** + ** Upper layer protocol interface. L2CA_xxx messages + ************************************************************************** + **************************************************************************/ + +/* + * NOTE! NOTE! NOTE! + * + * Bluetooth specification says that L2CA_xxx request must block until + * response is ready. We are not allowed to block in Netgraph, so we + * need to queue request and save some information that can be used + * later and help match request and response. + * + * The idea is to use "token" field from Netgraph message header. The + * upper layer protocol _MUST_ populate "token". L2CAP will queue request + * (using L2CAP command descriptor) and start processing. Later, when + * response is ready or timeout has occur L2CAP layer will create new + * Netgraph message, set "token" and RESP flag and send the message to + * the upper layer protocol. + * + * L2CA_xxx_Ind messages _WILL_NOT_ populate "token" and _WILL_NOT_ + * set RESP flag. There is no reason for this, because they are just + * notifications and do not require acknowlegment. + * + * NOTE: This is _NOT_ what NG_MKRESPONSE and NG_RESPOND_MSG do, however + * it is somewhat similar. + */ + +/* L2CA data packet header */ +typedef struct { + u_int32_t token; /* token to use in L2CAP_L2CA_WRITE */ + u_int16_t length; /* length of the data */ + u_int16_t lcid; /* local channel ID */ +} __attribute__ ((packed)) ng_l2cap_l2ca_hdr_t; + +/* L2CA_Connect */ +#define NGM_L2CAP_L2CA_CON 0x80 +/* Upper -> L2CAP */ +typedef struct { + u_int16_t psm; /* Protocol/Service Multiplexor */ + bdaddr_t bdaddr; /* remote unit address */ +} ng_l2cap_l2ca_con_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t lcid; /* local channel ID */ + u_int16_t result; /* 0x00 - success */ + u_int16_t status; /* if result != 0x00 */ +} ng_l2cap_l2ca_con_op; + +/* L2CA_ConnectInd */ +#define NGM_L2CAP_L2CA_CON_IND 0x81 +/* L2CAP -> Upper */ +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ + u_int16_t lcid; /* local channel ID */ + u_int16_t psm; /* Procotol/Service Multiplexor */ + u_int8_t ident; /* indentifier */ + u_int8_t unused; /* place holder */ +} ng_l2cap_l2ca_con_ind_ip; +/* No output parameters */ + +/* L2CA_ConnectRsp */ +#define NGM_L2CAP_L2CA_CON_RSP 0x82 +/* Upper -> L2CAP */ +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ + u_int8_t ident; /* "ident" from L2CAP_ConnectInd event */ + u_int8_t unused; /* place holder */ + u_int16_t lcid; /* local channel ID */ + u_int16_t result; /* 0x00 - success */ + u_int16_t status; /* if response != 0x00 */ +} ng_l2cap_l2ca_con_rsp_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - success */ +} ng_l2cap_l2ca_con_rsp_op; + +/* L2CA_Config */ +#define NGM_L2CAP_L2CA_CFG 0x83 +/* Upper -> L2CAP */ +typedef struct { + u_int16_t lcid; /* local channel ID */ + u_int16_t imtu; /* receiving MTU for the local channel */ + ng_l2cap_flow_t oflow; /* out flow */ + u_int16_t flush_timo; /* flush timeout (msec) */ + u_int16_t link_timo; /* link timeout (msec) */ +} ng_l2cap_l2ca_cfg_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - success */ + u_int16_t imtu; /* sending MTU for the remote channel */ + ng_l2cap_flow_t oflow; /* out flow */ + u_int16_t flush_timo; /* flush timeout (msec) */ +} ng_l2cap_l2ca_cfg_op; + +/* L2CA_ConfigRsp */ +#define NGM_L2CAP_L2CA_CFG_RSP 0x84 +/* Upper -> L2CAP */ +typedef struct { + u_int16_t lcid; /* local channel ID */ + u_int16_t omtu; /* sending MTU for the local channel */ + ng_l2cap_flow_t iflow; /* in FLOW */ +} ng_l2cap_l2ca_cfg_rsp_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - sucsess */ +} ng_l2cap_l2ca_cfg_rsp_op; + +/* L2CA_ConfigInd */ +#define NGM_L2CAP_L2CA_CFG_IND 0x85 +/* L2CAP -> Upper */ +typedef struct { + u_int16_t lcid; /* local channel ID */ + u_int16_t omtu; /* outgoing MTU for the local channel */ + ng_l2cap_flow_t iflow; /* in flow */ + u_int16_t flush_timo; /* flush timeout (msec) */ +} ng_l2cap_l2ca_cfg_ind_ip; +/* No output parameters */ + +/* L2CA_QoSViolationInd */ +#define NGM_L2CAP_L2CA_QOS_IND 0x86 +/* L2CAP -> Upper */ +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ +} ng_l2cap_l2ca_qos_ind_ip; +/* No output parameters */ + +/* L2CA_Disconnect */ +#define NGM_L2CAP_L2CA_DISCON 0x87 +/* Upper -> L2CAP */ +typedef struct { + u_int16_t lcid; /* local channel ID */ +} ng_l2cap_l2ca_discon_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - sucsess */ +} ng_l2cap_l2ca_discon_op; + +/* L2CA_DisconnectInd */ +#define NGM_L2CAP_L2CA_DISCON_IND 0x88 +/* L2CAP -> Upper */ +typedef ng_l2cap_l2ca_discon_ip ng_l2cap_l2ca_discon_ind_ip; +/* No output parameters */ + +/* L2CA_Write response */ +#define NGM_L2CAP_L2CA_WRITE 0x89 +/* No input parameters */ + +/* L2CAP -> Upper */ +typedef struct { + int result; /* result (0x00 - success) */ + u_int16_t length; /* amount of data written */ + u_int16_t lcid; /* local channel ID */ +} ng_l2cap_l2ca_write_op; + +/* L2CA_GroupCreate */ +#define NGM_L2CAP_L2CA_GRP_CREATE 0x8a +/* Upper -> L2CAP */ +typedef struct { + u_int16_t psm; /* Protocol/Service Multiplexor */ +} ng_l2cap_l2ca_grp_create_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t lcid; /* local group channel ID */ +} ng_l2cap_l2ca_grp_create_op; + +/* L2CA_GroupClose */ +#define NGM_L2CAP_L2CA_GRP_CLOSE 0x8b +/* Upper -> L2CAP */ +typedef struct { + u_int16_t lcid; /* local group channel ID */ +} ng_l2cap_l2ca_grp_close_ip; + +#if 0 +/* L2CAP -> Upper */ + * typedef struct { + * u_int16_t result; /* 0x00 - success */ + * } ng_l2cap_l2ca_grp_close_op; +#endif + +/* L2CA_GroupAddMember */ +#define NGM_L2CAP_L2CA_GRP_ADD_MEMBER 0x8c +/* Upper -> L2CAP */ +typedef struct { + u_int16_t lcid; /* local group channel ID */ + bdaddr_t bdaddr; /* remote unit address */ +} ng_l2cap_l2ca_grp_add_member_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - success */ +} ng_l2cap_l2ca_grp_add_member_op; + +/* L2CA_GroupRemoveMember */ +#define NGM_L2CAP_L2CA_GRP_REM_MEMBER 0x8d +/* Upper -> L2CAP */ +typedef ng_l2cap_l2ca_grp_add_member_ip ng_l2cap_l2ca_grp_rem_member_ip; + +/* L2CAP -> Upper */ +#if 0 + * typedef ng_l2cap_l2ca_grp_add_member_op ng_l2cap_l2ca_grp_rem_member_op; +#endif + +/* L2CA_GroupMembeship */ +#define NGM_L2CAP_L2CA_GRP_MEMBERSHIP 0x8e +/* Upper -> L2CAP */ +typedef struct { + u_int16_t lcid; /* local group channel ID */ +} ng_l2cap_l2ca_grp_get_members_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - success */ + u_int16_t nmembers; /* number of group members */ +/* bdaddr_t members[] -- group memebers */ +} ng_l2cap_l2ca_grp_get_members_op; + +/* L2CA_Ping */ +#define NGM_L2CAP_L2CA_PING 0x8f +/* Upper -> L2CAP */ +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ + u_int16_t echo_size; /* size of echo data in bytes */ +/* u_int8_t echo_data[] -- echo data */ +} ng_l2cap_l2ca_ping_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - success */ + bdaddr_t bdaddr; /* remote unit address */ + u_int16_t echo_size; /* size of echo data in bytes */ +/* u_int8_t echo_data[] -- echo data */ +} ng_l2cap_l2ca_ping_op; + +/* L2CA_GetInfo */ +#define NGM_L2CAP_L2CA_GET_INFO 0x90 +/* Upper -> L2CAP */ +typedef struct { + bdaddr_t bdaddr; /* remote unit address */ + u_int16_t info_type; /* info type */ +} ng_l2cap_l2ca_get_info_ip; + +/* L2CAP -> Upper */ +typedef struct { + u_int16_t result; /* 0x00 - success */ + u_int16_t info_size; /* size of info data in bytes */ +/* u_int8_t info_data[] -- info data */ +} ng_l2cap_l2ca_get_info_op; + +/* L2CA_EnableCLT/L2CA_DisableCLT */ +#define NGM_L2CAP_L2CA_ENABLE_CLT 0x91 +/* Upper -> L2CAP */ +typedef struct { + u_int16_t psm; /* Protocol/Service Multiplexor */ + u_int16_t enable; /* 0x00 - disable */ +} ng_l2cap_l2ca_enable_clt_ip; + +#if 0 +/* L2CAP -> Upper */ + * typedef struct { + * u_int16_t result; /* 0x00 - success */ + * } ng_l2cap_l2ca_enable_clt_op; +#endif + +/************************************************************************** + ************************************************************************** + ** L2CAP node messages + ************************************************************************** + **************************************************************************/ + +/* L2CAP connection states */ +#define NG_L2CAP_CON_CLOSED 0 /* connection closed */ +#define NG_L2CAP_W4_LP_CON_CFM 1 /* waiting... */ +#define NG_L2CAP_CON_OPEN 2 /* connection open */ + +/* L2CAP channel states */ +#define NG_L2CAP_CLOSED 0 /* channel closed */ +#define NG_L2CAP_W4_L2CAP_CON_RSP 1 /* wait for L2CAP resp. */ +#define NG_L2CAP_W4_L2CA_CON_RSP 2 /* wait for upper resp. */ +#define NG_L2CAP_CONFIG 3 /* L2CAP configuration */ +#define NG_L2CAP_OPEN 4 /* channel open */ +#define NG_L2CAP_W4_L2CAP_DISCON_RSP 5 /* wait for L2CAP discon. */ +#define NG_L2CAP_W4_L2CA_DISCON_RSP 6 /* wait for upper discon. */ + +/* Node flags */ +#define NG_L2CAP_CLT_SDP_DISABLED (1 << 0) /* disable SDP CLT */ +#define NG_L2CAP_CLT_RFCOMM_DISABLED (1 << 1) /* disable RFCOMM CLT */ +#define NG_L2CAP_CLT_TCP_DISABLED (1 << 2) /* disable TCP CLT */ + +/* Debug levels */ +#define NG_L2CAP_ALERT_LEVEL 1 +#define NG_L2CAP_ERR_LEVEL 2 +#define NG_L2CAP_WARN_LEVEL 3 +#define NG_L2CAP_INFO_LEVEL 4 + +/* Get node flags (see flags above) */ +#define NGM_L2CAP_NODE_GET_FLAGS 0x400 /* L2CAP -> User */ +typedef u_int16_t ng_l2cap_node_flags_ep; + +/* Get/Set debug level (see levels above) */ +#define NGM_L2CAP_NODE_GET_DEBUG 0x401 /* L2CAP -> User */ +#define NGM_L2CAP_NODE_SET_DEBUG 0x402 /* User -> L2CAP */ +typedef u_int16_t ng_l2cap_node_debug_ep; + +#define NGM_L2CAP_NODE_HOOK_INFO 0x409 /* L2CAP -> Upper */ +/* bdaddr_t bdaddr; -- local (source BDADDR) */ + +#define NGM_L2CAP_NODE_GET_CON_LIST 0x40a /* User -> L2CAP */ +typedef struct { + u_int32_t num_connections; /* number of connections */ +} ng_l2cap_node_con_list_ep; + +/* Connection flags */ +#define NG_L2CAP_CON_TX (1 << 0) /* sending data */ +#define NG_L2CAP_CON_RX (1 << 1) /* receiving data */ + +typedef struct { + u_int8_t state; /* connection state */ + u_int8_t flags; /* flags */ + int16_t pending; /* num. pending packets */ + u_int16_t con_handle; /* connection handle */ + bdaddr_t remote; /* remote bdaddr */ +} ng_l2cap_node_con_ep; + +#define NG_L2CAP_MAX_CON_NUM \ + ((0xffff - sizeof(ng_l2cap_node_con_list_ep))/sizeof(ng_l2cap_node_con_ep)) + +#define NGM_L2CAP_NODE_GET_CHAN_LIST 0x40b /* User -> L2CAP */ +typedef struct { + u_int32_t num_channels; /* number of channels */ +} ng_l2cap_node_chan_list_ep; + +typedef struct { + u_int32_t state; /* channel state */ + + u_int16_t scid; /* source (local) channel ID */ + u_int16_t dcid; /* destination (remote) channel ID */ + + u_int16_t imtu; /* incomming MTU */ + u_int16_t omtu; /* outgoing MTU */ + + u_int16_t psm; /* PSM */ + bdaddr_t remote; /* remote bdaddr */ +} ng_l2cap_node_chan_ep; + +#define NG_L2CAP_MAX_CHAN_NUM \ + ((0xffff - sizeof(ng_l2cap_node_chan_list_ep))/sizeof(ng_l2cap_node_chan_ep)) + +#endif /* ndef _NETGRAPH_L2CAP_H_ */ + diff --git a/sys/netgraph/bluetooth/include/ng_ubt.h b/sys/netgraph/bluetooth/include/ng_ubt.h new file mode 100644 index 0000000..1c55ad4 --- /dev/null +++ b/sys/netgraph/bluetooth/include/ng_ubt.h @@ -0,0 +1,103 @@ +/* + * ng_ubt.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_ubt.h,v 1.1 2002/11/09 19:09:02 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NG_UBT_H_ +#define _NG_UBT_H_ + +/* XXX FIXME Does not belong here. Move to usbdevs.h later */ +#define USB_VENDOR_MSI 0x0db0 /* MSI www.msi.com.tw */ +#define USB_VENDOR_EPOX 0x0a12 /* EPoX www.epox.com */ + +#define USB_PRODUCT_3COM_3CREB96 0x00a0 /* 3Com Bluetooth USB dongle */ +#define USB_PRODUCT_MITSUMI_BT_DONGLE 0x641f /* Mitsumi Bluetooth USB dongle*/ +#define USB_PRODUCT_TDK_BT_DONGLE 0x0309 /* TDK Bluetooth USB dongle */ +#define USB_PRODUCT_MSI_BT_DONGLE 0x1967 /* MSI Bluetooth USB dongle */ +#define USB_PRODUCT_DBW_120M_BT_DONGLE 0x2033 /* D-Link DBW-120M */ +#define USB_PRODUCT_BT_DG02_DONGLE 0x0001 /* EPoX BT-DG02 USB dongle */ + +/* XXX FIXME Does not belong here. Move to usb.h later */ +#define UICLASS_WIRELESS_CONTROLLER 0xe0 /* Wireless Controller */ +#define UISUBCLASS_RF_CONTROLLER 0x01 /* RF Controller */ +#define UIPROTO_BLUETOOTH 0x01 /* Bluetooth programming */ + +/************************************************************************** + ************************************************************************** + ** Netgraph node hook name, type name and type cookie and commands + ************************************************************************** + **************************************************************************/ + +#define NG_UBT_NODE_TYPE "ubt" +#define NG_UBT_HOOK "hook" + +#define NGM_UBT_COOKIE 1021837971 + +/* Debug levels */ +#define NG_UBT_ALERT_LEVEL 1 +#define NG_UBT_ERR_LEVEL 2 +#define NG_UBT_WARN_LEVEL 3 +#define NG_UBT_INFO_LEVEL 4 + +/************************************************************************** + ************************************************************************** + ** UBT node command/event parameters + ************************************************************************** + **************************************************************************/ + +#define NGM_UBT_NODE_SET_DEBUG 1 /* set debug level */ +#define NGM_UBT_NODE_GET_DEBUG 2 /* get debug level */ +typedef u_int16_t ng_ubt_node_debug_ep; + +#define NGM_UBT_NODE_SET_QLEN 3 /* set queue length */ +#define NGM_UBT_NODE_GET_QLEN 4 /* get queue length */ +typedef struct { + int32_t queue; /* queue index */ +#define NGM_UBT_NODE_QUEUE_IN 1 /* incoming queue */ +#define NGM_UBT_NODE_QUEUE_CMD 2 /* commands */ +#define NGM_UBT_NODE_QUEUE_ACL 3 /* ACL data */ +#define NGM_UBT_NODE_QUEUE_SCO 4 /* SCO data */ + + int32_t qlen; /* queue length */ +} ng_ubt_node_qlen_ep; + +#define NGM_UBT_NODE_GET_STAT 5 /* get statistic */ +typedef struct { + u_int32_t pckts_recv; /* # of packets received */ + u_int32_t bytes_recv; /* # of bytes received */ + u_int32_t pckts_sent; /* # of packets sent */ + u_int32_t bytes_sent; /* # of bytes sent */ + u_int32_t oerrors; /* # of output errors */ + u_int32_t ierrors; /* # of input errors */ +} ng_ubt_node_stat_ep; + +#define NGM_UBT_NODE_RESET_STAT 6 /* reset statistic */ + +#endif /* ndef _NG_UBT_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/TODO b/sys/netgraph/bluetooth/l2cap/TODO new file mode 100644 index 0000000..98d0440 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/TODO @@ -0,0 +1,43 @@ +$Id: TODO,v 1.8 2002/09/06 21:03:58 max Exp $ +$FreeBSD$ + +FIXME/TODO list + +0) Ping itself. Should L2CAP layer loopback data? + +1) Locking/SMP + + External code now uses ng_send_fn to inject data into Netgraph, so + it should be fine as long as Netgraph is SMP safe. Just need to + verify it. + +2) Understand and implement L2CAP QoS + + Will fix later. I only have CSR based hardware and it does not + support QoS. + +3) Better functions to manage CIDs and command ident's. + + Resource manager is not good because it uses MTX_DEF mutexes, + (i.e. could block/sleep) + +4) Implement group channels (multicast) + + Will fix later + +5) Add bytes/packets counters and commands to get/reset them + + Will fix later. What to count? + +6) Better way to get information about channels + + L2CAP can support about 65000 channels. Need define some good way + to get data from kernel to user space. For example if we need to pass + 1K of information for every channel, then worst case is that we need + to pass 65Mbytes of data from kernel to user space. Not good. + +7) Deal properly with "shutdown"s and hook "disconnect"s + + For now we destroy all channels when upstream hook is disconnected. + Is there a better way to handle this? + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.c b/sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.c new file mode 100644 index 0000000..0d28f1a --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.c @@ -0,0 +1,365 @@ +/* + * ng_l2cap_cmds.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_cmds.c,v 1.14 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_l2cap_var.h" +#include "ng_l2cap_cmds.h" +#include "ng_l2cap_evnt.h" +#include "ng_l2cap_llpi.h" +#include "ng_l2cap_ulpi.h" +#include "ng_l2cap_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** L2CAP commands processing module + ****************************************************************************** + ******************************************************************************/ + +/* + * Process L2CAP command queue on connection + */ + +void +ng_l2cap_con_wakeup(ng_l2cap_con_p con) +{ + ng_l2cap_cmd_p cmd = NULL; + struct mbuf *m = NULL; + int error = 0; + + /* Find first non-pending command in the queue */ + TAILQ_FOREACH(cmd, &con->cmd_list, next) { + KASSERT((cmd->con == con), +("%s: %s - invalid connection pointer!\n", + __func__, NG_NODE_NAME(con->l2cap->node))); + + if (!(cmd->flags & NG_L2CAP_CMD_PENDING)) + break; + } + + if (cmd == NULL) + return; + + /* Detach command packet */ + m = cmd->aux; + cmd->aux = NULL; + + /* Process command */ + switch (cmd->code) { + case NG_L2CAP_CMD_REJ: + case NG_L2CAP_DISCON_RSP: + case NG_L2CAP_ECHO_RSP: + case NG_L2CAP_INFO_RSP: + ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + break; + + case NG_L2CAP_CON_REQ: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + if (error != 0) { + ng_l2cap_l2ca_con_rsp(cmd->ch, cmd->token, + NG_L2CAP_NO_RESOURCES, 0); + ng_l2cap_free_chan(cmd->ch); /* will free commands */ + } else + ng_l2cap_command_timeout(cmd, + bluetooth_l2cap_rtx_timeout()); + break; + + case NG_L2CAP_CON_RSP: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + ng_l2cap_unlink_cmd(cmd); + if (cmd->ch != NULL) { + ng_l2cap_l2ca_con_rsp_rsp(cmd->ch, cmd->token, + (error == 0)? NG_L2CAP_SUCCESS : + NG_L2CAP_NO_RESOURCES); + if (error != 0) + ng_l2cap_free_chan(cmd->ch); + } + ng_l2cap_free_cmd(cmd); + break; + + case NG_L2CAP_CFG_REQ: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + if (error != 0) { + ng_l2cap_l2ca_cfg_rsp(cmd->ch, cmd->token, + NG_L2CAP_NO_RESOURCES); + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + } else + ng_l2cap_command_timeout(cmd, + bluetooth_l2cap_rtx_timeout()); + break; + + case NG_L2CAP_CFG_RSP: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + ng_l2cap_unlink_cmd(cmd); + if (cmd->ch != NULL) + ng_l2cap_l2ca_cfg_rsp_rsp(cmd->ch, cmd->token, + (error == 0)? NG_L2CAP_SUCCESS : + NG_L2CAP_NO_RESOURCES); + ng_l2cap_free_cmd(cmd); + break; + + case NG_L2CAP_DISCON_REQ: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + ng_l2cap_l2ca_discon_rsp(cmd->ch, cmd->token, + (error == 0)? NG_L2CAP_SUCCESS : NG_L2CAP_NO_RESOURCES); + if (error != 0) + ng_l2cap_free_chan(cmd->ch); /* XXX free channel */ + else + ng_l2cap_command_timeout(cmd, + bluetooth_l2cap_rtx_timeout()); + break; + + case NG_L2CAP_ECHO_REQ: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + if (error != 0) { + ng_l2cap_l2ca_ping_rsp(con, cmd->token, + NG_L2CAP_NO_RESOURCES, NULL); + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + } else + ng_l2cap_command_timeout(cmd, + bluetooth_l2cap_rtx_timeout()); + break; + + case NG_L2CAP_INFO_REQ: + error = ng_l2cap_lp_send(con, NG_L2CAP_SIGNAL_CID, m); + if (error != 0) { + ng_l2cap_l2ca_get_info_rsp(con, cmd->token, + NG_L2CAP_NO_RESOURCES, NULL); + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + } else + ng_l2cap_command_timeout(cmd, + bluetooth_l2cap_rtx_timeout()); + break; + + case NGM_L2CAP_L2CA_WRITE: { + int length = m->m_pkthdr.len; + + if (cmd->ch->dcid == NG_L2CAP_CLT_CID) { + m = ng_l2cap_prepend(m, sizeof(ng_l2cap_clt_hdr_t)); + if (m == NULL) + error = ENOBUFS; + else + mtod(m, ng_l2cap_clt_hdr_t *)->psm = + htole16(cmd->ch->psm); + } + + if (error == 0) + error = ng_l2cap_lp_send(con, cmd->ch->dcid, m); + + ng_l2cap_l2ca_write_rsp(cmd->ch, cmd->token, + (error == 0)? NG_L2CAP_SUCCESS : NG_L2CAP_NO_RESOURCES, + length); + + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + } break; + + /* XXX FIXME add other commands */ + + default: + KASSERT(0, +("%s: %s - unknown command code=%d\n", + __func__, NG_NODE_NAME(con->l2cap->node), cmd->code)); + + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + break; + } +} /* ng_l2cap_con_wakeup */ + +/* + * We have failed to open ACL connection to the remote unit. Could be negative + * confirmation or timeout. So fail any "delayed" commands, notify upper layer, + * remove all channels and remove connection descriptor. + */ + +void +ng_l2cap_con_fail(ng_l2cap_con_p con, u_int16_t result) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_cmd_p cmd = NULL; + ng_l2cap_chan_p ch = NULL; + + NG_L2CAP_INFO( +"%s: %s - ACL connection failed, result=%d\n", + __func__, NG_NODE_NAME(l2cap->node), result); + + /* Clean command queue */ + while (!TAILQ_EMPTY(&con->cmd_list)) { + cmd = TAILQ_FIRST(&con->cmd_list); + + ng_l2cap_unlink_cmd(cmd); + if(cmd->flags & NG_L2CAP_CMD_PENDING) + ng_l2cap_command_untimeout(cmd); + + KASSERT((cmd->con == con), +("%s: %s - invalid connection pointer!\n", + __func__, NG_NODE_NAME(con->l2cap->node))); + + switch (cmd->code) { + case NG_L2CAP_CMD_REJ: + case NG_L2CAP_DISCON_RSP: + case NG_L2CAP_ECHO_RSP: + case NG_L2CAP_INFO_RSP: + break; + + case NG_L2CAP_CON_REQ: + ng_l2cap_l2ca_con_rsp(cmd->ch, cmd->token, result, 0); + break; + + case NG_L2CAP_CON_RSP: + if (cmd->ch != NULL) + ng_l2cap_l2ca_con_rsp_rsp(cmd->ch, cmd->token, + result); + break; + + case NG_L2CAP_CFG_REQ: + case NG_L2CAP_CFG_RSP: + case NGM_L2CAP_L2CA_WRITE: + ng_l2cap_l2ca_discon_ind(cmd->ch); + break; + + case NG_L2CAP_DISCON_REQ: + ng_l2cap_l2ca_discon_rsp(cmd->ch, cmd->token, + NG_L2CAP_SUCCESS); + break; + + case NG_L2CAP_ECHO_REQ: + ng_l2cap_l2ca_ping_rsp(cmd->con, cmd->token, + result, NULL); + break; + + case NG_L2CAP_INFO_REQ: + ng_l2cap_l2ca_get_info_rsp(cmd->con, cmd->token, + result, NULL); + break; + + /* XXX FIXME add other commands */ + + default: + KASSERT(0, +("%s: %s - unexpected command code=%d\n", + __func__, NG_NODE_NAME(con->l2cap->node), + cmd->code)); + break; + } + + if (cmd->ch != NULL) + ng_l2cap_free_chan(cmd->ch); + + ng_l2cap_free_cmd(cmd); + } + + /* + * There still might be channels (in OPEN state?) that + * did not submit any commands, so diconnect them + */ + + LIST_FOREACH(ch, &l2cap->chan_list, next) + if (ch->con == con) + ng_l2cap_l2ca_discon_ind(ch); + + /* Free connection descriptor */ + ng_l2cap_free_con(con); +} /* ng_l2cap_con_fail */ + +/* + * Process L2CAP command timeout. In general - notify upper layer and destroy + * channel. Do not pay much attension to return code, just do our best. + */ + +void +ng_l2cap_process_command_timeout(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_l2cap_cmd_p cmd = (ng_l2cap_cmd_p) arg1; + + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command flags flags=%#x!\n", + __func__, NG_NODE_NAME(cmd->con->l2cap->node), cmd->flags)); + + cmd->flags &= ~NG_L2CAP_CMD_PENDING; + ng_l2cap_unlink_cmd(cmd); + + switch (cmd->code) { + case NG_L2CAP_CON_REQ: + ng_l2cap_l2ca_con_rsp(cmd->ch, cmd->token, NG_L2CAP_TIMEOUT, 0); + ng_l2cap_free_chan(cmd->ch); + break; + + case NG_L2CAP_CFG_REQ: + ng_l2cap_l2ca_cfg_rsp(cmd->ch, cmd->token, NG_L2CAP_TIMEOUT); + break; + + case NG_L2CAP_DISCON_REQ: + ng_l2cap_l2ca_discon_rsp(cmd->ch, cmd->token, NG_L2CAP_TIMEOUT); + ng_l2cap_free_chan(cmd->ch); /* XXX free channel */ + break; + + case NG_L2CAP_ECHO_REQ: + /* Echo request timed out. Let the upper layer know */ + ng_l2cap_l2ca_ping_rsp(cmd->con, cmd->token, + NG_L2CAP_TIMEOUT, NULL); + break; + + case NG_L2CAP_INFO_REQ: + /* Info request timed out. Let the upper layer know */ + ng_l2cap_l2ca_get_info_rsp(cmd->con, cmd->token, + NG_L2CAP_TIMEOUT, NULL); + break; + + /* XXX FIXME add other commands */ + + default: + KASSERT(0, +("%s: %s - unexpected command code=%d\n", + __func__, NG_NODE_NAME(cmd->con->l2cap->node), + cmd->code)); + break; + } + + ng_l2cap_free_cmd(cmd); +} /* ng_l2cap_process_command_timeout */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.h new file mode 100644 index 0000000..d107ad6 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_cmds.h @@ -0,0 +1,403 @@ +/* + * ng_l2cap_cmds.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_cmds.h,v 1.9 2002/04/16 00:43:56 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_L2CAP_CMDS_H_ +#define _NETGRAPH_L2CAP_CMDS_H_ + +/****************************************************************************** + ****************************************************************************** + ** L2CAP to L2CAP signaling command macros + ****************************************************************************** + ******************************************************************************/ + +/* + * Note: All L2CAP implementations are required to support minimal signaling + * MTU of 48 bytes. In order to simplify things we will send one command + * per one L2CAP packet. Given evrything above we can assume that one + * signaling packet will fit into single mbuf. + */ + +/* L2CAP_CommandRej */ +#define _ng_l2cap_cmd_rej(_m, _ident, _reason, _mtu, _scid, _dcid) \ +do { \ + struct _cmd_rej { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_cmd_rej_cp param; \ + ng_l2cap_cmd_rej_data_t data; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + c = mtod((_m), struct _cmd_rej *); \ + c->hdr.code = NG_L2CAP_CMD_REJ; \ + c->hdr.ident = (_ident); \ + c->hdr.length = sizeof(c->param); \ + \ + c->param.reason = htole16((_reason)); \ + \ + if ((_reason) == NG_L2CAP_REJ_MTU_EXCEEDED) { \ + c->data.mtu.mtu = htole16((_mtu)); \ + c->hdr.length += sizeof(c->data.mtu); \ + } else if ((_reason) == NG_L2CAP_REJ_INVALID_CID) { \ + c->data.cid.scid = htole16((_scid)); \ + c->data.cid.dcid = htole16((_dcid)); \ + c->hdr.length += sizeof(c->data.cid); \ + } \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(c->hdr) + \ + c->hdr.length; \ + \ + c->hdr.length = htole16(c->hdr.length); \ +} while (0) + +/* L2CAP_ConnectReq */ +#define _ng_l2cap_con_req(_m, _ident, _psm, _scid) \ +do { \ + struct _con_req { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_con_req_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _con_req *); \ + c->hdr.code = NG_L2CAP_CON_REQ; \ + c->hdr.ident = (_ident); \ + c->hdr.length = htole16(sizeof(c->param)); \ + \ + c->param.psm = htole16((_psm)); \ + c->param.scid = htole16((_scid)); \ +} while (0) + +/* L2CAP_ConnectRsp */ +#define _ng_l2cap_con_rsp(_m, _ident, _dcid, _scid, _result, _status) \ +do { \ + struct _con_rsp { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_con_rsp_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _con_rsp *); \ + c->hdr.code = NG_L2CAP_CON_RSP; \ + c->hdr.ident = (_ident); \ + c->hdr.length = htole16(sizeof(c->param)); \ + \ + c->param.dcid = htole16((_dcid)); \ + c->param.scid = htole16((_scid)); \ + c->param.result = htole16((_result)); \ + c->param.status = htole16((_status)); \ +} while (0) + +/* L2CAP_ConfigReq */ +#define _ng_l2cap_cfg_req(_m, _ident, _dcid, _flags, _data) \ +do { \ + struct _cfg_req { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_cfg_req_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) { \ + NG_FREE_M((_data)); \ + break; \ + } \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _cfg_req *); \ + c->hdr.code = NG_L2CAP_CFG_REQ; \ + c->hdr.ident = (_ident); \ + c->hdr.length = sizeof(c->param); \ + \ + c->param.dcid = htole16((_dcid)); \ + c->param.flags = htole16((_flags)); \ + if ((_data) != NULL) { \ + m_cat((_m), (_data)); \ + c->hdr.length += (_data)->m_pkthdr.len; \ + (_m)->m_pkthdr.len += (_data)->m_pkthdr.len; \ + } \ + \ + c->hdr.length = htole16(c->hdr.length); \ +} while (0) + +/* L2CAP_ConfigRsp */ +#define _ng_l2cap_cfg_rsp(_m, _ident, _scid, _flags, _result, _data) \ +do { \ + struct _cfg_rsp { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_cfg_rsp_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) { \ + NG_FREE_M((_data)); \ + break; \ + } \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _cfg_rsp *); \ + c->hdr.code = NG_L2CAP_CFG_RSP; \ + c->hdr.ident = (_ident); \ + c->hdr.length = sizeof(c->param); \ + \ + c->param.scid = htole16((_scid)); \ + c->param.flags = htole16((_flags)); \ + c->param.result = htole16((_result)); \ + if ((_data) != NULL) { \ + m_cat((_m), (_data)); \ + c->hdr.length += (_data)->m_pkthdr.len; \ + (_m)->m_pkthdr.len += (_data)->m_pkthdr.len; \ + } \ + \ + c->hdr.length = htole16(c->hdr.length); \ +} while (0) + +/* Build configuration options */ +#define _ng_l2cap_build_cfg_options(_m, _mtu, _flush_timo, _flow) \ +do { \ + u_int8_t *p = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = 0; \ + p = mtod((_m), u_int8_t *); \ + \ + if ((_mtu) != NULL) { \ + struct _cfg_opt_mtu { \ + ng_l2cap_cfg_opt_t hdr; \ + u_int16_t val; \ + } __attribute__ ((packed)) *o = NULL; \ + \ + o = (struct _cfg_opt_mtu *) p; \ + o->hdr.type = NG_L2CAP_OPT_MTU; \ + o->hdr.length = sizeof(o->val); \ + o->val = htole16(*(u_int16_t *)(_mtu)); \ + \ + (_m)->m_pkthdr.len += sizeof(*o); \ + p += sizeof(*o); \ + } \ + \ + if ((_flush_timo) != NULL) { \ + struct _cfg_opt_flush { \ + ng_l2cap_cfg_opt_t hdr; \ + u_int16_t val; \ + } __attribute__ ((packed)) *o = NULL; \ + \ + o = (struct _cfg_opt_flush *) p; \ + o->hdr.type = NG_L2CAP_OPT_FLUSH_TIMO; \ + o->hdr.length = sizeof(o->val); \ + o->val = htole16(*(u_int16_t *)(_flush_timo)); \ + \ + (_m)->m_pkthdr.len += sizeof(*o); \ + p += sizeof(*o); \ + } \ + \ + if ((_flow) != NULL) { \ + struct _cfg_opt_flow { \ + ng_l2cap_cfg_opt_t hdr; \ + ng_l2cap_flow_t val; \ + } __attribute__ ((packed)) *o = NULL; \ + \ + o = (struct _cfg_opt_flow *) p; \ + o->hdr.type = NG_L2CAP_OPT_QOS; \ + o->hdr.length = sizeof(o->val); \ + o->val.flags = ((ng_l2cap_flow_p)(_flow))->flags; \ + o->val.service_type = ((ng_l2cap_flow_p) \ + (_flow))->service_type; \ + o->val.token_rate = \ + htole32(((ng_l2cap_flow_p)(_flow))->token_rate);\ + o->val.token_bucket_size = \ + htole32(((ng_l2cap_flow_p) \ + (_flow))->token_bucket_size); \ + o->val.peak_bandwidth = \ + htole32(((ng_l2cap_flow_p) \ + (_flow))->peak_bandwidth); \ + o->val.latency = htole32(((ng_l2cap_flow_p) \ + (_flow))->latency); \ + o->val.delay_variation = \ + htole32(((ng_l2cap_flow_p) \ + (_flow))->delay_variation); \ + \ + (_m)->m_pkthdr.len += sizeof(*o); \ + } \ + \ + (_m)->m_len = (_m)->m_pkthdr.len; \ +} while (0) + +/* L2CAP_DisconnectReq */ +#define _ng_l2cap_discon_req(_m, _ident, _dcid, _scid) \ +do { \ + struct _discon_req { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_discon_req_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _discon_req *); \ + c->hdr.code = NG_L2CAP_DISCON_REQ; \ + c->hdr.ident = (_ident); \ + c->hdr.length = htole16(sizeof(c->param)); \ + \ + c->param.dcid = htole16((_dcid)); \ + c->param.scid = htole16((_scid)); \ +} while (0) + +/* L2CA_DisconnectRsp */ +#define _ng_l2cap_discon_rsp(_m, _ident, _dcid, _scid) \ +do { \ + struct _discon_rsp { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_discon_rsp_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _discon_rsp *); \ + c->hdr.code = NG_L2CAP_DISCON_RSP; \ + c->hdr.ident = (_ident); \ + c->hdr.length = htole16(sizeof(c->param)); \ + \ + c->param.dcid = htole16((_dcid)); \ + c->param.scid = htole16((_scid)); \ +} while (0) + +/* L2CAP_EchoReq */ +#define _ng_l2cap_echo_req(_m, _ident, _data, _size) \ +do { \ + ng_l2cap_cmd_hdr_t *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), ng_l2cap_cmd_hdr_t *); \ + c->code = NG_L2CAP_ECHO_REQ; \ + c->ident = (_ident); \ + c->length = 0; \ + \ + if ((_data) != NULL) { \ + m_copyback((_m), sizeof(*c), (_size), (_data)); \ + c->length += (_size); \ + } \ + \ + c->length = htole16(c->length); \ +} while (0) + +/* L2CAP_InfoReq */ +#define _ng_l2cap_info_req(_m, _ident, _type) \ +do { \ + struct _info_req { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_info_req_cp param; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(*c); \ + \ + c = mtod((_m), struct _info_req *); \ + c->hdr.code = NG_L2CAP_INFO_REQ; \ + c->hdr.ident = (_ident); \ + c->hdr.length = htole16(sizeof(c->param)); \ + \ + c->param.type = htole16((_type)); \ +} while (0) + +/* L2CAP_InfoRsp */ +#define _ng_l2cap_info_rsp(_m, _ident, _type, _result, _mtu) \ +do { \ + struct _info_rsp { \ + ng_l2cap_cmd_hdr_t hdr; \ + ng_l2cap_info_rsp_cp param; \ + ng_l2cap_info_rsp_data_t data; \ + } __attribute__ ((packed)) *c = NULL; \ + \ + MGETHDR((_m), M_DONTWAIT, MT_DATA); \ + if ((_m) == NULL) \ + break; \ + \ + c = mtod((_m), struct _info_rsp *); \ + c->hdr.code = NG_L2CAP_INFO_REQ; \ + c->hdr.ident = (_ident); \ + c->hdr.length = sizeof(c->param); \ + \ + c->param.type = htole16((_type)); \ + c->param.result = htole16((_result)); \ + \ + if ((_result) == NG_L2CAP_SUCCESS) { \ + switch ((_type)) { \ + case NG_L2CAP_CONNLESS_MTU: \ + c->data.mtu.mtu = htole16((_mtu)); \ + c->hdr.length += sizeof((c->data.mtu.mtu)); \ + break; \ + } \ + } \ + \ + (_m)->m_pkthdr.len = (_m)->m_len = sizeof(c->hdr) + \ + c->hdr.length; \ + \ + c->hdr.length = htole16(c->hdr.length); \ +} while (0) + +void ng_l2cap_con_wakeup (ng_l2cap_con_p); +void ng_l2cap_con_fail (ng_l2cap_con_p, u_int16_t); +void ng_l2cap_process_command_timeout (node_p, hook_p, void *, int); + +#endif /* ndef _NETGRAPH_L2CAP_CMDS_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_evnt.c b/sys/netgraph/bluetooth/l2cap/ng_l2cap_evnt.c new file mode 100644 index 0000000..3779b91 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_evnt.c @@ -0,0 +1,1337 @@ +/* + * ng_l2cap_evnt.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_evnt.c,v 1.18 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_l2cap_var.h" +#include "ng_l2cap_cmds.h" +#include "ng_l2cap_evnt.h" +#include "ng_l2cap_llpi.h" +#include "ng_l2cap_ulpi.h" +#include "ng_l2cap_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** L2CAP events processing module + ****************************************************************************** + ******************************************************************************/ + +static int ng_l2cap_process_signal_cmd (ng_l2cap_con_p); +static int ng_l2cap_process_cmd_rej (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_con_req (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_con_rsp (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_cfg_req (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_cfg_rsp (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_discon_req (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_discon_rsp (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_echo_req (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_echo_rsp (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_info_req (ng_l2cap_con_p, u_int8_t); +static int ng_l2cap_process_info_rsp (ng_l2cap_con_p, u_int8_t); +static int send_l2cap_reject + (ng_l2cap_con_p, u_int8_t, u_int16_t, u_int16_t, u_int16_t, u_int16_t); +static int send_l2cap_con_rej + (ng_l2cap_con_p, u_int8_t, u_int16_t, u_int16_t, u_int16_t); +static int send_l2cap_cfg_rsp + (ng_l2cap_con_p, u_int8_t, u_int16_t, u_int16_t, struct mbuf *); +static int get_next_l2cap_opt + (struct mbuf *, int *, ng_l2cap_cfg_opt_p, ng_l2cap_cfg_opt_val_p); + +/* + * Receive L2CAP packet. First get L2CAP header and verify packet. Than + * get destination channel and process packet. + */ + +int +ng_l2cap_receive(ng_l2cap_con_p con) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_hdr_t *hdr = NULL; + int error = 0; + + /* Check packet */ + if (con->rx_pkt->m_pkthdr.len < sizeof(*hdr)) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP packet. Packet too small, len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + con->rx_pkt->m_pkthdr.len); + error = EMSGSIZE; + goto drop; + } + + /* Get L2CAP header */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*hdr)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + hdr = mtod(con->rx_pkt, ng_l2cap_hdr_t *); + hdr->length = le16toh(hdr->length); + hdr->dcid = le16toh(hdr->dcid); + + /* Check payload size */ + if (hdr->length != con->rx_pkt->m_pkthdr.len - sizeof(*hdr)) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP packet. Payload length mismatch, length=%d, len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), hdr->length, + con->rx_pkt->m_pkthdr.len - sizeof(*hdr)); + error = EMSGSIZE; + goto drop; + } + + /* Process packet */ + switch (hdr->dcid) { + case NG_L2CAP_SIGNAL_CID: /* L2CAP command */ + m_adj(con->rx_pkt, sizeof(*hdr)); + error = ng_l2cap_process_signal_cmd(con); + break; + + case NG_L2CAP_CLT_CID: /* Connectionless packet */ + error = ng_l2cap_l2ca_clt_receive(con); + break; + + default: /* Data packet */ + error = ng_l2cap_l2ca_receive(con); + break; + } + + return (error); +drop: + NG_FREE_M(con->rx_pkt); + + return (error); +} /* ng_l2cap_receive */ + +/* + * Process L2CAP signaling command. We already know that destination channel ID + * is 0x1 that means we have received signaling command from peer's L2CAP layer. + * So get command header, decode and process it. + * + * XXX do we need to check signaling MTU here? + */ + +static int +ng_l2cap_process_signal_cmd(ng_l2cap_con_p con) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_cmd_hdr_t *hdr = NULL; + struct mbuf *m = NULL; + + while (con->rx_pkt != NULL) { + /* Verify packet length */ + if (con->rx_pkt->m_pkthdr.len < sizeof(*hdr)) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP signaling command. Packet too small, len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + con->rx_pkt->m_pkthdr.len); + NG_FREE_M(con->rx_pkt); + + return (EMSGSIZE); + } + + /* Get signaling command */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*hdr)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + hdr = mtod(con->rx_pkt, ng_l2cap_cmd_hdr_t *); + hdr->length = le16toh(hdr->length); + m_adj(con->rx_pkt, sizeof(*hdr)); + + /* Verify command length */ + if (con->rx_pkt->m_pkthdr.len < hdr->length) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP signaling command, code=%#x, ident=%d. " \ +"Invalid command length=%d, m_pkthdr.len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + hdr->code, hdr->ident, hdr->length, + con->rx_pkt->m_pkthdr.len); + NG_FREE_M(con->rx_pkt); + + return (EMSGSIZE); + } + + /* Get the command, save the rest (if any) */ + if (con->rx_pkt->m_pkthdr.len > hdr->length) + m = m_split(con->rx_pkt, hdr->length, M_DONTWAIT); + else + m = NULL; + + /* Process command */ + switch (hdr->code) { + case NG_L2CAP_CMD_REJ: + ng_l2cap_process_cmd_rej(con, hdr->ident); + break; + + case NG_L2CAP_CON_REQ: + ng_l2cap_process_con_req(con, hdr->ident); + break; + + case NG_L2CAP_CON_RSP: + ng_l2cap_process_con_rsp(con, hdr->ident); + break; + + case NG_L2CAP_CFG_REQ: + ng_l2cap_process_cfg_req(con, hdr->ident); + break; + + case NG_L2CAP_CFG_RSP: + ng_l2cap_process_cfg_rsp(con, hdr->ident); + break; + + case NG_L2CAP_DISCON_REQ: + ng_l2cap_process_discon_req(con, hdr->ident); + break; + + case NG_L2CAP_DISCON_RSP: + ng_l2cap_process_discon_rsp(con, hdr->ident); + break; + + case NG_L2CAP_ECHO_REQ: + ng_l2cap_process_echo_req(con, hdr->ident); + break; + + case NG_L2CAP_ECHO_RSP: + ng_l2cap_process_echo_rsp(con, hdr->ident); + break; + + case NG_L2CAP_INFO_REQ: + ng_l2cap_process_info_req(con, hdr->ident); + break; + + case NG_L2CAP_INFO_RSP: + ng_l2cap_process_info_rsp(con, hdr->ident); + break; + + default: + NG_L2CAP_ERR( +"%s: %s - unknown L2CAP signaling command, code=%#x, ident=%d, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + hdr->code, hdr->ident, hdr->length); + + /* + * Send L2CAP_CommandRej. Do not really care + * about the result + */ + + send_l2cap_reject(con, hdr->ident, + NG_L2CAP_REJ_NOT_UNDERSTOOD, 0, 0, 0); + NG_FREE_M(con->rx_pkt); + break; + } + + con->rx_pkt = m; + } + + return (0); +} /* ng_l2cap_process_signal_cmd */ + +/* + * Process L2CAP_CommandRej command + */ + +static int +ng_l2cap_process_cmd_rej(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_cmd_rej_cp *cp = NULL; + ng_l2cap_cmd_p cmd = NULL; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*cp)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + cp = mtod(con->rx_pkt, ng_l2cap_cmd_rej_cp *); + cp->reason = le16toh(cp->reason); + + /* Check if we have pending command descriptor */ + cmd = ng_l2cap_cmd_by_ident(con, ident); + if (cmd != NULL) { + KASSERT((cmd->con == con), +("%s: %s - invalid connection pointer!\n", + __func__, NG_NODE_NAME(con->l2cap->node))); + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command state, flags=%#x\n", + __func__, NG_NODE_NAME(con->l2cap->node), cmd->flags)); + + ng_l2cap_command_untimeout(cmd); + ng_l2cap_unlink_cmd(cmd); + + switch (cmd->code) { + case NG_L2CAP_CON_REQ: + ng_l2cap_l2ca_con_rsp(cmd->ch,cmd->token,cp->reason,0); + ng_l2cap_free_chan(cmd->ch); + break; + + case NG_L2CAP_CFG_REQ: + ng_l2cap_l2ca_cfg_rsp(cmd->ch, cmd->token, cp->reason); + break; + + case NG_L2CAP_DISCON_REQ: + ng_l2cap_l2ca_discon_rsp(cmd->ch,cmd->token,cp->reason); + ng_l2cap_free_chan(cmd->ch); /* XXX free channel */ + break; + + case NG_L2CAP_ECHO_REQ: + ng_l2cap_l2ca_ping_rsp(cmd->con, cmd->token, + cp->reason, NULL); + break; + + case NG_L2CAP_INFO_REQ: + ng_l2cap_l2ca_get_info_rsp(cmd->con, cmd->token, + cp->reason, NULL); + break; + + default: + NG_L2CAP_ALERT( +"%s: %s - unexpected L2CAP_CommandRej. Unexpected L2CAP command opcode=%d\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->code); + break; + } + + ng_l2cap_free_cmd(cmd); + } else + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_CommandRej command. " \ +"Requested ident does not exist, ident=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ident); + + NG_FREE_M(con->rx_pkt); + + return (0); +} /* ng_l2cap_process_cmd_rej */ + +/* + * Process L2CAP_ConnectReq command + */ + +static int +ng_l2cap_process_con_req(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + struct mbuf *m = con->rx_pkt; + ng_l2cap_con_req_cp *cp = NULL; + ng_l2cap_chan_p ch = NULL; + int error = 0; + u_int16_t dcid, psm; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(m, sizeof(*cp)); + if (m == NULL) + return (ENOBUFS); + + cp = mtod(m, ng_l2cap_con_req_cp *); + psm = le16toh(cp->psm); + dcid = le16toh(cp->scid); + + NG_FREE_M(m); + con->rx_pkt = NULL; + + /* + * Create new channel and send L2CA_ConnectInd notification + * to the upper layer protocol. + */ + + ch = ng_l2cap_new_chan(l2cap, con, psm); + if (ch == NULL) + return (send_l2cap_con_rej(con, ident, 0, dcid, + NG_L2CAP_NO_RESOURCES)); + + /* Update channel IDs */ + ch->dcid = dcid; + + /* Sent L2CA_ConnectInd notification to the upper layer */ + ch->ident = ident; + ch->state = NG_L2CAP_W4_L2CA_CON_RSP; + + error = ng_l2cap_l2ca_con_ind(ch); + if (error != 0) { + send_l2cap_con_rej(con, ident, ch->scid, dcid, + (error == ENOMEM)? NG_L2CAP_NO_RESOURCES : + NG_L2CAP_PSM_NOT_SUPPORTED); + ng_l2cap_free_chan(ch); + } + + return (error); +} /* ng_l2cap_process_con_req */ + +/* + * Process L2CAP_ConnectRsp command + */ + +static int +ng_l2cap_process_con_rsp(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + struct mbuf *m = con->rx_pkt; + ng_l2cap_con_rsp_cp *cp = NULL; + ng_l2cap_cmd_p cmd = NULL; + u_int16_t scid, dcid, result, status; + int error = 0; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(m, sizeof(*cp)); + if (m == NULL) + return (ENOBUFS); + + cp = mtod(m, ng_l2cap_con_rsp_cp *); + dcid = le16toh(cp->dcid); + scid = le16toh(cp->scid); + result = le16toh(cp->result); + status = le16toh(cp->status); + + NG_FREE_M(m); + con->rx_pkt = NULL; + + /* Check if we have pending command descriptor */ + cmd = ng_l2cap_cmd_by_ident(con, ident); + if (cmd == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConnectRsp command. ident=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ident, + con->con_handle); + + return (ENOENT); + } + + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command state, flags=%#x\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->flags)); + + /* Verify channel state, if invalid - do nothing */ + if (cmd->ch->state != NG_L2CAP_W4_L2CAP_CON_RSP) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConnectRsp. " \ +"Invalid channel state, cid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), scid, + cmd->ch->state); + goto reject; + } + + /* Verify CIDs and send reject if does not match */ + if (cmd->ch->scid != scid) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConnectRsp. Channel IDs do not match, scid=%d(%d)\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->ch->scid, + scid); + goto reject; + } + + /* + * Looks good. We got confirmation from our peer. Now process + * it. First disable RTX timer. Then check the result and send + * notification to the upper layer. + */ + + ng_l2cap_command_untimeout(cmd); + + if (result == NG_L2CAP_PENDING) { + /* + * Our peer wants more time to complete connection. We shall + * start ERTX timer and wait. Keep command in the list. + */ + + cmd->ch->dcid = dcid; + ng_l2cap_command_timeout(cmd, bluetooth_l2cap_ertx_timeout()); + + error = ng_l2cap_l2ca_con_rsp(cmd->ch, cmd->token, + result, status); + if (error != 0) + ng_l2cap_free_chan(cmd->ch); + } else { + ng_l2cap_unlink_cmd(cmd); + + if (result == NG_L2CAP_SUCCESS) { + /* + * Channel is open. Complete command and move to CONFIG + * state. Since we have sent positive confirmation we + * expect to receive L2CA_Config request from the upper + * layer protocol. + */ + + cmd->ch->dcid = dcid; + cmd->ch->state = NG_L2CAP_CONFIG; + } else + /* There was an error, so close the channel */ + NG_L2CAP_INFO( +"%s: %s - failed to open L2CAP channel, result=%d, status=%d\n", + __func__, NG_NODE_NAME(l2cap->node), result, + status); + + error = ng_l2cap_l2ca_con_rsp(cmd->ch, cmd->token, + result, status); + + /* XXX do we have to remove the channel on error? */ + if (error != 0 || result != NG_L2CAP_SUCCESS) + ng_l2cap_free_chan(cmd->ch); + + ng_l2cap_free_cmd(cmd); + } + + return (error); + +reject: + /* Send reject. Do not really care about the result */ + send_l2cap_reject(con, ident, NG_L2CAP_REJ_INVALID_CID, 0, scid, dcid); + + return (0); +} /* ng_l2cap_process_con_rsp */ + +/* + * Process L2CAP_ConfigReq command + */ + +static int +ng_l2cap_process_cfg_req(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + struct mbuf *m = con->rx_pkt; + ng_l2cap_cfg_req_cp *cp = NULL; + ng_l2cap_chan_p ch = NULL; + u_int16_t dcid, respond, result; + ng_l2cap_cfg_opt_t hdr; + ng_l2cap_cfg_opt_val_t val; + int off, error = 0; + + /* Get command parameters */ + con->rx_pkt = NULL; + NG_L2CAP_M_PULLUP(m, sizeof(*cp)); + if (m == NULL) + return (ENOBUFS); + + cp = mtod(m, ng_l2cap_cfg_req_cp *); + dcid = le16toh(cp->dcid); + respond = NG_L2CAP_OPT_CFLAG(le16toh(cp->flags)); + m_adj(m, sizeof(*cp)); + + /* Check if we have this channel and it is in valid state */ + ch = ng_l2cap_chan_by_scid(l2cap, dcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConfigReq command. " \ +"Channel does not exist, cid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), dcid); + goto reject; + } + + /* Verify channel state */ + if (ch->state != NG_L2CAP_CONFIG && ch->state != NG_L2CAP_OPEN) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConfigReq. " \ +"Invalid channel state, cid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), dcid, ch->state); + goto reject; + } + + if (ch->state == NG_L2CAP_OPEN) { /* Re-configuration */ + ch->cfg_state = 0; + ch->state = NG_L2CAP_CONFIG; + } + + for (result = 0, off = 0; ; ) { + error = get_next_l2cap_opt(m, &off, &hdr, &val); + if (error == 0) { /* We done with this packet */ + NG_FREE_M(m); + break; + } else if (error > 0) { /* Got option */ + switch (hdr.type) { + case NG_L2CAP_OPT_MTU: + ch->omtu = val.mtu; + break; + + case NG_L2CAP_OPT_FLUSH_TIMO: + ch->flush_timo = val.flush_timo; + break; + + case NG_L2CAP_OPT_QOS: + bcopy(&val.flow, &ch->iflow, sizeof(ch->iflow)); + break; + + default: + KASSERT(0, +("%s: %s - unknown option: %d\n", __func__, NG_NODE_NAME(l2cap->node), + hdr.type)); + break; + } + } else { /* Oops, something is wrong */ + respond = 1; + + if (error == -3) { + + /* + * Adjust mbuf so we can get to the start + * of the first option we did not like. + */ + + m_adj(m, off - sizeof(hdr)); + m->m_pkthdr.len = sizeof(hdr) + hdr.length; + + result = NG_L2CAP_UNKNOWN_OPTION; + } else { + /* XXX FIXME Send other reject codes? */ + NG_FREE_M(m); + result = NG_L2CAP_REJECT; + } + + break; + } + } + + /* + * Now check and see if we have to respond. If everything was OK then + * respond contain "C flag" and (if set) we will respond with empty + * packet and will wait for more options. + * + * Other case is that we did not like peer's options and will respond + * with L2CAP_Config response command with Reject error code. + * + * When "respond == 0" than we have received all options and we will + * sent L2CA_ConfigInd event to the upper layer protocol. + */ + + if (respond) { + error = send_l2cap_cfg_rsp(con, ident, ch->dcid, result, m); + if (error != 0) { + ng_l2cap_l2ca_discon_ind(ch); + ng_l2cap_free_chan(ch); + } + } else { + /* Send L2CA_ConfigInd event to the upper layer protocol */ + ch->ident = ident; + error = ng_l2cap_l2ca_cfg_ind(ch); + if (error != 0) + ng_l2cap_free_chan(ch); + } + + return (error); + +reject: + /* Send reject. Do not really care about the result */ + NG_FREE_M(m); + + send_l2cap_reject(con, ident, NG_L2CAP_REJ_INVALID_CID, 0, 0, dcid); + + return (0); +} /* ng_l2cap_process_cfg_req */ + +/* + * Process L2CAP_ConfigRsp command + */ + +static int +ng_l2cap_process_cfg_rsp(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + struct mbuf *m = con->rx_pkt; + ng_l2cap_cfg_rsp_cp *cp = NULL; + ng_l2cap_cmd_p cmd = NULL; + u_int16_t scid, cflag, result; + ng_l2cap_cfg_opt_t hdr; + ng_l2cap_cfg_opt_val_t val; + int off, error = 0; + + /* Get command parameters */ + con->rx_pkt = NULL; + NG_L2CAP_M_PULLUP(m, sizeof(*cp)); + if (m == NULL) + return (ENOBUFS); + + cp = mtod(m, ng_l2cap_cfg_rsp_cp *); + scid = le16toh(cp->scid); + cflag = NG_L2CAP_OPT_CFLAG(le16toh(cp->flags)); + result = le16toh(cp->result); + m_adj(m, sizeof(*cp)); + + /* Check if we have this command */ + cmd = ng_l2cap_cmd_by_ident(con, ident); + if (cmd == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConfigRsp command. ident=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ident, + con->con_handle); + NG_FREE_M(m); + + return (ENOENT); + } + + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command state, flags=%#x\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->flags)); + + /* Verify CIDs and send reject if does not match */ + if (cmd->ch->scid != scid) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConfigRsp. " \ +"Channel ID does not match, scid=%d(%d)\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->ch->scid, + scid); + goto reject; + } + + /* Verify channel state and reject if invalid */ + if (cmd->ch->state != NG_L2CAP_CONFIG) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_ConfigRsp. " \ +"Invalid channel state, scid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->ch->scid, + cmd->ch->state); + goto reject; + } + + /* + * Looks like it is our response, so process it. First parse options, + * then verify C flag. If it is set then we shall expect more + * configuration options from the peer and we will wait. Otherwise we + * have received all options and we will send L2CA_ConfigRsp event to + * the upper layer protocol. + */ + + ng_l2cap_command_untimeout(cmd); + + for (off = 0; ; ) { + error = get_next_l2cap_opt(m, &off, &hdr, &val); + if (error == 0) /* We done with this packet */ + break; + else if (error > 0) { /* Got option */ + switch (hdr.type) { + case NG_L2CAP_OPT_MTU: + cmd->ch->imtu = val.mtu; + break; + + case NG_L2CAP_OPT_FLUSH_TIMO: + cmd->ch->flush_timo = val.flush_timo; + break; + + case NG_L2CAP_OPT_QOS: + bcopy(&val.flow, &cmd->ch->oflow, + sizeof(cmd->ch->oflow)); + break; + + default: + KASSERT(0, +("%s: %s - unknown option: %d\n", __func__, NG_NODE_NAME(l2cap->node), + hdr.type)); + break; + } + } else { + /* + * XXX FIXME What to do here? + * + * This is really BAD :( options packet was broken, + * so let upper layer know and do not wait for more + * options + */ + + NG_L2CAP_ALERT( +"%s: %s - failed to parse configuration options, error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), error); + + result = NG_L2CAP_UNKNOWN; + cflag = 0; + + break; + } + } + + NG_FREE_M(m); + + if (cflag) /* Restart timer and wait for more options */ + ng_l2cap_command_timeout(cmd, bluetooth_l2cap_rtx_timeout()); + else { + ng_l2cap_unlink_cmd(cmd); + + /* Send L2CA_Config response to the upper layer protocol */ + error = ng_l2cap_l2ca_cfg_rsp(cmd->ch, cmd->token, result); + if (error != 0) { + /* + * XXX FIXME what to do here? we were not able to send + * response to the upper layer protocol, so for now + * just close the channel. Send L2CAP_Disconnect to + * remote peer? + */ + + NG_L2CAP_ERR( +"%s: %s - failed to send L2CA_Config response, error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), error); + + ng_l2cap_free_chan(cmd->ch); + } + + ng_l2cap_free_cmd(cmd); + } + + return (error); + +reject: + /* Send reject. Do not really care about the result */ + NG_FREE_M(m); + + send_l2cap_reject(con, ident, NG_L2CAP_REJ_INVALID_CID, 0, scid, 0); + + return (0); +} /* ng_l2cap_process_cfg_rsp */ + +/* + * Process L2CAP_DisconnectReq command + */ + +static int +ng_l2cap_process_discon_req(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_discon_req_cp *cp = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + u_int16_t scid, dcid; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*cp)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + cp = mtod(con->rx_pkt, ng_l2cap_discon_req_cp *); + dcid = le16toh(cp->dcid); + scid = le16toh(cp->scid); + + NG_FREE_M(con->rx_pkt); + + /* Check if we have this channel and it is in valid state */ + ch = ng_l2cap_chan_by_scid(l2cap, dcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_DisconnectReq message. " \ +"Channel does not exist, cid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), dcid); + goto reject; + } + + /* XXX Verify channel state and reject if invalid -- is that true? */ + if (ch->state != NG_L2CAP_OPEN && ch->state != NG_L2CAP_CONFIG) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_DisconnectReq. " \ +"Invalid channel state, cid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), dcid, ch->state); + goto reject; + } + + /* Match destination channel ID */ + if (ch->dcid != scid || ch->scid != dcid) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_DisconnectReq. " \ +"Channel IDs does not match, channel: scid=%d, dcid=%d, " \ +"request: scid=%d, dcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->scid, ch->dcid, + scid, dcid); + goto reject; + } + + /* + * Looks good, so notify upper layer protocol that channel is about + * to be disconnected and send L2CA_DisconnectInd message. Then respond + * with L2CAP_DisconnectRsp. + */ + + ng_l2cap_l2ca_discon_ind(ch); /* do not care about result */ + ng_l2cap_free_chan(ch); + + /* Send L2CAP_DisconnectRsp */ + cmd = ng_l2cap_new_cmd(con, NULL, ident, NG_L2CAP_DISCON_RSP, 0); + if (cmd == NULL) + return (ENOMEM); + + _ng_l2cap_discon_rsp(cmd->aux, ident, dcid, scid); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + + return (ENOBUFS); + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); + + return (0); + +reject: + /* Send reject. Do not really care about the result */ + send_l2cap_reject(con, ident, NG_L2CAP_REJ_INVALID_CID, 0, scid, dcid); + + return (0); +} /* ng_l2cap_process_discon_req */ + +/* + * Process L2CAP_DisconnectRsp command + */ + +static int +ng_l2cap_process_discon_rsp(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_discon_rsp_cp *cp = NULL; + ng_l2cap_cmd_p cmd = NULL; + u_int16_t scid, dcid; + int error = 0; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*cp)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + cp = mtod(con->rx_pkt, ng_l2cap_discon_rsp_cp *); + dcid = le16toh(cp->dcid); + scid = le16toh(cp->scid); + + NG_FREE_M(con->rx_pkt); + + /* Check if we have pending command descriptor */ + cmd = ng_l2cap_cmd_by_ident(con, ident); + if (cmd == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_DisconnectRsp command. ident=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ident, + con->con_handle); + goto out; + } + + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command state, flags=%#x\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->flags)); + + /* Verify channel state, do nothing if invalid */ + if (cmd->ch->state != NG_L2CAP_W4_L2CAP_DISCON_RSP) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_DisconnectRsp. " \ +"Invalid channel state, cid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), scid, + cmd->ch->state); + goto out; + } + + /* Verify CIDs and send reject if does not match */ + if (cmd->ch->scid != scid || cmd->ch->dcid != dcid) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_DisconnectRsp. " \ +"Channel IDs do not match, scid=%d(%d), dcid=%d(%d)\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->ch->scid, + scid, cmd->ch->dcid, dcid); + goto out; + } + + /* + * Looks like we have successfuly disconnected channel, + * so notify upper layer. + */ + + ng_l2cap_command_untimeout(cmd); + error = ng_l2cap_l2ca_discon_rsp(cmd->ch, cmd->token, NG_L2CAP_SUCCESS); + ng_l2cap_free_chan(cmd->ch); /* this will free commands too */ +out: + return (error); +} /* ng_l2cap_process_discon_rsp */ + +/* + * Process L2CAP_EchoReq command + */ + +static int +ng_l2cap_process_echo_req(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_cmd_hdr_t *hdr = NULL; + ng_l2cap_cmd_p cmd = NULL; + + con->rx_pkt = ng_l2cap_prepend(con->rx_pkt, sizeof(*hdr)); + if (con->rx_pkt == NULL) { + NG_L2CAP_ALERT( +"%s: %s - ng_l2cap_prepend() failed, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), sizeof(*hdr)); + + return (ENOBUFS); + } + + hdr = mtod(con->rx_pkt, ng_l2cap_cmd_hdr_t *); + hdr->code = NG_L2CAP_ECHO_RSP; + hdr->ident = ident; + hdr->length = htole16(con->rx_pkt->m_pkthdr.len - sizeof(*hdr)); + + cmd = ng_l2cap_new_cmd(con, NULL, ident, NG_L2CAP_ECHO_RSP, 0); + if (cmd == NULL) { + NG_FREE_M(con->rx_pkt); + + return (ENOBUFS); + } + + /* Attach data and link command to the queue */ + cmd->aux = con->rx_pkt; + con->rx_pkt = NULL; + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); + + return (0); +} /* ng_l2cap_process_echo_req */ + +/* + * Process L2CAP_EchoRsp command + */ + +static int +ng_l2cap_process_echo_rsp(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + + /* Check if we have this command */ + cmd = ng_l2cap_cmd_by_ident(con, ident); + if (cmd != NULL) { + KASSERT((cmd->con == con), +("%s: %s - invalid connection pointer!\n", + __func__, NG_NODE_NAME(l2cap->node))); + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command state, flags=%#x\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->flags)); + + ng_l2cap_command_untimeout(cmd); + ng_l2cap_unlink_cmd(cmd); + + error = ng_l2cap_l2ca_ping_rsp(cmd->con, cmd->token, + NG_L2CAP_SUCCESS, con->rx_pkt); + + ng_l2cap_free_cmd(cmd); + con->rx_pkt = NULL; + } else { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_EchoRsp command. " \ +"Requested ident does not exist, ident=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ident); + NG_FREE_M(con->rx_pkt); + } + + return (error); +} /* ng_l2cap_process_echo_rsp */ + +/* + * Process L2CAP_InfoReq command + */ + +static int +ng_l2cap_process_info_req(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_cmd_p cmd = NULL; + u_int16_t type; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(ng_l2cap_info_req_cp)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + type = le16toh(mtod(con->rx_pkt, ng_l2cap_info_req_cp *)->type); + NG_FREE_M(con->rx_pkt); + + cmd = ng_l2cap_new_cmd(con, NULL, ident, NG_L2CAP_INFO_RSP, 0); + if (cmd == NULL) + return (ENOMEM); + + switch (type) { + case NG_L2CAP_CONNLESS_MTU: + _ng_l2cap_info_rsp(cmd->aux, ident, NG_L2CAP_CONNLESS_MTU, + NG_L2CAP_SUCCESS, NG_L2CAP_MTU_DEFAULT); + break; + + default: + _ng_l2cap_info_rsp(cmd->aux, ident, type, + NG_L2CAP_NOT_SUPPORTED, 0); + break; + } + + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + + return (ENOBUFS); + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); + + return (0); +} /* ng_l2cap_process_info_req */ + +/* + * Process L2CAP_InfoRsp command + */ + +static int +ng_l2cap_process_info_rsp(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_info_rsp_cp *cp = NULL; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + + /* Get command parameters */ + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*cp)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + cp = mtod(con->rx_pkt, ng_l2cap_info_rsp_cp *); + cp->type = le16toh(cp->type); + cp->result = le16toh(cp->result); + m_adj(con->rx_pkt, sizeof(*cp)); + + /* Check if we have pending command descriptor */ + cmd = ng_l2cap_cmd_by_ident(con, ident); + if (cmd == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP_InfoRsp command. " \ +"Requested ident does not exist, ident=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ident); + NG_FREE_M(con->rx_pkt); + + return (ENOENT); + } + + KASSERT((cmd->con == con), +("%s: %s - invalid connection pointer!\n", + __func__, NG_NODE_NAME(l2cap->node))); + KASSERT((cmd->flags & NG_L2CAP_CMD_PENDING), +("%s: %s - invalid command state, flags=%#x\n", + __func__, NG_NODE_NAME(l2cap->node), cmd->flags)); + + ng_l2cap_command_untimeout(cmd); + ng_l2cap_unlink_cmd(cmd); + + if (cp->result == NG_L2CAP_SUCCESS) { + switch (cp->type) { + case NG_L2CAP_CONNLESS_MTU: + if (con->rx_pkt->m_pkthdr.len == sizeof(u_int16_t)) + *mtod(con->rx_pkt, u_int16_t *) = + le16toh(*mtod(con->rx_pkt,u_int16_t *)); + else { + cp->result = NG_L2CAP_UNKNOWN; /* XXX */ + + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP_InfoRsp command. " \ +"Bad connectionless MTU parameter, len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + con->rx_pkt->m_pkthdr.len); + } + break; + + default: + NG_L2CAP_WARN( +"%s: %s - invalid L2CAP_InfoRsp command. Unknown info type=%d\n", + __func__, NG_NODE_NAME(l2cap->node), cp->type); + break; + } + } + + error = ng_l2cap_l2ca_get_info_rsp(cmd->con, cmd->token, + cp->result, con->rx_pkt); + + ng_l2cap_free_cmd(cmd); + con->rx_pkt = NULL; + + return (error); +} /* ng_l2cap_process_info_rsp */ + +/* + * Send L2CAP reject + */ + +static int +send_l2cap_reject(ng_l2cap_con_p con, u_int8_t ident, u_int16_t reason, + u_int16_t mtu, u_int16_t scid, u_int16_t dcid) +{ + ng_l2cap_cmd_p cmd = NULL; + + cmd = ng_l2cap_new_cmd(con, NULL, ident, NG_L2CAP_CMD_REJ, 0); + if (cmd == NULL) + return (ENOMEM); + + _ng_l2cap_cmd_rej(cmd->aux, cmd->ident, reason, mtu, scid, dcid); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + + return (ENOBUFS); + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); + + return (0); +} /* send_l2cap_reject */ + +/* + * Send L2CAP connection reject + */ + +static int +send_l2cap_con_rej(ng_l2cap_con_p con, u_int8_t ident, u_int16_t scid, + u_int16_t dcid, u_int16_t result) +{ + ng_l2cap_cmd_p cmd = NULL; + + cmd = ng_l2cap_new_cmd(con, NULL, ident, NG_L2CAP_CON_RSP, 0); + if (cmd == NULL) + return (ENOMEM); + + _ng_l2cap_con_rsp(cmd->aux, cmd->ident, scid, dcid, result, 0); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + + return (ENOBUFS); + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); + + return (0); +} /* send_l2cap_con_rej */ + +/* + * Send L2CAP config response + */ + +static int +send_l2cap_cfg_rsp(ng_l2cap_con_p con, u_int8_t ident, u_int16_t scid, + u_int16_t result, struct mbuf *opt) +{ + ng_l2cap_cmd_p cmd = NULL; + + cmd = ng_l2cap_new_cmd(con, NULL, ident, NG_L2CAP_CFG_RSP, 0); + if (cmd == NULL) { + NG_FREE_M(opt); + + return (ENOMEM); + } + + _ng_l2cap_cfg_rsp(cmd->aux, cmd->ident, scid, 0, result, opt); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + + return (ENOBUFS); + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); + + return (0); +} /* send_l2cap_cfg_rsp */ + +/* + * Get next L2CAP configuration option + * + * Return codes: + * 0 no option + * 1 we have got option + * -1 header too short + * -2 bad option value or length + * -3 unknown option + */ + +static int +get_next_l2cap_opt(struct mbuf *m, int *off, ng_l2cap_cfg_opt_p hdr, + ng_l2cap_cfg_opt_val_p val) +{ + int hint, len = m->m_pkthdr.len - (*off); + + if (len == 0) + return (0); + if (len < 0 || len < sizeof(*hdr)) + return (-1); + + m_copydata(m, *off, sizeof(*hdr), (caddr_t) hdr); + *off += sizeof(*hdr); + len -= sizeof(*hdr); + + hint = NG_L2CAP_OPT_HINT(hdr->type); + hdr->type &= NG_L2CAP_OPT_HINT_MASK; + + switch (hdr->type) { + case NG_L2CAP_OPT_MTU: + if (hdr->length != NG_L2CAP_OPT_MTU_SIZE || len < hdr->length) + return (-2); + + m_copydata(m, *off, NG_L2CAP_OPT_MTU_SIZE, (caddr_t) val); + val->mtu = le16toh(val->mtu); + *off += NG_L2CAP_OPT_MTU_SIZE; + break; + + case NG_L2CAP_OPT_FLUSH_TIMO: + if (hdr->length != NG_L2CAP_OPT_FLUSH_TIMO_SIZE || + len < hdr->length) + return (-2); + + m_copydata(m, *off, NG_L2CAP_OPT_FLUSH_TIMO_SIZE, (caddr_t)val); + val->flush_timo = le16toh(val->flush_timo); + *off += NG_L2CAP_OPT_FLUSH_TIMO_SIZE; + break; + + case NG_L2CAP_OPT_QOS: + if (hdr->length != NG_L2CAP_OPT_QOS_SIZE || len < hdr->length) + return (-2); + + m_copydata(m, *off, NG_L2CAP_OPT_QOS_SIZE, (caddr_t) val); + val->flow.token_rate = le32toh(val->flow.token_rate); + val->flow.token_bucket_size = + le32toh(val->flow.token_bucket_size); + val->flow.peak_bandwidth = le32toh(val->flow.peak_bandwidth); + val->flow.latency = le32toh(val->flow.latency); + val->flow.delay_variation = le32toh(val->flow.delay_variation); + *off += NG_L2CAP_OPT_QOS_SIZE; + break; + + default: + if (hint) + *off += hdr->length; + else + return (-3); + break; + } + + return (1); +} /* get_next_l2cap_opt */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_evnt.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_evnt.h new file mode 100644 index 0000000..26fcac5 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_evnt.h @@ -0,0 +1,38 @@ +/* + * ng_l2cap_evnt.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_evnt.h,v 1.2 2002/04/16 00:43:56 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_L2CAP_EVNT_H_ +#define _NETGRAPH_L2CAP_EVNT_H_ + +int ng_l2cap_receive (ng_l2cap_con_p); + +#endif /* ndef _NETGRAPH_L2CAP_EVNT_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_llpi.c b/sys/netgraph/bluetooth/l2cap/ng_l2cap_llpi.c new file mode 100644 index 0000000..f505158 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_llpi.c @@ -0,0 +1,806 @@ +/* + * ng_l2cap_llpi.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_llpi.c,v 1.16 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_l2cap_var.h" +#include "ng_l2cap_cmds.h" +#include "ng_l2cap_evnt.h" +#include "ng_l2cap_llpi.h" +#include "ng_l2cap_ulpi.h" +#include "ng_l2cap_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** Lower Layer Protocol (HCI) Interface module + ****************************************************************************** + ******************************************************************************/ + +/* + * Send LP_ConnectReq event to the lower layer protocol. Create new connection + * descriptor and initialize it. Create LP_ConnectReq event and send it to the + * lower layer, then adjust connection state and start timer. The function WILL + * FAIL if connection to the remote unit already exists. + */ + +int +ng_l2cap_lp_con_req(ng_l2cap_p l2cap, bdaddr_p bdaddr) +{ + struct ng_mesg *msg = NULL; + ng_hci_lp_con_req_ep *ep = NULL; + ng_l2cap_con_p con = NULL; + int error = 0; + + /* Verify that we DO NOT have connection to the remote unit */ + con = ng_l2cap_con_by_addr(l2cap, bdaddr); + if (con != NULL) { + NG_L2CAP_ALERT( +"%s: %s - unexpected LP_ConnectReq event. " \ +"Connection already exists, state=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state, + con->con_handle); + + return (EEXIST); + } + + /* Check if lower layer protocol is still connected */ + if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci)) { + NG_L2CAP_ERR( +"%s: %s - hook \"%s\" is not connected or valid\n", + __func__, NG_NODE_NAME(l2cap->node), NG_L2CAP_HOOK_HCI); + + return (ENOTCONN); + } + + /* Create and intialize new connection descriptor */ + con = ng_l2cap_new_con(l2cap, bdaddr); + if (con == NULL) + return (ENOMEM); + + /* Create and send LP_ConnectReq event */ + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_CON_REQ, + sizeof(*ep), M_NOWAIT); + if (msg == NULL) { + ng_l2cap_free_con(con); + + return (ENOMEM); + } + + ep = (ng_hci_lp_con_req_ep *) (msg->data); + bcopy(bdaddr, &ep->bdaddr, sizeof(ep->bdaddr)); + ep->link_type = NG_HCI_LINK_ACL; + + con->state = NG_L2CAP_W4_LP_CON_CFM; + ng_l2cap_lp_timeout(con); + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->hci, NULL); + if (error != 0) + ng_l2cap_free_con(con); /* will remove timeout */ + + return (error); +} /* ng_l2cap_lp_con_req */ + +/* + * Process LP_ConnectCfm event from the lower layer protocol. It could be + * positive or negative. Verify remote unit address then stop the timer and + * process event. + */ + +int +ng_l2cap_lp_con_cfm(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_hci_lp_con_cfm_ep *ep = NULL; + ng_l2cap_con_p con = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ep)) { + NG_L2CAP_ALERT( +"%s: %s - invalid LP_ConnectCfm[Neg] message size\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_con_cfm_ep *) (msg->data); + + /* Check if we have requested/accepted this connection */ + con = ng_l2cap_con_by_addr(l2cap, &ep->bdaddr); + if (con == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_ConnectCfm event. Connection does not exist\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = ENOENT; + goto out; + } + + /* Check connection state */ + if (con->state != NG_L2CAP_W4_LP_CON_CFM) { + NG_L2CAP_ALERT( +"%s: %s - unexpected LP_ConnectCfm event. " \ +"Invalid connection state, state=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state, + con->con_handle); + error = EINVAL; + goto out; + } + + /* + * Looks like it is our confirmation. It is safe now to cancel + * connection timer and notify upper layer. + */ + + ng_l2cap_lp_untimeout(con); + + if (ep->status == 0) { + con->state = NG_L2CAP_CON_OPEN; + con->con_handle = ep->con_handle; + ng_l2cap_lp_deliver(con); + } else { + /* Negative confirmation - remove connection descriptor */ + con->state = NG_L2CAP_CON_CLOSED; + ng_l2cap_con_fail(con, ep->status); + } +out: + return (error); +} /* ng_l2cap_lp_con_cfm */ + +/* + * Process LP_ConnectInd event from the lower layer protocol. This is a good + * place to put some extra check on remote unit address and/or class. We could + * even forward this information to control hook (or check against internal + * black list) and thus implement some kind of firewall. But for now be simple + * and create new connection descriptor, start timer and send LP_ConnectRsp + * event (i.e. accept connection). + */ + +int +ng_l2cap_lp_con_ind(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_hci_lp_con_ind_ep *ep = NULL; + ng_hci_lp_con_rsp_ep *rp = NULL; + struct ng_mesg *rsp = NULL; + ng_l2cap_con_p con = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ep)) { + NG_L2CAP_ALERT( +"%s: %s - invalid LP_ConnectInd message size\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_con_ind_ep *) (msg->data); + + /* Make sure we have only one connection to the remote unit */ + con = ng_l2cap_con_by_addr(l2cap, &ep->bdaddr); + if (con != NULL) { + NG_L2CAP_ALERT( +"%s: %s - unexpected LP_ConnectInd event. " \ +"Connection already exists, state=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state, + con->con_handle); + error = EEXIST; + goto out; + } + + /* Check if lower layer protocol is still connected */ + if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci)) { + NG_L2CAP_ERR( +"%s: %s - hook \"%s\" is not connected or valid", + __func__, NG_NODE_NAME(l2cap->node), NG_L2CAP_HOOK_HCI); + error = ENOTCONN; + goto out; + } + + /* Create and intialize new connection descriptor */ + con = ng_l2cap_new_con(l2cap, &ep->bdaddr); + if (con == NULL) { + error = ENOMEM; + goto out; + } + + /* Create and send LP_ConnectRsp event */ + NG_MKMESSAGE(rsp, NGM_HCI_COOKIE, NGM_HCI_LP_CON_RSP, + sizeof(*rp), M_NOWAIT); + if (msg == NULL) { + ng_l2cap_free_con(con); + error = ENOMEM; + goto out; + } + + rp = (ng_hci_lp_con_rsp_ep *)(rsp->data); + rp->status = 0x00; /* accept connection */ + rp->link_type = NG_HCI_LINK_ACL; + bcopy(&ep->bdaddr, &rp->bdaddr, sizeof(rp->bdaddr)); + + con->state = NG_L2CAP_W4_LP_CON_CFM; + ng_l2cap_lp_timeout(con); + + NG_SEND_MSG_HOOK(error, l2cap->node, rsp, l2cap->hci, NULL); + if (error != 0) + ng_l2cap_free_con(con); /* will remove timeout */ +out: + return (error); +} /* ng_hci_lp_con_ind */ + +/* + * Process LP_DisconnectInd event from the lower layer protocol. We have been + * disconnected from the remote unit. So notify the upper layer protocol. + */ + +int +ng_l2cap_lp_discon_ind(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_hci_lp_discon_ind_ep *ep = NULL; + ng_l2cap_con_p con = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ep)) { + NG_L2CAP_ALERT( +"%s: %s - invalid LP_DisconnectInd message size\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_discon_ind_ep *) (msg->data); + + /* Check if we have this connection */ + con = ng_l2cap_con_by_handle(l2cap, ep->con_handle); + if (con == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_DisconnectInd event. " \ +"Connection does not exist, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ep->con_handle); + error = ENOENT; + goto out; + } + + /* XXX Verify connection state -- do we need to check this? */ + if (con->state != NG_L2CAP_CON_OPEN) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_DisconnectInd event. " \ +"Invalid connection state, state=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state, + con->con_handle); + error = EINVAL; + goto out; + } + + /* Notify upper layer and remove connection */ + con->state = NG_L2CAP_CON_CLOSED; + ng_l2cap_con_fail(con, ep->reason); +out: + return (error); +} /* ng_l2cap_lp_discon_ind */ + +/* + * Send LP_QoSSetupReq event to the lower layer protocol + */ + +int +ng_l2cap_lp_qos_req(ng_l2cap_p l2cap, u_int16_t con_handle, + ng_l2cap_flow_p flow) +{ + struct ng_mesg *msg = NULL; + ng_hci_lp_qos_req_ep *ep = NULL; + ng_l2cap_con_p con = NULL; + int error = 0; + + /* Verify that we have this connection */ + con = ng_l2cap_con_by_handle(l2cap, con_handle); + if (con == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_QoSSetupReq event. " \ +"Connection does not exist, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con_handle); + + return (ENOENT); + } + + /* Verify connection state */ + if (con->state != NG_L2CAP_CON_OPEN) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_QoSSetupReq event. " \ +"Invalid connection state, state=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state, + con->con_handle); + + return (EINVAL); + } + + /* Check if lower layer protocol is still connected */ + if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci)) { + NG_L2CAP_ERR( +"%s: %s - hook \"%s\" is not connected or valid", + __func__, NG_NODE_NAME(l2cap->node), NG_L2CAP_HOOK_HCI); + + return (ENOTCONN); + } + + /* Create and send LP_QoSSetupReq event */ + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_LP_QOS_REQ, + sizeof(*ep), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + ep = (ng_hci_lp_qos_req_ep *) (msg->data); + ep->con_handle = con_handle; + ep->flags = flow->flags; + ep->service_type = flow->service_type; + ep->token_rate = flow->token_rate; + ep->peak_bandwidth = flow->peak_bandwidth; + ep->latency = flow->latency; + ep->delay_variation = flow->delay_variation; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->hci, NULL); + + return (error); +} /* ng_l2cap_lp_con_req */ + +/* + * Process LP_QoSSetupCfm from the lower layer protocol + */ + +int +ng_l2cap_lp_qos_cfm(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_hci_lp_qos_cfm_ep *ep = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ep)) { + NG_L2CAP_ALERT( +"%s: %s - invalid LP_QoSSetupCfm[Neg] message size\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_qos_cfm_ep *) (msg->data); + /* XXX FIXME do something */ +out: + return (error); +} /* ng_l2cap_lp_qos_cfm */ + +/* + * Process LP_QoSViolationInd event from the lower layer protocol. Lower + * layer protocol has detected QoS Violation, so we MUST notify the + * upper layer. + */ + +int +ng_l2cap_lp_qos_ind(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_hci_lp_qos_ind_ep *ep = NULL; + ng_l2cap_con_p con = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ep)) { + NG_L2CAP_ALERT( +"%s: %s - invalid LP_QoSViolation message size\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = EMSGSIZE; + goto out; + } + + ep = (ng_hci_lp_qos_ind_ep *) (msg->data); + + /* Check if we have this connection */ + con = ng_l2cap_con_by_handle(l2cap, ep->con_handle); + if (con == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_QoSViolationInd event. " \ +"Connection does not exist, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ep->con_handle); + error = ENOENT; + goto out; + } + + /* Verify connection state */ + if (con->state != NG_L2CAP_CON_OPEN) { + NG_L2CAP_ERR( +"%s: %s - unexpected LP_QoSViolationInd event. " \ +"Invalid connection state, state=%d, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state, + con->con_handle); + error = EINVAL; + goto out; + } + + /* XXX FIXME Notify upper layer and terminate channels if required */ +out: + return (error); +} /* ng_l2cap_qos_ind */ + +/* + * Prepare L2CAP packet. Prepend packet with L2CAP packet header and then + * segment it according to HCI MTU. + */ + +int +ng_l2cap_lp_send(ng_l2cap_con_p con, u_int16_t dcid, struct mbuf *m0) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_hdr_t *l2cap_hdr = NULL; + ng_hci_acldata_pkt_t *acl_hdr = NULL; + struct mbuf *m_last = NULL, *m = NULL; + int len, flag = NG_HCI_PACKET_START; + + KASSERT((con->tx_pkt == NULL), +("%s: %s - another packet pending?!\n", __func__, NG_NODE_NAME(l2cap->node))); + KASSERT((l2cap->pkt_size > 0), +("%s: %s - invalid l2cap->pkt_size?!\n", __func__, NG_NODE_NAME(l2cap->node))); + + /* Prepend mbuf with L2CAP header */ + m0 = ng_l2cap_prepend(m0, sizeof(*l2cap_hdr)); + if (m0 == NULL) { + NG_L2CAP_ALERT( +"%s: %s - ng_l2cap_prepend(%d) failed\n", + __func__, NG_NODE_NAME(l2cap->node), + sizeof(*l2cap_hdr)); + + goto fail; + } + + l2cap_hdr = mtod(m0, ng_l2cap_hdr_t *); + l2cap_hdr->length = htole16(m0->m_pkthdr.len - sizeof(*l2cap_hdr)); + l2cap_hdr->dcid = htole16(dcid); + + /* + * Segment single L2CAP packet according to the HCI layer MTU. Convert + * each segment into ACL data packet and prepend it with ACL data packet + * header. Link all segments together via m_nextpkt link. + * + * XXX BC (Broadcast flag) will always be 0 (zero). + */ + + while (m0 != NULL) { + /* Check length of the packet against HCI MTU */ + len = m0->m_pkthdr.len; + if (len > l2cap->pkt_size) { + m = m_split(m0, l2cap->pkt_size, M_DONTWAIT); + if (m == NULL) { + NG_L2CAP_ALERT( +"%s: %s - m_split(%d) failed\n", __func__, NG_NODE_NAME(l2cap->node), + l2cap->pkt_size); + goto fail; + } + + len = l2cap->pkt_size; + } + + /* Convert packet fragment into ACL data packet */ + m0 = ng_l2cap_prepend(m0, sizeof(*acl_hdr)); + if (m0 == NULL) { + NG_L2CAP_ALERT( +"%s: %s - ng_l2cap_prepend(%d) failed\n", + __func__, NG_NODE_NAME(l2cap->node), + sizeof(*acl_hdr)); + goto fail; + } + + acl_hdr = mtod(m0, ng_hci_acldata_pkt_t *); + acl_hdr->type = NG_HCI_ACL_DATA_PKT; + acl_hdr->length = htole16(len); + acl_hdr->con_handle = htole16(NG_HCI_MK_CON_HANDLE( + con->con_handle, flag, 0)); + + /* Add fragment to the chain */ + m0->m_nextpkt = NULL; + + if (con->tx_pkt == NULL) + con->tx_pkt = m_last = m0; + else { + m_last->m_nextpkt = m0; + m_last = m0; + } + + NG_L2CAP_INFO( +"%s: %s - attaching ACL packet, con_handle=%d, PB=%#x, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->con_handle, + flag, len); + + m0 = m; + m = NULL; + flag = NG_HCI_PACKET_FRAGMENT; + } + + return (0); +fail: + NG_FREE_M(m0); + NG_FREE_M(m); + + while (con->tx_pkt != NULL) { + m = con->tx_pkt->m_nextpkt; + m_freem(con->tx_pkt); + con->tx_pkt = m; + } + + return (ENOBUFS); +} /* ng_l2cap_lp_send */ + +/* + * Receive ACL data packet from the HCI layer. First strip ACL packet header + * and get connection handle, PB (Packet Boundary) flag and payload length. + * Then find connection descriptor and verify its state. Then process ACL + * packet as follows. + * + * 1) If we got first segment (pb == NG_HCI_PACKET_START) then extract L2CAP + * header and get total length of the L2CAP packet. Then start new L2CAP + * packet. + * + * 2) If we got other (then first :) segment (pb == NG_HCI_PACKET_FRAGMENT) + * then add segment to the packet. + */ + +int +ng_l2cap_lp_receive(ng_l2cap_p l2cap, struct mbuf *m) +{ + ng_hci_acldata_pkt_t *acl_hdr = NULL; + ng_l2cap_hdr_t *l2cap_hdr = NULL; + ng_l2cap_con_p con = NULL; + u_int16_t con_handle, length, pb; + int error = 0; + + /* Check ACL data packet */ + if (m->m_pkthdr.len < sizeof(*acl_hdr)) { + NG_L2CAP_ERR( +"%s: %s - invalid ACL data packet. Packet too small, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), m->m_pkthdr.len); + error = EMSGSIZE; + goto drop; + } + + /* Strip ACL data packet header */ + NG_L2CAP_M_PULLUP(m, sizeof(*acl_hdr)); + if (m == NULL) + return (ENOBUFS); + + acl_hdr = mtod(m, ng_hci_acldata_pkt_t *); + m_adj(m, sizeof(*acl_hdr)); + + /* Get ACL connection handle, PB flag and payload length */ + acl_hdr->con_handle = le16toh(acl_hdr->con_handle); + con_handle = NG_HCI_CON_HANDLE(acl_hdr->con_handle); + pb = NG_HCI_PB_FLAG(acl_hdr->con_handle); + length = le16toh(acl_hdr->length); + + NG_L2CAP_INFO( +"%s: %s - got ACL data packet, con_handle=%d, PB=%#x, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con_handle, pb, length); + + /* Get connection descriptor */ + con = ng_l2cap_con_by_handle(l2cap, con_handle); + if (con == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected ACL data packet. " \ +"Connection does not exist, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con_handle); + error = ENOENT; + goto drop; + } + + /* Verify connection state */ + if (con->state != NG_L2CAP_CON_OPEN) { + NG_L2CAP_ERR( +"%s: %s - unexpected ACL data packet. Invalid connection state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->state); + error = EHOSTDOWN; + goto drop; + } + + /* Process packet */ + if (pb == NG_HCI_PACKET_START) { + if (con->rx_pkt != NULL) { + NG_L2CAP_ERR( +"%s: %s - dropping incomplete L2CAP packet, got %d bytes, want %d bytes\n", + __func__, NG_NODE_NAME(l2cap->node), + con->rx_pkt->m_pkthdr.len, con->rx_pkt_len); + NG_FREE_M(con->rx_pkt); + con->rx_pkt_len = 0; + } + + /* Get L2CAP header */ + if (m->m_pkthdr.len < sizeof(*l2cap_hdr)) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP packet start fragment. Packet too small, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + m->m_pkthdr.len); + error = EMSGSIZE; + goto drop; + } + + NG_L2CAP_M_PULLUP(m, sizeof(*l2cap_hdr)); + if (m == NULL) + return (ENOBUFS); + + l2cap_hdr = mtod(m, ng_l2cap_hdr_t *); + + NG_L2CAP_INFO( +"%s: %s - staring new L2CAP packet, con_handle=%d, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con_handle, + le16toh(l2cap_hdr->length)); + + /* Start new L2CAP packet */ + con->rx_pkt = m; + con->rx_pkt_len = le16toh(l2cap_hdr->length)+sizeof(*l2cap_hdr); + } else if (pb == NG_HCI_PACKET_FRAGMENT) { + if (con->rx_pkt == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected ACL data packet fragment, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + con->con_handle); + goto drop; + } + + /* Add fragment to the L2CAP packet */ + m_cat(con->rx_pkt, m); + con->rx_pkt->m_pkthdr.len += length; + } else { + NG_L2CAP_ERR( +"%s: %s - invalid ACL data packet. Invalid PB flag=%#x\n", + __func__, NG_NODE_NAME(l2cap->node), pb); + error = EINVAL; + goto drop; + } + + con->rx_pkt_len -= length; + if (con->rx_pkt_len < 0) { + NG_L2CAP_ALERT( +"%s: %s - packet length mismatch. Got %d bytes, offset %d bytes\n", + __func__, NG_NODE_NAME(l2cap->node), + con->rx_pkt->m_pkthdr.len, con->rx_pkt_len); + NG_FREE_M(con->rx_pkt); + con->rx_pkt_len = 0; + } else if (con->rx_pkt_len == 0) { + /* OK, we have got complete L2CAP packet, so process it */ + error = ng_l2cap_receive(con); + con->rx_pkt = NULL; + con->rx_pkt_len = 0; + } + + return (error); + +drop: + NG_FREE_M(m); + + return (error); +} /* ng_l2cap_lp_receive */ + +/* + * Send queued ACL packets to the HCI layer + */ + +void +ng_l2cap_lp_deliver(ng_l2cap_con_p con) +{ + ng_l2cap_p l2cap = con->l2cap; + struct mbuf *m = NULL; + int error; + + /* Check connection */ + if (con->state != NG_L2CAP_CON_OPEN) + return; + + if (con->tx_pkt == NULL) + ng_l2cap_con_wakeup(con); + + if (con->tx_pkt == NULL) + return; + + /* Check if lower layer protocol is still connected */ + if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci)) { + NG_L2CAP_ERR( +"%s: %s - hook \"%s\" is not connected or valid", + __func__, NG_NODE_NAME(l2cap->node), NG_L2CAP_HOOK_HCI); + + goto drop; /* XXX what to do with "pending"? */ + } + + /* Send ACL data packets */ + while (con->pending < con->l2cap->num_pkts && con->tx_pkt != NULL) { + m = con->tx_pkt; + con->tx_pkt = con->tx_pkt->m_nextpkt; + m->m_nextpkt = NULL; + + NG_L2CAP_INFO( +"%s: %s - sending ACL packet, con_handle=%d, len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->con_handle, + m->m_pkthdr.len); + + NG_SEND_DATA_ONLY(error, l2cap->hci, m); + if (error != 0) { + NG_L2CAP_ERR( +"%s: %s - could not send ACL data packet, con_handle=%d, error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + con->con_handle, error); + + goto drop; /* XXX what to do with "pending"? */ + } + + con->pending ++; + } + + NG_L2CAP_INFO( +"%s: %s - %d ACL packets have been sent, con_handle=%d\n", + __func__, NG_NODE_NAME(l2cap->node), con->pending, + con->con_handle); + + return; + +drop: + while (con->tx_pkt != NULL) { + m = con->tx_pkt->m_nextpkt; + m_freem(con->tx_pkt); + con->tx_pkt = m; + } +} /* ng_l2cap_lp_deliver */ + +/* + * Process connection timeout. Remove connection from the list. If there + * are any channels that wait for the connection then notify them. Free + * connection descriptor. + */ + +void +ng_l2cap_process_lp_timeout(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_l2cap_con_p con = (ng_l2cap_con_p) arg1; + ng_l2cap_p l2cap = con->l2cap; + + NG_L2CAP_ERR( +"%s: %s - ACL connection timeout\n", __func__, NG_NODE_NAME(l2cap->node)); + + /* + * Notify channels that connection has timed out. This will remove + * connection, channels and pending commands. + */ + + con->state = NG_L2CAP_CON_CLOSED; + ng_l2cap_con_fail(con, NG_L2CAP_TIMEOUT); +} /* ng_l2cap_process_lp_timeout */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_llpi.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_llpi.h new file mode 100644 index 0000000..161761e --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_llpi.h @@ -0,0 +1,48 @@ +/* + * ng_l2cap_llpi.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_llpi.h,v 1.6 2002/04/16 00:43:57 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_L2CAP_LLPI_H_ +#define _NETGRAPH_L2CAP_LLPI_H_ + +int ng_l2cap_lp_con_req (ng_l2cap_p, bdaddr_p); +int ng_l2cap_lp_con_cfm (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_lp_con_ind (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_lp_discon_ind (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_lp_qos_req (ng_l2cap_p, u_int16_t, ng_l2cap_flow_p); +int ng_l2cap_lp_qos_cfm (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_lp_qos_ind (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_lp_send (ng_l2cap_con_p, u_int16_t,struct mbuf *); +int ng_l2cap_lp_receive (ng_l2cap_p, struct mbuf *); +void ng_l2cap_lp_deliver (ng_l2cap_con_p); +void ng_l2cap_process_lp_timeout (node_p, hook_p, void *, int); + +#endif /* ndef _NETGRAPH_L2CAP_LLPI_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_main.c b/sys/netgraph/bluetooth/l2cap/ng_l2cap_main.c new file mode 100644 index 0000000..1dfc4c0 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_main.c @@ -0,0 +1,736 @@ +/* + * ng_l2cap_main.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_main.c,v 1.24 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <netgraph/ng_parse.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_l2cap_var.h" +#include "ng_l2cap_cmds.h" +#include "ng_l2cap_evnt.h" +#include "ng_l2cap_llpi.h" +#include "ng_l2cap_ulpi.h" +#include "ng_l2cap_misc.h" +#include "ng_l2cap_prse.h" + +/****************************************************************************** + ****************************************************************************** + ** This node implements Link Layer Control and Adaptation Protocol (L2CAP) + ****************************************************************************** + ******************************************************************************/ + +/* MALLOC define */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DEFINE(M_NETGRAPH_L2CAP, "netgraph_l2cap", + "Netgraph Bluetooth L2CAP node"); +#else +#define M_NETGRAPH_L2CAP M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Netgraph node methods */ +static ng_constructor_t ng_l2cap_constructor; +static ng_shutdown_t ng_l2cap_shutdown; +static ng_newhook_t ng_l2cap_newhook; +static ng_connect_t ng_l2cap_connect; +static ng_disconnect_t ng_l2cap_disconnect; +static ng_rcvmsg_t ng_l2cap_lower_rcvmsg; +static ng_rcvmsg_t ng_l2cap_upper_rcvmsg; +static ng_rcvmsg_t ng_l2cap_default_rcvmsg; +static ng_rcvdata_t ng_l2cap_rcvdata; + +/* Netgraph node type descriptor */ +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_L2CAP_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_l2cap_constructor, /* constructor */ + ng_l2cap_default_rcvmsg,/* control message */ + ng_l2cap_shutdown, /* destructor */ + ng_l2cap_newhook, /* new hook */ + NULL, /* findhook */ + ng_l2cap_connect, /* connect hook */ + ng_l2cap_rcvdata, /* data */ + ng_l2cap_disconnect, /* disconnect hook */ + ng_l2cap_cmdlist /* node command list */ +}; +NETGRAPH_INIT(l2cap, &typestruct); +MODULE_VERSION(ng_l2cap, NG_BLUETOOTH_VERSION); +MODULE_DEPEND(ng_l2cap, ng_bluetooth, NG_BLUETOOTH_VERSION, + NG_BLUETOOTH_VERSION, NG_BLUETOOTH_VERSION); + +/***************************************************************************** + ***************************************************************************** + ** Netgraph methods implementation + ***************************************************************************** + *****************************************************************************/ + +static void ng_l2cap_cleanup (ng_l2cap_p); +static void ng_l2cap_destroy_channels (ng_l2cap_p); + +/* + * Create new instance of L2CAP node + */ + +static int +ng_l2cap_constructor(node_p node) +{ + ng_l2cap_p l2cap = NULL; + + /* Create new L2CAP node */ + MALLOC(l2cap, ng_l2cap_p, sizeof(*l2cap), + M_NETGRAPH_L2CAP, M_NOWAIT|M_ZERO); + if (l2cap == NULL) + return (ENOMEM); + + l2cap->node = node; + l2cap->debug = NG_L2CAP_WARN_LEVEL; + + LIST_INIT(&l2cap->con_list); + LIST_INIT(&l2cap->chan_list); + + NG_NODE_SET_PRIVATE(node, l2cap); + NG_NODE_FORCE_WRITER(node); + + return (0); +} /* ng_l2cap_constructor */ + +/* + * Shutdown L2CAP node + */ + +static int +ng_l2cap_shutdown(node_p node) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); + + NG_NODE_SET_PRIVATE(node, NULL); + NG_NODE_UNREF(node); + + /* Clean up L2CAP node. Delete all connection, channels and commands */ + l2cap->node = NULL; + ng_l2cap_cleanup(l2cap); + + bzero(l2cap, sizeof(*l2cap)); + FREE(l2cap, M_NETGRAPH_L2CAP); + + return (0); +} /* ng_l2cap_shutdown */ + +/* + * Give our OK for a hook to be added. HCI layer is connected to the HCI + * (NG_L2CAP_HOOK_HCI) hook. As per specification L2CAP layer MUST provide + * Procol/Service Multiplexing, so the L2CAP node provides separate hooks + * for SDP (NG_L2CAP_HOOK_SDP), RFCOMM (NG_L2CAP_HOOK_RFCOMM) and TCP + * (NG_L2CAP_HOOK_TCP) protcols. Unknown PSM will be forwarded to + * NG_L2CAP_HOOK_ORPHAN hook. Control node/application is connected to + * control (NG_L2CAP_HOOK_CTL) hook. + */ + +static int +ng_l2cap_newhook(node_p node, hook_p hook, char const *name) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); + hook_p *h = NULL; + + if (strcmp(name, NG_L2CAP_HOOK_HCI) == 0) + h = &l2cap->hci; + else if (strcmp(name, NG_L2CAP_HOOK_L2C) == 0) + h = &l2cap->l2c; + else if (strcmp(name, NG_L2CAP_HOOK_CTL) == 0) + h = &l2cap->ctl; + else + return (EINVAL); + + if (*h != NULL) + return (EISCONN); + + *h = hook; + + return (0); +} /* ng_l2cap_newhook */ + +/* + * Give our final OK to connect hook. Nothing to do here. + */ + +static int +ng_l2cap_connect(hook_p hook) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + int error = 0; + + if (hook == l2cap->hci) + NG_HOOK_SET_RCVMSG(hook, ng_l2cap_lower_rcvmsg); + else + if (hook == l2cap->l2c || hook == l2cap->ctl) { + NG_HOOK_SET_RCVMSG(hook, ng_l2cap_upper_rcvmsg); + + /* Send delayed notification to the upper layer */ + error = ng_send_fn(l2cap->node, hook, ng_l2cap_send_hook_info, + NULL, 0); + } else + error = EINVAL; + + return (error); +} /* ng_l2cap_connect */ + +/* + * Disconnect the hook. For downstream hook we must notify upper layers. + * + * XXX For upstream hooks this is really ugly :( Hook was disconnected and it + * XXX is now too late to do anything. For now we just clean up our own mess + * XXX and remove all channels that use disconnected upstream hook. If we don't + * XXX do that then L2CAP node can get out of sync with upper layers. + * XXX No notification will be sent to remote peer. + */ + +static int +ng_l2cap_disconnect(hook_p hook) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + hook_p *h = NULL; + + if (hook == l2cap->hci) { + ng_l2cap_cleanup(l2cap); + h = &l2cap->hci; + } else + if (hook == l2cap->l2c) { + ng_l2cap_destroy_channels(l2cap); + h = &l2cap->l2c; + } else + if (hook == l2cap->ctl) + h = &l2cap->ctl; + else + return (EINVAL); + + *h = NULL; + + /* Shutdown when all hooks are disconnected */ + if (NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0 && + NG_NODE_IS_VALID(NG_HOOK_NODE(hook))) + ng_rmnode_self(NG_HOOK_NODE(hook)); + + return (0); +} /* ng_l2cap_disconnect */ + +/* + * Process control message from lower layer + */ + +static int +ng_l2cap_lower_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ + int error = 0; + + switch (msg->header.typecookie) { + case NGM_HCI_COOKIE: + switch (msg->header.cmd) { + /* HCI node is ready */ + case NGM_HCI_NODE_UP: { + ng_hci_node_up_ep *ep = NULL; + + if (msg->header.arglen != sizeof(*ep)) + error = EMSGSIZE; + else { + ep = (ng_hci_node_up_ep *)(msg->data); + + NG_L2CAP_INFO( +"%s: %s - HCI node is up, bdaddr: %x:%x:%x:%x:%x:%x, " \ +"pkt_size=%d bytes, num_pkts=%d\n", __func__, NG_NODE_NAME(l2cap->node), + ep->bdaddr.b[5], ep->bdaddr.b[4], + ep->bdaddr.b[3], ep->bdaddr.b[2], + ep->bdaddr.b[1], ep->bdaddr.b[0], + ep->pkt_size, ep->num_pkts); + + bcopy(&ep->bdaddr, &l2cap->bdaddr, + sizeof(l2cap->bdaddr)); + l2cap->pkt_size = ep->pkt_size; + l2cap->num_pkts = ep->num_pkts; + + /* Notify upper layers */ + ng_l2cap_send_hook_info(l2cap->node, + l2cap->l2c, NULL, 0); + ng_l2cap_send_hook_info(l2cap->node, + l2cap->ctl, NULL, 0); + } + } break; + + case NGM_HCI_SYNC_CON_QUEUE: { + ng_hci_sync_con_queue_ep *ep = NULL; + ng_l2cap_con_p con = NULL; + + if (msg->header.arglen != sizeof(*ep)) + error = EMSGSIZE; + else { + ep = (ng_hci_sync_con_queue_ep *)(msg->data); + con = ng_l2cap_con_by_handle(l2cap, + ep->con_handle); + if (con == NULL) + break; + + NG_L2CAP_INFO( +"%s: %s - sync HCI connection queue, con_handle=%d, pending=%d, completed=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + ep->con_handle, con->pending, + ep->completed); + + con->pending -= ep->completed; + if (con->pending < 0) { + NG_L2CAP_WARN( +"%s: %s - pending packet counter is out of sync! " \ +"con_handle=%d, pending=%d, completed=%d\n", __func__, + NG_NODE_NAME(l2cap->node), + con->con_handle, con->pending, + ep->completed); + + con->pending = 0; + } + + ng_l2cap_lp_deliver(con); + } + } break; + + /* LP_ConnectCfm[Neg] */ + case NGM_HCI_LP_CON_CFM: + error = ng_l2cap_lp_con_cfm(l2cap, msg); + break; + + /* LP_ConnectInd */ + case NGM_HCI_LP_CON_IND: + error = ng_l2cap_lp_con_ind(l2cap, msg); + break; + + /* LP_DisconnectInd */ + case NGM_HCI_LP_DISCON_IND: + error = ng_l2cap_lp_discon_ind(l2cap, msg); + break; + + /* LP_QoSSetupCfm[Neg] */ + case NGM_HCI_LP_QOS_CFM: + error = ng_l2cap_lp_qos_cfm(l2cap, msg); + break; + + /* LP_OoSViolationInd */ + case NGM_HCI_LP_QOS_IND: + error = ng_l2cap_lp_qos_ind(l2cap, msg); + break; + + default: + error = EINVAL; + break; + } + break; + + default: + return (ng_l2cap_default_rcvmsg(node, item, lasthook)); + /* NOT REACHED */ + } + + NG_FREE_ITEM(item); + + return (error); +} /* ng_l2cap_lower_rcvmsg */ + +/* + * Process control message from upper layer + */ + +static int +ng_l2cap_upper_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ + int error = 0; + + switch (msg->header.typecookie) { + case NGM_L2CAP_COOKIE: + switch (msg->header.cmd) { + /* L2CA_Connect */ + case NGM_L2CAP_L2CA_CON: + error = ng_l2cap_l2ca_con_req(l2cap, msg); + break; + + /* L2CA_ConnectRsp */ + case NGM_L2CAP_L2CA_CON_RSP: + error = ng_l2cap_l2ca_con_rsp_req(l2cap, msg); + break; + + /* L2CA_Config */ + case NGM_L2CAP_L2CA_CFG: + error = ng_l2cap_l2ca_cfg_req(l2cap, msg); + break; + + /* L2CA_ConfigRsp */ + case NGM_L2CAP_L2CA_CFG_RSP: + error = ng_l2cap_l2ca_cfg_rsp_req(l2cap, msg); + break; + + /* L2CA_Disconnect */ + case NGM_L2CAP_L2CA_DISCON: + error = ng_l2cap_l2ca_discon_req(l2cap, msg); + break; + + /* L2CA_GroupCreate */ + case NGM_L2CAP_L2CA_GRP_CREATE: + error = ng_l2cap_l2ca_grp_create(l2cap, msg); + break; + + /* L2CA_GroupClose */ + case NGM_L2CAP_L2CA_GRP_CLOSE: + error = ng_l2cap_l2ca_grp_close(l2cap, msg); + break; + + /* L2CA_GroupAddMember */ + case NGM_L2CAP_L2CA_GRP_ADD_MEMBER: + error = ng_l2cap_l2ca_grp_add_member_req(l2cap, msg); + break; + + /* L2CA_GroupDeleteMember */ + case NGM_L2CAP_L2CA_GRP_REM_MEMBER: + error = ng_l2cap_l2ca_grp_rem_member(l2cap, msg); + break; + + /* L2CA_GroupMembership */ + case NGM_L2CAP_L2CA_GRP_MEMBERSHIP: + error = ng_l2cap_l2ca_grp_get_members(l2cap, msg); + break; + + /* L2CA_Ping */ + case NGM_L2CAP_L2CA_PING: + error = ng_l2cap_l2ca_ping_req(l2cap, msg); + break; + + /* L2CA_GetInfo */ + case NGM_L2CAP_L2CA_GET_INFO: + error = ng_l2cap_l2ca_get_info_req(l2cap, msg); + break; + + /* L2CA_EnableCLT */ + case NGM_L2CAP_L2CA_ENABLE_CLT: + error = ng_l2cap_l2ca_enable_clt(l2cap, msg); + break; + + default: + return (ng_l2cap_default_rcvmsg(node, item, lasthook)); + /* NOT REACHED */ + } + break; + + default: + return (ng_l2cap_default_rcvmsg(node, item, lasthook)); + /* NOT REACHED */ + } + + NG_FREE_ITEM(item); + + return (error); +} /* ng_l2cap_upper_rcvmsg */ + +/* + * Default control message processing routine + */ + +static int +ng_l2cap_default_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); + struct ng_mesg *msg = NULL, *rsp = NULL; + int error = 0; + + /* Detach and process message */ + NGI_GET_MSG(item, msg); + + switch (msg->header.typecookie) { + case NGM_GENERIC_COOKIE: + switch (msg->header.cmd) { + case NGM_TEXT_STATUS: + NG_MKRESPONSE(rsp, msg, NG_TEXTRESPONSE, M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + snprintf(rsp->data, NG_TEXTRESPONSE, + "bdaddr %x:%x:%x:%x:%x:%x, " \ + "pkt_size %d\n" \ + "Hooks %s %s %s\n" \ + "Flags %#x\n", + l2cap->bdaddr.b[5], l2cap->bdaddr.b[4], + l2cap->bdaddr.b[3], l2cap->bdaddr.b[2], + l2cap->bdaddr.b[1], l2cap->bdaddr.b[0], + l2cap->pkt_size, + (l2cap->hci != NULL)? + NG_L2CAP_HOOK_HCI : "", + (l2cap->l2c != NULL)? + NG_L2CAP_HOOK_L2C : "", + (l2cap->ctl != NULL)? + NG_L2CAP_HOOK_CTL : "", + l2cap->flags); + break; + + default: + error = EINVAL; + break; + } + break; + + /* Messages from the upper layer or directed to the local node */ + case NGM_L2CAP_COOKIE: + switch (msg->header.cmd) { + /* Get node flags */ + case NGM_L2CAP_NODE_GET_FLAGS: + NG_MKRESPONSE(rsp, msg, sizeof(ng_l2cap_node_flags_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + *((ng_l2cap_node_flags_ep *)(rsp->data)) = + l2cap->flags; + break; + + /* Get node debug */ + case NGM_L2CAP_NODE_GET_DEBUG: + NG_MKRESPONSE(rsp, msg, sizeof(ng_l2cap_node_debug_ep), + M_NOWAIT); + if (rsp == NULL) + error = ENOMEM; + else + *((ng_l2cap_node_debug_ep *)(rsp->data)) = + l2cap->debug; + break; + + /* Set node debug */ + case NGM_L2CAP_NODE_SET_DEBUG: + if (msg->header.arglen != + sizeof(ng_l2cap_node_debug_ep)) + error = EMSGSIZE; + else + l2cap->debug = + *((ng_l2cap_node_debug_ep *)(msg->data)); + break; + + /* Get connection list */ + case NGM_L2CAP_NODE_GET_CON_LIST: { + ng_l2cap_con_p con = NULL; + ng_l2cap_node_con_list_ep *e1 = NULL; + ng_l2cap_node_con_ep *e2 = NULL; + int n = 0; + + /* Count number of connections */ + LIST_FOREACH(con, &l2cap->con_list, next) + n++; + if (n > NG_L2CAP_MAX_CON_NUM) + n = NG_L2CAP_MAX_CON_NUM; + + /* Prepare response */ + NG_MKRESPONSE(rsp, msg, + sizeof(*e1) + n * sizeof(*e2), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + e1 = (ng_l2cap_node_con_list_ep *)(rsp->data); + e2 = (ng_l2cap_node_con_ep *)(e1 + 1); + + e1->num_connections = n; + + LIST_FOREACH(con, &l2cap->con_list, next) { + e2->state = con->state; + + if (con->tx_pkt != NULL) + e2->flags |= NG_L2CAP_CON_TX; + if (con->rx_pkt != NULL) + e2->flags |= NG_L2CAP_CON_RX; + + e2->pending = con->pending; + + e2->con_handle = con->con_handle; + bcopy(&con->remote, &e2->remote, + sizeof(e2->remote)); + + e2 ++; + if (--n <= 0) + break; + } + } break; + + /* Get channel list */ + case NGM_L2CAP_NODE_GET_CHAN_LIST: { + ng_l2cap_chan_p ch = NULL; + ng_l2cap_node_chan_list_ep *e1 = NULL; + ng_l2cap_node_chan_ep *e2 = NULL; + int n = 0; + + /* Count number of channels */ + LIST_FOREACH(ch, &l2cap->chan_list, next) + n ++; + if (n > NG_L2CAP_MAX_CHAN_NUM) + n = NG_L2CAP_MAX_CHAN_NUM; + + /* Prepare response */ + NG_MKRESPONSE(rsp, msg, + sizeof(ng_l2cap_node_chan_list_ep) + + n * sizeof(ng_l2cap_node_chan_ep), M_NOWAIT); + if (rsp == NULL) { + error = ENOMEM; + break; + } + + e1 = (ng_l2cap_node_chan_list_ep *)(rsp->data); + e2 = (ng_l2cap_node_chan_ep *)(e1 + 1); + + e1->num_channels = n; + + LIST_FOREACH(ch, &l2cap->chan_list, next) { + e2->state = ch->state; + + e2->scid = ch->scid; + e2->dcid = ch->dcid; + + e2->imtu = ch->imtu; + e2->omtu = ch->omtu; + + e2->psm = ch->psm; + bcopy(&ch->con->remote, &e2->remote, + sizeof(e2->remote)); + + e2 ++; + if (--n <= 0) + break; + } + } break; + + default: + error = EINVAL; + break; + } + break; + + default: + error = EINVAL; + break; + } + + NG_RESPOND_MSG(error, node, item, rsp); + NG_FREE_MSG(msg); + + return (error); +} /* ng_l2cap_rcvmsg */ + +/* + * Process data packet from one of our hooks. + * + * From the HCI hook we expect to receive ACL data packets. ACL data packets + * gets re-assembled into one L2CAP packet (according to length) and then gets + * processed. + * + * NOTE: We expect to receive L2CAP packet header in the first fragment. + * Otherwise we WILL NOT be able to get length of the L2CAP packet. + * + * Signaling L2CAP packets (destination channel ID == 0x1) are processed within + * the node. Connectionless data packets (destination channel ID == 0x2) will + * be forwarded to appropriate upstream hook unless it is not connected or + * connectionless traffic for the specified PSM was disabled. + * + * From the upstream hooks we expect to receive data packets. These data + * packets will be converted into L2CAP data packets. The length of each + * L2CAP packet must not exceed channel's omtu (our peer's imtu). Then + * these L2CAP packets will be converted to ACL data packets (according to + * HCI layer MTU) and sent to lower layer. + * + * No data is expected from the control hook. + */ + +static int +ng_l2cap_rcvdata(hook_p hook, item_p item) +{ + ng_l2cap_p l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); + struct mbuf *m = NULL; + int error = 0; + + /* Detach mbuf, discard item and process data */ + NGI_GET_M(item, m); + NG_FREE_ITEM(item); + + if (hook == l2cap->hci) + error = ng_l2cap_lp_receive(l2cap, m); + else if (hook == l2cap->l2c) + error = ng_l2cap_l2ca_write_req(l2cap, m); + else { + NG_FREE_M(m); + error = EINVAL; + } + + return (error); +} /* ng_l2cap_rcvdata */ + +/* + * Clean all connections, channels and commands for the L2CAP node + */ + +static void +ng_l2cap_cleanup(ng_l2cap_p l2cap) +{ + ng_l2cap_con_p con = NULL; + + /* Clean up connection and channels */ + while (!LIST_EMPTY(&l2cap->con_list)) { + con = LIST_FIRST(&l2cap->con_list); + + if (con->state == NG_L2CAP_W4_LP_CON_CFM) + ng_l2cap_lp_untimeout(con); + + con->state = NG_L2CAP_CON_CLOSED; + ng_l2cap_con_fail(con, 0x16); + /* Connection terminated by local host */ + } +} /* ng_l2cap_cleanup */ + +/* + * Destroy all channels that use specified upstream hook + */ + +static void +ng_l2cap_destroy_channels(ng_l2cap_p l2cap) +{ + while (!LIST_EMPTY(&l2cap->chan_list)) + ng_l2cap_free_chan(LIST_FIRST(&l2cap->chan_list)); +} /* ng_l2cap_destroy_channels_by_hook */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.c b/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.c new file mode 100644 index 0000000..9fcbc6e --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.c @@ -0,0 +1,517 @@ +/* + * ng_l2cap_misc.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_misc.c,v 1.16 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_l2cap_var.h" +#include "ng_l2cap_cmds.h" +#include "ng_l2cap_evnt.h" +#include "ng_l2cap_llpi.h" +#include "ng_l2cap_ulpi.h" +#include "ng_l2cap_misc.h" + +static u_int16_t ng_l2cap_get_cid (ng_l2cap_p); +static void ng_l2cap_queue_lp_timeout (void *); +static void ng_l2cap_queue_command_timeout (void *); + +/****************************************************************************** + ****************************************************************************** + ** Utility routines + ****************************************************************************** + ******************************************************************************/ + +/* + * Send hook information to the upper layer + */ + +void +ng_l2cap_send_hook_info(node_p node, hook_p hook, void *arg1, int arg2) +{ + ng_l2cap_p l2cap = NULL; + struct ng_mesg *msg = NULL; + int error = 0; + + if (node == NULL || NG_NODE_NOT_VALID(node) || + hook == NULL || NG_HOOK_NOT_VALID(hook)) + return; + + l2cap = (ng_l2cap_p) NG_NODE_PRIVATE(node); + if (l2cap->hci == NULL || NG_HOOK_NOT_VALID(l2cap->hci) || + bcmp(&l2cap->bdaddr, NG_HCI_BDADDR_ANY, sizeof(l2cap->bdaddr)) == 0) + return; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_HOOK_INFO, + sizeof(bdaddr_t), M_NOWAIT); + if (msg != NULL) { + bcopy(&l2cap->bdaddr, msg->data, sizeof(bdaddr_t)); + NG_SEND_MSG_HOOK(error, node, msg, hook, NULL); + } else + error = ENOMEM; + + if (error != 0) + NG_L2CAP_INFO( +"%s: %s - failed to send HOOK_INFO message to hook \"%s\", error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), NG_HOOK_NAME(hook), + error); +} /* ng_l2cap_send_hook_info */ + +/* + * Create new connection descriptor for the "remote" unit. Will create new + * connection descriptor and signal channel. Will link both connection and + * channel to the l2cap node. + */ + +ng_l2cap_con_p +ng_l2cap_new_con(ng_l2cap_p l2cap, bdaddr_p bdaddr) +{ + ng_l2cap_con_p con = NULL; + + /* Create new connection descriptor */ + MALLOC(con, ng_l2cap_con_p, sizeof(*con), M_NETGRAPH_L2CAP, + M_NOWAIT|M_ZERO); + if (con == NULL) + return (NULL); + + con->l2cap = l2cap; + con->state = NG_L2CAP_CON_CLOSED; + + bcopy(bdaddr, &con->remote, sizeof(con->remote)); + callout_handle_init(&con->con_timo); + + con->ident = NG_L2CAP_FIRST_IDENT - 1; + TAILQ_INIT(&con->cmd_list); + + /* Link connection */ + LIST_INSERT_HEAD(&l2cap->con_list, con, next); + + return (con); +} /* ng_l2cap_new_con */ + +/* + * Free connection descriptor. Will unlink connection and free everything. + */ + +void +ng_l2cap_free_con(ng_l2cap_con_p con) +{ + ng_l2cap_chan_p f = NULL, n = NULL; + + if (con->state == NG_L2CAP_W4_LP_CON_CFM) + ng_l2cap_lp_untimeout(con); + + if (con->tx_pkt != NULL) { + while (con->tx_pkt != NULL) { + struct mbuf *m = con->tx_pkt->m_nextpkt; + + m_freem(con->tx_pkt); + con->tx_pkt = m; + } + } + + NG_FREE_M(con->rx_pkt); + + for (f = LIST_FIRST(&con->l2cap->chan_list); f != NULL; ) { + n = LIST_NEXT(f, next); + + if (f->con == con) + ng_l2cap_free_chan(f); + + f = n; + } + + while (!TAILQ_EMPTY(&con->cmd_list)) { + ng_l2cap_cmd_p cmd = TAILQ_FIRST(&con->cmd_list); + + ng_l2cap_unlink_cmd(cmd); + ng_l2cap_free_cmd(cmd); + } + + LIST_REMOVE(con, next); + bzero(con, sizeof(*con)); + FREE(con, M_NETGRAPH_L2CAP); +} /* ng_l2cap_free_con */ + +/* + * Get connection by "remote" address + */ + +ng_l2cap_con_p +ng_l2cap_con_by_addr(ng_l2cap_p l2cap, bdaddr_p bdaddr) +{ + ng_l2cap_con_p con = NULL; + + LIST_FOREACH(con, &l2cap->con_list, next) + if (bcmp(bdaddr, &con->remote, sizeof(con->remote)) == 0) + break; + + return (con); +} /* ng_l2cap_con_by_addr */ + +/* + * Get connection by "handle" + */ + +ng_l2cap_con_p +ng_l2cap_con_by_handle(ng_l2cap_p l2cap, u_int16_t con_handle) +{ + ng_l2cap_con_p con = NULL; + + LIST_FOREACH(con, &l2cap->con_list, next) + if (con->con_handle == con_handle) + break; + + return (con); +} /* ng_l2cap_con_by_handle */ + +/* + * Allocate new L2CAP channel descriptor on "con" conection with "psm". + * Will link the channel to the l2cap node + */ + +ng_l2cap_chan_p +ng_l2cap_new_chan(ng_l2cap_p l2cap, ng_l2cap_con_p con, u_int16_t psm) +{ + ng_l2cap_chan_p ch = NULL; + + MALLOC(ch, ng_l2cap_chan_p, sizeof(*ch), M_NETGRAPH_L2CAP, + M_NOWAIT|M_ZERO); + if (ch == NULL) + return (NULL); + + ch->scid = ng_l2cap_get_cid(l2cap); + + if (ch->scid != NG_L2CAP_NULL_CID) { + /* Initialize channel */ + ch->psm = psm; + ch->con = con; + ch->state = NG_L2CAP_CLOSED; + + /* Set MTU and flow control settings to defaults */ + ch->imtu = NG_L2CAP_MTU_DEFAULT; + bcopy(ng_l2cap_default_flow(), &ch->iflow, sizeof(ch->iflow)); + + ch->omtu = NG_L2CAP_MTU_DEFAULT; + bcopy(ng_l2cap_default_flow(), &ch->oflow, sizeof(ch->oflow)); + + ch->flush_timo = NG_L2CAP_FLUSH_TIMO_DEFAULT; + ch->link_timo = NG_L2CAP_LINK_TIMO_DEFAULT; + + LIST_INSERT_HEAD(&l2cap->chan_list, ch, next); + } else { + bzero(ch, sizeof(*ch)); + FREE(ch, M_NETGRAPH_L2CAP); + ch = NULL; + } + + return (ch); +} /* ng_l2cap_new_chan */ + +/* + * Get channel by source (local) channel ID + */ + +ng_l2cap_chan_p +ng_l2cap_chan_by_scid(ng_l2cap_p l2cap, u_int16_t scid) +{ + ng_l2cap_chan_p ch = NULL; + + LIST_FOREACH(ch, &l2cap->chan_list, next) + if (ch->scid == scid) + break; + + return (ch); +} /* ng_l2cap_chan_by_scid */ + +/* + * Free channel descriptor. + */ + +void +ng_l2cap_free_chan(ng_l2cap_chan_p ch) +{ + ng_l2cap_cmd_p f = NULL, n = NULL; + + f = TAILQ_FIRST(&ch->con->cmd_list); + while (f != NULL) { + n = TAILQ_NEXT(f, next); + + if (f->ch == ch) { + ng_l2cap_unlink_cmd(f); + ng_l2cap_free_cmd(f); + } + + f = n; + } + + LIST_REMOVE(ch, next); + bzero(ch, sizeof(*ch)); + FREE(ch, M_NETGRAPH_L2CAP); +} /* ng_l2cap_free_chan */ + +/* + * Create new L2CAP command descriptor. WILL NOT add command to the queue. + */ + +ng_l2cap_cmd_p +ng_l2cap_new_cmd(ng_l2cap_con_p con, ng_l2cap_chan_p ch, u_int8_t ident, + u_int8_t code, u_int32_t token) +{ + ng_l2cap_cmd_p cmd = NULL; + + KASSERT((ch == NULL || ch->con == con), +("%s: %s - invalid channel pointer!\n", + __func__, NG_NODE_NAME(con->l2cap->node))); + + MALLOC(cmd, ng_l2cap_cmd_p, sizeof(*cmd), M_NETGRAPH_L2CAP, + M_NOWAIT|M_ZERO); + if (cmd == NULL) + return (NULL); + + cmd->con = con; + cmd->ch = ch; + cmd->ident = ident; + cmd->code = code; + cmd->token = token; + callout_handle_init(&cmd->timo); + + return (cmd); +} /* ng_l2cap_new_cmd */ + +/* + * Get L2CAP command descriptor by ident + */ + +ng_l2cap_cmd_p +ng_l2cap_cmd_by_ident(ng_l2cap_con_p con, u_int8_t ident) +{ + ng_l2cap_cmd_p cmd = NULL; + + TAILQ_FOREACH(cmd, &con->cmd_list, next) + if (cmd->ident == ident) + break; + + return (cmd); +} /* ng_l2cap_cmd_by_ident */ + +/* + * Set LP timeout + */ + +void +ng_l2cap_lp_timeout(ng_l2cap_con_p con) +{ + NG_NODE_REF(con->l2cap->node); + con->con_timo = timeout(ng_l2cap_queue_lp_timeout, con, + bluetooth_hci_connect_timeout()); +} /* ng_l2cap_lp_timeout */ + +/* + * Unset LP timeout + */ + +void +ng_l2cap_lp_untimeout(ng_l2cap_con_p con) +{ + untimeout(ng_l2cap_queue_lp_timeout, con, con->con_timo); + NG_NODE_UNREF(con->l2cap->node); +} /* ng_l2cap_lp_untimeout */ + +/* + * OK, timeout has happend so queue LP timeout processing function + */ + +static void +ng_l2cap_queue_lp_timeout(void *context) +{ + ng_l2cap_con_p con = (ng_l2cap_con_p) context; + node_p node = con->l2cap->node; + + /* + * We need to save node pointer here, because ng_send_fn() + * can execute ng_l2cap_process_lp_timeout() without putting + * item into node's queue (if node can be locked). Once + * ng_l2cap_process_lp_timeout() executed the con pointer + * is no longer valid. + */ + + if (NG_NODE_IS_VALID(node)) + ng_send_fn(node, NULL, &ng_l2cap_process_lp_timeout, con, 0); + + NG_NODE_UNREF(node); +} /* ng_l2cap_queue_lp_timeout */ + +/* + * Set L2CAP command timeout + */ + +void +ng_l2cap_command_timeout(ng_l2cap_cmd_p cmd, int timo) +{ + NG_NODE_REF(cmd->con->l2cap->node); + cmd->flags |= NG_L2CAP_CMD_PENDING; + cmd->timo = timeout(ng_l2cap_queue_command_timeout, cmd, timo); +} /* ng_l2cap_command_timeout */ + +/* + * Unset L2CAP command timeout + */ + +void +ng_l2cap_command_untimeout(ng_l2cap_cmd_p cmd) +{ + cmd->flags &= ~NG_L2CAP_CMD_PENDING; + untimeout(ng_l2cap_queue_command_timeout, cmd, cmd->timo); + NG_NODE_UNREF(cmd->con->l2cap->node); +} /* ng_l2cap_command_untimeout */ + +/* + * OK, timeout has happend so queue L2CAP command timeout processing function + */ + +static void +ng_l2cap_queue_command_timeout(void *context) +{ + ng_l2cap_cmd_p cmd = (ng_l2cap_cmd_p) context; + node_p node = cmd->con->l2cap->node; + + /* + * We need to save node pointer here, because ng_send_fn() + * can execute ng_l2cap_process_command_timeout() without + * putting item into node's queue (if node can be locked). + * Once ng_l2cap_process_command_timeout() executed the + * cmd pointer is no longer valid. + */ + + if (NG_NODE_IS_VALID(node)) + ng_send_fn(node,NULL,&ng_l2cap_process_command_timeout,cmd,0); + + NG_NODE_UNREF(node); +} /* ng_l2cap_queue_command_timeout */ + +/* + * Prepend "m"buf with "size" bytes + */ + +struct mbuf * +ng_l2cap_prepend(struct mbuf *m, int size) +{ + M_PREPEND(m, size, M_DONTWAIT); + if (m == NULL || (m->m_len < size && (m = m_pullup(m, size)) == NULL)) + return (NULL); + + return (m); +} /* ng_l2cap_prepend */ + +/* + * Default flow settings + */ + +ng_l2cap_flow_p +ng_l2cap_default_flow(void) +{ + static ng_l2cap_flow_t default_flow = { + /* flags */ 0x0, + /* service_type */ NG_HCI_SERVICE_TYPE_BEST_EFFORT, + /* token_rate */ 0xffffffff, /* maximum */ + /* token_bucket_size */ 0xffffffff, /* maximum */ + /* peak_bandwidth */ 0x00000000, /* maximum */ + /* latency */ 0xffffffff, /* don't care */ + /* delay_variation */ 0xffffffff /* don't care */ + }; + + return (&default_flow); +} /* ng_l2cap_default_flow */ + +/* + * Get next available channel ID + * XXX FIXME this is *UGLY* but will do for now + */ + +static u_int16_t +ng_l2cap_get_cid(ng_l2cap_p l2cap) +{ + u_int16_t cid = l2cap->cid + 1; + + if (cid < NG_L2CAP_FIRST_CID) + cid = NG_L2CAP_FIRST_CID; + + while (cid != l2cap->cid) { + if (ng_l2cap_chan_by_scid(l2cap, cid) == NULL) { + l2cap->cid = cid; + + return (cid); + } + + cid ++; + if (cid < NG_L2CAP_FIRST_CID) + cid = NG_L2CAP_FIRST_CID; + } + + return (NG_L2CAP_NULL_CID); +} /* ng_l2cap_get_cid */ + +/* + * Get next available command ident + * XXX FIXME this is *UGLY* but will do for now + */ + +u_int8_t +ng_l2cap_get_ident(ng_l2cap_con_p con) +{ + u_int8_t ident = con->ident + 1; + + if (ident < NG_L2CAP_FIRST_IDENT) + ident = NG_L2CAP_FIRST_IDENT; + + while (ident != con->ident) { + if (ng_l2cap_cmd_by_ident(con, ident) == NULL) { + con->ident = ident; + + return (ident); + } + + ident ++; + if (ident < NG_L2CAP_FIRST_IDENT) + ident = NG_L2CAP_FIRST_IDENT; + } + + return (NG_L2CAP_NULL_IDENT); +} /* ng_l2cap_get_ident */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.h new file mode 100644 index 0000000..f0f72a3 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_misc.h @@ -0,0 +1,100 @@ +/* + * ng_l2cap_misc.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_misc.h,v 1.6 2002/04/16 00:43:57 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_L2CAP_MISC_H_ +#define _NETGRAPH_L2CAP_MISC_H_ 1 + +void ng_l2cap_send_hook_info (node_p, hook_p, void *, int); + +/* + * ACL Connections + */ + +ng_l2cap_con_p ng_l2cap_new_con (ng_l2cap_p, bdaddr_p); +ng_l2cap_con_p ng_l2cap_con_by_addr (ng_l2cap_p, bdaddr_p); +ng_l2cap_con_p ng_l2cap_con_by_handle (ng_l2cap_p, u_int16_t); +void ng_l2cap_free_con (ng_l2cap_con_p); + +/* + * L2CAP channels + */ + +ng_l2cap_chan_p ng_l2cap_new_chan (ng_l2cap_p, ng_l2cap_con_p, u_int16_t); +ng_l2cap_chan_p ng_l2cap_chan_by_scid (ng_l2cap_p, u_int16_t); +void ng_l2cap_free_chan (ng_l2cap_chan_p); + +/* + * L2CAP command descriptors + */ + +#define ng_l2cap_link_cmd(con, cmd) \ +do { \ + TAILQ_INSERT_TAIL(&(con)->cmd_list, (cmd), next); \ +} while (0) + +#define ng_l2cap_unlink_cmd(cmd) \ +do { \ + TAILQ_REMOVE(&((cmd)->con->cmd_list), (cmd), next); \ +} while (0) + +#define ng_l2cap_free_cmd(cmd) \ +do { \ + if ((cmd)->flags & NG_L2CAP_CMD_PENDING) \ + ng_l2cap_command_untimeout((cmd)); \ + \ + NG_FREE_M((cmd)->aux); \ + bzero((cmd), sizeof(*(cmd))); \ + FREE((cmd), M_NETGRAPH_L2CAP); \ +} while (0) + +ng_l2cap_cmd_p ng_l2cap_new_cmd (ng_l2cap_con_p, ng_l2cap_chan_p, + u_int8_t, u_int8_t, u_int32_t); +ng_l2cap_cmd_p ng_l2cap_cmd_by_ident (ng_l2cap_con_p, u_int8_t); +u_int8_t ng_l2cap_get_ident (ng_l2cap_con_p); + +/* + * Timeout + */ + +void ng_l2cap_lp_timeout (ng_l2cap_con_p); +void ng_l2cap_lp_untimeout (ng_l2cap_con_p); +void ng_l2cap_command_timeout (ng_l2cap_cmd_p, int); +void ng_l2cap_command_untimeout (ng_l2cap_cmd_p); + +/* + * Other stuff + */ + +struct mbuf * ng_l2cap_prepend (struct mbuf *, int); +ng_l2cap_flow_p ng_l2cap_default_flow (void); + +#endif /* ndef _NETGRAPH_L2CAP_MISC_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_prse.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_prse.h new file mode 100644 index 0000000..5209c24 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_prse.h @@ -0,0 +1,71 @@ +/* + * ng_l2cap_prse.h + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_prse.h,v 1.2 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +/*************************************************************************** + *************************************************************************** + ** ng_parse definitions for the L2CAP node + *************************************************************************** + ***************************************************************************/ + +#ifndef _NETGRAPH_L2CAP_PRSE_H_ +#define _NETGRAPH_L2CAP_PRSE_H_ 1 + +/* + * L2CAP node command list + */ + +static const struct ng_cmdlist ng_l2cap_cmdlist[] = { + { + NGM_L2CAP_COOKIE, + NGM_L2CAP_NODE_GET_FLAGS, + "get_flags", + NULL, + &ng_parse_uint16_type + }, + { + NGM_L2CAP_COOKIE, + NGM_L2CAP_NODE_GET_DEBUG, + "get_debug", + NULL, + &ng_parse_uint16_type + }, + { + NGM_L2CAP_COOKIE, + NGM_L2CAP_NODE_SET_DEBUG, + "set_debug", + &ng_parse_uint16_type, + NULL + }, + { 0, } +}; + +#endif /* ndef _NETGRAPH_L2CAP_PRSE_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_ulpi.c b/sys/netgraph/bluetooth/l2cap/ng_l2cap_ulpi.c new file mode 100644 index 0000000..c913d1c --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_ulpi.c @@ -0,0 +1,1640 @@ +/* + * ng_l2cap_ulpi.c + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_ulpi.c,v 1.22 2002/09/08 23:35:51 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/kernel.h> +#include <sys/endian.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/queue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_l2cap_var.h" +#include "ng_l2cap_cmds.h" +#include "ng_l2cap_evnt.h" +#include "ng_l2cap_llpi.h" +#include "ng_l2cap_ulpi.h" +#include "ng_l2cap_misc.h" + +/****************************************************************************** + ****************************************************************************** + ** Upper Layer Protocol Interface module + ****************************************************************************** + ******************************************************************************/ + +/* + * Process L2CA_Connect request from the upper layer protocol. + */ + +int +ng_l2cap_l2ca_con_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_con_ip *ip = NULL; + ng_l2cap_con_p con = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_Connect request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_con_ip *)(msg->data); + + /* Check if we have connection to the remote unit */ + con = ng_l2cap_con_by_addr(l2cap, &ip->bdaddr); + if (con == NULL) { + /* Submit LP_ConnectReq to the lower layer */ + error = ng_l2cap_lp_con_req(l2cap, &ip->bdaddr); + if (error != 0) { + NG_L2CAP_ERR( +"%s: %s - unable to send LP_ConnectReq message, error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), error); + goto out; + } + + /* This should not fail */ + con = ng_l2cap_con_by_addr(l2cap, &ip->bdaddr); + KASSERT((con != NULL), +("%s: %s - could not find connection!\n", __func__, NG_NODE_NAME(l2cap->node))); + } + + /* + * Create new empty channel descriptor. In case of any failure do + * not touch connection descriptor. + */ + + ch = ng_l2cap_new_chan(l2cap, con, ip->psm); + if (ch == NULL) { + error = ENOMEM; + goto out; + } + + /* Now create L2CAP_ConnectReq command */ + cmd = ng_l2cap_new_cmd(ch->con, ch, ng_l2cap_get_ident(con), + NG_L2CAP_CON_REQ, msg->header.token); + if (cmd == NULL) { + ng_l2cap_free_chan(ch); + error = ENOMEM; + goto out; + } + + if (cmd->ident == NG_L2CAP_NULL_IDENT) { + ng_l2cap_free_cmd(cmd); + ng_l2cap_free_chan(ch); + error = EIO; + goto out; + } + + /* Create L2CAP command packet */ + _ng_l2cap_con_req(cmd->aux, cmd->ident, ch->psm, ch->scid); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + ng_l2cap_free_chan(ch); + error = ENOBUFS; + goto out; + } + + ch->state = NG_L2CAP_W4_L2CAP_CON_RSP; + + /* Link command to the queue */ + ng_l2cap_link_cmd(ch->con, cmd); + ng_l2cap_lp_deliver(ch->con); +out: + return (error); +} /* ng_l2cap_l2ca_con_req */ + +/* + * Send L2CA_Connect response to the upper layer protocol. + */ + +int +ng_l2cap_l2ca_con_rsp(ng_l2cap_chan_p ch, u_int32_t token, u_int16_t result, + u_int16_t status) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_con_op *op = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_Connect response message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_Connect response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CON, + sizeof(*op), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_con_op *)(msg->data); + + /* + * XXX Spec. says we should only populate LCID when result == 0 + * What about PENDING? What the heck, for now always populate + * LCID :) + */ + + op->lcid = ch->scid; + op->result = result; + op->status = status; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_con_rsp */ + +/* + * Process L2CA_ConnectRsp request from the upper layer protocol. + */ + +int +ng_l2cap_l2ca_con_rsp_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_con_rsp_ip *ip = NULL; + ng_l2cap_con_p con = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + u_int16_t dcid; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_ConnectRsp request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_con_rsp_ip *)(msg->data); + + /* Check if we have this channel */ + ch = ng_l2cap_chan_by_scid(l2cap, ip->lcid); + if (ch == NULL) { + NG_L2CAP_ALERT( +"%s: %s - unexpected L2CA_ConnectRsp request message. " \ +"Channel does not exist, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ip->lcid); + error = ENOENT; + goto out; + } + + /* Check channel state */ + if (ch->state != NG_L2CAP_W4_L2CA_CON_RSP) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_ConnectRsp request message. " \ +"Invalid channel state, state=%d, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->state, + ip->lcid); + error = EINVAL; + goto out; + } + + dcid = ch->dcid; + con = ch->con; + + /* + * Now we are pretty much sure it is our response. So create and send + * L2CAP_ConnectRsp message to our peer. + */ + + if (ch->ident != ip->ident) + NG_L2CAP_WARN( +"%s: %s - channel ident and response ident do not match, scid=%d, ident=%d. " \ +"Will use response ident=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->scid, + ch->ident, ip->ident); + + /* Check result */ + switch (ip->result) { + case NG_L2CAP_SUCCESS: + ch->state = NG_L2CAP_CONFIG; + ch->cfg_state = 0; + break; + + case NG_L2CAP_PENDING: + break; + + default: + ng_l2cap_free_chan(ch); + ch = NULL; + break; + } + + /* Create L2CAP command */ + cmd = ng_l2cap_new_cmd(con, ch, ip->ident, NG_L2CAP_CON_RSP, + msg->header.token); + if (cmd == NULL) { + if (ch != NULL) + ng_l2cap_free_chan(ch); + + error = ENOMEM; + goto out; + } + + _ng_l2cap_con_rsp(cmd->aux, cmd->ident, ip->lcid, dcid, + ip->result, ip->status); + if (cmd->aux == NULL) { + if (ch != NULL) + ng_l2cap_free_chan(ch); + + ng_l2cap_free_cmd(cmd); + error = ENOBUFS; + goto out; + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); +out: + return (error); +} /* ng_l2cap_l2ca_con_rsp_req */ + +/* + * Send L2CAP_ConnectRsp response to the upper layer + */ + +int +ng_l2cap_l2ca_con_rsp_rsp(ng_l2cap_chan_p ch, u_int32_t token, u_int16_t result) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_con_rsp_op *op = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_ConnectRsp response message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_ConnectRsp response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CON_RSP, + sizeof(*op), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_con_rsp_op *)(msg->data); + op->result = result; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_con_rsp_rsp */ + +/* + * Send L2CA_ConnectInd message to the upper layer protocol. + */ + +int +ng_l2cap_l2ca_con_ind(ng_l2cap_chan_p ch) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_con_ind_ip *ip = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_ConnectInd message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_ConnectInd message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CON_IND, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + ip = (ng_l2cap_l2ca_con_ind_ip *)(msg->data); + + bcopy(&ch->con->remote, &ip->bdaddr, sizeof(ip->bdaddr)); + ip->lcid = ch->scid; + ip->psm = ch->psm; + ip->ident = ch->ident; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_con_ind */ + +/* + * Process L2CA_Config request from the upper layer protocol + */ + +int +ng_l2cap_l2ca_cfg_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_cfg_ip *ip = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + struct mbuf *opt = NULL; + u_int16_t *mtu = NULL, *flush_timo = NULL; + ng_l2cap_flow_p flow = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - Invalid L2CA_Config request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_cfg_ip *)(msg->data); + + /* Check if we have this channel */ + ch = ng_l2cap_chan_by_scid(l2cap, ip->lcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_Config request message. " \ +"Channel does not exist, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ip->lcid); + error = ENOENT; + goto out; + } + + /* Check channel state */ + if (ch->state != NG_L2CAP_OPEN && ch->state != NG_L2CAP_CONFIG) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_Config request message. " \ +"Invalid channel state, state=%d, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->state, + ch->scid); + error = EINVAL; + goto out; + } + + /* Set requested channel configuration options */ + ch->imtu = ip->imtu; + bcopy(&ip->oflow, &ch->oflow, sizeof(ch->oflow)); + ch->flush_timo = ip->flush_timo; + ch->link_timo = ip->link_timo; + + /* Compare channel settings with defaults */ + if (ch->imtu != NG_L2CAP_MTU_DEFAULT) + mtu = &ch->imtu; + if (ch->flush_timo != NG_L2CAP_FLUSH_TIMO_DEFAULT) + flush_timo = &ch->flush_timo; + if (bcmp(ng_l2cap_default_flow(), &ch->oflow, sizeof(ch->oflow)) != 0) + flow = &ch->oflow; + + /* Create configuration options */ + _ng_l2cap_build_cfg_options(opt, mtu, flush_timo, flow); + if (opt == NULL) { + error = ENOBUFS; + goto out; + } + + /* Create L2CAP command descriptor */ + cmd = ng_l2cap_new_cmd(ch->con, ch, ng_l2cap_get_ident(ch->con), + NG_L2CAP_CFG_REQ, msg->header.token); + if (cmd == NULL) { + NG_FREE_M(opt); + error = ENOMEM; + goto out; + } + + if (cmd->ident == NG_L2CAP_NULL_IDENT) { + ng_l2cap_free_cmd(cmd); + NG_FREE_M(opt); + error = EIO; + goto out; + } + + /* Create L2CAP command packet */ + _ng_l2cap_cfg_req(cmd->aux, cmd->ident, ch->dcid, 0, opt); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + error = ENOBUFS; + goto out; + } + + /* Adjust channel state for re-configuration */ + if (ch->state == NG_L2CAP_OPEN) { + ch->state = NG_L2CAP_CONFIG; + ch->cfg_state = 0; + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(ch->con, cmd); + ng_l2cap_lp_deliver(ch->con); +out: + return (error); +} /* ng_l2cap_l2ca_cfg_req */ + +/* + * Send L2CA_Config response to the upper layer protocol + */ + +int +ng_l2cap_l2ca_cfg_rsp(ng_l2cap_chan_p ch, u_int32_t token, u_int16_t result) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_cfg_op *op = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_Config response message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_Config response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CFG, + sizeof(*op), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_cfg_op *)(msg->data); + op->result = result; + op->imtu = ch->imtu; + bcopy(&ch->oflow, &op->oflow, sizeof(op->oflow)); + op->flush_timo = ch->flush_timo; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + + if (error == 0 && result == NG_L2CAP_SUCCESS) { + ch->cfg_state |= NG_L2CAP_CFG_IN; + + if (ch->cfg_state == NG_L2CAP_CFG_BOTH) + ch->state = NG_L2CAP_OPEN; + } + } + + return (error); +} /* ng_l2cap_l2ca_cfg_rsp */ + +/* + * Process L2CA_ConfigRsp request from the upper layer protocol + * + * XXX XXX XXX + * + * NOTE: The Bluetooth specification says that Configuration_Response + * (L2CA_ConfigRsp) should be used to issue response to configuration request + * indication. The minor problem here is L2CAP command ident. We should use + * ident from original L2CAP request to make sure our peer can match request + * and response. For some reason Bluetooth specification does not include + * ident field into L2CA_ConfigInd and L2CA_ConfigRsp messages. This seems + * strange to me, because L2CA_ConnectInd and L2CA_ConnectRsp do have ident + * field. So we should store last known L2CAP request command ident in channel. + * Also it seems that upper layer can not reject configuration request, as + * Configuration_Response message does not have status/reason field. + */ + +int +ng_l2cap_l2ca_cfg_rsp_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_cfg_rsp_ip *ip = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + struct mbuf *opt = NULL; + u_int16_t *mtu = NULL; + ng_l2cap_flow_p flow = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_ConfigRsp request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_cfg_rsp_ip *)(msg->data); + + /* Check if we have this channel */ + ch = ng_l2cap_chan_by_scid(l2cap, ip->lcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_ConfigRsp request message. " \ +"Channel does not exist, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ip->lcid); + error = ENOENT; + goto out; + } + + /* Check channel state */ + if (ch->state != NG_L2CAP_CONFIG) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_ConfigRsp request message. " \ +"Invalid channel state, state=%d, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->state, + ch->scid); + error = EINVAL; + goto out; + } + + /* Set channel settings */ + if (ip->omtu != ch->omtu) { + ch->omtu = ip->omtu; + mtu = &ch->omtu; + } + + if (bcmp(&ip->iflow, &ch->iflow, sizeof(ch->iflow)) != 0) { + bcopy(&ip->iflow, &ch->iflow, sizeof(ch->iflow)); + flow = &ch->iflow; + } + + if (mtu != NULL || flow != NULL) { + _ng_l2cap_build_cfg_options(opt, mtu, NULL, flow); + if (opt == NULL) { + error = ENOBUFS; + goto out; + } + } + + /* Create L2CAP command */ + cmd = ng_l2cap_new_cmd(ch->con, ch, ch->ident, NG_L2CAP_CFG_RSP, + msg->header.token); + if (cmd == NULL) { + NG_FREE_M(opt); + error = ENOMEM; + goto out; + } + + _ng_l2cap_cfg_rsp(cmd->aux,cmd->ident,ch->dcid,0,NG_L2CAP_SUCCESS,opt); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + error = ENOBUFS; + goto out; + } + + /* XXX FIXME - not here ??? */ + ch->cfg_state |= NG_L2CAP_CFG_OUT; + if (ch->cfg_state == NG_L2CAP_CFG_BOTH) + ch->state = NG_L2CAP_OPEN; + + /* Link command to the queue */ + ng_l2cap_link_cmd(ch->con, cmd); + ng_l2cap_lp_deliver(ch->con); +out: + return (error); +} /* ng_l2cap_l2ca_cfg_rsp_req */ + +/* + * Send L2CA_ConfigRsp response to the upper layer protocol + */ + +int +ng_l2cap_l2ca_cfg_rsp_rsp(ng_l2cap_chan_p ch, u_int32_t token, u_int16_t result) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_cfg_rsp_op *op = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_ConfigRsp response message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_ConfigRsp response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CFG_RSP, + sizeof(*op), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_cfg_rsp_op *)(msg->data); + op->result = result; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_cfg_rsp_rsp */ + +/* + * Send L2CA_ConfigInd message to the upper layer protocol + * + * XXX XXX XXX + * + * NOTE: The Bluetooth specification says that Configuration_Response + * (L2CA_ConfigRsp) should be used to issue response to configuration request + * indication. The minor problem here is L2CAP command ident. We should use + * ident from original L2CAP request to make sure our peer can match request + * and response. For some reason Bluetooth specification does not include + * ident field into L2CA_ConfigInd and L2CA_ConfigRsp messages. This seems + * strange to me, because L2CA_ConnectInd and L2CA_ConnectRsp do have ident + * field. So we should store last known L2CAP request command ident in channel. + * Also it seems that upper layer can not reject configuration request, as + * Configuration_Response message does not have status/reason field. + */ + +int +ng_l2cap_l2ca_cfg_ind(ng_l2cap_chan_p ch) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_cfg_ind_ip *ip = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - Unable to send L2CA_ConfigInd message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_ConnectInd message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CFG_IND, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + ip = (ng_l2cap_l2ca_cfg_ind_ip *)(msg->data); + ip->lcid = ch->scid; + ip->omtu = ch->omtu; + bcopy(&ch->iflow, &ip->iflow, sizeof(ip->iflow)); + ip->flush_timo = ch->flush_timo; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_cfg_ind */ + +/* + * Process L2CA_Write event + */ + +int +ng_l2cap_l2ca_write_req(ng_l2cap_p l2cap, struct mbuf *m) +{ + ng_l2cap_l2ca_hdr_t *l2ca_hdr = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + u_int32_t token = 0; + + /* Make sure we can access L2CA data packet header */ + if (m->m_pkthdr.len < sizeof(*l2ca_hdr)) { + NG_L2CAP_ERR( +"%s: %s - L2CA Data packet too small, len=%d\n", + __func__,NG_NODE_NAME(l2cap->node),m->m_pkthdr.len); + error = EMSGSIZE; + goto drop; + } + + /* Get L2CA data packet header */ + NG_L2CAP_M_PULLUP(m, sizeof(*l2ca_hdr)); + if (m == NULL) + return (ENOBUFS); + + l2ca_hdr = mtod(m, ng_l2cap_l2ca_hdr_t *); + token = l2ca_hdr->token; + m_adj(m, sizeof(*l2ca_hdr)); + + /* Verify payload size */ + if (l2ca_hdr->length != m->m_pkthdr.len) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CA Data packet. " \ +"Payload length does not match, length=%d, len=%d\n", + __func__, NG_NODE_NAME(l2cap->node), l2ca_hdr->length, + m->m_pkthdr.len); + error = EMSGSIZE; + goto drop; + } + + /* Check channel ID */ + if (l2ca_hdr->lcid < NG_L2CAP_FIRST_CID) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CA Data packet. Inavlid channel ID, cid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), l2ca_hdr->lcid); + error = EINVAL; + goto drop; + } + + /* Verify that we have the channel and make sure it is open */ + ch = ng_l2cap_chan_by_scid(l2cap, l2ca_hdr->lcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CA Data packet. Channel does not exist, cid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), l2ca_hdr->lcid); + error = ENOENT; + goto drop; + } + + if (ch->state != NG_L2CAP_OPEN) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CA Data packet. Invalid channel state, scid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->scid, + ch->state); + error = EHOSTDOWN; + goto drop; /* XXX not always - re-configure */ + } + + /* Create L2CAP command descriptor */ + cmd = ng_l2cap_new_cmd(ch->con, ch, 0, NGM_L2CAP_L2CA_WRITE, token); + if (cmd == NULL) { + error = ENOMEM; + goto drop; + } + + /* Attach data packet and link command to the queue */ + cmd->aux = m; + ng_l2cap_link_cmd(ch->con, cmd); + ng_l2cap_lp_deliver(ch->con); + + return (error); +drop: + NG_FREE_M(m); + + return (error); +} /* ng_l2cap_l2ca_write_req */ + +/* + * Send L2CA_Write response + */ + +int +ng_l2cap_l2ca_write_rsp(ng_l2cap_chan_p ch, u_int32_t token, u_int16_t result, + u_int16_t length) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_write_op *op = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_WriteRsp message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_WriteRsp message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_WRITE, + sizeof(*op), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_write_op *)(msg->data); + op->result = result; + op->length = length; + op->lcid = ch->scid; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_write_rsp */ + +/* + * Receive packet from the lower layer protocol and send it to the upper + * layer protocol (L2CAP_Read) + */ + +int +ng_l2cap_l2ca_receive(ng_l2cap_con_p con) +{ + ng_l2cap_p l2cap = con->l2cap; + ng_l2cap_hdr_t *hdr = NULL; + ng_l2cap_chan_p ch = NULL; + int error = 0; + + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*hdr)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + hdr = mtod(con->rx_pkt, ng_l2cap_hdr_t *); + + /* Check channel */ + ch = ng_l2cap_chan_by_scid(l2cap, hdr->dcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CAP data packet. Channel does not exist, cid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), hdr->dcid); + error = ENOENT; + goto drop; + } + + /* Check channel state */ + if (ch->state != NG_L2CAP_OPEN) { + NG_L2CAP_WARN( +"%s: %s - unexpected L2CAP data packet. " \ +"Invalid channel state, cid=%d, state=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->scid, + ch->state); + error = EHOSTDOWN; /* XXX not always - re-configuration */ + goto drop; + } + + /* Check payload size and channel's MTU */ + if (hdr->length > ch->imtu) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP data packet. " \ +"Packet too big, length=%d, imtu=%d, cid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), hdr->length, + ch->imtu, ch->scid); + error = EMSGSIZE; + goto drop; + } + + /* + * If we got here then everything looks good and we can sent packet + * to the upper layer protocol. + */ + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CAP data packet. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + error = ENOTCONN; + goto drop; + } + + NG_SEND_DATA_ONLY(error, l2cap->l2c, con->rx_pkt); + con->rx_pkt = NULL; +drop: + NG_FREE_M(con->rx_pkt); /* checks for != NULL */ + + return (error); +} /* ng_l2cap_receive */ + +/* + * Receive connectioless (multicast) packet from the lower layer protocol and + * send it to the upper layer protocol + */ + +int +ng_l2cap_l2ca_clt_receive(ng_l2cap_con_p con) +{ + struct _clt_pkt { + ng_l2cap_hdr_t h; + ng_l2cap_clt_hdr_t c_h; + } __attribute__ ((packed)) *hdr = NULL; + ng_l2cap_p l2cap = con->l2cap; + int length, error = 0; + + NG_L2CAP_M_PULLUP(con->rx_pkt, sizeof(*hdr)); + if (con->rx_pkt == NULL) + return (ENOBUFS); + + hdr = mtod(con->rx_pkt, struct _clt_pkt *); + + /* Check packet */ + length = con->rx_pkt->m_pkthdr.len - sizeof(*hdr); + if (length < 0) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP CLT data packet. Packet too small, length=%d\n", + __func__, NG_NODE_NAME(l2cap->node), length); + error = EMSGSIZE; + goto drop; + } + + /* Check payload size against CLT MTU */ + if (length > NG_L2CAP_MTU_DEFAULT) { + NG_L2CAP_ERR( +"%s: %s - invalid L2CAP CLT data packet. Packet too big, length=%d, mtu=%d\n", + __func__, NG_NODE_NAME(l2cap->node), length, + NG_L2CAP_MTU_DEFAULT); + error = EMSGSIZE; + goto drop; + } + + hdr->c_h.psm = le16toh(hdr->c_h.psm); + + /* + * If we got here then everything looks good and we can sent packet + * to the upper layer protocol. + */ + + /* Select upstream hook based on PSM */ + switch (hdr->c_h.psm) { + case NG_L2CAP_PSM_SDP: + if (l2cap->flags & NG_L2CAP_CLT_SDP_DISABLED) + goto drop; + break; + + case NG_L2CAP_PSM_RFCOMM: + if (l2cap->flags & NG_L2CAP_CLT_RFCOMM_DISABLED) + goto drop; + break; + + case NG_L2CAP_PSM_TCP: + if (l2cap->flags & NG_L2CAP_CLT_TCP_DISABLED) + goto drop; + break; + } + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CAP CLT data packet. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), hdr->c_h.psm); + error = ENOTCONN; + goto drop; + } + + NG_SEND_DATA_ONLY(error, l2cap->l2c, con->rx_pkt); + con->rx_pkt = NULL; +drop: + NG_FREE_M(con->rx_pkt); /* checks for != NULL */ + + return (error); +} /* ng_l2cap_l2ca_clt_receive */ + +/* + * Send L2CA_QoSViolationInd to the upper layer protocol + */ + +int +ng_l2cap_l2ca_qos_ind(ng_l2cap_chan_p ch) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_qos_ind_ip *ip = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_QoSViolationInd message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_QoSViolationInd message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_QOS_IND, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + ip = (ng_l2cap_l2ca_qos_ind_ip *)(msg->data); + bcopy(&ch->con->remote, &ip->bdaddr, sizeof(ip->bdaddr)); + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_qos_ind */ + +/* + * Process L2CA_Disconnect request from the upper layer protocol. + */ + +int +ng_l2cap_l2ca_discon_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_discon_ip *ip = NULL; + ng_l2cap_chan_p ch = NULL; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_Disconnect request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_discon_ip *)(msg->data); + + /* Check if we have this channel */ + ch = ng_l2cap_chan_by_scid(l2cap, ip->lcid); + if (ch == NULL) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_Disconnect request message. " \ +"Channel does not exist, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ip->lcid); + error = ENOENT; + goto out; + } + + /* Check channel state */ + if (ch->state != NG_L2CAP_CONFIG && ch->state != NG_L2CAP_OPEN && + ch->state != NG_L2CAP_W4_L2CAP_DISCON_RSP) { + NG_L2CAP_ERR( +"%s: %s - unexpected L2CA_Disconnect request message. " \ +"Invalid channel state, state=%d, lcid=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->state, + ch->scid); + error = EINVAL; + goto out; + } + + /* Create and send L2CAP_DisconReq message */ + cmd = ng_l2cap_new_cmd(ch->con, ch, ng_l2cap_get_ident(ch->con), + NG_L2CAP_DISCON_REQ, msg->header.token); + if (cmd == NULL) { + ng_l2cap_free_chan(ch); + error = ENOMEM; + goto out; + } + + if (cmd->ident == NG_L2CAP_NULL_IDENT) { + ng_l2cap_free_chan(ch); + ng_l2cap_free_cmd(cmd); + error = EIO; + goto out; + } + + _ng_l2cap_discon_req(cmd->aux, cmd->ident, ch->dcid, ch->scid); + if (cmd->aux == NULL) { + ng_l2cap_free_chan(ch); + ng_l2cap_free_cmd(cmd); + error = ENOBUFS; + goto out; + } + + ch->state = NG_L2CAP_W4_L2CAP_DISCON_RSP; + + /* Link command to the queue */ + ng_l2cap_link_cmd(ch->con, cmd); + ng_l2cap_lp_deliver(ch->con); +out: + return (error); +} /* ng_l2cap_l2ca_discon_req */ + +/* + * Send L2CA_Disconnect response to the upper layer protocol + */ + +int +ng_l2cap_l2ca_discon_rsp(ng_l2cap_chan_p ch, u_int32_t token, u_int16_t result) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_discon_op *op = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_Disconnect response message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_Disconnect response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_DISCON, + sizeof(*op), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_discon_op *)(msg->data); + op->result = result; + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_discon_rsp */ + +/* + * Send L2CA_DisconnectInd message to the upper layer protocol. + */ + +int +ng_l2cap_l2ca_discon_ind(ng_l2cap_chan_p ch) +{ + ng_l2cap_p l2cap = ch->con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_discon_ind_ip *ip = NULL; + int error = 0; + + /* Check if upstream hook is connected and valid */ + if (l2cap->l2c == NULL || NG_HOOK_NOT_VALID(l2cap->l2c)) { + NG_L2CAP_ERR( +"%s: %s - unable to send L2CA_DisconnectInd message. " \ +"Hook is not connected or valid, psm=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ch->psm); + + return (ENOTCONN); + } + + /* Create and send L2CA_DisconnectInd message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_DISCON_IND, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + ip = (ng_l2cap_l2ca_discon_ind_ip *)(msg->data); + ip->lcid = ch->scid; + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->l2c, NULL); + } + + return (error); +} /* ng_l2cap_l2ca_discon_ind */ + +/* + * Process L2CA_GroupCreate request from the upper layer protocol. + * XXX FIXME + */ + +int +ng_l2cap_l2ca_grp_create(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + return (ENOTSUP); +} /* ng_l2cap_l2ca_grp_create */ + +/* + * Process L2CA_GroupClose request from the upper layer protocol + * XXX FIXME + */ + +int +ng_l2cap_l2ca_grp_close(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + return (ENOTSUP); +} /* ng_l2cap_l2ca_grp_close */ + +/* + * Process L2CA_GroupAddMember request from the upper layer protocol. + * XXX FIXME + */ + +int +ng_l2cap_l2ca_grp_add_member_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + return (ENOTSUP); +} /* ng_l2cap_l2ca_grp_add_member_req */ + +/* + * Send L2CA_GroupAddMember response to the upper layer protocol. + * XXX FIXME + */ + +int +ng_l2cap_l2ca_grp_add_member_rsp(ng_l2cap_chan_p ch, u_int32_t token, + u_int16_t result) +{ + return (0); +} /* ng_l2cap_l2ca_grp_add_member_rsp */ + +/* + * Process L2CA_GroupDeleteMember request from the upper layer protocol + * XXX FIXME + */ + +int +ng_l2cap_l2ca_grp_rem_member(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + return (ENOTSUP); +} /* ng_l2cap_l2ca_grp_rem_member */ + +/* + * Process L2CA_GroupGetMembers request from the upper layer protocol + * XXX FIXME + */ + +int +ng_l2cap_l2ca_grp_get_members(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + return (ENOTSUP); +} /* ng_l2cap_l2ca_grp_get_members */ + +/* + * Process L2CA_Ping request from the upper layer protocol + */ + +int +ng_l2cap_l2ca_ping_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_ping_ip *ip = NULL; + ng_l2cap_con_p con = NULL; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + + /* Verify message */ + if (msg->header.arglen < sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_Ping request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_ping_ip *)(msg->data); + if (ip->echo_size > NG_L2CAP_MAX_ECHO_SIZE) { + NG_L2CAP_WARN( +"%s: %s - invalid L2CA_Ping request. Echo size is too big, echo_size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), ip->echo_size); + error = EMSGSIZE; + goto out; + } + + /* Check if we have connection to the unit */ + con = ng_l2cap_con_by_addr(l2cap, &ip->bdaddr); + if (con == NULL) { + /* Submit LP_ConnectReq to the lower layer */ + error = ng_l2cap_lp_con_req(l2cap, &ip->bdaddr); + if (error != 0) { + NG_L2CAP_ERR( +"%s: %s - unable to send LP_ConnectReq message, error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), error); + goto out; + } + + /* This should not fail */ + con = ng_l2cap_con_by_addr(l2cap, &ip->bdaddr); + KASSERT((con != NULL), +("%s: %s - could not find connection!\n", __func__, NG_NODE_NAME(l2cap->node))); + } + + /* Create L2CAP command descriptor */ + cmd = ng_l2cap_new_cmd(con, NULL, ng_l2cap_get_ident(con), + NG_L2CAP_ECHO_REQ, msg->header.token); + if (cmd == NULL) { + error = ENOMEM; + goto out; + } + + if (cmd->ident == NG_L2CAP_NULL_IDENT) { + ng_l2cap_free_cmd(cmd); + error = EIO; + goto out; + } + + /* Create L2CAP command packet */ + _ng_l2cap_echo_req(cmd->aux, cmd->ident, + msg->data + sizeof(*ip), ip->echo_size); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + error = ENOBUFS; + goto out; + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); +out: + return (error); +} /* ng_l2cap_l2ca_ping_req */ + +/* + * Send L2CA_Ping response to the upper layer protocol + */ + +int +ng_l2cap_l2ca_ping_rsp(ng_l2cap_con_p con, u_int32_t token, u_int16_t result, + struct mbuf *data) +{ + ng_l2cap_p l2cap = con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_ping_op *op = NULL; + int error = 0, size = 0; + + /* Check if control hook is connected and valid */ + if (l2cap->ctl == NULL || NG_HOOK_NOT_VALID(l2cap->ctl)) { + NG_L2CAP_WARN( +"%s: %s - unable to send L2CA_Ping response message. " \ +"Hook is not connected or valid\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = ENOTCONN; + goto out; + } + + size = (data == NULL)? 0 : data->m_pkthdr.len; + + /* Create and send L2CA_Ping response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_PING, + sizeof(*op) + size, M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_ping_op *)(msg->data); + op->result = result; + bcopy(&con->remote, &op->bdaddr, sizeof(op->bdaddr)); + if (data != NULL && size > 0) { + op->echo_size = size; + m_copydata(data, 0, size, (caddr_t) op + sizeof(*op)); + } + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->ctl, NULL); + } +out: + NG_FREE_M(data); + + return (error); +} /* ng_l2cap_l2ca_ping_rsp */ + +/* + * Process L2CA_GetInfo request from the upper layer protocol + */ + +int +ng_l2cap_l2ca_get_info_req(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_get_info_ip *ip = NULL; + ng_l2cap_con_p con = NULL; + ng_l2cap_cmd_p cmd = NULL; + int error = 0; + + /* Verify message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_GetInfo request message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + error = EMSGSIZE; + goto out; + } + + ip = (ng_l2cap_l2ca_get_info_ip *)(msg->data); + + /* Check if we have connection to the unit */ + con = ng_l2cap_con_by_addr(l2cap, &ip->bdaddr); + if (con == NULL) { + /* Submit LP_ConnectReq to the lower layer */ + error = ng_l2cap_lp_con_req(l2cap, &ip->bdaddr); + if (error != 0) { + NG_L2CAP_ERR( +"%s: %s - unable to send LP_ConnectReq message, error=%d\n", + __func__, NG_NODE_NAME(l2cap->node), error); + goto out; + } + + /* This should not fail */ + con = ng_l2cap_con_by_addr(l2cap, &ip->bdaddr); + KASSERT((con != NULL), +("%s: %s - could not find connection!\n", __func__, NG_NODE_NAME(l2cap->node))); + } + + /* Create L2CAP command descriptor */ + cmd = ng_l2cap_new_cmd(con, NULL, ng_l2cap_get_ident(con), + NG_L2CAP_INFO_REQ, msg->header.token); + if (cmd == NULL) { + error = ENOMEM; + goto out; + } + + if (cmd->ident == NG_L2CAP_NULL_IDENT) { + ng_l2cap_free_cmd(cmd); + error = EIO; + goto out; + } + + /* Create L2CAP command packet */ + _ng_l2cap_info_req(cmd->aux, cmd->ident, ip->info_type); + if (cmd->aux == NULL) { + ng_l2cap_free_cmd(cmd); + error = ENOBUFS; + goto out; + } + + /* Link command to the queue */ + ng_l2cap_link_cmd(con, cmd); + ng_l2cap_lp_deliver(con); +out: + return (error); +} /* ng_l2cap_l2ca_get_info_req */ + +/* + * Send L2CA_GetInfo response to the upper layer protocol + */ + +int +ng_l2cap_l2ca_get_info_rsp(ng_l2cap_con_p con, u_int32_t token, + u_int16_t result, struct mbuf *data) +{ + ng_l2cap_p l2cap = con->l2cap; + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_get_info_op *op = NULL; + int error = 0, size; + + /* Check if control hook is connected and valid */ + if (l2cap->ctl == NULL || NG_HOOK_NOT_VALID(l2cap->ctl)) { + NG_L2CAP_WARN( +"%s: %s - unable to send L2CA_GetInfo response message. " \ +"Hook is not connected or valid\n", + __func__, NG_NODE_NAME(l2cap->node)); + error = ENOTCONN; + goto out; + } + + size = (data == NULL)? 0 : data->m_pkthdr.len; + + /* Create and send L2CA_GetInfo response message */ + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_GET_INFO, + sizeof(*op) + size, M_NOWAIT); + if (msg == NULL) + error = ENOMEM; + else { + msg->header.token = token; + msg->header.flags |= NGF_RESP; + + op = (ng_l2cap_l2ca_get_info_op *)(msg->data); + op->result = result; + if (data != NULL && size > 0) { + op->info_size = size; + m_copydata(data, 0, size, (caddr_t) op + sizeof(*op)); + } + + NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->ctl, NULL); + } +out: + NG_FREE_M(data); + + return (error); +} /* ng_l2cap_l2ca_get_info_rsp */ + +/* + * Process L2CA_EnableCLT message from the upper layer protocol + * XXX convert to NGN_L2CAP_NODE_SET_FLAGS? + */ + +int +ng_l2cap_l2ca_enable_clt(ng_l2cap_p l2cap, struct ng_mesg *msg) +{ + ng_l2cap_l2ca_enable_clt_ip *ip = NULL; + int error = 0; +#if 0 + * ng_l2cap_l2ca_enable_clt_op *op = NULL; + * u_int16_t result; + * u_int32_t token; +#endif + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) { + NG_L2CAP_ALERT( +"%s: %s - invalid L2CA_EnableCLT message size, size=%d\n", + __func__, NG_NODE_NAME(l2cap->node), + msg->header.arglen); + + return (EMSGSIZE); + } + + /* Process request */ + ip = (ng_l2cap_l2ca_enable_clt_ip *) (msg->data); +#if 0 + * result = NG_L2CAP_SUCCESS; +#endif + + switch (ip->psm) + { + case 0: + /* Special case: disable/enable all PSM */ + if (ip->enable) + l2cap->flags &= ~(NG_L2CAP_CLT_SDP_DISABLED | + NG_L2CAP_CLT_RFCOMM_DISABLED | + NG_L2CAP_CLT_TCP_DISABLED); + else + l2cap->flags |= (NG_L2CAP_CLT_SDP_DISABLED | + NG_L2CAP_CLT_RFCOMM_DISABLED | + NG_L2CAP_CLT_TCP_DISABLED); + break; + + case NG_L2CAP_PSM_SDP: + if (ip->enable) + l2cap->flags &= ~NG_L2CAP_CLT_SDP_DISABLED; + else + l2cap->flags |= NG_L2CAP_CLT_SDP_DISABLED; + break; + + case NG_L2CAP_PSM_RFCOMM: + if (ip->enable) + l2cap->flags &= ~NG_L2CAP_CLT_RFCOMM_DISABLED; + else + l2cap->flags |= NG_L2CAP_CLT_RFCOMM_DISABLED; + break; + + case NG_L2CAP_PSM_TCP: + if (ip->enable) + l2cap->flags &= ~NG_L2CAP_CLT_TCP_DISABLED; + else + l2cap->flags |= NG_L2CAP_CLT_TCP_DISABLED; + break; + + default: + NG_L2CAP_ERR( +"%s: %s - unsupported PSM=%d\n", __func__, NG_NODE_NAME(l2cap->node), ip->psm); +#if 0 + * result = NG_L2CAP_PSM_NOT_SUPPORTED; +#endif + error = ENOTSUP; + break; + } + +#if 0 + * /* Create and send response message */ + * token = msg->header.token; + * NG_FREE_MSG(msg); + * NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_ENABLE_CLT, + * sizeof(*op), M_NOWAIT); + * if (msg == NULL) + * error = ENOMEM; + * else { + * msg->header.token = token; + * msg->header.flags |= NGF_RESP; + * + * op = (ng_l2cap_l2ca_enable_clt_op *)(msg->data); + * op->result = result; + * } + * + * /* Send response to control hook */ + * if (l2cap->ctl != NULL && NG_HOOK_IS_VALID(l2cap->ctl)) + * NG_SEND_MSG_HOOK(error, l2cap->node, msg, l2cap->ctl, NULL); +#endif + + return (error); +} /* ng_l2cap_l2ca_enable_clt */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_ulpi.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_ulpi.h new file mode 100644 index 0000000..6c464e6 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_ulpi.h @@ -0,0 +1,77 @@ +/* + * ng_l2cap_ulpi.h + * + * Copyright (c) Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_ulpi.h,v 1.5 2002/07/04 21:48:53 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_L2CAP_ULPI_H_ +#define _NETGRAPH_L2CAP_ULPI_H_ + +int ng_l2cap_l2ca_con_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_con_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t, u_int16_t); +int ng_l2cap_l2ca_con_rsp_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_con_rsp_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t); +int ng_l2cap_l2ca_con_ind (ng_l2cap_chan_p); + +int ng_l2cap_l2ca_cfg_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_cfg_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t); +int ng_l2cap_l2ca_cfg_rsp_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_cfg_rsp_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t); +int ng_l2cap_l2ca_cfg_ind (ng_l2cap_chan_p); + +int ng_l2cap_l2ca_write_req (ng_l2cap_p, struct mbuf *); +int ng_l2cap_l2ca_write_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t, u_int16_t); + +int ng_l2cap_l2ca_receive (ng_l2cap_con_p); +int ng_l2cap_l2ca_clt_receive (ng_l2cap_con_p); + +int ng_l2cap_l2ca_qos_ind (ng_l2cap_chan_p); + +int ng_l2cap_l2ca_discon_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_discon_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t); +int ng_l2cap_l2ca_discon_ind (ng_l2cap_chan_p); + +int ng_l2cap_l2ca_grp_create (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_grp_close (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_grp_add_member_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_grp_add_member_rsp (ng_l2cap_chan_p, u_int32_t, u_int16_t); +int ng_l2cap_l2ca_grp_rem_member (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_grp_get_members (ng_l2cap_p, struct ng_mesg *); + +int ng_l2cap_l2ca_ping_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_ping_rsp (ng_l2cap_con_p, u_int32_t, u_int16_t, + struct mbuf *); + +int ng_l2cap_l2ca_get_info_req (ng_l2cap_p, struct ng_mesg *); +int ng_l2cap_l2ca_get_info_rsp (ng_l2cap_con_p, u_int32_t, u_int16_t, + struct mbuf *); + +int ng_l2cap_l2ca_enable_clt (ng_l2cap_p, struct ng_mesg *); + +#endif /* ndef _NETGRAPH_L2CAP_ULPI_H_ */ + diff --git a/sys/netgraph/bluetooth/l2cap/ng_l2cap_var.h b/sys/netgraph/bluetooth/l2cap/ng_l2cap_var.h new file mode 100644 index 0000000..057fa28 --- /dev/null +++ b/sys/netgraph/bluetooth/l2cap/ng_l2cap_var.h @@ -0,0 +1,182 @@ +/* + * ng_l2cap_var.h + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_l2cap_var.h,v 1.13 2002/09/04 21:38:38 max Exp $ + * $FreeBSD$ + */ + +#ifndef _NETGRAPH_L2CAP_VAR_H_ +#define _NETGRAPH_L2CAP_VAR_H_ 1 + +/* MALLOC decalation */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DECLARE(M_NETGRAPH_L2CAP); +#else +#define M_NETGRAPH_L2CAP M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Debug */ +#define NG_L2CAP_ALERT if (l2cap->debug >= NG_L2CAP_ALERT_LEVEL) printf +#define NG_L2CAP_ERR if (l2cap->debug >= NG_L2CAP_ERR_LEVEL) printf +#define NG_L2CAP_WARN if (l2cap->debug >= NG_L2CAP_WARN_LEVEL) printf +#define NG_L2CAP_INFO if (l2cap->debug >= NG_L2CAP_INFO_LEVEL) printf + +/* Wrapper around m_pullup */ +#define NG_L2CAP_M_PULLUP(m, s) \ + do { \ + if ((m)->m_len < (s)) \ + (m) = m_pullup((m), (s)); \ + if ((m) == NULL) \ + NG_L2CAP_ALERT("%s: %s - m_pullup(%d) failed\n", \ + __func__, NG_NODE_NAME(l2cap->node), (s)); \ + } while (0) + +/* + * L2CAP signaling command ident's are assigned relative to the connection, + * because there is only one signaling channel (cid == 0x01) for every + * connection. So up to 254 (0xff - 0x01) L2CAP commands can be pending at the + * same time for the same connection. + */ + +#define NG_L2CAP_NULL_IDENT 0x00 /* DO NOT USE THIS IDENT */ +#define NG_L2CAP_FIRST_IDENT 0x01 /* dynamically alloc. (start) */ +#define NG_L2CAP_LAST_IDENT 0xff /* dynamically alloc. (end) */ + +/* + * L2CAP (Node private) + */ + +struct ng_l2cap_con; +struct ng_l2cap_chan; + +typedef struct ng_l2cap { + node_p node; /* node ptr */ + + ng_l2cap_node_debug_ep debug; /* debug level */ + ng_l2cap_node_flags_ep flags; /* L2CAP node flags */ + + bdaddr_t bdaddr; /* unit BDADDR */ + u_int16_t pkt_size; /* max. ACL packet size */ + u_int16_t num_pkts; /* out queue size */ + + hook_p hci; /* HCI downstream hook */ + hook_p l2c; /* L2CAP upstream hook */ + hook_p ctl; /* control hook */ + + LIST_HEAD(, ng_l2cap_con) con_list; /* ACL connections */ + + u_int16_t cid; /* last allocated CID */ + LIST_HEAD(, ng_l2cap_chan) chan_list; /* L2CAP channels */ +} ng_l2cap_t; +typedef ng_l2cap_t * ng_l2cap_p; + +/* + * L2CAP connection descriptor + */ + +struct ng_l2cap_cmd; + +typedef struct ng_l2cap_con { + ng_l2cap_p l2cap; /* pointer to L2CAP */ + + u_int16_t state; /* ACL connection state */ + + bdaddr_t remote; /* remote unit address */ + u_int16_t con_handle; /* ACL connection handle */ + struct callout_handle con_timo; /* connection timeout */ + + u_int8_t ident; /* last allocated ident */ + TAILQ_HEAD(, ng_l2cap_cmd) cmd_list; /* pending L2CAP cmds */ + + struct mbuf *tx_pkt; /* xmitted L2CAP packet */ + int pending; /* num. of pending pkts */ + + struct mbuf *rx_pkt; /* received L2CAP packet */ + int rx_pkt_len; /* packet len. so far */ + + LIST_ENTRY(ng_l2cap_con) next; /* link */ +} ng_l2cap_con_t; +typedef ng_l2cap_con_t * ng_l2cap_con_p; + +/* + * L2CAP channel descriptor + */ + +typedef struct ng_l2cap_chan { + ng_l2cap_con_p con; /* pointer to connection */ + + u_int16_t state; /* channel state */ + + u_int8_t cfg_state; /* configuration state */ +#define NG_L2CAP_CFG_IN (1 << 0) /* incoming cfg path done */ +#define NG_L2CAP_CFG_OUT (1 << 1) /* outgoing cfg path done */ +#define NG_L2CAP_CFG_BOTH (NG_L2CAP_CFG_IN|NG_L2CAP_CFG_OUT) + + u_int8_t ident; /* last L2CAP req. ident */ + + u_int16_t psm; /* channel PSM */ + u_int16_t scid; /* source channel ID */ + u_int16_t dcid; /* destination channel ID */ + + u_int16_t imtu; /* incoming channel MTU */ + ng_l2cap_flow_t iflow; /* incoming flow control */ + + u_int16_t omtu; /* outgoing channel MTU */ + ng_l2cap_flow_t oflow; /* outgoing flow control */ + + u_int16_t flush_timo; /* flush timeout */ + u_int16_t link_timo; /* link timeout */ + + LIST_ENTRY(ng_l2cap_chan) next; /* link */ +} ng_l2cap_chan_t; +typedef ng_l2cap_chan_t * ng_l2cap_chan_p; + +/* + * L2CAP command descriptor + */ + +typedef struct ng_l2cap_cmd { + ng_l2cap_con_p con; /* L2CAP connection */ + ng_l2cap_chan_p ch; /* L2CAP channel */ + + u_int16_t flags; /* command flags */ +#define NG_L2CAP_CMD_PENDING (1 << 0) /* command is pending */ + + u_int8_t code; /* L2CAP command opcode */ + u_int8_t ident; /* L2CAP command ident */ + u_int32_t token; /* L2CA message token */ + + struct callout_handle timo; /* RTX/ERTX timeout */ + + struct mbuf *aux; /* optional data */ + + TAILQ_ENTRY(ng_l2cap_cmd) next; /* link */ +} ng_l2cap_cmd_t; +typedef ng_l2cap_cmd_t * ng_l2cap_cmd_p; + +#endif /* ndef _NETGRAPH_L2CAP_VAR_H_ */ + diff --git a/sys/netgraph/bluetooth/socket/TODO b/sys/netgraph/bluetooth/socket/TODO new file mode 100644 index 0000000..97ba9ed --- /dev/null +++ b/sys/netgraph/bluetooth/socket/TODO @@ -0,0 +1,15 @@ +$Id: TODO,v 1.4 2002/09/06 21:03:56 max Exp $ +$FreeBSD$ + +FIXME/TODO list + +1) Deal properly with "shutdown"s and hook "disconnect"s + + How to let L2CAP node that user called "shutdown" on node or + have "disconnect"ed downstream hook. Should L2CAP node deal + with it? + +2) Locking + + It is OK to use mutexes, but is there a better way? + diff --git a/sys/netgraph/bluetooth/socket/ng_btsocket.c b/sys/netgraph/bluetooth/socket/ng_btsocket.c new file mode 100644 index 0000000..f3eb8ff --- /dev/null +++ b/sys/netgraph/bluetooth/socket/ng_btsocket.c @@ -0,0 +1,258 @@ +/* + * ng_btsocket.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket.c,v 1.20 2002/09/13 17:56:58 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/errno.h> +#include <sys/domain.h> +#include <sys/kernel.h> +#include <sys/lock.h> +#include <sys/mutex.h> +#include <sys/protosw.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/sysctl.h> +#include <bitstring.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_btsocket.h" +#include "ng_btsocket_hci_raw.h" +#include "ng_btsocket_l2cap.h" + +static int ng_btsocket_modevent (module_t, int, void *); +extern struct domain ng_btsocket_domain; + +/* + * Bluetooth raw HCI sockets + */ + +static struct pr_usrreqs ng_btsocket_hci_raw_usrreqs = { + ng_btsocket_hci_raw_abort, /* abort */ + pru_accept_notsupp, /* accept */ + ng_btsocket_hci_raw_attach, /* attach */ + ng_btsocket_hci_raw_bind, /* bind */ + ng_btsocket_hci_raw_connect, /* connect */ + pru_connect2_notsupp, /* connect2 */ + ng_btsocket_hci_raw_control, /* control */ + ng_btsocket_hci_raw_detach, /* detach */ + ng_btsocket_hci_raw_disconnect, /* disconnect */ + pru_listen_notsupp, /* listen */ + ng_btsocket_hci_raw_peeraddr, /* peeraddr */ + pru_rcvd_notsupp, /* rcvd */ + pru_rcvoob_notsupp, /* rcvoob */ + ng_btsocket_hci_raw_send, /* send */ + pru_sense_null, /* send */ + NULL, /* shutdown */ + ng_btsocket_hci_raw_sockaddr, /* sockaddr */ + sosend, + soreceive, + sopoll +}; + +/* + * Bluetooth raw L2CAP sockets + */ + +static struct pr_usrreqs ng_btsocket_l2cap_raw_usrreqs = { + ng_btsocket_l2cap_raw_abort, /* abort */ + pru_accept_notsupp, /* accept */ + ng_btsocket_l2cap_raw_attach, /* attach */ + ng_btsocket_l2cap_raw_bind, /* bind */ + ng_btsocket_l2cap_raw_connect, /* connect */ + pru_connect2_notsupp, /* connect2 */ + ng_btsocket_l2cap_raw_control, /* control */ + ng_btsocket_l2cap_raw_detach, /* detach */ + ng_btsocket_l2cap_raw_disconnect, /* disconnect */ + pru_listen_notsupp, /* listen */ + ng_btsocket_l2cap_raw_peeraddr, /* peeraddr */ + pru_rcvd_notsupp, /* rcvd */ + pru_rcvoob_notsupp, /* rcvoob */ + ng_btsocket_l2cap_raw_send, /* send */ + pru_sense_null, /* send */ + NULL, /* shutdown */ + ng_btsocket_l2cap_raw_sockaddr, /* sockaddr */ + sosend, + soreceive, + sopoll +}; + +/* + * Bluetooth SEQPACKET L2CAP sockets + */ + +static struct pr_usrreqs ng_btsocket_l2cap_usrreqs = { + ng_btsocket_l2cap_abort, /* abort */ + ng_btsocket_l2cap_accept, /* accept */ + ng_btsocket_l2cap_attach, /* attach */ + ng_btsocket_l2cap_bind, /* bind */ + ng_btsocket_l2cap_connect, /* connect */ + pru_connect2_notsupp, /* connect2 */ + ng_btsocket_l2cap_control, /* control */ + ng_btsocket_l2cap_detach, /* detach */ + ng_btsocket_l2cap_disconnect, /* disconnect */ + ng_btsocket_l2cap_listen, /* listen */ + ng_btsocket_l2cap_peeraddr, /* peeraddr */ + pru_rcvd_notsupp, /* rcvd */ + pru_rcvoob_notsupp, /* rcvoob */ + ng_btsocket_l2cap_send, /* send */ + pru_sense_null, /* send */ + NULL, /* shutdown */ + ng_btsocket_l2cap_sockaddr, /* sockaddr */ + sosend, + soreceive, + sopoll +}; + +/* + * Definitions of protocols supported in the BLUETOOTH domain + */ + +static struct protosw ng_btsocket_protosw[] = { +{ + SOCK_RAW, /* protocol type */ + &ng_btsocket_domain, /* backpointer to domain */ + BLUETOOTH_PROTO_HCI, /* protocol */ + PR_ATOMIC | PR_ADDR, /* flags */ + NULL, NULL, NULL, /* input, output, ctlinput */ + ng_btsocket_hci_raw_ctloutput, /* ctloutput */ + NULL, /* ousrreq() */ + ng_btsocket_hci_raw_init, /* init */ + NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */ + &ng_btsocket_hci_raw_usrreqs, /* usrreq table (above) */ + /* { NULL } */ /* pfh (protocol filter head?) */ +}, +{ + SOCK_RAW, /* protocol type */ + &ng_btsocket_domain, /* backpointer to domain */ + BLUETOOTH_PROTO_L2CAP, /* protocol */ + PR_ATOMIC | PR_ADDR, /* flags */ + NULL, NULL, NULL, /* input, output, ctlinput */ + NULL, /* ctloutput */ + NULL, /* ousrreq() */ + ng_btsocket_l2cap_raw_init, /* init */ + NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */ + &ng_btsocket_l2cap_raw_usrreqs, /* usrreq table (above) */ + /* { NULL } */ /* pfh (protocol filter head?) */ +}, +{ + SOCK_SEQPACKET, /* protocol type */ + &ng_btsocket_domain, /* backpointer to domain */ + BLUETOOTH_PROTO_L2CAP, /* protocol */ + PR_ATOMIC | PR_CONNREQUIRED, /* flags */ + NULL, NULL, NULL, /* input, output, ctlinput */ + ng_btsocket_l2cap_ctloutput, /* ctloutput */ + NULL, /* ousrreq() */ + ng_btsocket_l2cap_init, /* init */ + NULL, NULL, NULL, /* fasttimeo, slowtimo, drain */ + &ng_btsocket_l2cap_usrreqs, /* usrreq table (above) */ + /* { NULL } */ /* pfh (protocol filter head?) */ +} +}; +#define ng_btsocket_protosw_size \ + (sizeof(ng_btsocket_protosw)/sizeof(ng_btsocket_protosw[0])) +#define ng_btsocket_protosw_end \ + &ng_btsocket_protosw[ng_btsocket_protosw_size] + +/* + * BLUETOOTH domain + */ + +struct domain ng_btsocket_domain = { + AF_BLUETOOTH, /* family */ + "bluetooth", /* domain name */ + NULL, /* init() */ + NULL, /* externalize() */ + NULL, /* dispose() */ + ng_btsocket_protosw, /* protosw entry */ + ng_btsocket_protosw_end, /* end of protosw entries */ + NULL, /* next domain in list */ + NULL, /* rtattach() */ + 0, /* arg to rtattach in bits */ + 0 /* maxrtkey */ +}; + +/* + * Socket sysctl tree + */ + +SYSCTL_NODE(_net_bluetooth_hci, OID_AUTO, sockets, CTLFLAG_RW, + 0, "Bluetooth HCI sockets family"); +SYSCTL_NODE(_net_bluetooth_l2cap, OID_AUTO, sockets, CTLFLAG_RW, + 0, "Bluetooth L2CAP sockets family"); + +/* + * Module + */ + +static moduledata_t ng_btsocket_mod = { + "ng_btsocket", + ng_btsocket_modevent, + NULL +}; + +DECLARE_MODULE(ng_btsocket, ng_btsocket_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); +MODULE_VERSION(ng_btsocket, NG_BLUETOOTH_VERSION); +MODULE_DEPEND(ng_btsocket, ng_bluetooth, NG_BLUETOOTH_VERSION, + NG_BLUETOOTH_VERSION, NG_BLUETOOTH_VERSION); +MODULE_DEPEND(ng_btsocket, netgraph, NG_ABI_VERSION, + NG_ABI_VERSION, NG_ABI_VERSION); + +/* + * Handle loading and unloading for this node type. + * This is to handle auxiliary linkages (e.g protocol domain addition). + */ + +static int +ng_btsocket_modevent(module_t mod, int event, void *data) +{ + int error = 0; + + switch (event) { + case MOD_LOAD: + net_add_domain(&ng_btsocket_domain); + break; + + case MOD_UNLOAD: + /* XXX can't unload protocol domain yet */ + error = EBUSY; + break; + + default: + error = EOPNOTSUPP; + break; + } + + return (error); +} /* ng_btsocket_modevent */ + diff --git a/sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c b/sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c new file mode 100644 index 0000000..69fcbf0 --- /dev/null +++ b/sys/netgraph/bluetooth/socket/ng_btsocket_hci_raw.c @@ -0,0 +1,1320 @@ +/* + * ng_btsocket_hci_raw.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket_hci_raw.c,v 1.3 2002/11/12 22:31:39 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/domain.h> +#include <sys/errno.h> +#include <sys/filedesc.h> +#include <sys/ioccom.h> +#include <sys/kernel.h> +#include <sys/lock.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/mutex.h> +#include <sys/protosw.h> +#include <sys/queue.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/sysctl.h> +#include <sys/taskqueue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <bitstring.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_btsocket.h" +#include "ng_btsocket_hci_raw.h" + +/* MALLOC define */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DEFINE(M_NETGRAPH_BTSOCKET_HCI_RAW, "netgraph_btsocks_hci_raw", + "Netgraph Bluetooth raw HCI sockets"); +#else +#define M_NETGRAPH_BTSOCKET_HCI_RAW M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Netgraph node methods */ +static ng_constructor_t ng_btsocket_hci_raw_node_constructor; +static ng_rcvmsg_t ng_btsocket_hci_raw_node_rcvmsg; +static ng_shutdown_t ng_btsocket_hci_raw_node_shutdown; +static ng_newhook_t ng_btsocket_hci_raw_node_newhook; +static ng_connect_t ng_btsocket_hci_raw_node_connect; +static ng_rcvdata_t ng_btsocket_hci_raw_node_rcvdata; +static ng_disconnect_t ng_btsocket_hci_raw_node_disconnect; + +static void ng_btsocket_hci_raw_input (void *, int); +static void ng_btsocket_hci_raw_output(node_p, hook_p, void *, int); +static void ng_btsocket_hci_raw_savctl(ng_btsocket_hci_raw_pcb_p, + struct mbuf **, + struct mbuf *); + +/* Netgraph type descriptor */ +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_BTSOCKET_HCI_RAW_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_btsocket_hci_raw_node_constructor, /* constructor */ + ng_btsocket_hci_raw_node_rcvmsg, /* control message */ + ng_btsocket_hci_raw_node_shutdown, /* destructor */ + ng_btsocket_hci_raw_node_newhook, /* new hook */ + NULL, /* find hook */ + ng_btsocket_hci_raw_node_connect, /* connect hook */ + ng_btsocket_hci_raw_node_rcvdata, /* data */ + ng_btsocket_hci_raw_node_disconnect, /* disconnect hook */ + NULL /* node command list */ +}; + +/* Globals */ +extern int ifqmaxlen; +static u_int32_t ng_btsocket_hci_raw_debug_level; +static u_int32_t ng_btsocket_hci_raw_ioctl_timeout; +static node_p ng_btsocket_hci_raw_node; +static struct ng_bt_itemq ng_btsocket_hci_raw_queue; +static struct mtx ng_btsocket_hci_raw_queue_mtx; +static struct task ng_btsocket_hci_raw_task; +static LIST_HEAD(, ng_btsocket_hci_raw_pcb) ng_btsocket_hci_raw_sockets; +static struct mtx ng_btsocket_hci_raw_sockets_mtx; +static u_int32_t ng_btsocket_hci_raw_token; +static struct mtx ng_btsocket_hci_raw_token_mtx; + +/* Sysctl tree */ +SYSCTL_DECL(_net_bluetooth_hci_sockets); +SYSCTL_NODE(_net_bluetooth_hci_sockets, OID_AUTO, raw, CTLFLAG_RW, + 0, "Bluetooth raw HCI sockets family"); +SYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, debug_level, CTLFLAG_RW, + &ng_btsocket_hci_raw_debug_level, NG_BTSOCKET_WARN_LEVEL, + "Bluetooth raw HCI sockets debug level"); +SYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, ioctl_timeout, CTLFLAG_RW, + &ng_btsocket_hci_raw_ioctl_timeout, 5, + "Bluetooth raw HCI sockets ioctl timeout"); +SYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, queue_len, CTLFLAG_RD, + &ng_btsocket_hci_raw_queue.len, 0, + "Bluetooth raw HCI sockets input queue length"); +SYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, queue_maxlen, CTLFLAG_RD, + &ng_btsocket_hci_raw_queue.maxlen, 0, + "Bluetooth raw HCI sockets input queue max. length"); +SYSCTL_INT(_net_bluetooth_hci_sockets_raw, OID_AUTO, queue_drops, CTLFLAG_RD, + &ng_btsocket_hci_raw_queue.drops, 0, + "Bluetooth raw HCI sockets input queue drops"); + +/* Debug */ +#define NG_BTSOCKET_HCI_RAW_INFO \ + if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_INFO_LEVEL) \ + printf + +#define NG_BTSOCKET_HCI_RAW_WARN \ + if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_WARN_LEVEL) \ + printf + +#define NG_BTSOCKET_HCI_RAW_ERR \ + if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_ERR_LEVEL) \ + printf + +#define NG_BTSOCKET_HCI_RAW_ALERT \ + if (ng_btsocket_hci_raw_debug_level >= NG_BTSOCKET_ALERT_LEVEL) \ + printf + +/**************************************************************************** + **************************************************************************** + ** Netgraph specific + **************************************************************************** + ****************************************************************************/ + +/* + * Netgraph node constructor. Do not allow to create node of this type. + */ + +static int +ng_btsocket_hci_raw_node_constructor(node_p node) +{ + return (EINVAL); +} /* ng_btsocket_hci_raw_node_constructor */ + +/* + * Netgraph node destructor. Just let old node go and create new fresh one. + */ + +static int +ng_btsocket_hci_raw_node_shutdown(node_p node) +{ + int error = 0; + + NG_NODE_UNREF(node); + + error = ng_make_node_common(&typestruct, &ng_btsocket_hci_raw_node); + if (error != 0) { + NG_BTSOCKET_HCI_RAW_ALERT( +"%s: Could not create Netgraph node, error=%d\n", __func__, error); + + ng_btsocket_hci_raw_node = NULL; + + return (ENOMEM); + } + + error = ng_name_node(ng_btsocket_hci_raw_node, + NG_BTSOCKET_HCI_RAW_NODE_TYPE); + if (error != 0) { + NG_BTSOCKET_HCI_RAW_ALERT( +"%s: Could not name Netgraph node, error=%d\n", __func__, error); + + NG_NODE_UNREF(ng_btsocket_hci_raw_node); + ng_btsocket_hci_raw_node = NULL; + + return (EINVAL); + } + + return (0); +} /* ng_btsocket_hci_raw_node_shutdown */ + +/* + * Create new hook. Just say "yes" + */ + +static int +ng_btsocket_hci_raw_node_newhook(node_p node, hook_p hook, char const *name) +{ + return (0); +} /* ng_btsocket_hci_raw_node_newhook */ + +/* + * Connect hook. Just say "yes" + */ + +static int +ng_btsocket_hci_raw_node_connect(hook_p hook) +{ + return (0); +} /* ng_btsocket_hci_raw_node_connect */ + +/* + * Disconnect hook + */ + +static int +ng_btsocket_hci_raw_node_disconnect(hook_p hook) +{ + return (0); +} /* ng_btsocket_hci_raw_node_disconnect */ + +/* + * Receive control message. + * Make sure it is a message from HCI node and it is a response. + * Enqueue item and schedule input task. + */ + +static int +ng_btsocket_hci_raw_node_rcvmsg(node_p node, item_p item, hook_p lasthook) +{ + struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ + int error = 0; + + if (msg != NULL && + msg->header.typecookie == NGM_HCI_COOKIE && + msg->header.flags & NGF_RESP) { + mtx_lock(&ng_btsocket_hci_raw_queue_mtx); + if (NG_BT_ITEMQ_FULL(&ng_btsocket_hci_raw_queue)) { + NG_BTSOCKET_HCI_RAW_ERR( +"%s: Input queue is full\n", __func__); + + NG_BT_ITEMQ_DROP(&ng_btsocket_hci_raw_queue); + NG_FREE_ITEM(item); + error = ENOBUFS; + } else { + NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_hci_raw_queue, item); + error = taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_hci_raw_task); + } + mtx_unlock(&ng_btsocket_hci_raw_queue_mtx); + } else { + NG_FREE_ITEM(item); + error = EINVAL; + } + + return (error); +} /* ng_btsocket_hci_raw_node_rcvmsg */ + +/* + * Receive packet from the one of our hook. + * Prepend every packet with sockaddr_hci and record sender's node name. + * Enqueue item and schedule input task. + */ + +static int +ng_btsocket_hci_raw_node_rcvdata(hook_p hook, item_p item) +{ + struct mbuf *nam = NULL; + int error; + + MGET(nam, M_DONTWAIT, MT_SONAME); + if (nam != NULL) { + struct sockaddr_hci *sa = mtod(nam, struct sockaddr_hci *); + + nam->m_len = sizeof(struct sockaddr_hci); + + sa->hci_len = sizeof(*sa); + sa->hci_family = AF_BLUETOOTH; + strncpy(sa->hci_node, NG_PEER_NODE_NAME(hook), + sizeof(sa->hci_node)); + sa->hci_node[sizeof(sa->hci_node) - 1] = 0; /* sanity */ + + NGI_GET_M(item, nam->m_next); + NGI_M(item) = nam; + + mtx_lock(&ng_btsocket_hci_raw_queue_mtx); + if (NG_BT_ITEMQ_FULL(&ng_btsocket_hci_raw_queue)) { + NG_BTSOCKET_HCI_RAW_ERR( +"%s: Input queue is full\n", __func__); + + NG_BT_ITEMQ_DROP(&ng_btsocket_hci_raw_queue); + NG_FREE_ITEM(item); + error = ENOBUFS; + } else { + NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_hci_raw_queue, item); + error = taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_hci_raw_task); + } + mtx_unlock(&ng_btsocket_hci_raw_queue_mtx); + } else { + NG_BTSOCKET_HCI_RAW_ERR( +"%s: Failed to allocate address mbuf\n", __func__); + + NG_FREE_ITEM(item); + error = ENOBUFS; + } + + return (error); +} /* ng_btsocket_hci_raw_node_rcvdata */ + +/**************************************************************************** + **************************************************************************** + ** Sockets specific + **************************************************************************** + ****************************************************************************/ + +/* + * Get next token + */ + +static void +ng_btsocket_hci_raw_get_token(u_int32_t *token) +{ + mtx_lock(&ng_btsocket_hci_raw_token_mtx); + + if (++ ng_btsocket_hci_raw_token == 0) + ng_btsocket_hci_raw_token = 1; + + *token = ng_btsocket_hci_raw_token; + + mtx_unlock(&ng_btsocket_hci_raw_token_mtx); +} /* ng_btsocket_hci_raw_token */ + +/* + * Send Netgraph message to the node - do not expect reply + */ + +static int +ng_btsocket_raw_send_ngmsg(char *path, int cmd, void *arg, int arglen) +{ + struct ng_mesg *msg = NULL; + int error = 0; + + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, cmd, arglen, M_WAITOK); + if (msg == NULL) + return (ENOMEM); + + if (arg != NULL && arglen > 0) + bcopy(arg, msg->data, arglen); + + NG_SEND_MSG_PATH(error, ng_btsocket_hci_raw_node, msg, path, NULL); + + return (error); +} /* ng_btsocket_raw_send_ngmsg */ + +/* + * Send Netgraph message to the node (no data) and wait for reply + */ + +static int +ng_btsocket_raw_send_sync_ngmsg(ng_btsocket_hci_raw_pcb_p pcb, char *path, + int cmd, void *rsp, int rsplen) +{ + struct ng_mesg *msg = NULL; + int error = 0; + + ng_btsocket_hci_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, cmd, 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + return (ENOMEM); + } + msg->header.token = pcb->token; + + NG_SEND_MSG_PATH(error, ng_btsocket_hci_raw_node, msg, path, NULL); + if (error != 0) { + pcb->token = 0; + return (error); + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "hcictl", + ng_btsocket_hci_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + return (error); + } + + if (pcb->msg != NULL && pcb->msg->header.cmd == cmd) + bcopy(pcb->msg->data, rsp, rsplen); + else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + + return (0); +} /* ng_btsocket_raw_send_sync_ngmsg */ + +/* + * Create control information for the packet + */ + +static void +ng_btsocket_hci_raw_savctl(ng_btsocket_hci_raw_pcb_p pcb, struct mbuf **ctl, + struct mbuf *m) +{ + int dir; + struct timeval tv; + + if (pcb->flags & NG_BTSOCKET_HCI_RAW_DIRECTION) { + dir = (m->m_flags & M_PROTO1)? 1 : 0; + *ctl = sbcreatecontrol((caddr_t) &dir, sizeof(dir), + SCM_HCI_RAW_DIRECTION, SOL_HCI_RAW); + if (*ctl != NULL) + ctl = &((*ctl)->m_next); + } + + if (pcb->so->so_options & SO_TIMESTAMP) { + microtime(&tv); + *ctl = sbcreatecontrol((caddr_t) &tv, sizeof(tv), + SCM_TIMESTAMP, SOL_SOCKET); + if (*ctl != NULL) + ctl = &((*ctl)->m_next); + } +} /* ng_btsocket_hci_raw_savctl */ + +/* + * Raw HCI sockets data input routine + */ + +static void +ng_btsocket_hci_raw_data_input(struct mbuf *nam) +{ + ng_btsocket_hci_raw_pcb_p pcb = NULL; + struct mbuf *m0 = NULL, *m = NULL; + struct sockaddr_hci *sa = NULL; + bitstr_t *mask = NULL; + int bit; + + m0 = nam->m_next; + nam->m_next = NULL; + + KASSERT((nam->m_type == MT_SONAME), + ("%s: m_type=%d\n", __func__, nam->m_type)); + KASSERT((m0->m_flags & M_PKTHDR), + ("%s: m_flags=%#x\n", __func__, m0->m_flags)); + + sa = mtod(nam, struct sockaddr_hci *); + + mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); + + LIST_FOREACH(pcb, &ng_btsocket_hci_raw_sockets, next) { + /* + * If socket was bound then check address and + * make sure it matches. + */ + + if (pcb->addr.hci_node[0] != 0 && + strcmp(sa->hci_node, pcb->addr.hci_node) != 0) + continue; + + /* + * Check packet agains socket filter + * XXX do we have to call m_pullup() here? + */ + + switch (*mtod(m0, u_int8_t *)) { + case NG_HCI_CMD_PKT: + case NG_HCI_ACL_DATA_PKT: + case NG_HCI_SCO_DATA_PKT: + mask = pcb->filter.packet_mask; + bit = *mtod(m0, u_int8_t *) - 1; + break; + + case NG_HCI_EVENT_PKT: + mask = pcb->filter.event_mask; + bit = mtod(m0, ng_hci_event_pkt_t *)->event - 1; + break; + + default: + KASSERT(0, +("%s: invalid packet type=%#x\n", __func__, *mtod(m0, u_int8_t *))); + + mask = NULL; + bit = 0; + break; + } + + if (mask == NULL || !bit_test(mask, bit)) + continue; + + /* + * Make a copy of the packet, append to the socket's + * receive queue and wakeup socket. sbappendaddr() + * will check if socket has enough buffer space. + */ + + m = m_dup(m0, M_DONTWAIT); + if (m != NULL) { + struct mbuf *ctl = NULL; + + ng_btsocket_hci_raw_savctl(pcb, &ctl, m); + + if (sbappendaddr(&pcb->so->so_rcv, + (struct sockaddr *) sa, m, ctl)) + sorwakeup(pcb->so); + else { + NG_BTSOCKET_HCI_RAW_WARN( +"%s: sbappendadd() failed\n", __func__); + + NG_FREE_M(m); + NG_FREE_M(ctl); + } + } + } + + mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); + + NG_FREE_M(nam); + NG_FREE_M(m0); +} /* ng_btsocket_hci_raw_data_input */ + +/* + * Raw HCI sockets message input routine + */ + +static void +ng_btsocket_hci_raw_msg_input(struct ng_mesg *msg) +{ + ng_btsocket_hci_raw_pcb_p pcb = NULL; + + if (msg->header.token != 0) { + mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); + + LIST_FOREACH(pcb, &ng_btsocket_hci_raw_sockets, next) { + if (msg->header.token == pcb->token) { + pcb->msg = msg; + msg = NULL; + wakeup(&pcb->msg); + break; + } + } + + mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); + } + + NG_FREE_MSG(msg); /* checks for != NULL */ +} /* ng_btsocket_hci_raw_msg_input */ + +/* + * Raw HCI sockets input routines + */ + +static void +ng_btsocket_hci_raw_input(void *context, int pending) +{ + item_p item = NULL; + + for (;;) { + mtx_lock(&ng_btsocket_hci_raw_queue_mtx); + NG_BT_ITEMQ_DEQUEUE(&ng_btsocket_hci_raw_queue, item); + mtx_unlock(&ng_btsocket_hci_raw_queue_mtx); + + if (item == NULL) + break; + + switch(item->el_flags & NGQF_TYPE) { + case NGQF_DATA: { + struct mbuf *m = NULL; + + NGI_GET_M(item, m); + ng_btsocket_hci_raw_data_input(m); + } break; + + case NGQF_MESG: { + struct ng_mesg *msg = NULL; + + NGI_GET_MSG(item, msg); + ng_btsocket_hci_raw_msg_input(msg); + } break; + + default: + KASSERT(0, +("%s: invalid item type=%ld\n", __func__, (item->el_flags & NGQF_TYPE))); + break; + } + + NG_FREE_ITEM(item); + } +} /* ng_btsocket_hci_raw_input */ + +/* + * Raw HCI sockets output routine + */ + +static void +ng_btsocket_hci_raw_output(node_p node, hook_p hook, void *arg1, int arg2) +{ + struct mbuf *nam = (struct mbuf *) arg1, *m = NULL; + struct sockaddr_hci *sa = NULL; + int error; + + m = nam->m_next; + nam->m_next = NULL; + + KASSERT((nam->m_type == MT_SONAME), + ("%s: m_type=%d\n", __func__, nam->m_type)); + KASSERT((m->m_flags & M_PKTHDR), + ("%s: m_flags=%#x\n", __func__, m->m_flags)); + + sa = mtod(nam, struct sockaddr_hci *); + + /* + * Find downstream hook + * XXX For now access node hook list directly. Should be safe because + * we used ng_send_fn() and we should have exclusive lock on the node. + */ + + LIST_FOREACH(hook, &node->nd_hooks, hk_hooks) { + if (hook == NULL || NG_HOOK_NOT_VALID(hook) || + NG_NODE_NOT_VALID(NG_PEER_NODE(hook))) + continue; + + if (strcmp(sa->hci_node, NG_PEER_NODE_NAME(hook)) == 0) { + NG_SEND_DATA_ONLY(error, hook, m); /* sets m to NULL */ + break; + } + } + + NG_FREE_M(nam); /* check for != NULL */ + NG_FREE_M(m); +} /* ng_btsocket_hci_raw_output */ + +/* + * Initialize everything + */ + +void +ng_btsocket_hci_raw_init(void) +{ + int error = 0; + + ng_btsocket_hci_raw_node = NULL; + ng_btsocket_hci_raw_debug_level = NG_BTSOCKET_WARN_LEVEL; + ng_btsocket_hci_raw_ioctl_timeout = 5; + + /* Register Netgraph node type */ + error = ng_newtype(&typestruct); + if (error != 0) { + NG_BTSOCKET_HCI_RAW_ALERT( +"%s: Could not register Netgraph node type, error=%d\n", __func__, error); + + return; + } + + /* Create Netgrapg node */ + error = ng_make_node_common(&typestruct, &ng_btsocket_hci_raw_node); + if (error != 0) { + NG_BTSOCKET_HCI_RAW_ALERT( +"%s: Could not create Netgraph node, error=%d\n", __func__, error); + + ng_btsocket_hci_raw_node = NULL; + + return; + } + + error = ng_name_node(ng_btsocket_hci_raw_node, + NG_BTSOCKET_HCI_RAW_NODE_TYPE); + if (error != 0) { + NG_BTSOCKET_HCI_RAW_ALERT( +"%s: Could not name Netgraph node, error=%d\n", __func__, error); + + NG_NODE_UNREF(ng_btsocket_hci_raw_node); + ng_btsocket_hci_raw_node = NULL; + + return; + } + + /* Create input queue */ + NG_BT_ITEMQ_INIT(&ng_btsocket_hci_raw_queue, ifqmaxlen); + mtx_init(&ng_btsocket_hci_raw_queue_mtx, + "btsocks_hci_raw_queue_mtx", NULL, MTX_DEF); + TASK_INIT(&ng_btsocket_hci_raw_task, 0, + ng_btsocket_hci_raw_input, NULL); + + /* Create list of sockets */ + LIST_INIT(&ng_btsocket_hci_raw_sockets); + mtx_init(&ng_btsocket_hci_raw_sockets_mtx, + "btsocks_hci_raw_sockets_mtx", NULL, MTX_DEF); + + /* Tokens */ + ng_btsocket_hci_raw_token = 0; + mtx_init(&ng_btsocket_hci_raw_token_mtx, + "btsocks_hci_raw_token_mtx", NULL, MTX_DEF); +} /* ng_btsocket_hci_raw_init */ + +/* + * Abort connection on socket + */ + +int +ng_btsocket_hci_raw_abort(struct socket *so) +{ + soisdisconnected(so); + + return (ng_btsocket_hci_raw_detach(so)); +} /* ng_btsocket_hci_raw_abort */ + +/* + * Create new raw HCI socket + */ + +int +ng_btsocket_hci_raw_attach(struct socket *so, int proto, struct thread *td) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + int error = 0; + + if (pcb != NULL) + return (EISCONN); + + if (ng_btsocket_hci_raw_node == NULL) + return (EPROTONOSUPPORT); + if (proto != BLUETOOTH_PROTO_HCI) + return (EPROTONOSUPPORT); + if (so->so_type != SOCK_RAW) + return (ESOCKTNOSUPPORT); + if ((error = suser(td)) != 0) + return (error); + + error = soreserve(so, NG_BTSOCKET_HCI_RAW_SENDSPACE, + NG_BTSOCKET_HCI_RAW_RECVSPACE); + if (error != 0) + return (error); + + MALLOC(pcb, ng_btsocket_hci_raw_pcb_p, sizeof(*pcb), + M_NETGRAPH_BTSOCKET_HCI_RAW, M_WAITOK | M_ZERO); + if (pcb == NULL) + return (ENOMEM); + + so->so_pcb = (caddr_t) pcb; + pcb->so = so; + + /* + * Set default socket filter. By default socket only accepts HCI + * Command_Complete and Command_Status event packets. + */ + + bit_set(pcb->filter.event_mask, NG_HCI_EVENT_COMMAND_COMPL - 1); + bit_set(pcb->filter.event_mask, NG_HCI_EVENT_COMMAND_STATUS - 1); + + mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); + LIST_INSERT_HEAD(&ng_btsocket_hci_raw_sockets, pcb, next); + mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); + + return (0); +} /* ng_btsocket_hci_raw_attach */ + +/* + * Bind raw HCI socket + */ + +int +ng_btsocket_hci_raw_bind(struct socket *so, struct sockaddr *nam, + struct thread *td) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + struct sockaddr_hci *sa = (struct sockaddr_hci *) nam; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + if (sa == NULL) + return (EINVAL); + if (sa->hci_family != AF_BLUETOOTH) + return (EAFNOSUPPORT); + if (sa->hci_len != sizeof(*sa)) + return (EINVAL); + if (sa->hci_node[0] == 0) + return (EINVAL); + + bcopy(sa, &pcb->addr, sizeof(pcb->addr)); + + return (0); +} /* ng_btsocket_hci_raw_bind */ + +/* + * Connect raw HCI socket + */ + +int +ng_btsocket_hci_raw_connect(struct socket *so, struct sockaddr *nam, + struct thread *td) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + struct sockaddr_hci *sa = (struct sockaddr_hci *) nam; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + if (sa == NULL) + return (EINVAL); + if (sa->hci_family != AF_BLUETOOTH) + return (EAFNOSUPPORT); + if (sa->hci_len != sizeof(*sa)) + return (EINVAL); + if (sa->hci_node[0] == 0) + return (EDESTADDRREQ); + if (bcmp(sa, &pcb->addr, sizeof(pcb->addr)) != 0) + return (EADDRNOTAVAIL); + + soisconnected(so); + + return (0); +} /* ng_btsocket_hci_raw_connect */ + +/* + * Process ioctl on socket + */ + +int +ng_btsocket_hci_raw_control(struct socket *so, u_long cmd, caddr_t data, + struct ifnet *ifp, struct thread *td) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + char path[NG_NODELEN + 2], + *hci_node = (char *) data; + struct ng_mesg *msg = NULL; + int error = 0; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + /* + * Make sure caller has provided HCI node name, if not try to + * use addr from socket (if socket was bound) + */ + + if (hci_node[0] == 0) { + if (pcb->addr.hci_node[0] == 0) + return (EINVAL); + + bzero(hci_node, sizeof(pcb->addr.hci_node)); + strncpy(hci_node,pcb->addr.hci_node,sizeof(pcb->addr.hci_node)); + } + + snprintf(path, sizeof(path), "%s:", hci_node); + + switch (cmd) { + case SIOC_HCI_RAW_NODE_GET_STATE: { + struct ng_btsocket_hci_raw_node_state *p = + (struct ng_btsocket_hci_raw_node_state *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_STATE, + &p->state, sizeof(p->state)); + } break; + + case SIOC_HCI_RAW_NODE_INIT: + error = ng_btsocket_raw_send_ngmsg(path, NGM_HCI_NODE_INIT, + NULL, 0); + break; + + case SIOC_HCI_RAW_NODE_GET_DEBUG: { + struct ng_btsocket_hci_raw_node_debug *p = + (struct ng_btsocket_hci_raw_node_debug *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_DEBUG, + &p->debug, sizeof(p->debug)); + } break; + + case SIOC_HCI_RAW_NODE_SET_DEBUG: { + struct ng_btsocket_hci_raw_node_debug *p = + (struct ng_btsocket_hci_raw_node_debug *) data; + + error = ng_btsocket_raw_send_ngmsg(path, NGM_HCI_NODE_SET_DEBUG, + &p->debug, sizeof(p->debug)); + } break; + + case SIOC_HCI_RAW_NODE_GET_BUFFER: { + struct ng_btsocket_hci_raw_node_buffer *p = + (struct ng_btsocket_hci_raw_node_buffer *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_BUFFER, + &p->buffer, sizeof(p->buffer)); + } break; + + case SIOC_HCI_RAW_NODE_GET_BDADDR: { + struct ng_btsocket_hci_raw_node_bdaddr *p = + (struct ng_btsocket_hci_raw_node_bdaddr *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_BDADDR, + &p->bdaddr, sizeof(p->bdaddr)); + } break; + + case SIOC_HCI_RAW_NODE_GET_FEATURES: { + struct ng_btsocket_hci_raw_node_features *p = + (struct ng_btsocket_hci_raw_node_features *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_FEATURES, + &p->features, sizeof(p->features)); + } break; + + case SIOC_HCI_RAW_NODE_GET_STAT: { + struct ng_btsocket_hci_raw_node_stat *p = + (struct ng_btsocket_hci_raw_node_stat *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_STAT, + &p->stat, sizeof(p->stat)); + } break; + + case SIOC_HCI_RAW_NODE_RESET_STAT: + error = ng_btsocket_raw_send_ngmsg(path, + NGM_HCI_NODE_RESET_STAT, NULL, 0); + break; + + case SIOC_HCI_RAW_NODE_FLUSH_NEIGHBOR_CACHE: + error = ng_btsocket_raw_send_ngmsg(path, + NGM_HCI_NODE_FLUSH_NEIGHBOR_CACHE, NULL, 0); + break; + + case SIOC_HCI_RAW_NODE_GET_NEIGHBOR_CACHE: { + struct ng_btsocket_hci_raw_node_neighbor_cache *p = + (struct ng_btsocket_hci_raw_node_neighbor_cache *) data; + ng_hci_node_get_neighbor_cache_ep *p1 = NULL; + ng_hci_node_neighbor_cache_entry_ep *p2 = NULL; + + if (p->num_entries <= 0 || + p->num_entries > NG_HCI_MAX_NEIGHBOR_NUM || + p->entries == NULL) { + error = EINVAL; + break; + } + + ng_btsocket_hci_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, + NGM_HCI_NODE_GET_NEIGHBOR_CACHE, 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + NG_SEND_MSG_PATH(error,ng_btsocket_hci_raw_node,msg,path,NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "hcictl", + ng_btsocket_hci_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_HCI_NODE_GET_NEIGHBOR_CACHE) { + /* Return data back to user space */ + p1 = (ng_hci_node_get_neighbor_cache_ep *) + (pcb->msg->data); + p2 = (ng_hci_node_neighbor_cache_entry_ep *) + (p1 + 1); + + p->num_entries = min(p->num_entries, p1->num_entries); + if (p->num_entries > 0) + error = copyout((caddr_t) p2, + (caddr_t) p->entries, + p->num_entries * sizeof(*p2)); + } else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + }break; + + case SIOC_HCI_RAW_NODE_GET_CON_LIST: { + struct ng_btsocket_hci_raw_con_list *p = + (struct ng_btsocket_hci_raw_con_list *) data; + ng_hci_node_con_list_ep *p1 = NULL; + ng_hci_node_con_ep *p2 = NULL; + + if (p->num_connections == 0 || + p->num_connections > NG_HCI_MAX_CON_NUM || + p->connections == NULL) { + error = EINVAL; + break; + } + + ng_btsocket_hci_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_HCI_COOKIE, NGM_HCI_NODE_GET_CON_LIST, + 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + NG_SEND_MSG_PATH(error,ng_btsocket_hci_raw_node,msg,path,NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "hcictl", + ng_btsocket_hci_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_HCI_NODE_GET_CON_LIST) { + /* Return data back to user space */ + p1 = (ng_hci_node_con_list_ep *)(pcb->msg->data); + p2 = (ng_hci_node_con_ep *)(p1 + 1); + + p->num_connections = min(p->num_connections, + p1->num_connections); + if (p->num_connections > 0) + error = copyout((caddr_t) p2, + (caddr_t) p->connections, + p->num_connections * sizeof(*p2)); + } else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + case SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK: { + struct ng_btsocket_hci_raw_node_link_policy_mask *p = + (struct ng_btsocket_hci_raw_node_link_policy_mask *) + data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_LINK_POLICY_SETTINGS_MASK, + &p->policy_mask, sizeof(p->policy_mask)); + } break; + + case SIOC_HCI_RAW_NODE_SET_LINK_POLICY_MASK: { + struct ng_btsocket_hci_raw_node_link_policy_mask *p = + (struct ng_btsocket_hci_raw_node_link_policy_mask *) + data; + + error = ng_btsocket_raw_send_ngmsg(path, + NGM_HCI_NODE_SET_LINK_POLICY_SETTINGS_MASK, + &p->policy_mask, sizeof(p->policy_mask)); + } break; + + case SIOC_HCI_RAW_NODE_GET_PACKET_MASK: { + struct ng_btsocket_hci_raw_node_packet_mask *p = + (struct ng_btsocket_hci_raw_node_packet_mask *) data; + + error = ng_btsocket_raw_send_sync_ngmsg(pcb, path, + NGM_HCI_NODE_GET_PACKET_MASK, + &p->packet_mask, sizeof(p->packet_mask)); + } break; + + case SIOC_HCI_RAW_NODE_SET_PACKET_MASK: { + struct ng_btsocket_hci_raw_node_packet_mask *p = + (struct ng_btsocket_hci_raw_node_packet_mask *) data; + + error = ng_btsocket_raw_send_ngmsg(path, + NGM_HCI_NODE_SET_PACKET_MASK, + &p->packet_mask, sizeof(p->packet_mask)); + + } break; + + default: + error = EINVAL; + break; + } + + return (error); +} /* ng_btsocket_hci_raw_control */ + +/* + * Process getsockopt/setsockopt system calls + */ + +int +ng_btsocket_hci_raw_ctloutput(struct socket *so, struct sockopt *sopt) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + struct ng_btsocket_hci_raw_filter filter; + int error = 0, dir; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + if (sopt->sopt_level != SOL_HCI_RAW) + return (0); + + switch (sopt->sopt_dir) { + case SOPT_GET: + switch (sopt->sopt_name) { + case SO_HCI_RAW_FILTER: + error = sooptcopyout(sopt, &pcb->filter, + sizeof(pcb->filter)); + break; + + case SO_HCI_RAW_DIRECTION: + dir = (pcb->flags & NG_BTSOCKET_HCI_RAW_DIRECTION)?1:0; + error = sooptcopyout(sopt, &dir, sizeof(dir)); + break; + + default: + error = EINVAL; + break; + } + break; + + case SOPT_SET: + switch (sopt->sopt_name) { + case SO_HCI_RAW_FILTER: + error = sooptcopyin(sopt, &filter, sizeof(filter), + sizeof(filter)); + if (error == 0) + bcopy(&filter, &pcb->filter, + sizeof(pcb->filter)); + break; + + case SO_HCI_RAW_DIRECTION: + error = sooptcopyin(sopt, &dir, sizeof(dir), + sizeof(dir)); + if (error != 0) + break; + + if (dir) + pcb->flags |= NG_BTSOCKET_HCI_RAW_DIRECTION; + else + pcb->flags &= ~NG_BTSOCKET_HCI_RAW_DIRECTION; + break; + + default: + error = EINVAL; + break; + } + break; + + default: + error = EINVAL; + break; + } + + return (error); +} /* ng_btsocket_hci_raw_ctloutput */ + +/* + * Detach raw HCI socket + */ + +int +ng_btsocket_hci_raw_detach(struct socket *so) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + so->so_pcb = NULL; + sotryfree(so); + + mtx_lock(&ng_btsocket_hci_raw_sockets_mtx); + LIST_REMOVE(pcb, next); + mtx_unlock(&ng_btsocket_hci_raw_sockets_mtx); + + bzero(pcb, sizeof(*pcb)); + FREE(pcb, M_NETGRAPH_BTSOCKET_HCI_RAW); + + return (0); +} /* ng_btsocket_hci_raw_detach */ + +/* + * Disconnect raw HCI socket + */ + +int +ng_btsocket_hci_raw_disconnect(struct socket *so) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + soisdisconnected(so); + + return (0); +} /* ng_btsocket_hci_raw_disconnect */ + +/* + * Get socket peer's address + */ + +int +ng_btsocket_hci_raw_peeraddr(struct socket *so, struct sockaddr **nam) +{ + return (EOPNOTSUPP); +} /* ng_btsocket_hci_raw_peeraddr */ + +/* + * Send data + */ + +int +ng_btsocket_hci_raw_send(struct socket *so, int flags, struct mbuf *m, + struct sockaddr *sa, struct mbuf *control, struct thread *td) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + struct mbuf *nam = NULL; + int error = 0; + + if (ng_btsocket_hci_raw_node == NULL) { + error = ENETDOWN; + goto drop; + } + if (pcb == NULL) { + error = EINVAL; + goto drop; + } + if (control != NULL) { + error = EINVAL; + goto drop; + } + + if (m->m_pkthdr.len < sizeof(ng_hci_cmd_pkt_t) || + m->m_pkthdr.len > sizeof(ng_hci_cmd_pkt_t) + NG_HCI_CMD_PKT_SIZE) { + error = EMSGSIZE; + goto drop; + } + + if (sa == NULL) { + if (pcb->addr.hci_node[0] == 0) { + error = EDESTADDRREQ; + goto drop; + } + + sa = (struct sockaddr *) &pcb->addr; + } + + MGET(nam, M_WAITOK, MT_SONAME); + if (nam == NULL) { + error = ENOBUFS; + goto drop; + } + + nam->m_len = sizeof(struct sockaddr_hci); + bcopy(sa,mtod(nam, struct sockaddr_hci *),sizeof(struct sockaddr_hci)); + + nam->m_next = m; + m = NULL; + + return (ng_send_fn(ng_btsocket_hci_raw_node, NULL, + ng_btsocket_hci_raw_output, nam, 0)); +drop: + NG_FREE_M(control); /* NG_FREE_M checks for != NULL */ + NG_FREE_M(nam); + NG_FREE_M(m); + + return (error); +} /* ng_btsocket_hci_raw_send */ + +/* + * Get socket address + */ + +int +ng_btsocket_hci_raw_sockaddr(struct socket *so, struct sockaddr **nam) +{ + ng_btsocket_hci_raw_pcb_p pcb = so2hci_raw_pcb(so); + struct sockaddr_hci sa; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_hci_raw_node == NULL) + return (EINVAL); + + bzero(&sa, sizeof(sa)); + sa.hci_len = sizeof(sa); + sa.hci_family = AF_BLUETOOTH; + strncpy(sa.hci_node, pcb->addr.hci_node, sizeof(sa.hci_node)); + + *nam = dup_sockaddr((struct sockaddr *) &sa, 0); + + return ((*nam == NULL)? ENOMEM : 0); +} /* ng_btsocket_hci_raw_sockaddr */ + diff --git a/sys/netgraph/bluetooth/socket/ng_btsocket_l2cap.c b/sys/netgraph/bluetooth/socket/ng_btsocket_l2cap.c new file mode 100644 index 0000000..8360038 --- /dev/null +++ b/sys/netgraph/bluetooth/socket/ng_btsocket_l2cap.c @@ -0,0 +1,2717 @@ +/* + * ng_btsocket_l2cap.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket_l2cap.c,v 1.5 2002/10/26 03:34:37 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/domain.h> +#include <sys/endian.h> +#include <sys/errno.h> +#include <sys/filedesc.h> +#include <sys/ioccom.h> +#include <sys/kernel.h> +#include <sys/lock.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/mutex.h> +#include <sys/protosw.h> +#include <sys/queue.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/sysctl.h> +#include <sys/taskqueue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <bitstring.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_btsocket.h" +#include "ng_btsocket_l2cap.h" + +/* MALLOC define */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DEFINE(M_NETGRAPH_BTSOCKET_L2CAP, "netgraph_btsocks_l2cap", + "Netgraph Bluetooth L2CAP sockets"); +#else +#define M_NETGRAPH_BTSOCKET_L2CAP M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Netgraph node methods */ +static ng_constructor_t ng_btsocket_l2cap_node_constructor; +static ng_rcvmsg_t ng_btsocket_l2cap_node_rcvmsg; +static ng_shutdown_t ng_btsocket_l2cap_node_shutdown; +static ng_newhook_t ng_btsocket_l2cap_node_newhook; +static ng_connect_t ng_btsocket_l2cap_node_connect; +static ng_rcvdata_t ng_btsocket_l2cap_node_rcvdata; +static ng_disconnect_t ng_btsocket_l2cap_node_disconnect; + +static void ng_btsocket_l2cap_input (void *, int); +static void ng_btsocket_l2cap_rtclean (void *, int); + +/* Netgraph type descriptor */ +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_BTSOCKET_L2CAP_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_btsocket_l2cap_node_constructor, /* constructor */ + ng_btsocket_l2cap_node_rcvmsg, /* control message */ + ng_btsocket_l2cap_node_shutdown, /* destructor */ + ng_btsocket_l2cap_node_newhook, /* new hook */ + NULL, /* find hook */ + ng_btsocket_l2cap_node_connect, /* connect hook */ + ng_btsocket_l2cap_node_rcvdata, /* data */ + ng_btsocket_l2cap_node_disconnect, /* disconnect hook */ + NULL /* node command list */ +}; + +/* Globals */ +extern int ifqmaxlen; +static u_int32_t ng_btsocket_l2cap_debug_level; +static u_int32_t ng_btsocket_l2cap_ioctl_timeout; +static node_p ng_btsocket_l2cap_node; +static struct ng_bt_itemq ng_btsocket_l2cap_queue; +static struct mtx ng_btsocket_l2cap_queue_mtx; +static struct task ng_btsocket_l2cap_queue_task; +static LIST_HEAD(, ng_btsocket_l2cap_pcb) ng_btsocket_l2cap_sockets; +static struct mtx ng_btsocket_l2cap_sockets_mtx; +static u_int32_t ng_btsocket_l2cap_token; +static struct mtx ng_btsocket_l2cap_token_mtx; +static LIST_HEAD(, ng_btsocket_l2cap_rtentry) ng_btsocket_l2cap_rt; +static struct mtx ng_btsocket_l2cap_rt_mtx; +static struct task ng_btsocket_l2cap_rt_task; + +/* Sysctl tree */ +SYSCTL_DECL(_net_bluetooth_l2cap_sockets); +SYSCTL_NODE(_net_bluetooth_l2cap_sockets, OID_AUTO, seq, CTLFLAG_RW, + 0, "Bluetooth SEQPACKET L2CAP sockets family"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_seq, OID_AUTO, debug_level, + CTLFLAG_RW, + &ng_btsocket_l2cap_debug_level, NG_BTSOCKET_WARN_LEVEL, + "Bluetooth SEQPACKET L2CAP sockets debug level"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_seq, OID_AUTO, ioctl_timeout, + CTLFLAG_RW, + &ng_btsocket_l2cap_ioctl_timeout, 5, + "Bluetooth SEQPACKET L2CAP sockets ioctl timeout"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_seq, OID_AUTO, queue_len, + CTLFLAG_RD, + &ng_btsocket_l2cap_queue.len, 0, + "Bluetooth SEQPACKET L2CAP sockets input queue length"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_seq, OID_AUTO, queue_maxlen, + CTLFLAG_RD, + &ng_btsocket_l2cap_queue.maxlen, 0, + "Bluetooth SEQPACKET L2CAP sockets input queue max. length"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_seq, OID_AUTO, queue_drops, + CTLFLAG_RD, + &ng_btsocket_l2cap_queue.drops, 0, + "Bluetooth SEQPACKET L2CAP sockets input queue drops"); + +/* Debug */ +#define NG_BTSOCKET_L2CAP_INFO \ + if (ng_btsocket_l2cap_debug_level >= NG_BTSOCKET_INFO_LEVEL) \ + printf + +#define NG_BTSOCKET_L2CAP_WARN \ + if (ng_btsocket_l2cap_debug_level >= NG_BTSOCKET_WARN_LEVEL) \ + printf + +#define NG_BTSOCKET_L2CAP_ERR \ + if (ng_btsocket_l2cap_debug_level >= NG_BTSOCKET_ERR_LEVEL) \ + printf + +#define NG_BTSOCKET_L2CAP_ALERT \ + if (ng_btsocket_l2cap_debug_level >= NG_BTSOCKET_ALERT_LEVEL) \ + printf + +/* + * Netgraph message processing routines + */ + +static int ng_btsocket_l2cap_process_l2ca_con_req_rsp + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); +static int ng_btsocket_l2cap_process_l2ca_con_rsp_rsp + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); +static int ng_btsocket_l2cap_process_l2ca_con_ind + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); + +static int ng_btsocket_l2cap_process_l2ca_cfg_req_rsp + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); +static int ng_btsocket_l2cap_process_l2ca_cfg_rsp_rsp + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); +static int ng_btsocket_l2cap_process_l2ca_cfg_ind + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); + +static int ng_btsocket_l2cap_process_l2ca_discon_rsp + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); +static int ng_btsocket_l2cap_process_l2ca_discon_ind + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); + +static int ng_btsocket_l2cap_process_l2ca_write_rsp + (struct ng_mesg *, ng_btsocket_l2cap_rtentry_p); + +/* + * Send L2CA_xxx messages to the lower layer + */ + +static int ng_btsocket_l2cap_send_l2ca_con_req + (ng_btsocket_l2cap_pcb_p); +static int ng_btsocket_l2cap_send_l2ca_con_rsp_req + (u_int32_t, ng_btsocket_l2cap_rtentry_p, bdaddr_p, int, int, int); +static int ng_btsocket_l2cap_send_l2ca_cfg_req + (ng_btsocket_l2cap_pcb_p); +static int ng_btsocket_l2cap_send_l2ca_cfg_rsp + (ng_btsocket_l2cap_pcb_p); +static int ng_btsocket_l2cap_send_l2ca_discon_req + (u_int32_t, ng_btsocket_l2cap_pcb_p); + +static int ng_btsocket_l2cap_send2 + (ng_btsocket_l2cap_pcb_p); + +/* + * Timeout processing routines + */ + +static void ng_btsocket_l2cap_timeout (ng_btsocket_l2cap_pcb_p); +static void ng_btsocket_l2cap_untimeout (ng_btsocket_l2cap_pcb_p); +static void ng_btsocket_l2cap_process_timeout (void *); + +/* + * Other stuff + */ + +static ng_btsocket_l2cap_pcb_p ng_btsocket_l2cap_pcb_by_addr(bdaddr_p, int); +static ng_btsocket_l2cap_pcb_p ng_btsocket_l2cap_pcb_by_token(u_int32_t); +static ng_btsocket_l2cap_pcb_p ng_btsocket_l2cap_pcb_by_cid (bdaddr_p, int); +static void ng_btsocket_l2cap_get_token (u_int32_t *); +static int ng_btsocket_l2cap_result2errno(int); + +/***************************************************************************** + ***************************************************************************** + ** Netgraph node interface + ***************************************************************************** + *****************************************************************************/ + +/* + * Netgraph node constructor. Do not allow to create node of this type. + */ + +static int +ng_btsocket_l2cap_node_constructor(node_p node) +{ + return (EINVAL); +} /* ng_btsocket_l2cap_node_constructor */ + +/* + * Do local shutdown processing. Let old node go and create new fresh one. + */ + +static int +ng_btsocket_l2cap_node_shutdown(node_p node) +{ + int error = 0; + + NG_NODE_UNREF(node); + + /* Create new node */ + error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_node); + if (error != 0) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not create Netgraph node, error=%d\n", __func__, error); + + ng_btsocket_l2cap_node = NULL; + + return (error); + } + + error = ng_name_node(ng_btsocket_l2cap_node, + NG_BTSOCKET_L2CAP_NODE_TYPE); + if (error != NULL) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not name Netgraph node, error=%d\n", __func__, error); + + NG_NODE_UNREF(ng_btsocket_l2cap_node); + ng_btsocket_l2cap_node = NULL; + + return (error); + } + + return (0); +} /* ng_btsocket_l2cap_node_shutdown */ + +/* + * We allow any hook to be connected to the node. + */ + +static int +ng_btsocket_l2cap_node_newhook(node_p node, hook_p hook, char const *name) +{ + return (0); +} /* ng_btsocket_l2cap_node_newhook */ + +/* + * Just say "YEP, that's OK by me!" + */ + +static int +ng_btsocket_l2cap_node_connect(hook_p hook) +{ + NG_HOOK_SET_PRIVATE(hook, NULL); + NG_HOOK_REF(hook); /* Keep extra reference to the hook */ + +#if 0 + NG_HOOK_FORCE_QUEUE(NG_HOOK_PEER(hook)); + NG_HOOK_FORCE_QUEUE(hook); +#endif + + return (0); +} /* ng_btsocket_l2cap_node_connect */ + +/* + * Hook disconnection. Schedule route cleanup task + */ + +static int +ng_btsocket_l2cap_node_disconnect(hook_p hook) +{ + /* + * If hook has private information than we must have this hook in + * the routing table and must schedule cleaning for the routing table. + * Otherwise hook was connected but we never got "hook_info" message, + * so we have never added this hook to the routing table and it save + * to just delete it. + */ + + if (NG_HOOK_PRIVATE(hook) != NULL) + return (taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_l2cap_rt_task)); + + NG_HOOK_UNREF(hook); /* Remove extra reference */ + + return (0); +} /* ng_btsocket_l2cap_node_disconnect */ + +/* + * Process incoming messages + */ + +static int +ng_btsocket_l2cap_node_rcvmsg(node_p node, item_p item, hook_p hook) +{ + struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ + int error = 0; + + if (msg != NULL && msg->header.typecookie == NGM_L2CAP_COOKIE) { + mtx_lock(&ng_btsocket_l2cap_queue_mtx); + if (NG_BT_ITEMQ_FULL(&ng_btsocket_l2cap_queue)) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Input queue is full (msg)\n", __func__); + + NG_BT_ITEMQ_DROP(&ng_btsocket_l2cap_queue); + NG_FREE_ITEM(item); + error = ENOBUFS; + } else { + if (hook != NULL) { + NG_HOOK_REF(hook); + NGI_SET_HOOK(item, hook); + } + + NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_l2cap_queue, item); + error = taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_l2cap_queue_task); + } + mtx_unlock(&ng_btsocket_l2cap_queue_mtx); + } else { + NG_FREE_ITEM(item); + error = EINVAL; + } + + return (error); +} /* ng_btsocket_l2cap_node_rcvmsg */ + +/* + * Receive data on a hook + */ + +static int +ng_btsocket_l2cap_node_rcvdata(hook_p hook, item_p item) +{ + int error = 0; + + mtx_lock(&ng_btsocket_l2cap_queue_mtx); + if (NG_BT_ITEMQ_FULL(&ng_btsocket_l2cap_queue)) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Input queue is full (data)\n", __func__); + + NG_BT_ITEMQ_DROP(&ng_btsocket_l2cap_queue); + NG_FREE_ITEM(item); + error = ENOBUFS; + } else { + NG_HOOK_REF(hook); + NGI_SET_HOOK(item, hook); + + NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_l2cap_queue, item); + error = taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_l2cap_queue_task); + } + mtx_unlock(&ng_btsocket_l2cap_queue_mtx); + + return (error); +} /* ng_btsocket_l2cap_node_rcvdata */ + +/* + * Process L2CA_Connect respose. Socket layer must have initiated connection, + * so we have to have a socket associated with message token. + */ + +static int +ng_btsocket_l2cap_process_l2ca_con_req_rsp(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_con_op *op = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + int error = 0; + + if (msg->header.arglen != sizeof(*op)) + return (EMSGSIZE); + + op = (ng_l2cap_l2ca_con_op *)(msg->data); + + /* Look for the socket with the token */ + pcb = ng_btsocket_l2cap_pcb_by_token(msg->header.token); + if (pcb == NULL) + return (ENOENT); + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Connect response, token=%d, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, result=%d, status=%d, " \ +"state=%d\n", __func__, msg->header.token, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, op->lcid, op->result, op->status, + pcb->state); + + if (pcb->state != NG_BTSOCKET_L2CAP_CONNECTING) { + mtx_unlock(&pcb->pcb_mtx); + return (ENOENT); + } + + ng_btsocket_l2cap_untimeout(pcb); + + if (op->result == NG_L2CAP_PENDING) { + ng_btsocket_l2cap_timeout(pcb); + mtx_unlock(&pcb->pcb_mtx); + return (0); + } + + if (op->result == NG_L2CAP_SUCCESS) { + /* + * Channel is now open, so update local channel ID and + * start configuration process. Source and destination + * addresses as well as route must be already set. + */ + + pcb->cid = op->lcid; + + error = ng_btsocket_l2cap_send_l2ca_cfg_req(pcb); + if (error != 0) { + /* Send disconnect request with "zero" token */ + ng_btsocket_l2cap_send_l2ca_discon_req(0, pcb); + + /* ... and close the socket */ + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + } else { + pcb->cfg_state = NG_BTSOCKET_L2CAP_CFG_IN_SENT; + pcb->state = NG_BTSOCKET_L2CAP_CONFIGURING; + + ng_btsocket_l2cap_timeout(pcb); + } + } else { + /* + * We have failed to open connection, so convert result + * code to "errno" code and disconnect the socket. Channel + * already has been closed. + */ + + pcb->so->so_error = ng_btsocket_l2cap_result2errno(op->result); + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + } + + mtx_unlock(&pcb->pcb_mtx); + + return (error); +} /* ng_btsocket_l2cap_process_l2ca_con_req_rsp */ + +/* + * Process L2CA_ConnectRsp response + */ + +static int +ng_btsocket_l2cap_process_l2ca_con_rsp_rsp(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_con_rsp_op *op = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + + if (msg->header.arglen != sizeof(*op)) + return (EMSGSIZE); + + op = (ng_l2cap_l2ca_con_rsp_op *)(msg->data); + + /* Look for the socket with the token */ + pcb = ng_btsocket_l2cap_pcb_by_token(msg->header.token); + if (pcb == NULL) + return (ENOENT); + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_ConnectRsp response, token=%d, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, result=%d, state=%d\n", + __func__, msg->header.token, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, op->result, pcb->state); + + if (pcb->state != NG_BTSOCKET_L2CAP_CONNECTING) { + mtx_unlock(&pcb->pcb_mtx); + return (ENOENT); + } + + ng_btsocket_l2cap_untimeout(pcb); + + /* Check the result and disconnect the socket on failure */ + if (op->result != NG_L2CAP_SUCCESS) { + /* Close the socket - channel already closed */ + pcb->so->so_error = ng_btsocket_l2cap_result2errno(op->result); + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + } else { + /* Move to CONFIGURING state and wait for CONFIG_IND */ + pcb->cfg_state = 0; + pcb->state = NG_BTSOCKET_L2CAP_CONFIGURING; + ng_btsocket_l2cap_timeout(pcb); + } + + mtx_unlock(&pcb->pcb_mtx); + + return (0); +} /* ng_btsocket_process_l2ca_con_rsp_rsp */ + +/* + * Process L2CA_Connect indicator. Find socket that listens on address + * and PSM. Find exact or closest match. Create new socket and initiate + * connection. + */ + +static int +ng_btsocket_l2cap_process_l2ca_con_ind(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_con_ind_ip *ip = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL, *pcb1 = NULL; + int error = 0; + u_int32_t token = 0; + u_int16_t result = 0; + + if (msg->header.arglen != sizeof(*ip)) + return (EMSGSIZE); + + ip = (ng_l2cap_l2ca_con_ind_ip *)(msg->data); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Connect indicator, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, ident=%d\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + ip->bdaddr.b[5], ip->bdaddr.b[4], ip->bdaddr.b[3], + ip->bdaddr.b[2], ip->bdaddr.b[1], ip->bdaddr.b[0], + ip->psm, ip->lcid, ip->ident); + + pcb = ng_btsocket_l2cap_pcb_by_addr(&rt->src, ip->psm); + if (pcb != NULL) { + struct socket *so1 = NULL; + + mtx_lock(&pcb->pcb_mtx); + + /* + * First check the pending connections queue and if we have + * space then create new socket and set proper source address. + */ + + if (pcb->so->so_qlen <= pcb->so->so_qlimit) + so1 = sonewconn(pcb->so, 0); + + if (so1 == NULL) { + result = NG_L2CAP_NO_RESOURCES; + goto respond; + } + + /* + * If we got here than we have created new socket. So complete + * connection. If we we listening on specific address then copy + * source address from listening socket, otherwise copy source + * address from hook's routing information. + */ + + pcb1 = so2l2cap_pcb(so1); + KASSERT((pcb1 != NULL), +("%s: pcb1 == NULL\n", __func__)); + + mtx_lock(&pcb1->pcb_mtx); + + if (bcmp(&pcb->src, NG_HCI_BDADDR_ANY, sizeof(pcb->src)) != 0) + bcopy(&pcb->src, &pcb1->src, sizeof(pcb1->src)); + else + bcopy(&rt->src, &pcb1->src, sizeof(pcb1->src)); + + pcb1->flags &= ~NG_BTSOCKET_L2CAP_CLIENT; + + bcopy(&ip->bdaddr, &pcb1->dst, sizeof(pcb1->dst)); + pcb1->psm = ip->psm; + pcb1->cid = ip->lcid; + pcb1->rt = rt; + + /* Copy socket settings */ + pcb1->imtu = pcb->imtu; + bcopy(&pcb->oflow, &pcb1->oflow, sizeof(pcb1->oflow)); + pcb1->flush_timo = pcb->flush_timo; + + token = pcb1->token; + } else + /* Nobody listens on requested BDADDR/PSM */ + result = NG_L2CAP_PSM_NOT_SUPPORTED; + +respond: + error = ng_btsocket_l2cap_send_l2ca_con_rsp_req(token, rt, + &ip->bdaddr, ip->ident, ip->lcid, result); + if (pcb1 != NULL) { + if (error != 0) { + pcb1->so->so_error = error; + pcb1->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb1->so); + } else { + pcb1->state = NG_BTSOCKET_L2CAP_CONNECTING; + soisconnecting(pcb1->so); + + ng_btsocket_l2cap_timeout(pcb1); + } + + mtx_unlock(&pcb1->pcb_mtx); + } + + if (pcb != NULL) + mtx_unlock(&pcb->pcb_mtx); + + return (error); +} /* ng_btsocket_l2cap_process_l2ca_con_ind */ + +/* + * Process L2CA_Config response + */ + +static int +ng_btsocket_l2cap_process_l2ca_cfg_req_rsp(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_cfg_op *op = NULL; + ng_btsocket_l2cap_pcb_p pcb = NULL; + + if (msg->header.arglen != sizeof(*op)) + return (EMSGSIZE); + + op = (ng_l2cap_l2ca_cfg_op *)(msg->data); + + /* + * Socket must have issued a Configure request, so we must have a + * socket that wants to be configured. Use Netgraph message token + * to find it + */ + + pcb = ng_btsocket_l2cap_pcb_by_token(msg->header.token); + if (pcb == NULL) { + /* + * XXX FIXME what to do here? We could not find a + * socket with requested token. We even can not send + * Disconnect, because we do not know channel ID + */ + + return (ENOENT); + } + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Config response, token=%d, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, result=%d, state=%d, " \ +"cfg_state=%x\n", + __func__, msg->header.token, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, op->result, pcb->state, pcb->cfg_state); + + if (pcb->state != NG_BTSOCKET_L2CAP_CONFIGURING) { + mtx_unlock(&pcb->pcb_mtx); + return (ENOENT); + } + + if (op->result == NG_L2CAP_SUCCESS) { + /* + * XXX FIXME Actually set flush and link timeout. + * Set QoS here if required. Resolve conficts (flush_timo). + * Save incoming MTU (peer's outgoing MTU) and outgoing flow + * spec. + */ + + pcb->imtu = op->imtu; + bcopy(&op->oflow, &pcb->oflow, sizeof(pcb->oflow)); + pcb->flush_timo = op->flush_timo; + + /* + * We have configured incoming side, so record it and check + * if configuration is complete. If complete then mark socket + * as connected, otherwise wait for the peer. + */ + + pcb->cfg_state &= ~NG_BTSOCKET_L2CAP_CFG_IN_SENT; + pcb->cfg_state |= NG_BTSOCKET_L2CAP_CFG_IN; + + if (pcb->cfg_state == NG_BTSOCKET_L2CAP_CFG_BOTH) { + /* Configuration complete - mark socket as open */ + ng_btsocket_l2cap_untimeout(pcb); + pcb->state = NG_BTSOCKET_L2CAP_OPEN; + soisconnected(pcb->so); + } + } else { + /* + * Something went wrong. Could be unacceptable parameters, + * reject or unknown option. That's too bad, but we will + * not negotiate. Send Disconnect and close the channel. + */ + + ng_btsocket_l2cap_untimeout(pcb); + + switch (op->result) { + case NG_L2CAP_UNACCEPTABLE_PARAMS: + case NG_L2CAP_UNKNOWN_OPTION: + pcb->so->so_error = EINVAL; + break; + + default: + pcb->so->so_error = ECONNRESET; + break; + } + + /* Send disconnect with "zero" token */ + ng_btsocket_l2cap_send_l2ca_discon_req(0, pcb); + + /* ... and close the socket */ + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + } + + mtx_unlock(&pcb->pcb_mtx); + + return (0); +} /* ng_btsocket_l2cap_process_l2ca_cfg_req_rsp */ + +/* + * Process L2CA_ConfigRsp response + */ + +static int +ng_btsocket_l2cap_process_l2ca_cfg_rsp_rsp(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_cfg_rsp_op *op = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + int error = 0; + + if (msg->header.arglen != sizeof(*op)) + return (EMSGSIZE); + + op = (ng_l2cap_l2ca_cfg_rsp_op *)(msg->data); + + /* Look for the socket with the token */ + pcb = ng_btsocket_l2cap_pcb_by_token(msg->header.token); + if (pcb == NULL) + return (ENOENT); + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_ConfigRsp response, token=%d, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, result=%d, state=%d, " \ +"cfg_state=%x\n", + __func__, msg->header.token, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, op->result, pcb->state, pcb->cfg_state); + + if (pcb->state != NG_BTSOCKET_L2CAP_CONFIGURING) { + mtx_unlock(&pcb->pcb_mtx); + return (ENOENT); + } + + /* Check the result and disconnect socket of failure */ + if (op->result != NG_L2CAP_SUCCESS) + goto disconnect; + + /* + * Now we done with remote side configuration. Configure local + * side if we have not done it yet. + */ + + pcb->cfg_state &= ~NG_BTSOCKET_L2CAP_CFG_OUT_SENT; + pcb->cfg_state |= NG_BTSOCKET_L2CAP_CFG_OUT; + + if (pcb->cfg_state == NG_BTSOCKET_L2CAP_CFG_BOTH) { + /* Configuration complete - mask socket as open */ + ng_btsocket_l2cap_untimeout(pcb); + pcb->state = NG_BTSOCKET_L2CAP_OPEN; + soisconnected(pcb->so); + } else { + if (!(pcb->cfg_state & NG_BTSOCKET_L2CAP_CFG_IN_SENT)) { + /* Send L2CA_Config request - incoming path */ + error = ng_btsocket_l2cap_send_l2ca_cfg_req(pcb); + if (error != 0) + goto disconnect; + + pcb->cfg_state |= NG_BTSOCKET_L2CAP_CFG_IN_SENT; + } + } + + mtx_unlock(&pcb->pcb_mtx); + + return (error); + +disconnect: + ng_btsocket_l2cap_untimeout(pcb); + + /* Send disconnect with "zero" token */ + ng_btsocket_l2cap_send_l2ca_discon_req(0, pcb); + + /* ... and close the socket */ + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + + mtx_unlock(&pcb->pcb_mtx); + + return (error); +} /* ng_btsocket_l2cap_process_l2ca_cfg_rsp_rsp */ + +/* + * Process L2CA_Config indicator + */ + +static int +ng_btsocket_l2cap_process_l2ca_cfg_ind(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_cfg_ind_ip *ip = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + int error = 0; + + if (msg->header.arglen != sizeof(*ip)) + return (EMSGSIZE); + + ip = (ng_l2cap_l2ca_cfg_ind_ip *)(msg->data); + + /* Check for the open socket that has given channel ID */ + pcb = ng_btsocket_l2cap_pcb_by_cid(&rt->src, ip->lcid); + if (pcb == NULL) + return (ENOENT); + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Config indicator, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, state=%d, cfg_state=%x\n", + __func__, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, pcb->state, pcb->cfg_state); + + /* XXX FIXME re-configuration on open socket */ + if (pcb->state != NG_BTSOCKET_L2CAP_CONFIGURING) { + mtx_unlock(&pcb->pcb_mtx); + return (ENOENT); + } + + /* + * XXX FIXME Actually set flush and link timeout. Set QoS here if + * required. Resolve conficts (flush_timo). Note outgoing MTU (peer's + * incoming MTU) and incoming flow spec. + */ + + pcb->omtu = ip->omtu; + bcopy(&ip->iflow, &pcb->iflow, sizeof(pcb->iflow)); + pcb->flush_timo = ip->flush_timo; + + /* + * Send L2CA_Config response to our peer and check for the errors, + * if any send disconnect to close the channel. + */ + + if (sbreserve(&pcb->so->so_snd, ip->omtu, pcb->so, curthread)) { + if (!(pcb->cfg_state & NG_BTSOCKET_L2CAP_CFG_OUT_SENT)) { + error = ng_btsocket_l2cap_send_l2ca_cfg_rsp(pcb); + if (error == 0) + pcb->cfg_state |= NG_BTSOCKET_L2CAP_CFG_OUT_SENT; + } + } else + error = ENOBUFS; + + if (error != 0) { + ng_btsocket_l2cap_untimeout(pcb); + + pcb->so->so_error = error; + + /* Send disconnect with "zero" token */ + ng_btsocket_l2cap_send_l2ca_discon_req(0, pcb); + + /* ... and close the socket */ + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + } + + mtx_unlock(&pcb->pcb_mtx); + + return (error); +} /* ng_btsocket_l2cap_process_l2cap_cfg_ind */ + +/* + * Process L2CA_Disconnect response + */ + +static int +ng_btsocket_l2cap_process_l2ca_discon_rsp(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_discon_op *op = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + + /* Check message */ + if (msg->header.arglen != sizeof(*op)) + return (EMSGSIZE); + + op = (ng_l2cap_l2ca_discon_op *)(msg->data); + + /* + * Socket layer must have issued L2CA_Disconnect request, so there + * must be a socket that wants to be disconnected. Use Netgraph + * message token to find it. + */ + + pcb = ng_btsocket_l2cap_pcb_by_token(msg->header.token); + if (pcb == NULL) + return (0); + + mtx_lock(&pcb->pcb_mtx); + + /* XXX Close socket no matter what op->result says */ + if (pcb->state != NG_BTSOCKET_L2CAP_CLOSED) { + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Disconnect response, token=%d, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, result=%d, state=%d\n", + __func__, msg->header.token, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, op->result, pcb->state); + + ng_btsocket_l2cap_untimeout(pcb); + + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + } + + mtx_unlock(&pcb->pcb_mtx); + + return (0); +} /* ng_btsocket_l2cap_process_l2ca_discon_rsp */ + +/* + * Process L2CA_Disconnect indicator + */ + +static int +ng_btsocket_l2cap_process_l2ca_discon_ind(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_discon_ind_ip *ip = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + + /* Check message */ + if (msg->header.arglen != sizeof(*ip)) + return (EMSGSIZE); + + ip = (ng_l2cap_l2ca_discon_ind_ip *)(msg->data); + + /* Look for the socket with given channel ID */ + pcb = ng_btsocket_l2cap_pcb_by_cid(&rt->src, ip->lcid); + if (pcb == NULL) + return (0); + + /* + * Channel has already been destroyed, so disconnect the socket + * and be done with it. If there was any pending request we can + * not do anything here anyway. + */ + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Disconnect indicator, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, state=%d\n", + __func__, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, pcb->state); + + if (pcb->flags & NG_BTSOCKET_L2CAP_TIMO) + ng_btsocket_l2cap_untimeout(pcb); + + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + + mtx_unlock(&pcb->pcb_mtx); + + return (0); +} /* ng_btsocket_l2cap_process_l2ca_discon_ind */ + +/* + * Process L2CA_Write response + */ + +static int +ng_btsocket_l2cap_process_l2ca_write_rsp(struct ng_mesg *msg, + ng_btsocket_l2cap_rtentry_p rt) +{ + ng_l2cap_l2ca_write_op *op = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + + /* Check message */ + if (msg->header.arglen != sizeof(*op)) + return (EMSGSIZE); + + op = (ng_l2cap_l2ca_write_op *)(msg->data); + + /* Look for the socket with given token */ + pcb = ng_btsocket_l2cap_pcb_by_token(msg->header.token); + if (pcb == NULL) + return (ENOENT); + + mtx_lock(&pcb->pcb_mtx); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CA_Write response, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dst bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, lcid=%d, result=%d, length=%d, " \ +"state=%d\n", __func__, + pcb->src.b[5], pcb->src.b[4], pcb->src.b[3], + pcb->src.b[2], pcb->src.b[1], pcb->src.b[0], + pcb->dst.b[5], pcb->dst.b[4], pcb->dst.b[3], + pcb->dst.b[2], pcb->dst.b[1], pcb->dst.b[0], + pcb->psm, pcb->cid, op->result, op->length, + pcb->state); + + if (pcb->state != NG_BTSOCKET_L2CAP_OPEN) { + mtx_unlock(&pcb->pcb_mtx); + return (ENOENT); + } + + ng_btsocket_l2cap_untimeout(pcb); + + /* + * Check if we have more data to send + */ + + sbdroprecord(&pcb->so->so_snd); + if (pcb->so->so_snd.sb_cc > 0) { + if (ng_btsocket_l2cap_send2(pcb) == 0) + ng_btsocket_l2cap_timeout(pcb); + else + sbdroprecord(&pcb->so->so_snd); /* XXX */ + } + + /* + * Now set the result, drop packet from the socket send queue and + * ask for more (wakeup sender) + */ + + pcb->so->so_error = ng_btsocket_l2cap_result2errno(op->result); + sowwakeup(pcb->so); + + mtx_unlock(&pcb->pcb_mtx); + + return (0); +} /* ng_btsocket_l2cap_process_l2ca_write_rsp */ + +/* + * Send L2CA_Connect request + */ + +static int +ng_btsocket_l2cap_send_l2ca_con_req(ng_btsocket_l2cap_pcb_p pcb) +{ + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_con_ip *ip = NULL; + int error = 0; + + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (pcb->rt == NULL || + pcb->rt->hook == NULL || NG_HOOK_NOT_VALID(pcb->rt->hook)) + return (ENETDOWN); + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CON, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + msg->header.token = pcb->token; + + ip = (ng_l2cap_l2ca_con_ip *)(msg->data); + bcopy(&pcb->dst, &ip->bdaddr, sizeof(ip->bdaddr)); + ip->psm = pcb->psm; + + NG_SEND_MSG_HOOK(error,ng_btsocket_l2cap_node,msg,pcb->rt->hook,NULL); + + return (error); +} /* ng_btsocket_l2cap_send_l2ca_con_req */ + +/* + * Send L2CA_Connect response + */ + +static int +ng_btsocket_l2cap_send_l2ca_con_rsp_req(u_int32_t token, + ng_btsocket_l2cap_rtentry_p rt, bdaddr_p dst, int ident, + int lcid, int result) +{ + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_con_rsp_ip *ip = NULL; + int error = 0; + + if (rt == NULL || rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook)) + return (ENETDOWN); + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CON_RSP, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + msg->header.token = token; + + ip = (ng_l2cap_l2ca_con_rsp_ip *)(msg->data); + bcopy(dst, &ip->bdaddr, sizeof(ip->bdaddr)); + ip->ident = ident; + ip->lcid = lcid; + ip->result = result; + ip->status = 0; + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_node, msg, rt->hook, NULL); + + return (error); +} /* ng_btsocket_l2cap_send_l2ca_con_rsp_req */ + +/* + * Send L2CA_Config request + */ + +static int +ng_btsocket_l2cap_send_l2ca_cfg_req(ng_btsocket_l2cap_pcb_p pcb) +{ + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_cfg_ip *ip = NULL; + int error = 0; + + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (pcb->rt == NULL || + pcb->rt->hook == NULL || NG_HOOK_NOT_VALID(pcb->rt->hook)) + return (ENETDOWN); + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CFG, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + msg->header.token = pcb->token; + + ip = (ng_l2cap_l2ca_cfg_ip *)(msg->data); + ip->lcid = pcb->cid; + ip->imtu = pcb->imtu; + bcopy(&pcb->oflow, &ip->oflow, sizeof(ip->oflow)); + ip->flush_timo = pcb->flush_timo; + ip->link_timo = pcb->link_timo; + + NG_SEND_MSG_HOOK(error,ng_btsocket_l2cap_node,msg,pcb->rt->hook,NULL); + + return (error); +} /* ng_btsocket_l2cap_send_l2ca_cfg_req */ + +/* + * Send L2CA_Config response + */ + +static int +ng_btsocket_l2cap_send_l2ca_cfg_rsp(ng_btsocket_l2cap_pcb_p pcb) +{ + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_cfg_rsp_ip *ip = NULL; + int error = 0; + + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (pcb->rt == NULL || + pcb->rt->hook == NULL || NG_HOOK_NOT_VALID(pcb->rt->hook)) + return (ENETDOWN); + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_CFG_RSP, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + msg->header.token = pcb->token; + + ip = (ng_l2cap_l2ca_cfg_rsp_ip *)(msg->data); + ip->lcid = pcb->cid; + ip->omtu = pcb->omtu; + bcopy(&pcb->iflow, &ip->iflow, sizeof(ip->iflow)); + + NG_SEND_MSG_HOOK(error,ng_btsocket_l2cap_node,msg,pcb->rt->hook,NULL); + + return (error); +} /* ng_btsocket_l2cap_send_l2ca_cfg_rsp */ + +/* + * Send L2CA_Disconnect request + */ + +static int +ng_btsocket_l2cap_send_l2ca_discon_req(u_int32_t token, + ng_btsocket_l2cap_pcb_p pcb) +{ + struct ng_mesg *msg = NULL; + ng_l2cap_l2ca_discon_ip *ip = NULL; + int error = 0; + + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (pcb->rt == NULL || + pcb->rt->hook == NULL || NG_HOOK_NOT_VALID(pcb->rt->hook)) + return (ENETDOWN); + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_L2CA_DISCON, + sizeof(*ip), M_NOWAIT); + if (msg == NULL) + return (ENOMEM); + + msg->header.token = token; + + ip = (ng_l2cap_l2ca_discon_ip *)(msg->data); + ip->lcid = pcb->cid; + + NG_SEND_MSG_HOOK(error,ng_btsocket_l2cap_node,msg,pcb->rt->hook,NULL); + + return (error); +} /* ng_btsocket_l2cap_send_l2ca_discon_req */ + +/***************************************************************************** + ***************************************************************************** + ** Socket interface + ***************************************************************************** + *****************************************************************************/ + +/* + * L2CAP sockets data input routine + */ + +static void +ng_btsocket_l2cap_data_input(struct mbuf *m, hook_p hook) +{ + ng_l2cap_hdr_t *hdr = NULL; + ng_l2cap_clt_hdr_t *clt_hdr = NULL; + ng_btsocket_l2cap_pcb_t *pcb = NULL; + ng_btsocket_l2cap_rtentry_t *rt = NULL; + + if (hook == NULL) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Invalid source hook for L2CAP data packet\n", __func__); + goto drop; + } + + rt = (ng_btsocket_l2cap_rtentry_t *) NG_HOOK_PRIVATE(hook); + if (rt == NULL) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not find out source bdaddr for L2CAP data packet\n", __func__); + goto drop; + } + + /* Make sure we can access header */ + if (m->m_pkthdr.len < sizeof(*hdr)) { + NG_BTSOCKET_L2CAP_ERR( +"%s: L2CAP data packet too small, len=%d\n", __func__, m->m_pkthdr.len); + goto drop; + } + + if (m->m_len < sizeof(*hdr)) { + m = m_pullup(m, sizeof(*hdr)); + if (m == NULL) + goto drop; + } + + /* Strip L2CAP packet header and verify packet length */ + hdr = mtod(m, ng_l2cap_hdr_t *); + m_adj(m, sizeof(*hdr)); + + if (hdr->length != m->m_pkthdr.len) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Bad L2CAP data packet length, len=%d, length=%d\n", + __func__, m->m_pkthdr.len, hdr->length); + goto drop; + } + + /* + * Now process packet. Two cases: + * + * 1) Normal packet (cid != 2) then find connected socket and append + * mbuf to the socket queue. Wakeup socket. + * + * 2) Broadcast packet (cid == 2) then find all sockets that connected + * to the given PSM and have SO_BROADCAST bit set and append mbuf + * to the socket queue. Wakeup socket. + */ + + NG_BTSOCKET_L2CAP_INFO( +"%s: Received L2CAP datat packet: src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dcid=%d, length=%d\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + hdr->dcid, hdr->length); + + if (NG_L2CAP_FIRST_CID <= hdr->dcid && hdr->dcid <= NG_L2CAP_LAST_CID) { + /* Normal packet: find connected socket */ + pcb = ng_btsocket_l2cap_pcb_by_cid(&rt->src, hdr->dcid); + if (pcb == NULL) + goto drop; + + mtx_lock(&pcb->pcb_mtx); + + if (pcb->state != NG_BTSOCKET_L2CAP_OPEN) { + NG_BTSOCKET_L2CAP_ERR( +"%s: No connected socket found, src bdaddr=%x:%x:%x:%x:%x:%x, dcid=%d, " \ +"state=%d\n", __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + hdr->dcid, pcb->state); + + mtx_unlock(&pcb->pcb_mtx); + goto drop; + } + + /* Check packet size against socket's incoming MTU */ + if (hdr->length > pcb->imtu) { + NG_BTSOCKET_L2CAP_ERR( +"%s: L2CAP data packet too big, src bdaddr=%x:%x:%x:%x:%x:%x, " \ +"dcid=%d, length=%d, imtu=%d\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + hdr->dcid, hdr->length, pcb->imtu); + + mtx_unlock(&pcb->pcb_mtx); + goto drop; + } + + /* Check if we have enough space in socket receive queue */ + if (m->m_pkthdr.len > sbspace(&pcb->so->so_rcv)) { + + /* + * This is really bad. Receive queue on socket does + * not have enough space for the packet. We do not + * have any other choice but drop the packet. L2CAP + * does not provide any flow control. + */ + + NG_BTSOCKET_L2CAP_ERR( +"%s: Not enough space in socket receive queue. Dropping L2CAP data packet, " \ +"src bdaddr=%x:%x:%x:%x:%x:%x, dcid=%d, len=%d, space=%ld\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + hdr->dcid, m->m_pkthdr.len, + sbspace(&pcb->so->so_rcv)); + + mtx_unlock(&pcb->pcb_mtx); + goto drop; + } + + /* Append packet to the socket receive queue and wakeup */ + sbappendrecord(&pcb->so->so_rcv, m); + m = NULL; + + sorwakeup(pcb->so); + mtx_unlock(&pcb->pcb_mtx); + } else if (hdr->dcid == NG_L2CAP_CLT_CID) { + /* Broadcast packet: give packet to all sockets */ + + /* Check packet size against connectionless MTU */ + if (hdr->length > NG_L2CAP_MTU_DEFAULT) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Connectionless L2CAP data packet too big, " \ +"src bdaddr=%x:%x:%x:%x:%x:%x, length=%d\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + hdr->length); + goto drop; + } + + /* Make sure we can access connectionless header */ + if (m->m_pkthdr.len < sizeof(*clt_hdr)) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Can not get L2CAP connectionless packet header, " \ +"src bdaddr=%x:%x:%x:%x:%x:%x, length=%d\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + hdr->length); + goto drop; + } + + if (m->m_len < sizeof(*clt_hdr)) { + m = m_pullup(m, sizeof(*clt_hdr)); + if (m == NULL) + goto drop; + } + + /* Strip connectionless header and deliver packet */ + clt_hdr = mtod(m, ng_l2cap_clt_hdr_t *); + m_adj(m, sizeof(*clt_hdr)); + + NG_BTSOCKET_L2CAP_INFO( +"%s: Got L2CAP connectionless data packet, " \ +"src bdaddr=%x:%x:%x:%x:%x:%x, psm=%d, length=%d\n", + __func__, + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0], + clt_hdr->psm, hdr->length); + + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + + LIST_FOREACH(pcb, &ng_btsocket_l2cap_sockets, next) { + struct mbuf *copy = NULL; + + mtx_lock(&pcb->pcb_mtx); + + if (bcmp(&rt->src, &pcb->src, sizeof(pcb->src)) != 0 || + pcb->psm != clt_hdr->psm || + pcb->state != NG_BTSOCKET_L2CAP_OPEN || + (pcb->so->so_options & SO_BROADCAST) == 0 || + m->m_pkthdr.len > sbspace(&pcb->so->so_rcv)) + goto next; + + /* + * Create a copy of the packet and append it to the + * socket's queue. If m_dup() failed - no big deal + * it is a broadcast traffic after all + */ + + copy = m_dup(m, M_NOWAIT); + if (copy != NULL) { + sbappendrecord(&pcb->so->so_rcv, copy); + sorwakeup(pcb->so); + } +next: + mtx_unlock(&pcb->pcb_mtx); + } + + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + } +drop: + NG_FREE_M(m); /* checks for m != NULL */ +} /* ng_btsocket_l2cap_data_input */ + +/* + * L2CAP sockets default message input routine + */ + +static void +ng_btsocket_l2cap_default_msg_input(struct ng_mesg *msg, hook_p hook) +{ + switch (msg->header.cmd) { + case NGM_L2CAP_NODE_HOOK_INFO: { + ng_btsocket_l2cap_rtentry_t *rt = NULL; + + if (hook == NULL || msg->header.arglen != sizeof(bdaddr_t)) + break; + + if (bcmp(msg->data, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) + break; + + rt = (ng_btsocket_l2cap_rtentry_t *) NG_HOOK_PRIVATE(hook); + if (rt == NULL) { + MALLOC(rt, ng_btsocket_l2cap_rtentry_p, sizeof(*rt), + M_NETGRAPH_BTSOCKET_L2CAP, M_NOWAIT|M_ZERO); + if (rt == NULL) + break; + + mtx_lock(&ng_btsocket_l2cap_rt_mtx); + LIST_INSERT_HEAD(&ng_btsocket_l2cap_rt, rt, next); + mtx_unlock(&ng_btsocket_l2cap_rt_mtx); + + NG_HOOK_SET_PRIVATE(hook, rt); + } + + bcopy(msg->data, &rt->src, sizeof(rt->src)); + rt->hook = hook; + + NG_BTSOCKET_L2CAP_INFO( +"%s: Updating hook \"%s\", src bdaddr=%x:%x:%x:%x:%x:%x\n", + __func__, NG_HOOK_NAME(hook), + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0]); + } break; + + default: + NG_BTSOCKET_L2CAP_WARN( +"%s: Unknown message, cmd=%d\n", __func__, msg->header.cmd); + break; + } + + NG_FREE_MSG(msg); /* Checks for msg != NULL */ +} /* ng_btsocket_l2cap_default_msg_input */ + +/* + * L2CAP sockets L2CA message input routine + */ + +static void +ng_btsocket_l2cap_l2ca_msg_input(struct ng_mesg *msg, hook_p hook) +{ + ng_btsocket_l2cap_rtentry_p rt = NULL; + + if (hook == NULL) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Invalid source hook for L2CA message\n", __func__); + goto drop; + } + + rt = (ng_btsocket_l2cap_rtentry_p) NG_HOOK_PRIVATE(hook); + if (rt == NULL) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not find out source bdaddr for L2CA message\n", __func__); + goto drop; + } + + switch (msg->header.cmd) { + case NGM_L2CAP_L2CA_CON: /* L2CA_Connect response */ + ng_btsocket_l2cap_process_l2ca_con_req_rsp(msg, rt); + break; + + case NGM_L2CAP_L2CA_CON_RSP: /* L2CA_ConnectRsp response */ + ng_btsocket_l2cap_process_l2ca_con_rsp_rsp(msg, rt); + break; + + case NGM_L2CAP_L2CA_CON_IND: /* L2CA_Connect indicator */ + ng_btsocket_l2cap_process_l2ca_con_ind(msg, rt); + break; + + case NGM_L2CAP_L2CA_CFG: /* L2CA_Config response */ + ng_btsocket_l2cap_process_l2ca_cfg_req_rsp(msg, rt); + break; + + case NGM_L2CAP_L2CA_CFG_RSP: /* L2CA_ConfigRsp response */ + ng_btsocket_l2cap_process_l2ca_cfg_rsp_rsp(msg, rt); + break; + + case NGM_L2CAP_L2CA_CFG_IND: /* L2CA_Config indicator */ + ng_btsocket_l2cap_process_l2ca_cfg_ind(msg, rt); + break; + + case NGM_L2CAP_L2CA_DISCON: /* L2CA_Disconnect response */ + ng_btsocket_l2cap_process_l2ca_discon_rsp(msg, rt); + break; + + case NGM_L2CAP_L2CA_DISCON_IND: /* L2CA_Disconnect indicator */ + ng_btsocket_l2cap_process_l2ca_discon_ind(msg, rt); + break; + + case NGM_L2CAP_L2CA_WRITE: /* L2CA_Write response */ + ng_btsocket_l2cap_process_l2ca_write_rsp(msg, rt); + break; + + /* XXX FIXME add other L2CA messages */ + + default: + NG_BTSOCKET_L2CAP_WARN( +"%s: Unknown L2CA message, cmd=%d\n", __func__, msg->header.cmd); + break; + } +drop: + NG_FREE_MSG(msg); +} /* ng_btsocket_l2cap_l2ca_msg_input */ + +/* + * L2CAP sockets input routine + */ + +static void +ng_btsocket_l2cap_input(void *context, int pending) +{ + item_p item = NULL; + hook_p hook = NULL; + + for (;;) { + mtx_lock(&ng_btsocket_l2cap_queue_mtx); + NG_BT_ITEMQ_DEQUEUE(&ng_btsocket_l2cap_queue, item); + mtx_unlock(&ng_btsocket_l2cap_queue_mtx); + + if (item == NULL) + break; + + NGI_GET_HOOK(item, hook); + if (hook != NULL && NG_HOOK_NOT_VALID(hook)) + goto drop; + + switch(item->el_flags & NGQF_TYPE) { + case NGQF_DATA: { + struct mbuf *m = NULL; + + NGI_GET_M(item, m); + ng_btsocket_l2cap_data_input(m, hook); + } break; + + case NGQF_MESG: { + struct ng_mesg *msg = NULL; + + NGI_GET_MSG(item, msg); + + switch (msg->header.cmd) { + case NGM_L2CAP_L2CA_CON: + case NGM_L2CAP_L2CA_CON_RSP: + case NGM_L2CAP_L2CA_CON_IND: + case NGM_L2CAP_L2CA_CFG: + case NGM_L2CAP_L2CA_CFG_RSP: + case NGM_L2CAP_L2CA_CFG_IND: + case NGM_L2CAP_L2CA_DISCON: + case NGM_L2CAP_L2CA_DISCON_IND: + case NGM_L2CAP_L2CA_WRITE: + /* XXX FIXME add other L2CA messages */ + ng_btsocket_l2cap_l2ca_msg_input(msg, hook); + break; + + default: + ng_btsocket_l2cap_default_msg_input(msg, hook); + break; + } + } break; + + default: + KASSERT(0, +("%s: invalid item type=%ld\n", __func__, (item->el_flags & NGQF_TYPE))); + break; + } +drop: + if (hook != NULL) + NG_HOOK_UNREF(hook); + + NG_FREE_ITEM(item); + } +} /* ng_btsocket_l2cap_input */ + +/* + * Route cleanup task. Gets scheduled when hook is disconnected. Here we + * will find all sockets that use "invalid" hook and disconnect them. + */ + +static void +ng_btsocket_l2cap_rtclean(void *context, int pending) +{ + ng_btsocket_l2cap_pcb_p pcb = NULL; + ng_btsocket_l2cap_rtentry_p rt = NULL; + + mtx_lock(&ng_btsocket_l2cap_rt_mtx); + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + + /* + * First disconnect all sockets that use "invalid" hook + */ + + LIST_FOREACH(pcb, &ng_btsocket_l2cap_sockets, next) { + mtx_lock(&pcb->pcb_mtx); + + if (pcb->rt != NULL && + pcb->rt->hook != NULL && NG_HOOK_NOT_VALID(pcb->rt->hook)) { + if (pcb->flags & NG_BTSOCKET_L2CAP_TIMO) + ng_btsocket_l2cap_untimeout(pcb); + + pcb->so->so_error = ENETDOWN; + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + + pcb->token = 0; + pcb->rt = NULL; + } + + mtx_unlock(&pcb->pcb_mtx); + } + + /* + * Now cleanup routing table + */ + + rt = LIST_FIRST(&ng_btsocket_l2cap_rt); + while (rt != NULL) { + ng_btsocket_l2cap_rtentry_p rt_next = LIST_NEXT(rt, next); + + if (rt->hook != NULL && NG_HOOK_NOT_VALID(rt->hook)) { + LIST_REMOVE(rt, next); + + NG_HOOK_SET_PRIVATE(rt->hook, NULL); + NG_HOOK_UNREF(rt->hook); /* Remove extra reference */ + + bzero(rt, sizeof(*rt)); + FREE(rt, M_NETGRAPH_BTSOCKET_L2CAP); + } + + rt = rt_next; + } + + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + mtx_unlock(&ng_btsocket_l2cap_rt_mtx); +} /* ng_btsocket_l2cap_rtclean */ + +/* + * Initialize everything + */ + +void +ng_btsocket_l2cap_init(void) +{ + int error = 0; + + ng_btsocket_l2cap_node = NULL; + ng_btsocket_l2cap_debug_level = NG_BTSOCKET_WARN_LEVEL; + ng_btsocket_l2cap_ioctl_timeout = 5; + + /* Register Netgraph node type */ + error = ng_newtype(&typestruct); + if (error != 0) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not register Netgraph node type, error=%d\n", __func__, error); + + return; + } + + /* Create Netgrapg node */ + error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_node); + if (error != 0) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not create Netgraph node, error=%d\n", __func__, error); + + ng_btsocket_l2cap_node = NULL; + + return; + } + + error = ng_name_node(ng_btsocket_l2cap_node, + NG_BTSOCKET_L2CAP_NODE_TYPE); + if (error != 0) { + NG_BTSOCKET_L2CAP_ALERT( +"%s: Could not name Netgraph node, error=%d\n", __func__, error); + + NG_NODE_UNREF(ng_btsocket_l2cap_node); + ng_btsocket_l2cap_node = NULL; + + return; + } + + /* Create input queue */ + NG_BT_ITEMQ_INIT(&ng_btsocket_l2cap_queue, ifqmaxlen); + mtx_init(&ng_btsocket_l2cap_queue_mtx, + "btsocks_l2cap_queue_mtx", NULL, MTX_DEF); + TASK_INIT(&ng_btsocket_l2cap_queue_task, 0, + ng_btsocket_l2cap_input, NULL); + + /* Create list of sockets */ + LIST_INIT(&ng_btsocket_l2cap_sockets); + mtx_init(&ng_btsocket_l2cap_sockets_mtx, + "btsocks_l2cap_sockets_mtx", NULL, MTX_DEF); + + /* Tokens */ + ng_btsocket_l2cap_token = 0; + mtx_init(&ng_btsocket_l2cap_token_mtx, + "btsocks_l2cap_token_mtx", NULL, MTX_DEF); + + /* Routing table */ + LIST_INIT(&ng_btsocket_l2cap_rt); + mtx_init(&ng_btsocket_l2cap_rt_mtx, + "btsocks_l2cap_rt_mtx", NULL, MTX_DEF); + TASK_INIT(&ng_btsocket_l2cap_rt_task, 0, + ng_btsocket_l2cap_rtclean, NULL); +} /* ng_btsocket_l2cap_init */ + +/* + * Abort connection on socket + */ + +int +ng_btsocket_l2cap_abort(struct socket *so) +{ + so->so_error = ECONNABORTED; + + return (ng_btsocket_l2cap_detach(so)); +} /* ng_btsocket_l2cap_abort */ + +/* + * Accept connection on socket. Nothing to do here, socket must be connected + * and ready, so just return peer address and be done with it. + */ + +int +ng_btsocket_l2cap_accept(struct socket *so, struct sockaddr **nam) +{ + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + return (ng_btsocket_l2cap_peeraddr(so, nam)); +} /* ng_btsocket_l2cap_accept */ + +/* + * Create and attach new socket + */ + +int +ng_btsocket_l2cap_attach(struct socket *so, int proto, struct thread *td) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + int error; + + /* Check socket and protocol */ + if (ng_btsocket_l2cap_node == NULL) + return (EPROTONOSUPPORT); + if (so->so_type != SOCK_SEQPACKET) + return (ESOCKTNOSUPPORT); + +#if 0 /* XXX sonewconn() calls "pru_attach" with proto == 0 */ + if (proto != 0) + if (proto != BLUETOOTH_PROTO_L2CAP) + return (EPROTONOSUPPORT); +#endif /* XXX */ + + if (pcb != NULL) + return (EISCONN); + + /* Reserve send and receive space if it is not reserved yet */ + if ((so->so_snd.sb_hiwat == 0) || (so->so_rcv.sb_hiwat == 0)) { + error = soreserve(so, NG_BTSOCKET_L2CAP_SENDSPACE, + NG_BTSOCKET_L2CAP_RECVSPACE); + if (error != 0) + return (error); + } + + /* Allocate the PCB */ + MALLOC(pcb, ng_btsocket_l2cap_pcb_p, sizeof(*pcb), + M_NETGRAPH_BTSOCKET_L2CAP, M_NOWAIT | M_ZERO); + if (pcb == NULL) + return (ENOMEM); + + /* Link the PCB and the socket */ + so->so_pcb = (caddr_t) pcb; + pcb->so = so; + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + + /* Initialize PCB */ + pcb->imtu = pcb->omtu = NG_L2CAP_MTU_DEFAULT; + + /* Default flow */ + pcb->iflow.flags = 0x0; + pcb->iflow.service_type = NG_HCI_SERVICE_TYPE_BEST_EFFORT; + pcb->iflow.token_rate = 0xffffffff; /* maximum */ + pcb->iflow.token_bucket_size = 0xffffffff; /* maximum */ + pcb->iflow.peak_bandwidth = 0x00000000; /* maximum */ + pcb->iflow.latency = 0xffffffff; /* don't care */ + pcb->iflow.delay_variation = 0xffffffff; /* don't care */ + + bcopy(&pcb->iflow, &pcb->oflow, sizeof(pcb->oflow)); + + pcb->flush_timo = NG_L2CAP_FLUSH_TIMO_DEFAULT; + pcb->link_timo = NG_L2CAP_LINK_TIMO_DEFAULT; + + ng_btsocket_l2cap_get_token(&pcb->token); + + callout_handle_init(&pcb->timo); + mtx_init(&pcb->pcb_mtx, "btsocket_pcb_mtx", NULL, MTX_DEF); + + /* Add the PCB to the list */ + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + LIST_INSERT_HEAD(&ng_btsocket_l2cap_sockets, pcb, next); + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + + return (0); +} /* ng_btsocket_l2cap_attach */ + +/* + * Bind socket + */ + +int +ng_btsocket_l2cap_bind(struct socket *so, struct sockaddr *nam, + struct thread *td) +{ + ng_btsocket_l2cap_pcb_t *pcb = NULL; + struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam; + int psm, error = 0; + + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + /* Verify address */ + if (sa == NULL) + return (EINVAL); + if (sa->l2cap_family != AF_BLUETOOTH) + return (EAFNOSUPPORT); + if (sa->l2cap_len != sizeof(*sa)) + return (EINVAL); + + psm = le16toh(sa->l2cap_psm); + + /* + * Check if other socket has this address already (look for exact + * match PSM and bdaddr) and assign socket address if it's available. + * + * Note: socket can be bound to ANY PSM (zero) thus allowing several + * channels with the same PSM between the same pair of BD_ADDR'es. + */ + + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + + LIST_FOREACH(pcb, &ng_btsocket_l2cap_sockets, next) + if (psm != 0 && psm == pcb->psm && + bcmp(&pcb->src, &sa->l2cap_bdaddr, sizeof(bdaddr_t)) == 0) + break; + + if (pcb == NULL) { + /* Set socket address */ + pcb = so2l2cap_pcb(so); + if (pcb != NULL) { + bcopy(&sa->l2cap_bdaddr, &pcb->src, sizeof(pcb->src)); + pcb->psm = psm; + } else + error = EINVAL; + } else + error = EADDRINUSE; + + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + + return (error); +} /* ng_btsocket_l2cap_bind */ + +/* + * Connect socket + */ + +int +ng_btsocket_l2cap_connect(struct socket *so, struct sockaddr *nam, + struct thread *td) +{ + ng_btsocket_l2cap_pcb_t *pcb = so2l2cap_pcb(so); + struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam; + ng_btsocket_l2cap_rtentry_t *rt = NULL; + int have_src, error = 0; + + /* Check socket */ + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + if (pcb->state == NG_BTSOCKET_L2CAP_CONNECTING) + return (EINPROGRESS); + + /* Verify address */ + if (sa == NULL) + return (EINVAL); + if (sa->l2cap_family != AF_BLUETOOTH) + return (EAFNOSUPPORT); + if (sa->l2cap_len != sizeof(*sa)) + return (EINVAL); + if (sa->l2cap_psm == 0 || + bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) + return (EDESTADDRREQ); + if (pcb->psm != 0 && pcb->psm != le16toh(sa->l2cap_psm)) + return (EINVAL); + + /* Send destination address and PSM */ + bcopy(&sa->l2cap_bdaddr, &pcb->dst, sizeof(pcb->dst)); + pcb->psm = le16toh(sa->l2cap_psm); + + /* + * Routing. Socket should be bound to some source address. The source + * address can be ANY. Destination address must be set and it must not + * be ANY. If source address is ANY then find first rtentry that has + * src != dst. + */ + + pcb->rt = NULL; + have_src = bcmp(&pcb->src, NG_HCI_BDADDR_ANY, sizeof(pcb->src)); + + mtx_lock(&ng_btsocket_l2cap_rt_mtx); + + LIST_FOREACH(rt, &ng_btsocket_l2cap_rt, next) { + if (rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook)) + continue; + + /* Match src and dst */ + if (have_src) { + if (bcmp(&pcb->src, &rt->src, sizeof(rt->src)) == 0) + break; + } else { + if (bcmp(&pcb->dst, &rt->src, sizeof(rt->src)) != 0) + break; + } + } + + if (rt != NULL) { + pcb->rt = rt; + + if (!have_src) + bcopy(&rt->src, &pcb->src, sizeof(pcb->src)); + } else + error = EHOSTUNREACH; + + mtx_unlock(&ng_btsocket_l2cap_rt_mtx); + + /* + * Send L2CA_Connect request + */ + + if (error == 0) { + mtx_lock(&pcb->pcb_mtx); + error = ng_btsocket_l2cap_send_l2ca_con_req(pcb); + if (error == 0) { + pcb->flags |= NG_BTSOCKET_L2CAP_CLIENT; + pcb->state = NG_BTSOCKET_L2CAP_CONNECTING; + soisconnecting(pcb->so); + + ng_btsocket_l2cap_timeout(pcb); + } + mtx_unlock(&pcb->pcb_mtx); + } + + return (error); +} /* ng_btsocket_l2cap_connect */ + +/* + * Process ioctl's calls on socket + */ + +int +ng_btsocket_l2cap_control(struct socket *so, u_long cmd, caddr_t data, + struct ifnet *ifp, struct thread *td) +{ + return (EINVAL); +} /* ng_btsocket_l2cap_control */ + +/* + * Process getsockopt/setsockopt system calls + */ + +int +ng_btsocket_l2cap_ctloutput(struct socket *so, struct sockopt *sopt) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + int error = 0; + ng_l2cap_cfg_opt_val_t v; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + if (sopt->sopt_level != SOL_L2CAP) + return (0); + + mtx_lock(&pcb->pcb_mtx); + + switch (sopt->sopt_dir) { + case SOPT_GET: + switch (sopt->sopt_name) { + case SO_L2CAP_IMTU: /* get incoming MTU */ + error = sooptcopyout(sopt, &pcb->imtu, + sizeof(pcb->imtu)); + break; + + case SO_L2CAP_OMTU: /* get outgoing (peer incoming) MTU */ + error = sooptcopyout(sopt, &pcb->omtu, + sizeof(pcb->omtu)); + break; + + case SO_L2CAP_IFLOW: /* get incoming flow spec. */ + error = sooptcopyout(sopt, &pcb->iflow, + sizeof(pcb->iflow)); + break; + + case SO_L2CAP_OFLOW: /* get outgoing flow spec. */ + error = sooptcopyout(sopt, &pcb->oflow, + sizeof(pcb->oflow)); + break; + + case SO_L2CAP_FLUSH: /* get flush timeout */ + error = sooptcopyout(sopt, &pcb->flush_timo, + sizeof(pcb->flush_timo)); + break; + + default: + error = ENOPROTOOPT; + break; + } + break; + + case SOPT_SET: + /* + * We do not allow to change these parameters while + * socket is connected or we are in the process of + * creating a connection + * + * XXX may be this should indicate re-configuration of the + * open channel? + */ + + if (pcb->state != NG_BTSOCKET_L2CAP_CLOSED) + return (EACCES); + + switch (sopt->sopt_name) { + case SO_L2CAP_IMTU: /* set incoming MTU */ + error = sooptcopyin(sopt, &v, sizeof(v), sizeof(v.mtu)); + if (error == 0) + pcb->imtu = v.mtu; + break; + + case SO_L2CAP_OFLOW: /* set outgoing flow spec. */ + error = sooptcopyin(sopt, &v, sizeof(v),sizeof(v.flow)); + if (error == 0) + bcopy(&v.flow, &pcb->oflow, sizeof(pcb->oflow)); + break; + + case SO_L2CAP_FLUSH: /* set flush timeout */ + error = sooptcopyin(sopt, &v, sizeof(v), + sizeof(v.flush_timo)); + if (error == 0) + pcb->flush_timo = v.flush_timo; + break; + + default: + error = ENOPROTOOPT; + break; + } + break; + + default: + error = EINVAL; + break; + } + + mtx_unlock(&pcb->pcb_mtx); + + return (error); +} /* ng_btsocket_l2cap_ctloutput */ + +/* + * Detach and destroy socket + */ + +int +ng_btsocket_l2cap_detach(struct socket *so) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + mtx_lock(&pcb->pcb_mtx); + + /* XXX what to do with pending request? */ + if (pcb->flags & NG_BTSOCKET_L2CAP_TIMO) + ng_btsocket_l2cap_untimeout(pcb); + + if (pcb->state != NG_BTSOCKET_L2CAP_CLOSED && + pcb->state != NG_BTSOCKET_L2CAP_DISCONNECTING) + /* Send disconnect request with "zero" token */ + ng_btsocket_l2cap_send_l2ca_discon_req(0, pcb); + + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(so); + + so->so_pcb = NULL; + sotryfree(so); + + mtx_unlock(&pcb->pcb_mtx); + + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + LIST_REMOVE(pcb, next); + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + + mtx_destroy(&pcb->pcb_mtx); + bzero(pcb, sizeof(*pcb)); + FREE(pcb, M_NETGRAPH_BTSOCKET_L2CAP); + + return (0); +} /* ng_btsocket_l2cap_detach */ + +/* + * Disconnect socket + */ + +int +ng_btsocket_l2cap_disconnect(struct socket *so) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + int error = 0; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + mtx_lock(&pcb->pcb_mtx); + + if (pcb->state == NG_BTSOCKET_L2CAP_DISCONNECTING) { + mtx_unlock(&pcb->pcb_mtx); + return (EINPROGRESS); + } + + if (pcb->state != NG_BTSOCKET_L2CAP_CLOSED) { + /* XXX FIXME what to do with pending request? */ + if (pcb->flags & NG_BTSOCKET_L2CAP_TIMO) + ng_btsocket_l2cap_untimeout(pcb); + + error = ng_btsocket_l2cap_send_l2ca_discon_req(pcb->token, pcb); + if (error == 0) { + pcb->state = NG_BTSOCKET_L2CAP_DISCONNECTING; + soisdisconnecting(so); + + ng_btsocket_l2cap_timeout(pcb); + } + + /* XXX FIXME what to do if error != 0 */ + } + + mtx_unlock(&pcb->pcb_mtx); + + return (error); +} /* ng_btsocket_l2cap_disconnect */ + +/* + * Listen on socket + */ + +int +ng_btsocket_l2cap_listen(struct socket *so, struct thread *td) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + return ((pcb->psm == 0)? EDESTADDRREQ : 0); +} /* ng_btsocket_listen */ + +/* + * Get peer address + */ + +int +ng_btsocket_l2cap_peeraddr(struct socket *so, struct sockaddr **nam) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + struct sockaddr_l2cap sa; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + bcopy(&pcb->dst, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr)); + sa.l2cap_psm = htole16(pcb->psm); + sa.l2cap_len = sizeof(sa); + sa.l2cap_family = AF_BLUETOOTH; + + *nam = dup_sockaddr((struct sockaddr *) &sa, 0); + + return ((*nam == NULL)? ENOMEM : 0); +} /* ng_btsocket_l2cap_peeraddr */ + +/* + * Send data to socket + */ + +int +ng_btsocket_l2cap_send(struct socket *so, int flags, struct mbuf *m, + struct sockaddr *nam, struct mbuf *control, struct thread *td) +{ + ng_btsocket_l2cap_pcb_t *pcb = so2l2cap_pcb(so); + int error = 0; + + if (ng_btsocket_l2cap_node == NULL) { + error = ENETDOWN; + goto drop; + } + + /* Check socket and input */ + if (pcb == NULL || m == NULL || control != NULL) { + error = EINVAL; + goto drop; + } + + mtx_lock(&pcb->pcb_mtx); + + /* Make sure socket is connected */ + if (pcb->state != NG_BTSOCKET_L2CAP_OPEN) { + mtx_unlock(&pcb->pcb_mtx); + error = ENOTCONN; + goto drop; + } + + /* Check route */ + if (pcb->rt == NULL || + pcb->rt->hook == NULL || NG_HOOK_NOT_VALID(pcb->rt->hook)) { + mtx_unlock(&pcb->pcb_mtx); + error = ENETDOWN; + goto drop; + } + + /* Check packet size agains outgoing (peer's incoming) MTU) */ + if (m->m_pkthdr.len > pcb->omtu) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Packet too big, len=%d, omtu=%d\n", __func__, m->m_pkthdr.len, pcb->omtu); + + mtx_unlock(&pcb->pcb_mtx); + error = EMSGSIZE; + goto drop; + } + + /* + * First put packet on socket send queue. Then check if we have + * pending timeout. If we do not have timeout then we must send + * packet and schedule timeout. Otherwise do nothing and wait for + * L2CA_WRITE_RSP. + */ + + sbappendrecord(&pcb->so->so_snd, m); + m = NULL; + + if (!(pcb->flags & NG_BTSOCKET_L2CAP_TIMO)) { + error = ng_btsocket_l2cap_send2(pcb); + if (error == 0) + ng_btsocket_l2cap_timeout(pcb); + else + sbdroprecord(&pcb->so->so_snd); /* XXX */ + } + + mtx_unlock(&pcb->pcb_mtx); +drop: + NG_FREE_M(m); /* checks for != NULL */ + NG_FREE_M(control); + + return (error); +} /* ng_btsocket_l2cap_send */ + +/* + * Send first packet in the socket queue to the L2CAP layer + */ + +static int +ng_btsocket_l2cap_send2(ng_btsocket_l2cap_pcb_p pcb) +{ + struct mbuf *m = NULL; + ng_l2cap_l2ca_hdr_t *hdr = NULL; + int error = 0; + + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (pcb->so->so_snd.sb_cc == 0) + return (EINVAL); /* XXX */ + + m = m_dup(pcb->so->so_snd.sb_mb, M_NOWAIT); + if (m == NULL) + return (ENOBUFS); + + /* Create L2CA packet header */ + M_PREPEND(m, sizeof(*hdr), M_NOWAIT); + if (m != NULL) + if (m->m_len < sizeof(*hdr)) + m = m_pullup(m, sizeof(*hdr)); + + if (m == NULL) { + NG_BTSOCKET_L2CAP_ERR( +"%s: Failed to create L2CA packet header\n", __func__); + + return (ENOBUFS); + } + + hdr = mtod(m, ng_l2cap_l2ca_hdr_t *); + hdr->token = pcb->token; + hdr->length = m->m_pkthdr.len - sizeof(*hdr); + hdr->lcid = pcb->cid; + + NG_BTSOCKET_L2CAP_INFO( +"%s: Sending packet: len=%d, length=%d, lcid=%d, token=%d, state=%d\n", + __func__, m->m_pkthdr.len, hdr->length, hdr->lcid, + hdr->token, pcb->state); + + /* + * If we got here than we have successfuly creates new L2CAP + * data packet and now we can send it to the L2CAP layer + */ + + NG_SEND_DATA_ONLY(error, pcb->rt->hook, m); + + return (error); +} /* ng_btsocket_l2cap_send2 */ + +/* + * Get socket address + */ + +int +ng_btsocket_l2cap_sockaddr(struct socket *so, struct sockaddr **nam) +{ + ng_btsocket_l2cap_pcb_p pcb = so2l2cap_pcb(so); + struct sockaddr_l2cap sa; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_node == NULL) + return (EINVAL); + + bcopy(&pcb->src, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr)); + sa.l2cap_psm = htole16(pcb->psm); + sa.l2cap_len = sizeof(sa); + sa.l2cap_family = AF_BLUETOOTH; + + *nam = dup_sockaddr((struct sockaddr *) &sa, 0); + + return ((*nam == NULL)? ENOMEM : 0); +} /* ng_btsocket_l2cap_sockaddr */ + +/***************************************************************************** + ***************************************************************************** + ** Misc. functions + ***************************************************************************** + *****************************************************************************/ + +/* + * Look for the socket that listens on given PSM and bdaddr. Returns exact or + * close match (if any). + */ + +static ng_btsocket_l2cap_pcb_p +ng_btsocket_l2cap_pcb_by_addr(bdaddr_p bdaddr, int psm) +{ + ng_btsocket_l2cap_pcb_p p = NULL, p1 = NULL; + + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + + LIST_FOREACH(p, &ng_btsocket_l2cap_sockets, next) { + if (p->so == NULL || !(p->so->so_options & SO_ACCEPTCONN) || + p->psm != psm) + continue; + + if (bcmp(&p->src, bdaddr, sizeof(p->src)) == 0) + break; + + if (bcmp(&p->src, NG_HCI_BDADDR_ANY, sizeof(p->src)) == 0) + p1 = p; + } + + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + + return ((p != NULL)? p : p1); +} /* ng_btsocket_l2cap_pcb_by_addr */ + +/* + * Look for the socket that has given token + */ + +static ng_btsocket_l2cap_pcb_p +ng_btsocket_l2cap_pcb_by_token(u_int32_t token) +{ + ng_btsocket_l2cap_pcb_p p = NULL; + + if (token != 0) { + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + + LIST_FOREACH(p, &ng_btsocket_l2cap_sockets, next) + if (p->token == token) + break; + + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + } + + return (p); +} /* ng_btsocket_l2cap_pcb_by_token */ + +/* + * Look for the socket that assigned to given source address and channel ID + */ + +static ng_btsocket_l2cap_pcb_p +ng_btsocket_l2cap_pcb_by_cid(bdaddr_p src, int cid) +{ + ng_btsocket_l2cap_pcb_p p = NULL; + + mtx_lock(&ng_btsocket_l2cap_sockets_mtx); + + LIST_FOREACH(p, &ng_btsocket_l2cap_sockets, next) + if (p->cid == cid && bcmp(src, &p->src, sizeof(p->src)) == 0) + break; + + mtx_unlock(&ng_btsocket_l2cap_sockets_mtx); + + return (p); +} /* ng_btsocket_l2cap_pcb_by_cid */ + +/* + * Set timeout on socket + */ + +static void +ng_btsocket_l2cap_timeout(ng_btsocket_l2cap_pcb_p pcb) +{ + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (!(pcb->flags & NG_BTSOCKET_L2CAP_TIMO)) { + pcb->flags |= NG_BTSOCKET_L2CAP_TIMO; + pcb->timo = timeout(ng_btsocket_l2cap_process_timeout, pcb, + bluetooth_l2cap_ertx_timeout()); + } else + KASSERT(0, +("%s: Duplicated socket timeout?!\n", __func__)); +} /* ng_btsocket_l2cap_timeout */ + +/* + * Unset timeout on socket + */ + +static void +ng_btsocket_l2cap_untimeout(ng_btsocket_l2cap_pcb_p pcb) +{ + mtx_assert(&pcb->pcb_mtx, MA_OWNED); + + if (pcb->flags & NG_BTSOCKET_L2CAP_TIMO) { + untimeout(ng_btsocket_l2cap_process_timeout, pcb, pcb->timo); + pcb->flags &= ~NG_BTSOCKET_L2CAP_TIMO; + } else + KASSERT(0, +("%s: No socket timeout?!\n", __func__)); +} /* ng_btsocket_l2cap_untimeout */ + +/* + * Process timeout on socket + */ + +static void +ng_btsocket_l2cap_process_timeout(void *xpcb) +{ + ng_btsocket_l2cap_pcb_p pcb = (ng_btsocket_l2cap_pcb_p) xpcb; + + mtx_lock(&pcb->pcb_mtx); + + pcb->flags &= ~NG_BTSOCKET_L2CAP_TIMO; + pcb->so->so_error = ETIMEDOUT; + + switch (pcb->state) { + case NG_BTSOCKET_L2CAP_CONNECTING: + case NG_BTSOCKET_L2CAP_CONFIGURING: + /* Send disconnect request with "zero" token */ + if (pcb->cid != 0) + ng_btsocket_l2cap_send_l2ca_discon_req(0, pcb); + + /* ... and close the socket */ + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + break; + + case NG_BTSOCKET_L2CAP_OPEN: + /* Send timeout - drop packet and wakeup sender */ + sbdroprecord(&pcb->so->so_snd); + sowwakeup(pcb->so); + break; + + case NG_BTSOCKET_L2CAP_DISCONNECTING: + /* Disconnect timeout - disconnect the socket anyway */ + pcb->state = NG_BTSOCKET_L2CAP_CLOSED; + soisdisconnected(pcb->so); + break; + + default: + NG_BTSOCKET_L2CAP_ERR( +"%s: Invalid socket state=%d\n", __func__, pcb->state); + break; + } + + mtx_unlock(&pcb->pcb_mtx); +} /* ng_btsocket_l2cap_process_timeout */ + +/* + * Get next token + */ + +static void +ng_btsocket_l2cap_get_token(u_int32_t *token) +{ + mtx_lock(&ng_btsocket_l2cap_token_mtx); + + if (++ ng_btsocket_l2cap_token == 0) + ng_btsocket_l2cap_token = 1; + + *token = ng_btsocket_l2cap_token; + + mtx_unlock(&ng_btsocket_l2cap_token_mtx); +} /* ng_btsocket_l2cap_get_token */ + +/* + * Translate HCI/L2CAP error code into "errno" code + * XXX Note: Some L2CAP and HCI error codes have the same value, but + * different meaning + */ + +static int +ng_btsocket_l2cap_result2errno(int result) +{ + switch (result) { + case 0x00: /* No error */ + return (0); + + case 0x01: /* Unknown HCI command */ + return (ENODEV); + + case 0x02: /* No connection */ + return (ENOTCONN); + + case 0x03: /* Hardware failure */ + return (EIO); + + case 0x04: /* Page timeout */ + return (EHOSTDOWN); + + case 0x05: /* Authentication failure */ + case 0x06: /* Key missing */ + case 0x18: /* Pairing not allowed */ + case 0x21: /* Role change not allowed */ + case 0x24: /* LMP PSU not allowed */ + case 0x25: /* Encryption mode not acceptable */ + case 0x26: /* Unit key used */ + return (EACCES); + + case 0x07: /* Memory full */ + return (ENOMEM); + + case 0x08: /* Connection timeout */ + case 0x10: /* Host timeout */ + case 0x22: /* LMP response timeout */ + case 0xee: /* HCI timeout */ + case 0xeeee: /* L2CAP timeout */ + return (ETIMEDOUT); + + case 0x09: /* Max number of connections */ + case 0x0a: /* Max number of SCO connections to a unit */ + return (EMLINK); + + case 0x0b: /* ACL connection already exists */ + return (EEXIST); + + case 0x0c: /* Command disallowed */ + return (EBUSY); + + case 0x0d: /* Host rejected due to limited resources */ + case 0x0e: /* Host rejected due to securiity reasons */ + case 0x0f: /* Host rejected due to remote unit is a personal unit */ + case 0x1b: /* SCO offset rejected */ + case 0x1c: /* SCO interval rejected */ + case 0x1d: /* SCO air mode rejected */ + return (ECONNREFUSED); + + case 0x11: /* Unsupported feature or parameter value */ + case 0x19: /* Unknown LMP PDU */ + case 0x1a: /* Unsupported remote feature */ + case 0x20: /* Unsupported LMP parameter value */ + case 0x27: /* QoS is not supported */ + case 0x29: /* Paring with unit key not supported */ + return (EOPNOTSUPP); + + case 0x12: /* Invalid HCI command parameter */ + case 0x1e: /* Invalid LMP parameters */ + return (EINVAL); + + case 0x13: /* Other end terminated connection: User ended connection */ + case 0x14: /* Other end terminated connection: Low resources */ + case 0x15: /* Other end terminated connection: About to power off */ + return (ECONNRESET); + + case 0x16: /* Connection terminated by local host */ + return (ECONNABORTED); + +#if 0 /* XXX not yet */ + case 0x17: /* Repeated attempts */ + case 0x1f: /* Unspecified error */ + case 0x23: /* LMP error transaction collision */ + case 0x28: /* Instant passed */ +#endif + } + + return (ENOSYS); +} /* ng_btsocket_l2cap_result2errno */ + diff --git a/sys/netgraph/bluetooth/socket/ng_btsocket_l2cap_raw.c b/sys/netgraph/bluetooth/socket/ng_btsocket_l2cap_raw.c new file mode 100644 index 0000000..3b24afd --- /dev/null +++ b/sys/netgraph/bluetooth/socket/ng_btsocket_l2cap_raw.c @@ -0,0 +1,1222 @@ +/* + * ng_btsocket_l2cap_raw.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: ng_btsocket_l2cap_raw.c,v 1.1 2002/09/04 21:44:00 max Exp $ + * $FreeBSD$ + */ + +#include <sys/param.h> +#include <sys/systm.h> +#include <sys/domain.h> +#include <sys/errno.h> +#include <sys/filedesc.h> +#include <sys/ioccom.h> +#include <sys/kernel.h> +#include <sys/lock.h> +#include <sys/malloc.h> +#include <sys/mbuf.h> +#include <sys/mutex.h> +#include <sys/protosw.h> +#include <sys/queue.h> +#include <sys/socket.h> +#include <sys/socketvar.h> +#include <sys/sysctl.h> +#include <sys/taskqueue.h> +#include <netgraph/ng_message.h> +#include <netgraph/netgraph.h> +#include <bitstring.h> +#include "ng_bluetooth.h" +#include "ng_hci.h" +#include "ng_l2cap.h" +#include "ng_btsocket.h" +#include "ng_btsocket_l2cap.h" + +/* MALLOC define */ +#ifdef NG_SEPARATE_MALLOC +MALLOC_DEFINE(M_NETGRAPH_BTSOCKET_L2CAP_RAW, "netgraph_btsocks_l2cap_raw", + "Netgraph Bluetooth raw L2CAP sockets"); +#else +#define M_NETGRAPH_BTSOCKET_L2CAP_RAW M_NETGRAPH +#endif /* NG_SEPARATE_MALLOC */ + +/* Netgraph node methods */ +static ng_constructor_t ng_btsocket_l2cap_raw_node_constructor; +static ng_rcvmsg_t ng_btsocket_l2cap_raw_node_rcvmsg; +static ng_shutdown_t ng_btsocket_l2cap_raw_node_shutdown; +static ng_newhook_t ng_btsocket_l2cap_raw_node_newhook; +static ng_connect_t ng_btsocket_l2cap_raw_node_connect; +static ng_rcvdata_t ng_btsocket_l2cap_raw_node_rcvdata; +static ng_disconnect_t ng_btsocket_l2cap_raw_node_disconnect; + +static void ng_btsocket_l2cap_raw_input (void *, int); +static void ng_btsocket_l2cap_raw_rtclean (void *, int); +static void ng_btsocket_l2cap_raw_get_token (u_int32_t *); + +/* Netgraph type descriptor */ +static struct ng_type typestruct = { + NG_ABI_VERSION, + NG_BTSOCKET_L2CAP_RAW_NODE_TYPE, /* typename */ + NULL, /* modevent */ + ng_btsocket_l2cap_raw_node_constructor, /* constructor */ + ng_btsocket_l2cap_raw_node_rcvmsg, /* control message */ + ng_btsocket_l2cap_raw_node_shutdown, /* destructor */ + ng_btsocket_l2cap_raw_node_newhook, /* new hook */ + NULL, /* find hook */ + ng_btsocket_l2cap_raw_node_connect, /* connect hook */ + ng_btsocket_l2cap_raw_node_rcvdata, /* data */ + ng_btsocket_l2cap_raw_node_disconnect, /* disconnect hook */ + NULL /* node command list */ +}; + +/* Globals */ +extern int ifqmaxlen; +static u_int32_t ng_btsocket_l2cap_raw_debug_level; +static u_int32_t ng_btsocket_l2cap_raw_ioctl_timeout; +static node_p ng_btsocket_l2cap_raw_node; +static struct ng_bt_itemq ng_btsocket_l2cap_raw_queue; +static struct mtx ng_btsocket_l2cap_raw_queue_mtx; +static struct task ng_btsocket_l2cap_raw_queue_task; +static LIST_HEAD(, ng_btsocket_l2cap_raw_pcb) ng_btsocket_l2cap_raw_sockets; +static struct mtx ng_btsocket_l2cap_raw_sockets_mtx; +static u_int32_t ng_btsocket_l2cap_raw_token; +static struct mtx ng_btsocket_l2cap_raw_token_mtx; +static LIST_HEAD(, ng_btsocket_l2cap_rtentry) ng_btsocket_l2cap_raw_rt; +static struct mtx ng_btsocket_l2cap_raw_rt_mtx; +static struct task ng_btsocket_l2cap_raw_rt_task; + +/* Sysctl tree */ +SYSCTL_DECL(_net_bluetooth_l2cap_sockets); +SYSCTL_NODE(_net_bluetooth_l2cap_sockets, OID_AUTO, raw, CTLFLAG_RW, + 0, "Bluetooth raw L2CAP sockets family"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, debug_level, + CTLFLAG_RW, + &ng_btsocket_l2cap_raw_debug_level, NG_BTSOCKET_WARN_LEVEL, + "Bluetooth raw L2CAP sockets debug level"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, ioctl_timeout, + CTLFLAG_RW, + &ng_btsocket_l2cap_raw_ioctl_timeout, 5, + "Bluetooth raw L2CAP sockets ioctl timeout"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, queue_len, + CTLFLAG_RD, + &ng_btsocket_l2cap_raw_queue.len, 0, + "Bluetooth raw L2CAP sockets input queue length"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, queue_maxlen, + CTLFLAG_RD, + &ng_btsocket_l2cap_raw_queue.maxlen, 0, + "Bluetooth raw L2CAP sockets input queue max. length"); +SYSCTL_INT(_net_bluetooth_l2cap_sockets_raw, OID_AUTO, queue_drops, + CTLFLAG_RD, + &ng_btsocket_l2cap_raw_queue.drops, 0, + "Bluetooth raw L2CAP sockets input queue drops"); + +/* Debug */ +#define NG_BTSOCKET_L2CAP_RAW_INFO \ + if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_INFO_LEVEL) \ + printf + +#define NG_BTSOCKET_L2CAP_RAW_WARN \ + if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_WARN_LEVEL) \ + printf + +#define NG_BTSOCKET_L2CAP_RAW_ERR \ + if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_ERR_LEVEL) \ + printf + +#define NG_BTSOCKET_L2CAP_RAW_ALERT \ + if (ng_btsocket_l2cap_raw_debug_level >= NG_BTSOCKET_ALERT_LEVEL) \ + printf + +/***************************************************************************** + ***************************************************************************** + ** Netgraph node interface + ***************************************************************************** + *****************************************************************************/ + +/* + * Netgraph node constructor. Do not allow to create node of this type. + */ + +static int +ng_btsocket_l2cap_raw_node_constructor(node_p node) +{ + return (EINVAL); +} /* ng_btsocket_l2cap_raw_node_constructor */ + +/* + * Do local shutdown processing. Let old node go and create new fresh one. + */ + +static int +ng_btsocket_l2cap_raw_node_shutdown(node_p node) +{ + int error = 0; + + NG_NODE_UNREF(node); + + /* Create new node */ + error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_raw_node); + if (error != 0) { + NG_BTSOCKET_L2CAP_RAW_ALERT( +"%s: Could not create Netgraph node, error=%d\n", __func__, error); + + ng_btsocket_l2cap_raw_node = NULL; + + return (error); + } + + error = ng_name_node(ng_btsocket_l2cap_raw_node, + NG_BTSOCKET_L2CAP_RAW_NODE_TYPE); + if (error != NULL) { + NG_BTSOCKET_L2CAP_RAW_ALERT( +"%s: Could not name Netgraph node, error=%d\n", __func__, error); + + NG_NODE_UNREF(ng_btsocket_l2cap_raw_node); + ng_btsocket_l2cap_raw_node = NULL; + + return (error); + } + + return (0); +} /* ng_btsocket_l2cap_raw_node_shutdown */ + +/* + * We allow any hook to be connected to the node. + */ + +static int +ng_btsocket_l2cap_raw_node_newhook(node_p node, hook_p hook, char const *name) +{ + return (0); +} /* ng_btsocket_l2cap_raw_node_newhook */ + +/* + * Just say "YEP, that's OK by me!" + */ + +static int +ng_btsocket_l2cap_raw_node_connect(hook_p hook) +{ + NG_HOOK_SET_PRIVATE(hook, NULL); + NG_HOOK_REF(hook); /* Keep extra reference to the hook */ + + return (0); +} /* ng_btsocket_l2cap_raw_node_connect */ + +/* + * Hook disconnection. Schedule route cleanup task + */ + +static int +ng_btsocket_l2cap_raw_node_disconnect(hook_p hook) +{ + /* + * If hook has private information than we must have this hook in + * the routing table and must schedule cleaning for the routing table. + * Otherwise hook was connected but we never got "hook_info" message, + * so we have never added this hook to the routing table and it save + * to just delete it. + */ + + if (NG_HOOK_PRIVATE(hook) != NULL) + return (taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_l2cap_raw_rt_task)); + + NG_HOOK_UNREF(hook); /* Remove extra reference */ + + return (0); +} /* ng_btsocket_l2cap_raw_node_disconnect */ + +/* + * Process incoming messages + */ + +static int +ng_btsocket_l2cap_raw_node_rcvmsg(node_p node, item_p item, hook_p hook) +{ + struct ng_mesg *msg = NGI_MSG(item); /* item still has message */ + int error = 0; + + if (msg != NULL && msg->header.typecookie == NGM_L2CAP_COOKIE) { + mtx_lock(&ng_btsocket_l2cap_raw_queue_mtx); + if (NG_BT_ITEMQ_FULL(&ng_btsocket_l2cap_raw_queue)) { + NG_BTSOCKET_L2CAP_RAW_ERR( +"%s: Input queue is full\n", __func__); + + NG_BT_ITEMQ_DROP(&ng_btsocket_l2cap_raw_queue); + NG_FREE_ITEM(item); + error = ENOBUFS; + } else { + if (hook != NULL) { + NG_HOOK_REF(hook); + NGI_SET_HOOK(item, hook); + } + + NG_BT_ITEMQ_ENQUEUE(&ng_btsocket_l2cap_raw_queue, item); + error = taskqueue_enqueue(taskqueue_swi, + &ng_btsocket_l2cap_raw_queue_task); + } + mtx_unlock(&ng_btsocket_l2cap_raw_queue_mtx); + } else { + NG_FREE_ITEM(item); + error = EINVAL; + } + + return (error); +} /* ng_btsocket_l2cap_raw_node_rcvmsg */ + +/* + * Receive data on a hook + */ + +static int +ng_btsocket_l2cap_raw_node_rcvdata(hook_p hook, item_p item) +{ + NG_FREE_ITEM(item); + + return (EINVAL); +} /* ng_btsocket_l2cap_raw_node_rcvdata */ + +/***************************************************************************** + ***************************************************************************** + ** Socket interface + ***************************************************************************** + *****************************************************************************/ + +/* + * L2CAP sockets input routine + */ + +static void +ng_btsocket_l2cap_raw_input(void *context, int pending) +{ + item_p item = NULL; + hook_p hook = NULL; + struct ng_mesg *msg = NULL; + + for (;;) { + mtx_lock(&ng_btsocket_l2cap_raw_queue_mtx); + NG_BT_ITEMQ_DEQUEUE(&ng_btsocket_l2cap_raw_queue, item); + mtx_unlock(&ng_btsocket_l2cap_raw_queue_mtx); + + if (item == NULL) + break; + + KASSERT((item->el_flags & NGQF_TYPE) == NGQF_MESG, +("%s: invalid item type=%ld\n", __func__, (item->el_flags & NGQF_TYPE))); + + NGI_GET_MSG(item, msg); + NGI_GET_HOOK(item, hook); + NG_FREE_ITEM(item); + + switch (msg->header.cmd) { + case NGM_L2CAP_NODE_HOOK_INFO: { + ng_btsocket_l2cap_rtentry_t *rt = NULL; + + if (hook == NULL || NG_HOOK_NOT_VALID(hook) || + msg->header.arglen != sizeof(bdaddr_t)) + break; + + if (bcmp(msg->data, NG_HCI_BDADDR_ANY, + sizeof(bdaddr_t)) == 0) + break; + + rt = (ng_btsocket_l2cap_rtentry_t *) + NG_HOOK_PRIVATE(hook); + if (rt == NULL) { + MALLOC(rt, ng_btsocket_l2cap_rtentry_p, + sizeof(*rt), + M_NETGRAPH_BTSOCKET_L2CAP_RAW, + M_NOWAIT|M_ZERO); + if (rt == NULL) + break; + + mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); + LIST_INSERT_HEAD(&ng_btsocket_l2cap_raw_rt, + rt, next); + mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); + + NG_HOOK_SET_PRIVATE(hook, rt); + } + + bcopy(msg->data, &rt->src, sizeof(rt->src)); + rt->hook = hook; + + NG_BTSOCKET_L2CAP_RAW_INFO( +"%s: Updating hook \"%s\", src bdaddr=%x:%x:%x:%x:%x:%x\n", + __func__, NG_HOOK_NAME(hook), + rt->src.b[5], rt->src.b[4], rt->src.b[3], + rt->src.b[2], rt->src.b[1], rt->src.b[0]); + } break; + + case NGM_L2CAP_NODE_GET_FLAGS: + case NGM_L2CAP_NODE_GET_DEBUG: + case NGM_L2CAP_NODE_GET_CON_LIST: + case NGM_L2CAP_NODE_GET_CHAN_LIST: + case NGM_L2CAP_L2CA_PING: + case NGM_L2CAP_L2CA_GET_INFO: { + ng_btsocket_l2cap_raw_pcb_p pcb = NULL; + + if (msg->header.token == 0 || + !(msg->header.flags & NGF_RESP)) + break; + + mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); + + LIST_FOREACH(pcb, &ng_btsocket_l2cap_raw_sockets, next) + if (pcb->token == msg->header.token) { + pcb->msg = msg; + msg = NULL; + wakeup(&pcb->msg); + break; + } + + mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); + } break; + + default: + NG_BTSOCKET_L2CAP_RAW_WARN( +"%s: Unknown message, cmd=%d\n", __func__, msg->header.cmd); + break; + } + + if (hook != NULL) + NG_HOOK_UNREF(hook); /* remove extra reference */ + + NG_FREE_MSG(msg); /* Checks for msg != NULL */ + } +} /* ng_btsocket_l2cap_raw_default_msg_input */ + +/* + * Route cleanup task. Gets scheduled when hook is disconnected. Here we + * will find all sockets that use "invalid" hook and disconnect them. + */ + +static void +ng_btsocket_l2cap_raw_rtclean(void *context, int pending) +{ + ng_btsocket_l2cap_raw_pcb_p pcb = NULL; + ng_btsocket_l2cap_rtentry_p rt = NULL; + + mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); + mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); + + /* + * First disconnect all sockets that use "invalid" hook + */ + + LIST_FOREACH(pcb, &ng_btsocket_l2cap_raw_sockets, next) + if (pcb->rt != NULL && + pcb->rt->hook != NULL && NG_HOOK_NOT_VALID(pcb->rt->hook)) { + if (pcb->so != NULL && + pcb->so->so_state & SS_ISCONNECTED) + soisdisconnected(pcb->so); + + pcb->rt = NULL; + } + + /* + * Now cleanup routing table + */ + + rt = LIST_FIRST(&ng_btsocket_l2cap_raw_rt); + while (rt != NULL) { + ng_btsocket_l2cap_rtentry_p rt_next = LIST_NEXT(rt, next); + + if (rt->hook != NULL && NG_HOOK_NOT_VALID(rt->hook)) { + LIST_REMOVE(rt, next); + + NG_HOOK_SET_PRIVATE(rt->hook, NULL); + NG_HOOK_UNREF(rt->hook); /* Remove extra reference */ + + bzero(rt, sizeof(*rt)); + FREE(rt, M_NETGRAPH_BTSOCKET_L2CAP_RAW); + } + + rt = rt_next; + } + + mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); + mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); +} /* ng_btsocket_l2cap_raw_rtclean */ + +/* + * Initialize everything + */ + +void +ng_btsocket_l2cap_raw_init(void) +{ + int error = 0; + + ng_btsocket_l2cap_raw_node = NULL; + ng_btsocket_l2cap_raw_debug_level = NG_BTSOCKET_WARN_LEVEL; + ng_btsocket_l2cap_raw_ioctl_timeout = 5; + + /* Register Netgraph node type */ + error = ng_newtype(&typestruct); + if (error != 0) { + NG_BTSOCKET_L2CAP_RAW_ALERT( +"%s: Could not register Netgraph node type, error=%d\n", __func__, error); + + return; + } + + /* Create Netgrapg node */ + error = ng_make_node_common(&typestruct, &ng_btsocket_l2cap_raw_node); + if (error != 0) { + NG_BTSOCKET_L2CAP_RAW_ALERT( +"%s: Could not create Netgraph node, error=%d\n", __func__, error); + + ng_btsocket_l2cap_raw_node = NULL; + + return; + } + + error = ng_name_node(ng_btsocket_l2cap_raw_node, + NG_BTSOCKET_L2CAP_RAW_NODE_TYPE); + if (error != 0) { + NG_BTSOCKET_L2CAP_RAW_ALERT( +"%s: Could not name Netgraph node, error=%d\n", __func__, error); + + NG_NODE_UNREF(ng_btsocket_l2cap_raw_node); + ng_btsocket_l2cap_raw_node = NULL; + + return; + } + + /* Create input queue */ + NG_BT_ITEMQ_INIT(&ng_btsocket_l2cap_raw_queue, ifqmaxlen); + mtx_init(&ng_btsocket_l2cap_raw_queue_mtx, + "btsocks_l2cap_queue_mtx", NULL, MTX_DEF); + TASK_INIT(&ng_btsocket_l2cap_raw_queue_task, 0, + ng_btsocket_l2cap_raw_input, NULL); + + /* Create list of sockets */ + LIST_INIT(&ng_btsocket_l2cap_raw_sockets); + mtx_init(&ng_btsocket_l2cap_raw_sockets_mtx, + "btsocks_l2cap_sockets_mtx", NULL, MTX_DEF); + + /* Tokens */ + ng_btsocket_l2cap_raw_token = 0; + mtx_init(&ng_btsocket_l2cap_raw_token_mtx, + "btsocks_l2cap_token_mtx", NULL, MTX_DEF); + + /* Routing table */ + LIST_INIT(&ng_btsocket_l2cap_raw_rt); + mtx_init(&ng_btsocket_l2cap_raw_rt_mtx, + "btsocks_l2cap_rt_mtx", NULL, MTX_DEF); + TASK_INIT(&ng_btsocket_l2cap_raw_rt_task, 0, + ng_btsocket_l2cap_raw_rtclean, NULL); +} /* ng_btsocket_l2cap_raw_init */ + +/* + * Abort connection on socket + */ + +int +ng_btsocket_l2cap_raw_abort(struct socket *so) +{ + return (ng_btsocket_l2cap_raw_detach(so)); +} /* ng_btsocket_l2cap_raw_abort */ + +/* + * Create and attach new socket + */ + +int +ng_btsocket_l2cap_raw_attach(struct socket *so, int proto, struct thread *td) +{ + ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); + int error; + + if (pcb != NULL) + return (EISCONN); + + if (ng_btsocket_l2cap_raw_node == NULL) + return (EPROTONOSUPPORT); + if (so->so_type != SOCK_RAW) + return (ESOCKTNOSUPPORT); + if ((error = suser(td)) != 0) + return (error); + + /* Reserve send and receive space if it is not reserved yet */ + error = soreserve(so, NG_BTSOCKET_L2CAP_RAW_SENDSPACE, + NG_BTSOCKET_L2CAP_RAW_RECVSPACE); + if (error != 0) + return (error); + + /* Allocate the PCB */ + MALLOC(pcb, ng_btsocket_l2cap_raw_pcb_p, sizeof(*pcb), + M_NETGRAPH_BTSOCKET_L2CAP_RAW, M_WAITOK | M_ZERO); + if (pcb == NULL) + return (ENOMEM); + + /* Link the PCB and the socket */ + so->so_pcb = (caddr_t) pcb; + pcb->so = so; + + /* Add the PCB to the list */ + mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); + LIST_INSERT_HEAD(&ng_btsocket_l2cap_raw_sockets, pcb, next); + mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); + + return (0); +} /* ng_btsocket_l2cap_raw_attach */ + +/* + * Bind socket + */ + +int +ng_btsocket_l2cap_raw_bind(struct socket *so, struct sockaddr *nam, + struct thread *td) +{ + ng_btsocket_l2cap_raw_pcb_t *pcb = so2l2cap_raw_pcb(so); + struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_raw_node == NULL) + return (EINVAL); + + if (sa == NULL) + return (EINVAL); + if (sa->l2cap_family != AF_BLUETOOTH) + return (EAFNOSUPPORT); + if (sa->l2cap_len != sizeof(*sa)) + return (EINVAL); + if (bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) + return (EINVAL); + + bcopy(&sa->l2cap_bdaddr, &pcb->src, sizeof(pcb->src)); + + return (0); +} /* ng_btsocket_l2cap_raw_bind */ + +/* + * Connect socket + */ + +int +ng_btsocket_l2cap_raw_connect(struct socket *so, struct sockaddr *nam, + struct thread *td) +{ + ng_btsocket_l2cap_raw_pcb_t *pcb = so2l2cap_raw_pcb(so); + struct sockaddr_l2cap *sa = (struct sockaddr_l2cap *) nam; + ng_btsocket_l2cap_rtentry_t *rt = NULL; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_raw_node == NULL) + return (EINVAL); + + if (sa == NULL) + return (EINVAL); + if (sa->l2cap_family != AF_BLUETOOTH) + return (EAFNOSUPPORT); + if (sa->l2cap_len != sizeof(*sa)) + return (EINVAL); + if (bcmp(&sa->l2cap_bdaddr, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) + return (EINVAL); + if (bcmp(&sa->l2cap_bdaddr, &pcb->src, sizeof(pcb->src)) != 0) + return (EADDRNOTAVAIL); + + /* + * Find hook with specified source address + */ + + pcb->rt = NULL; + + mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); + + LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) { + if (rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook)) + continue; + + if (bcmp(&pcb->src, &rt->src, sizeof(rt->src)) == 0) + break; + } + + if (rt != NULL) { + pcb->rt = rt; + soisconnected(so); + } + + mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); + + return ((pcb->rt != NULL)? 0 : ENETDOWN); +} /* ng_btsocket_l2cap_raw_connect */ + +/* + * Find hook that matches source address + */ + +static ng_btsocket_l2cap_rtentry_p +ng_btsocket_l2cap_raw_find_src_route(bdaddr_p src) +{ + ng_btsocket_l2cap_rtentry_p rt = NULL; + + if (bcmp(src, NG_HCI_BDADDR_ANY, sizeof(*src)) != 0) { + mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); + + LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) + if (rt->hook != NULL && NG_HOOK_IS_VALID(rt->hook) && + bcmp(src, &rt->src, sizeof(*src)) == 0) + break; + + mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); + } + + return (rt); +} /* ng_btsocket_l2cap_raw_find_src_route */ + +/* + * Find first hook does does not match destination address + */ + +static ng_btsocket_l2cap_rtentry_p +ng_btsocket_l2cap_raw_find_dst_route(bdaddr_p dst) +{ + ng_btsocket_l2cap_rtentry_p rt = NULL; + + if (bcmp(dst, NG_HCI_BDADDR_ANY, sizeof(*dst)) != 0) { + mtx_lock(&ng_btsocket_l2cap_raw_rt_mtx); + + LIST_FOREACH(rt, &ng_btsocket_l2cap_raw_rt, next) + if (rt->hook != NULL && NG_HOOK_IS_VALID(rt->hook) && + bcmp(dst, &rt->src, sizeof(*dst)) != 0) + break; + + mtx_unlock(&ng_btsocket_l2cap_raw_rt_mtx); + } + + return (rt); +} /* ng_btsocket_l2cap_raw_find_dst_route */ + +/* + * Process ioctl's calls on socket + */ + +int +ng_btsocket_l2cap_raw_control(struct socket *so, u_long cmd, caddr_t data, + struct ifnet *ifp, struct thread *td) +{ + ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); + bdaddr_t *src = (bdaddr_t *) data; + ng_btsocket_l2cap_rtentry_p rt = pcb->rt; + struct ng_mesg *msg = NULL; + int error = 0; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_raw_node == NULL) + return (EINVAL); + + if (rt == NULL || rt->hook == NULL || NG_HOOK_NOT_VALID(rt->hook)) { + if (cmd == SIOC_L2CAP_L2CA_PING || + cmd == SIOC_L2CAP_L2CA_GET_INFO) + rt = ng_btsocket_l2cap_raw_find_dst_route(src + 1); + else + rt = ng_btsocket_l2cap_raw_find_src_route(src); + + if (rt == NULL) + return (EHOSTUNREACH); + } + + bcopy(&rt->src, src, sizeof(*src)); + + switch (cmd) { + case SIOC_L2CAP_NODE_GET_FLAGS: { + struct ng_btsocket_l2cap_raw_node_flags *p = + (struct ng_btsocket_l2cap_raw_node_flags *) data; + + ng_btsocket_l2cap_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_GET_FLAGS, + 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, + rt->hook, NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "l2ctl", + ng_btsocket_l2cap_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_L2CAP_NODE_GET_FLAGS) + p->flags = *((ng_l2cap_node_flags_ep *) + (pcb->msg->data)); + else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + case SIOC_L2CAP_NODE_GET_DEBUG: { + struct ng_btsocket_l2cap_raw_node_debug *p = + (struct ng_btsocket_l2cap_raw_node_debug *) data; + + ng_btsocket_l2cap_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_GET_DEBUG, + 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, + rt->hook, NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "l2ctl", + ng_btsocket_l2cap_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_L2CAP_NODE_GET_DEBUG) + p->debug = *((ng_l2cap_node_debug_ep *) + (pcb->msg->data)); + else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + case SIOC_L2CAP_NODE_SET_DEBUG: { + struct ng_btsocket_l2cap_raw_node_debug *p = + (struct ng_btsocket_l2cap_raw_node_debug *) data; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_SET_DEBUG, + sizeof(ng_l2cap_node_debug_ep), M_WAITOK); + if (msg == NULL) { + error = ENOMEM; + break; + } + + *((ng_l2cap_node_debug_ep *)(msg->data)) = p->debug; + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, + msg, rt->hook, NULL); + } break; + + case SIOC_L2CAP_NODE_GET_CON_LIST: { + struct ng_btsocket_l2cap_raw_con_list *p = + (struct ng_btsocket_l2cap_raw_con_list *) data; + ng_l2cap_node_con_list_ep *p1 = NULL; + ng_l2cap_node_con_ep *p2 = NULL; + + if (p->num_connections == 0 || + p->num_connections > NG_L2CAP_MAX_CON_NUM || + p->connections == NULL) { + error = EINVAL; + break; + } + + ng_btsocket_l2cap_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, NGM_L2CAP_NODE_GET_CON_LIST, + 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, + rt->hook, NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "l2ctl", + ng_btsocket_l2cap_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_L2CAP_NODE_GET_CON_LIST) { + /* Return data back to user space */ + p1 = (ng_l2cap_node_con_list_ep *)(pcb->msg->data); + p2 = (ng_l2cap_node_con_ep *)(p1 + 1); + + p->num_connections = min(p->num_connections, + p1->num_connections); + if (p->num_connections > 0) + error = copyout((caddr_t) p2, + (caddr_t) p->connections, + p->num_connections * sizeof(*p2)); + } else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + case SIOC_L2CAP_NODE_GET_CHAN_LIST: { + struct ng_btsocket_l2cap_raw_chan_list *p = + (struct ng_btsocket_l2cap_raw_chan_list *) data; + ng_l2cap_node_chan_list_ep *p1 = NULL; + ng_l2cap_node_chan_ep *p2 = NULL; + + if (p->num_channels == 0 || + p->num_channels > NG_L2CAP_MAX_CHAN_NUM || + p->channels == NULL) { + error = EINVAL; + break; + } + + ng_btsocket_l2cap_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, + NGM_L2CAP_NODE_GET_CHAN_LIST, 0, M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, + rt->hook, NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "l2ctl", + ng_btsocket_l2cap_raw_ioctl_timeout * hz); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_L2CAP_NODE_GET_CHAN_LIST) { + /* Return data back to user space */ + p1 = (ng_l2cap_node_chan_list_ep *)(pcb->msg->data); + p2 = (ng_l2cap_node_chan_ep *)(p1 + 1); + + p->num_channels = min(p->num_channels, + p1->num_channels); + if (p->num_channels > 0) + error = copyout((caddr_t) p2, + (caddr_t) p->channels, + p->num_channels * sizeof(*p2)); + } else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + case SIOC_L2CAP_L2CA_PING: { + struct ng_btsocket_l2cap_raw_ping *p = + (struct ng_btsocket_l2cap_raw_ping *) data; + ng_l2cap_l2ca_ping_ip *ip = NULL; + ng_l2cap_l2ca_ping_op *op = NULL; + + if ((p->echo_size != 0 && p->echo_data == NULL) || + p->echo_size > NG_L2CAP_MAX_ECHO_SIZE) { + error = EINVAL; + break; + } + + /* Loop back local ping */ + if (bcmp(&p->echo_dst, &rt->src, sizeof(rt->src)) == 0) { + p->result = 0; + break; + } + + ng_btsocket_l2cap_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, + NGM_L2CAP_L2CA_PING, sizeof(*ip) + p->echo_size, + M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + ip = (ng_l2cap_l2ca_ping_ip *)(msg->data); + bcopy(&p->echo_dst, &ip->bdaddr, sizeof(ip->bdaddr)); + ip->echo_size = p->echo_size; + + if (ip->echo_size > 0) { + error = copyin(p->echo_data, ip + 1, p->echo_size); + if (error != 0) { + NG_FREE_MSG(msg); + pcb->token = 0; + break; + } + } + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, + rt->hook, NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "l2ctl", + bluetooth_l2cap_rtx_timeout()); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_L2CAP_L2CA_PING) { + /* Return data back to the user space */ + op = (ng_l2cap_l2ca_ping_op *)(pcb->msg->data); + p->result = op->result; + p->echo_size = min(p->echo_size, op->echo_size); + + if (p->echo_size > 0) + error = copyout(op + 1, p->echo_data, + p->echo_size); + } else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + case SIOC_L2CAP_L2CA_GET_INFO: { + struct ng_btsocket_l2cap_raw_get_info *p = + (struct ng_btsocket_l2cap_raw_get_info *) data; + ng_l2cap_l2ca_get_info_ip *ip = NULL; + ng_l2cap_l2ca_get_info_op *op = NULL; + + if ((p->info_size != 0 && p->info_data == NULL) || + bcmp(&p->info_dst, &rt->src, sizeof(rt->src)) == 0) { + error = EINVAL; + break; + } + + ng_btsocket_l2cap_raw_get_token(&pcb->token); + pcb->msg = NULL; + + NG_MKMESSAGE(msg, NGM_L2CAP_COOKIE, + NGM_L2CAP_L2CA_GET_INFO, sizeof(*ip) + p->info_size, + M_WAITOK); + if (msg == NULL) { + pcb->token = 0; + error = ENOMEM; + break; + } + msg->header.token = pcb->token; + + ip = (ng_l2cap_l2ca_get_info_ip *)(msg->data); + bcopy(&p->info_dst, &ip->bdaddr, sizeof(ip->bdaddr)); + ip->info_type = p->info_type; + + NG_SEND_MSG_HOOK(error, ng_btsocket_l2cap_raw_node, msg, + rt->hook, NULL); + if (error != 0) { + pcb->token = 0; + break; + } + + error = tsleep(&pcb->msg, PZERO|PCATCH, "l2ctl", + bluetooth_l2cap_rtx_timeout()); + if (error != 0) { + pcb->token = 0; + break; + } + + if (pcb->msg != NULL && + pcb->msg->header.cmd == NGM_L2CAP_L2CA_GET_INFO) { + /* Return data back to the user space */ + op = (ng_l2cap_l2ca_get_info_op *)(pcb->msg->data); + p->result = op->result; + p->info_size = min(p->info_size, op->info_size); + + if (p->info_size > 0) + error = copyout(op + 1, p->info_data, + p->info_size); + } else + error = EINVAL; + + NG_FREE_MSG(pcb->msg); /* checks for != NULL */ + pcb->token = 0; + } break; + + default: + error = EINVAL; + break; + } + + return (error); +} /* ng_btsocket_l2cap_raw_control */ + +/* + * Detach and destroy socket + */ + +int +ng_btsocket_l2cap_raw_detach(struct socket *so) +{ + ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_raw_node == NULL) + return (EINVAL); + + so->so_pcb = NULL; + sotryfree(so); + + mtx_lock(&ng_btsocket_l2cap_raw_sockets_mtx); + LIST_REMOVE(pcb, next); + mtx_unlock(&ng_btsocket_l2cap_raw_sockets_mtx); + + bzero(pcb, sizeof(*pcb)); + FREE(pcb, M_NETGRAPH_BTSOCKET_L2CAP_RAW); + + return (0); +} /* ng_btsocket_l2cap_raw_detach */ + +/* + * Disconnect socket + */ + +int +ng_btsocket_l2cap_raw_disconnect(struct socket *so) +{ + ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_raw_node == NULL) + return (EINVAL); + + pcb->rt = NULL; + soisdisconnected(so); + + return (0); +} /* ng_btsocket_l2cap_raw_disconnect */ + +/* + * Get peer address + */ + +int +ng_btsocket_l2cap_raw_peeraddr(struct socket *so, struct sockaddr **nam) +{ + return (EOPNOTSUPP); +} /* ng_btsocket_l2cap_raw_peeraddr */ + +/* + * Send data to socket + */ + +int +ng_btsocket_l2cap_raw_send(struct socket *so, int flags, struct mbuf *m, + struct sockaddr *nam, struct mbuf *control, struct thread *td) +{ + NG_FREE_M(m); /* Checks for m != NULL */ + NG_FREE_M(control); + + return (EOPNOTSUPP); +} /* ng_btsocket_l2cap_raw_send */ + +/* + * Get socket address + */ + +int +ng_btsocket_l2cap_raw_sockaddr(struct socket *so, struct sockaddr **nam) +{ + ng_btsocket_l2cap_raw_pcb_p pcb = so2l2cap_raw_pcb(so); + struct sockaddr_l2cap sa; + + if (pcb == NULL) + return (EINVAL); + if (ng_btsocket_l2cap_raw_node == NULL) + return (EINVAL); + + bcopy(&pcb->src, &sa.l2cap_bdaddr, sizeof(sa.l2cap_bdaddr)); + sa.l2cap_psm = 0; + sa.l2cap_len = sizeof(sa); + sa.l2cap_family = AF_BLUETOOTH; + + *nam = dup_sockaddr((struct sockaddr *) &sa, 0); + + return ((*nam == NULL)? ENOMEM : 0); +} /* ng_btsocket_l2cap_raw_sockaddr */ + +/* + * Get next token + */ + +static void +ng_btsocket_l2cap_raw_get_token(u_int32_t *token) +{ + mtx_lock(&ng_btsocket_l2cap_raw_token_mtx); + + if (++ ng_btsocket_l2cap_raw_token == 0) + ng_btsocket_l2cap_raw_token = 1; + + *token = ng_btsocket_l2cap_raw_token; + + mtx_unlock(&ng_btsocket_l2cap_raw_token_mtx); +} /* ng_btsocket_l2cap_raw_get_token */ + diff --git a/usr.bin/bluetooth/Makefile b/usr.bin/bluetooth/Makefile new file mode 100644 index 0000000..1da9ef2 --- /dev/null +++ b/usr.bin/bluetooth/Makefile @@ -0,0 +1,5 @@ +# $FreeBSD$ +SUBDIR= btsockstat + +.include <bsd.subdir.mk> + diff --git a/usr.bin/bluetooth/btsockstat/Makefile b/usr.bin/bluetooth/btsockstat/Makefile new file mode 100644 index 0000000..ea78892 --- /dev/null +++ b/usr.bin/bluetooth/btsockstat/Makefile @@ -0,0 +1,17 @@ +# $Id: Makefile,v 1.1.1.1 2002/09/09 16:12:49 max Exp $ +# $FreeBSD$ + +PROG= btsockstat +MAN1= btsockstat.1 + +DESTDIR= /usr/bin/ +MANDIR= ../share/man/man + +WARNS?= 2 +CFLAGS+= -g -I../../../sys/netgraph/bluetooth/include/ + +SRCS= btsockstat.c +DPADD= ${LIBKVM} +LDADD= -lkvm + +.include <bsd.prog.mk> diff --git a/usr.bin/bluetooth/btsockstat/btsockstat.1 b/usr.bin/bluetooth/btsockstat/btsockstat.1 new file mode 100644 index 0000000..a1295cd --- /dev/null +++ b/usr.bin/bluetooth/btsockstat/btsockstat.1 @@ -0,0 +1,73 @@ +.\" btsockstat.1 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: btsockstat.1,v 1.2 2002/11/12 17:08:34 max Exp $ +.\" $FreeBSD$ +.Dd August 31, 2002 +.Dt BTSOCKSTAT 1 +.Os +.Sh NAME +.Nm btsockstat +.Nd show Bluetooth sockets information +.Sh SYNOPSIS +.Nm +.Op Fl p Ar protocol +.Op Fl r +.Op Fl M Ar core +.Sh DESCRIPTION +The +.Nm +command symbolically displays the contents of various Bluetooth sockets +related data structures. There are few output formats, depending on the +options for the information presented. +.Nm +will print results to the standard output and error messages to the +standard error. +.Pp +The options are as follows: +.Bl -tag -width indent +.It Fl p Ar protocol +Display a list of active sockets (protocol control blocks) for each +specified protocol. Supported protocols are: +.Cm hci_raw , l2cap_raw +and +.Cm l2cap . +.It Fl r +Display a list of active routing entries (if any) for specified protocol. +.It Fl M Ar core +Extract values associated with the name list from the specified core +instead of the default +.Pa /dev/kmem. +.El +.Sh BUGS +Most likely. Please report if found. +.Sh DIAGNOSTICS +.Ex -std +.Sh SEE ALSO +.Xr ng_btsocket 4 +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com + diff --git a/usr.bin/bluetooth/btsockstat/btsockstat.c b/usr.bin/bluetooth/btsockstat/btsockstat.c new file mode 100644 index 0000000..d123502 --- /dev/null +++ b/usr.bin/bluetooth/btsockstat/btsockstat.c @@ -0,0 +1,484 @@ +/* + * btsockstat.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: btsockstat.c,v 1.2 2002/09/16 19:40:14 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/callout.h> +#include <sys/param.h> +#include <sys/queue.h> +#include <sys/socket.h> +#include <sys/socketvar.h> + +#include <net/if.h> +#include <net/if_var.h> + +#include <bitstring.h> +#include <err.h> +#include <fcntl.h> +#include <kvm.h> +#include <limits.h> + +#include <ng_hci.h> +#include <ng_l2cap.h> +#include <ng_btsocket.h> +#include <ng_btsocket_hci_raw.h> +#include <ng_btsocket_l2cap.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> + +static void hcirawpr (kvm_t *kvmd, u_long addr); +static void l2caprawpr (kvm_t *kvmd, u_long addr); +static void l2cappr (kvm_t *kvmd, u_long addr); +static void l2caprtpr (kvm_t *kvmd, u_long addr); + +static kvm_t * kopen (char const *memf); +static int kread (kvm_t *kvmd, u_long addr, char *buffer, int size); + +static void usage (void); + +/* + * List of symbols + */ + +static struct nlist nl[] = { +#define N_HCI_RAW 0 + { "_ng_btsocket_hci_raw_sockets" }, +#define N_L2CAP_RAW 1 + { "_ng_btsocket_l2cap_raw_sockets" }, +#define N_L2CAP 2 + { "_ng_btsocket_l2cap_sockets" }, +#define N_L2CAP_RAW_RT 3 + { "_ng_btsocket_l2cap_raw_rt" }, +#define N_L2CAP_RT 4 + { "_ng_btsocket_l2cap_rt" }, + { "" }, +}; + +/* + * Main + */ + +int +main(int argc, char *argv[]) +{ + int opt, proto = -1, route = 0; + kvm_t *kvmd = NULL; + char *memf = NULL; + + while ((opt = getopt(argc, argv, "hM:p:r")) != -1) { + switch (opt) { + case 'M': + memf = optarg; + break; + + case 'p': + if (strcasecmp(optarg, "hci_raw") == 0) + proto = N_HCI_RAW; + else if (strcasecmp(optarg, "l2cap_raw") == 0) + proto = N_L2CAP_RAW; + else if (strcasecmp(optarg, "l2cap") == 0) + proto = N_L2CAP; + else + usage(); + /* NOT REACHED */ + break; + + case 'r': + route = 1; + break; + + case 'h': + default: + usage(); + /* NOT REACHED */ + } + } + + if (proto == N_HCI_RAW && route) + usage(); + /* NOT REACHED */ + + kvmd = kopen(memf); + if (kvmd == NULL) + return (1); + + switch (proto) { + case N_HCI_RAW: + hcirawpr(kvmd, nl[N_HCI_RAW].n_value); + break; + + case N_L2CAP_RAW: + if (route) + l2caprtpr(kvmd, nl[N_L2CAP_RAW_RT].n_value); + else + l2caprawpr(kvmd, nl[N_L2CAP_RAW].n_value); + break; + + case N_L2CAP: + if (route) + l2caprtpr(kvmd, nl[N_L2CAP_RT].n_value); + else + l2cappr(kvmd, nl[N_L2CAP].n_value); + break; + + default: + if (route) { + l2caprtpr(kvmd, nl[N_L2CAP_RAW_RT].n_value); + l2caprtpr(kvmd, nl[N_L2CAP_RT].n_value); + } else { + hcirawpr(kvmd, nl[N_HCI_RAW].n_value); + l2caprawpr(kvmd, nl[N_L2CAP_RAW].n_value); + l2cappr(kvmd, nl[N_L2CAP].n_value); + } + break; + } + + return (kvm_close(kvmd)); +} /* main */ + +/* + * Print raw HCI sockets + */ + +static void +hcirawpr(kvm_t *kvmd, u_long addr) +{ + ng_btsocket_hci_raw_pcb_p this = NULL, next = NULL; + ng_btsocket_hci_raw_pcb_t pcb; + struct socket so; + int first = 1; + + if (addr == 0) + return; + + if (kread(kvmd, addr, (char *) &this, sizeof(this)) < 0) + return; + + for ( ; this != NULL; this = next) { + if (kread(kvmd, (u_long) this, (char *) &pcb, sizeof(pcb)) < 0) + return; + if (kread(kvmd, (u_long) pcb.so, (char *) &so, sizeof(so)) < 0) + return; + + next = LIST_NEXT(&pcb, next); + + if (first) { + first = 0; + fprintf(stdout, +"Active raw HCI sockets\n" \ +"%-8.8s %-8.8s %-6.6s %-6.6s %-6.6s %-16.16s\n", + "Socket", + "PCB", + "Flags", + "Recv-Q", + "Send-Q", + "Local address"); + } + + if (pcb.addr.hci_node[0] == 0) { + pcb.addr.hci_node[0] = '*'; + pcb.addr.hci_node[1] = 0; + } + + fprintf(stdout, +"%-8.8x %-8.8x %-6.6x %6d %6d %-16.16s\n", + (int) pcb.so, + (int) this, + pcb.flags, + so.so_rcv.sb_cc, + so.so_snd.sb_cc, + pcb.addr.hci_node); + } +} /* hcirawpr */ + +/* + * Print raw L2CAP sockets + */ + +static void +l2caprawpr(kvm_t *kvmd, u_long addr) +{ + ng_btsocket_l2cap_raw_pcb_p this = NULL, next = NULL; + ng_btsocket_l2cap_raw_pcb_t pcb; + struct socket so; + int first = 1; + char bdaddr[32]; + + if (addr == 0) + return; + + if (kread(kvmd, addr, (char *) &this, sizeof(this)) < 0) + return; + + for ( ; this != NULL; this = next) { + if (kread(kvmd, (u_long) this, (char *) &pcb, sizeof(pcb)) < 0) + return; + if (kread(kvmd, (u_long) pcb.so, (char *) &so, sizeof(so)) < 0) + return; + + next = LIST_NEXT(&pcb, next); + + if (first) { + first = 0; + fprintf(stdout, +"Active raw L2CAP sockets\n" \ +"%-8.8s %-8.8s %-6.6s %-6.6s %-18.18s\n", + "Socket", + "PCB", + "Recv-Q", + "Send-Q", + "Local address"); + } + + if (memcmp(&pcb.src, NG_HCI_BDADDR_ANY, sizeof(pcb.src)) == 0) { + bdaddr[0] = '*'; + bdaddr[1] = 0; + } else + snprintf(bdaddr, sizeof(bdaddr), +"%02x:%02x:%02x:%02x:%02x:%02x", + pcb.src.b[5], pcb.src.b[4], pcb.src.b[3], + pcb.src.b[2], pcb.src.b[1], pcb.src.b[0]); + + fprintf(stdout, +"%-8.8x %-8.8x %6d %6d %-18.18s\n", + (int) pcb.so, + (int) this, + so.so_rcv.sb_cc, + so.so_snd.sb_cc, + bdaddr); + } +} /* l2caprawpr */ + +/* + * Print L2CAP sockets + */ + +static void +l2cappr(kvm_t *kvmd, u_long addr) +{ + static char const * const states[] = { + /* NG_BTSOCKET_L2CAP_CLOSED */ "CLOSED", + /* NG_BTSOCKET_L2CAP_CONNECTING */ "CON", + /* NG_BTSOCKET_L2CAP_CONFIGURING */ "CONFIG", + /* NG_BTSOCKET_L2CAP_OPEN */ "OPEN", + /* NG_BTSOCKET_L2CAP_DISCONNECTING */ "DISCON" + }; +#define state2str(x) \ + (((x) >= sizeof(states)/sizeof(states[0]))? "UNKNOWN" : states[(x)]) + + ng_btsocket_l2cap_pcb_p this = NULL, next = NULL; + ng_btsocket_l2cap_pcb_t pcb; + struct socket so; + int first = 1; + char local[32], remote[32]; + + + if (addr == 0) + return; + + if (kread(kvmd, addr, (char *) &this, sizeof(this)) < 0) + return; + + for ( ; this != NULL; this = next) { + if (kread(kvmd, (u_long) this, (char *) &pcb, sizeof(pcb)) < 0) + return; + if (kread(kvmd, (u_long) pcb.so, (char *) &so, sizeof(so)) < 0) + return; + + next = LIST_NEXT(&pcb, next); + + if (first) { + first = 0; + fprintf(stdout, +"Active L2CAP sockets\n" \ +"%-8.8s %-6.6s %-6.6s %-24.24s %-18.18s %-5.5s %s\n", + "PCB", + "Recv-Q", + "Send-Q", + "Local address/PSM", + "Foreign address", + "CID", + "State"); + } + + if (memcmp(&pcb.src, NG_HCI_BDADDR_ANY, sizeof(pcb.src)) == 0) + snprintf(local, sizeof(local), "*/%d", pcb.psm); + else + snprintf(local, sizeof(local), +"%02x:%02x:%02x:%02x:%02x:%02x/%d", + pcb.src.b[5], pcb.src.b[4], pcb.src.b[3], + pcb.src.b[2], pcb.src.b[1], pcb.src.b[0], + pcb.psm); + + if (memcmp(&pcb.dst, NG_HCI_BDADDR_ANY, sizeof(pcb.dst)) == 0) { + remote[0] = '*'; + remote[1] = 0; + } else + snprintf(remote, sizeof(remote), +"%02x:%02x:%02x:%02x:%02x:%02x", + pcb.dst.b[5], pcb.dst.b[4], pcb.dst.b[3], + pcb.dst.b[2], pcb.dst.b[1], pcb.dst.b[0]); + + fprintf(stdout, +"%-8.8x %6d %6d %-24.24s %-18.18s %-5d %s\n", + (int) this, + so.so_rcv.sb_cc, + so.so_snd.sb_cc, + local, + remote, + pcb.cid, + (so.so_options & SO_ACCEPTCONN)? + "LISTEN" : state2str(pcb.state)); + } +} /* l2cappr */ + +/* + * Print L2CAP routing table + */ + +static void +l2caprtpr(kvm_t *kvmd, u_long addr) +{ + ng_btsocket_l2cap_rtentry_p this = NULL, next = NULL; + ng_btsocket_l2cap_rtentry_t rt; + int first = 1; + char bdaddr[32]; + + if (addr == 0) + return; + + if (kread(kvmd, addr, (char *) &this, sizeof(this)) < 0) + return; + + for ( ; this != NULL; this = next) { + if (kread(kvmd, (u_long) this, (char *) &rt, sizeof(rt)) < 0) + return; + + next = LIST_NEXT(&rt, next); + + if (first) { + first = 0; + fprintf(stdout, +"Known %sL2CAP routes\n", (addr == nl[N_L2CAP_RAW_RT].n_value)? "raw " : ""); + fprintf(stdout, +"%-8.8s %-8.8s %-18.18s\n", "RTentry", + "Hook", + "BD_ADDR"); + } + + if (memcmp(&rt.src, NG_HCI_BDADDR_ANY, sizeof(rt.src)) == 0) { + bdaddr[0] = '-'; + bdaddr[1] = 0; + } else + snprintf(bdaddr, sizeof(bdaddr), +"%02x:%02x:%02x:%02x:%02x:%02x", rt.src.b[5], rt.src.b[4], rt.src.b[3], + rt.src.b[2], rt.src.b[1], rt.src.b[0]); + + fprintf(stdout, +"%-8.8x %-8.8x %-18.18s\n", + (int) this, + (int) rt.hook, + bdaddr); + } +} /* l2caprtpr */ + +/* + * Open kvm + */ + +static kvm_t * +kopen(char const *memf) +{ + kvm_t *kvmd = NULL; + char errbuf[_POSIX2_LINE_MAX]; + + /* + * Discard setgid privileges if not the running kernel so that + * bad guys can't print interesting stuff from kernel memory. + */ + + if (memf != NULL) + setgid(getgid()); + + kvmd = kvm_openfiles(NULL, memf, NULL, O_RDONLY, errbuf); + if (kvmd == NULL) { + warnx("kvm_openfiles: %s", errbuf); + return (NULL); + } + + if (kvm_nlist(kvmd, nl) < 0) { + warnx("kvm_nlist: %s", kvm_geterr(kvmd)); + goto fail; + } + + if (nl[0].n_type == 0) { + warnx("kvm_nlist: no namelist"); + goto fail; + } + + return (kvmd); +fail: + kvm_close(kvmd); + + return (NULL); +} /* kopen */ + +/* + * Read kvm + */ + +static int +kread(kvm_t *kvmd, u_long addr, char *buffer, int size) +{ + if (kvmd == NULL || buffer == NULL) + return (-1); + + if (kvm_read(kvmd, addr, buffer, size) != size) { + warnx("kvm_read: %s", kvm_geterr(kvmd)); + return (-1); + } + + return (0); +} /* kread */ + +/* + * Print usage and exit + */ + +static void +usage(void) +{ + fprintf(stdout, "Usage: btsockstat [-M core ] [-p proto] [-r]\n"); + exit(255); +} /* usage */ + diff --git a/usr.sbin/bluetooth/Makefile b/usr.sbin/bluetooth/Makefile new file mode 100644 index 0000000..821a003 --- /dev/null +++ b/usr.sbin/bluetooth/Makefile @@ -0,0 +1,12 @@ +# $Id$ +# $FreeBSD$ + +SUBDIR= \ + bt3cfw \ + hccontrol \ + hcseriald \ + l2control \ + l2ping + +.include <bsd.subdir.mk> + diff --git a/usr.sbin/bluetooth/bt3cfw/Makefile b/usr.sbin/bluetooth/bt3cfw/Makefile new file mode 100644 index 0000000..05ae1ab --- /dev/null +++ b/usr.sbin/bluetooth/bt3cfw/Makefile @@ -0,0 +1,15 @@ +# $Id: Makefile,v 1.1.1.1 2002/11/12 00:39:18 max Exp $ +# $FreeBSD$ + +DESTDIR= /usr/sbin/ +MANDIR= ../share/man/man +PROG= bt3cfw +MAN8= bt3cfw.8 +WARNS?= 2 +CFLAGS+= -g -I../../../sys/netgraph/bluetooth/include +SRCS= bt3cfw.c + +DPADD= ${LIBNETGRAPH} +LDADD= -lnetgraph + +.include <bsd.prog.mk> diff --git a/usr.sbin/bluetooth/bt3cfw/bt3cfw.8 b/usr.sbin/bluetooth/bt3cfw/bt3cfw.8 new file mode 100644 index 0000000..e85cb16 --- /dev/null +++ b/usr.sbin/bluetooth/bt3cfw/bt3cfw.8 @@ -0,0 +1,69 @@ +.\" bt3cfw.1 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: bt3cfw.8,v 1.1.1.1 2002/11/12 00:39:18 max Exp $ +.\" $FreeBSD$ +.Dd November 11, 2002 +.Dt BT3CFW 8 +.Os +.Sh NAME +.Nm BT3CFW +.Nd Firmware download utility for 3Com Bluetooth PC card driver +.Sh SYNOPSIS +.Nm +.Op Fl n Ar Netgraph node name +.Op Fl f Ar Firmware file name +.Sh DESCRIPTION +The +.Nm +utility connects to the specified Netgraph driver node of type +.Dv BTCCC +and downloads specified firmware file. +.Pp +Due to copyright issues I will no longer provide firmware with the card +driver. The firmware can be obtained from the Windows driver package that +can be downloaded from the 3COM web site at no charge. The firmware name +is BT3CPCC.BIN. I'm using original firmware that came with the card on CD-ROM. +.Bd -literal -offset indent +MD5 (BT3CPCC.BIN) = 36170fda56ea9fdbf1702c966f8a97f1 +.Ed +.Pp +The options are as follows: +.Bl -tag -width indent +.It Fl n Ar Netgraph node name +Connect to the specified Netgraph driver node of type +.Dv BTCCC . +.It Fl f Ar Firmware file name +Specify firmware file name for download. +.El +.Sh BUGS +Please report if found. +.Sh DIAGNOSTICS +.Ex -std +.Sh SEE ALSO +.Xr ng_bt3c 4 +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/usr.sbin/bluetooth/bt3cfw/bt3cfw.c b/usr.sbin/bluetooth/bt3cfw/bt3cfw.c new file mode 100644 index 0000000..09252ac --- /dev/null +++ b/usr.sbin/bluetooth/bt3cfw/bt3cfw.c @@ -0,0 +1,227 @@ +/* + * bt3cfw.c + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: bt3cfw.c,v 1.1.1.1 2002/11/12 00:39:18 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <errno.h> +#include <netgraph.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <syslog.h> +#include <unistd.h> +#include "ng_bt3c.h" + +#define BT3CFW_IDENT "bt3cfw" +#define BT3CFW_MAX_FIRMWARE_SIZE 0xffff + +/* Convert hex ASCII to int4 */ +static int +hexa2int4(const char *a) +{ + if ('0' <= *a && *a <= '9') + return (*a - '0'); + + if ('A' <= *a && *a <= 'F') + return (*a - 'A' + 0xa); + + if ('a' <= *a && *a <= 'f') + return (*a - 'a' + 0xa); + + syslog(LOG_ERR, "Invalid hex character: '%c' (%#x)", *a, *a); + exit(255); +} + +/* Convert hex ASCII to int8 */ +static int +hexa2int8(const char *a) +{ + return ((hexa2int4(a) << 4) | hexa2int4(a + 1)); +} + +/* Convert hex ASCII to int16 */ +static int +hexa2int16(const char *a) +{ + return ((hexa2int8(a) << 8) | hexa2int8(a + 2)); +} + +/* Convert hex ASCII to int32 */ +static int +hexa2int32(const char *a) +{ + return ((hexa2int16(a) << 16) | hexa2int16(a + 4)); +} + +/* Display usage() and exit */ +static void +usage(void) +{ + syslog(LOG_ERR, "Usage: %s -f FirmwareFile -n NodeName", BT3CFW_IDENT); + exit(255); +} + +/* Main */ +int +main(int argc, char *argv[]) +{ + FILE *firmware_file = NULL; + char buffer[80], path[NG_PATHLEN + 1], + *firmware_filename = NULL; + u_int8_t *firmware = NULL; + int firmware_size, opt, cs, ds; + + memset(path, 0, sizeof(path)); + openlog(BT3CFW_IDENT, LOG_NDELAY|LOG_PID|LOG_PERROR, LOG_USER); + + while ((opt = getopt(argc, argv, "f:hn:")) != -1) { + switch (opt) { + case 'f': + firmware_filename = optarg; + break; + + case 'n': + snprintf(path, sizeof(path), "%s:", optarg); + break; + + case 'h': + default: + usage(); + /* NOT REACHED */ + } + } + + if (firmware_filename == NULL || path[0] == 0) + usage(); + /* NOT REACHED */ + + firmware = (u_int8_t *) calloc(BT3CFW_MAX_FIRMWARE_SIZE, + sizeof(u_int8_t)); + if (firmware == NULL) { + syslog(LOG_ERR, "Could not allocate firmware buffer"); + exit(255); + } + + if ((firmware_file = fopen(firmware_filename, "r")) == NULL) { + syslog(LOG_ERR, "Could not open BT3C firmware file %s. %s (%d)", + firmware_filename, strerror(errno), errno); + exit(255); + } + + firmware_size = 0; + + while (fgets(buffer, sizeof(buffer), firmware_file)) { + int i, size, address, cs, fcs; + + size = hexa2int8(buffer + 2); + address = hexa2int32(buffer + 4); + fcs = hexa2int8(buffer + 2 + size * 2); + + if (buffer[1] == '3') { + ng_bt3c_firmware_block_ep *block = NULL; + u_int16_t *data = NULL; + + block = (ng_bt3c_firmware_block_ep *) + (firmware + firmware_size); + + firmware_size += sizeof(*block); + if (firmware_size >= BT3CFW_MAX_FIRMWARE_SIZE) { + syslog(LOG_ERR, "Could not add new firmware " \ + "block. Firmware file %s is " \ + "too big, firmware_size=%d", + firmware_filename, + firmware_size); + exit(255); + } + + block->block_address = address; + block->block_size = (size - 4) / 2; + block->block_alignment = (block->block_size * 2) % 3; + if (block->block_alignment != 0) + block->block_alignment = 3 - block->block_alignment; + + firmware_size += (block->block_size * 2); + firmware_size += block->block_alignment; + if (firmware_size >= BT3CFW_MAX_FIRMWARE_SIZE) { + syslog(LOG_ERR, "Could not add new firmware " \ + "data. Firmware file %s is " \ + "too big, firmware_size=%d", + firmware_filename, + firmware_size); + exit(255); + } + + /* First part of the cheksum: size and address */ + cs = 0; + for (i = 0; i < 5; i++) + cs += hexa2int8(buffer + 2 + i * 2); + + /* Data + second part of the cheksum: data */ + data = (u_int16_t *)(block + 1); + for (i = 0; i < block->block_size; i++) { + data[i] = hexa2int16(buffer + (i * 4) + 12); + cs += (((data[i] & 0xff00) >> 8) & 0xff); + cs += (data[i] & 0x00ff); + } + } else + for (cs = 0, i = 0; i < size; i++) + cs += hexa2int8(buffer + 2 + i * 2); + + if (((cs + fcs) & 0xff) != 0xff) { + syslog(LOG_ERR, "Invalid firmware file %s. Checksum " \ + "error, cs=%#x, fcs=%#x, checksum=%#x", + firmware_filename, (cs & 0xff), fcs, + ((cs + fcs) & 0xff)); + exit(255); + } + } + + /* Send firmware to the card */ + if (NgMkSockNode(NULL, &cs, &ds) < 0) { + syslog(LOG_ERR, "Could not create Netgraph socket. %s (%d)", + strerror(errno), errno); + exit(255); + } + + if (NgSendMsg(cs, path, NGM_BT3C_COOKIE, + NGM_BT3C_NODE_DOWNLOAD_FIRMWARE, + (void const *) firmware, firmware_size) < 0) { + syslog(LOG_ERR, "Could not send Netgraph message. %s (%d)", + strerror(errno), errno); + exit(255); + } + + free(firmware); + firmware = NULL; + + return (0); +} + diff --git a/usr.sbin/bluetooth/hccontrol/Makefile b/usr.sbin/bluetooth/hccontrol/Makefile new file mode 100644 index 0000000..c816c3c --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/Makefile @@ -0,0 +1,14 @@ +# $Id: Makefile,v 1.6 2002/09/06 18:52:41 max Exp $ +# $FreeBSD$ + +DESTDIR= /usr/sbin/ +MANDIR= ../share/man/man +PROG= hccontrol +MAN8= hccontrol.8 +WARNS?= 2 +CFLAGS+= -g -I../../../sys/netgraph/bluetooth/include +SRCS= send_recv.c link_policy.c link_control.c \ + host_controller_baseband.c info.c status.c node.c hccontrol.c \ + util.c + +.include <bsd.prog.mk> diff --git a/usr.sbin/bluetooth/hccontrol/hccontrol.8 b/usr.sbin/bluetooth/hccontrol/hccontrol.8 new file mode 100644 index 0000000..555cf32 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/hccontrol.8 @@ -0,0 +1,163 @@ +.\" hccontrol.8 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: hccontrol.8,v 1.8 2002/11/12 22:33:17 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt HCCONTROL 8 +.Os +.Sh NAME +.Nm hccontrol +.Nd HCI configuration utility +.Sh SYNOPSIS +.Nm +.Op Fl n Ar HCI node name +.Op Ar command +.Op Ar parameters ... +.Sh DESCRIPTION +The +.Nm +utility connects to the specified Netgraph node of type +.Em HCI +and attempts to send specified command to the HCI Netgraph node or to the +associated Bluetooth device. +.Nm +will print results to the standard output and error messages to +the standard error. +.Pp +The options are as follows: +.Bl -tag -width indent +.It Fl n Ar HCI node name +Connect to the specified HCI Netgraph node. +.It command +One of the supported commands (see below). Special command +.Dq help +can be used to obtain the list of all supported commands. To get more +information about specific command use +.Dq help command . +.It parameters +One or more optional space separated command parameters. +.El +.Sh COMMANDS +The currently supported HCI commands in +.Nm +are: +.Pp +.Bd -literal -offset indent -compact +Inquiry +Create_Connection +Disconnect +Add_SCO_Connection +Change_Connection_Packet_Type +Remote_Name_Request +Read_Remote_Supported_Features +Read_Remote_Version_Information +Read_Clock_Offset +Role_Discovery +Switch_Role +Read_Link_Policy_Settings +Write_Link_Policy_Settings +Reset +Read_Pin_Type +Write_Pin_Type +Read_Stored_Link_Key +Write_Stored_Link_Key +Delete_Stored_Link_Key +Change_Local_Name +Read_Local_Name +Read_Connection_Accept_Timeout +Write_Connection_Accept_Timeout +Read_Page_Timeout +Write_Page_Timeout +Read_Scan_Enable +Write_Scan_Enable +Read_Page_Scan_Activity +Write_Page_Scan_Activity +Read_Inquiry_Scan_Activity +Write_Inquiry_Scan_Activity +Read_Authentication_Enable +Write_Authentication_Enable +Read_Encryption_Mode +Write_Encryption_Mode +Read_Class_Of_Device +Write_Class_Of_Device +Read_Voice_Settings +Write_Voice_Settings +Read_Number_Broadcast_Retransmissions +Write_Number_Broadcast_Retransmissions +Read_Hold_Mode_Activity +Write_Hold_Mode_Activity +Read_SCO_Flow_Control_Enable +Write_SCO_Flow_Control_Enable +Read_Link_Supervision_Timeout +Write_Link_Supervision_Timeout +Read_Local_Version_Information +Read_Local_Supported_Features +Read_Buffer_Size +Read_Country_Code +Read_BD_ADDR +Read_Failed_Contact_Counter +Reset_Failed_Contact_Counter +Get_Link_Quality +Read_RSSI +.Ed +.Pp +The currently supported node commands in +.Nm +are: +.Pp +.Bd -literal -offset indent -compact +Read_Node_State +Initialize +Read_Debug_Level +Write_Debug_Level +Read_Command_Timeout +Write_Command_Timeout +Read_Node_Buffer_Size +Read_Node_BD_ADDR +Read_Node_Features +Read_Node_Stat +Reset_Node_Stat +Flush_Neighbor_Cache +Read_Neighbor_Cache +Read_Connection_List +Read_Node_Link_Policy_Settings_Mask +Write_Node_Link_Policy_Settings_Mask +Read_Node_Packet_Mask +Write_Node_Packet_Mask +.Ed +.Pp +.Sh BUGS +Most likely. Please report if found. +.Sh DIAGNOSTICS +.Ex -std +.Sh SEE ALSO +.Xr netgraph 3 , +.Xr netgraph 4 , +.Xr ng_hci 4 , +.Xr hcseriald 8 +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/usr.sbin/bluetooth/hccontrol/hccontrol.c b/usr.sbin/bluetooth/hccontrol/hccontrol.c new file mode 100644 index 0000000..12b70eb --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/hccontrol.c @@ -0,0 +1,274 @@ +/* + * hccontrol.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: hccontrol.c,v 1.11 2002/09/12 18:19:43 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/sysctl.h> +#include <assert.h> +#include <bitstring.h> +#include <err.h> +#include <errno.h> +#include <ng_hci.h> +#include <ng_l2cap.h> +#include <ng_btsocket.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include "hccontrol.h" + +/* Prototypes */ +static int do_hci_command (char const *, int, char **); +static struct hci_command * find_hci_command (char const *, struct hci_command *); +static void print_hci_command (struct hci_command *); +static void usage (void); + +/* Globals */ +int verbose = 0; +int timeout; + +/* Main */ +int +main(int argc, char *argv[]) +{ + char *node = NULL; + int n; + + /* Process command line arguments */ + while ((n = getopt(argc, argv, "n:v")) != -1) { + switch (n) { + case 'n': + node = optarg; + break; + + case 'v': + verbose = 1; + break; + + case '?': + default: + usage(); + } + } + + argc -= optind; + argv += optind; + + if (*argv == NULL) + usage(); + + n = do_hci_command(node, argc, argv); + + return (n); +} /* main */ + +/* Create socket and bind it */ +static int +socket_open(char const *node) +{ + struct sockaddr_hci addr; + struct ng_btsocket_hci_raw_filter filter; + int s, mib[4]; + size_t size; + + if (node == NULL) + usage(); + + s = socket(PF_BLUETOOTH, SOCK_RAW, BLUETOOTH_PROTO_HCI); + if (s < 0) + err(1, "Could not create socket"); + + memset(&addr, 0, sizeof(addr)); + addr.hci_len = sizeof(addr); + addr.hci_family = AF_BLUETOOTH; + strncpy(addr.hci_node, node, sizeof(addr.hci_node)); + if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) + err(2, "Could not bind socket, node=%s", node); + + if (connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) + err(3, "Could not connect socket, node=%s", node); + + memset(&filter, 0, sizeof(filter)); + bit_set(filter.event_mask, NG_HCI_EVENT_COMMAND_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_COMMAND_STATUS - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_INQUIRY_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_INQUIRY_RESULT - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_CON_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_DISCON_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_RETURN_LINK_KEYS - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_CON_PKT_TYPE_CHANGED - 1); + bit_set(filter.event_mask, NG_HCI_EVENT_ROLE_CHANGE - 1); + + if (setsockopt(s, SOL_HCI_RAW, SO_HCI_RAW_FILTER, + (void * const) &filter, sizeof(filter)) < 0) + err(4, "Could not setsockopt()"); + + size = (sizeof(mib)/sizeof(mib[0])); + if (sysctlnametomib("net.bluetooth.hci.command_timeout",mib,&size) < 0) + err(5, "Could not sysctlnametomib()"); + + if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), + (void *) &timeout, &size, NULL, 0) < 0) + err(6, "Could not sysctl()"); + + timeout ++; + + return (s); +} /* socket_open */ + +/* Execute commands */ +static int +do_hci_command(char const *node, int argc, char **argv) +{ + char *cmd = argv[0]; + struct hci_command *c = NULL; + int s, e, help; + + help = 0; + if (strcasecmp(cmd, "help") == 0) { + argc --; + argv ++; + + if (argc <= 0) { + fprintf(stdout, "Supported commands:\n"); + print_hci_command(link_control_commands); + print_hci_command(link_policy_commands); + print_hci_command(host_controller_baseband_commands); + print_hci_command(info_commands); + print_hci_command(status_commands); + print_hci_command(node_commands); + fprintf(stdout, "\nFor more information use " \ + "'help command'\n"); + + return (OK); + } + + help = 1; + cmd = argv[0]; + } + + c = find_hci_command(cmd, link_control_commands); + if (c != NULL) + goto execute; + + c = find_hci_command(cmd, link_policy_commands); + if (c != NULL) + goto execute; + + c = find_hci_command(cmd, host_controller_baseband_commands); + if (c != NULL) + goto execute; + + c = find_hci_command(cmd, info_commands); + if (c != NULL) + goto execute; + + c = find_hci_command(cmd, status_commands); + if (c != NULL) + goto execute; + + c = find_hci_command(cmd, node_commands); + if (c == NULL) { + fprintf(stdout, "Unknown command: \"%s\"\n", cmd); + return (ERROR); + } +execute: + if (!help) { + s = socket_open(node); + e = (c->handler)(s, -- argc, ++ argv); + close(s); + } else + e = USAGE; + + switch (e) { + case OK: + case FAILED: + break; + + case ERROR: + fprintf(stdout, "Could not execute command \"%s\". %s\n", + cmd, strerror(errno)); + break; + + case USAGE: + fprintf(stdout, "Usage: %s\n%s\n", c->command, c->description); + break; + + default: assert(0); break; + } + + + return (e); +} /* do_hci_command */ + +/* Try to find command in specified category */ +static struct hci_command * +find_hci_command(char const *command, struct hci_command *category) +{ + struct hci_command *c = NULL; + + for (c = category; c->command != NULL; c++) { + char *c_end = strchr(c->command, ' '); + + if (c_end != NULL) { + int len = c_end - c->command; + + if (strncasecmp(command, c->command, len) == 0) + return (c); + } else if (strcasecmp(command, c->command) == 0) + return (c); + } + + return (NULL); +} /* find_hci_command */ + +/* Try to find command in specified category */ +static void +print_hci_command(struct hci_command *category) +{ + struct hci_command *c = NULL; + + for (c = category; c->command != NULL; c++) + fprintf(stdout, "\t%s\n", c->command); +} /* print_hci_command */ + +/* Usage */ +static void +usage(void) +{ + fprintf(stdout, "Usage: hccontrol -n HCI_node_name cmd [p1] [..]]\n"); + exit(255); +} /* usage */ + diff --git a/usr.sbin/bluetooth/hccontrol/hccontrol.h b/usr.sbin/bluetooth/hccontrol/hccontrol.h new file mode 100644 index 0000000..8bcf764 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/hccontrol.h @@ -0,0 +1,75 @@ +/* + * hccontrol.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: hccontrol.h,v 1.8 2002/09/12 18:19:43 max Exp $ + * $FreeBSD$ + */ + +#ifndef _HCCONTROL_H_ +#define _HCCONTROL_H_ + +#define OK 0 /* everything was OK */ +#define ERROR 1 /* could not execute command */ +#define FAILED 2 /* error was reported */ +#define USAGE 3 /* invalid parameters */ + +struct hci_command { + char const *command; + char const *description; + int (*handler)(int, int, char **); +}; + +extern int timeout; +extern int verbose; +extern struct hci_command link_control_commands[]; +extern struct hci_command link_policy_commands[]; +extern struct hci_command host_controller_baseband_commands[]; +extern struct hci_command info_commands[]; +extern struct hci_command status_commands[]; +extern struct hci_command node_commands[]; + +int hci_request (int, int, char const *, int, char *, int *); +int hci_simple_request (int, int, char *, int *); +int hci_send (int, char const *, int); +int hci_recv (int, char *, int *); + +char const * const hci_link2str (int); +char const * const hci_pin2str (int); +char const * const hci_scan2str (int); +char const * const hci_encrypt2str (int, int); +char const * const hci_coding2str (int); +char const * const hci_vdata2str (int); +char const * const hci_hmode2str (int, char *, int); +char const * const hci_ver2str (int); +char const * const hci_manufacturer2str(int); +char const * const hci_features2str (u_int8_t *, char *, int); +char const * const hci_cc2str (int); +char const * const hci_con_state2str (int); +char const * const hci_status2str (int); + +#endif /* _HCCONTROL_H_ */ + diff --git a/usr.sbin/bluetooth/hccontrol/host_controller_baseband.c b/usr.sbin/bluetooth/hccontrol/host_controller_baseband.c new file mode 100644 index 0000000..3aa1571 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/host_controller_baseband.c @@ -0,0 +1,1713 @@ +/* + * host_controller_baseband.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: host_controller_baseband.c,v 1.12 2002/11/19 18:34:06 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/endian.h> +#include <errno.h> +#include <ng_hci.h> +#include <stdio.h> +#include <string.h> +#include "hccontrol.h" + +/* Convert hex ASCII to int4 */ +static int +hci_hexa2int4(const char *a) +{ + if ('0' <= *a && *a <= '9') + return (*a - '0'); + + if ('A' <= *a && *a <= 'F') + return (*a - 'A' + 0xa); + + if ('a' <= *a && *a <= 'f') + return (*a - 'a' + 0xa); + + return (-1); +} + +/* Convert hex ASCII to int8 */ +static int +hci_hexa2int8(const char *a) +{ + int hi = hci_hexa2int4(a); + int lo = hci_hexa2int4(a + 1); + + if (hi < 0 || lo < 0) + return (-1); + + return ((hi << 4) | lo); +} + +/* Convert ascii hex string to the u_int8_t[] */ +static int +hci_hexstring2array(char const *s, u_int8_t *a, int asize) +{ + int i, l, b; + + l = strlen(s) / 2; + if (l > asize) + l = asize; + + for (i = 0; i < l; i++) { + b = hci_hexa2int8(s + i * 2); + if (b < 0) + return (-1); + + a[i] = (b & 0xff); + } + + return (0); +} + +/* Send RESET to the unit */ +static int +hci_reset(int s, int argc, char **argv) +{ + ng_hci_status_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_RESET), (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_reset */ + +/* Send Read_PIN_Type command to the unit */ +static int +hci_read_pin_type(int s, int argc, char **argv) +{ + ng_hci_read_pin_type_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_PIN_TYPE), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "PIN type: %s [%#02x]\n", + hci_pin2str(rp.pin_type), rp.pin_type); + + return (OK); +} /* hci_read_pin_type */ + +/* Send Write_PIN_Type command to the unit */ +static int +hci_write_pin_type(int s, int argc, char **argv) +{ + ng_hci_write_pin_type_cp cp; + ng_hci_write_pin_type_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 1) + return (USAGE); + + cp.pin_type = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_PIN_TYPE), + (char const *) &cp, sizeof(cp), + (char *) &rp , &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_pin_type */ + +/* Send Read_Stored_Link_Key command to the unit */ +static int +hci_read_stored_link_key(int s, int argc, char **argv) +{ + struct { + ng_hci_cmd_pkt_t hdr; + ng_hci_read_stored_link_key_cp cp; + } __attribute__ ((packed)) cmd; + + struct { + ng_hci_event_pkt_t hdr; + union { + ng_hci_command_compl_ep cc; + ng_hci_return_link_keys_ep key; + u_int8_t b[NG_HCI_EVENT_PKT_SIZE]; + } ep; + } __attribute__ ((packed)) event; + + int n,a0,a1,a2,a3,a4,a5; + + /* Send command */ + memset(&cmd, 0, sizeof(cmd)); + cmd.hdr.type = NG_HCI_CMD_PKT; + cmd.hdr.opcode = htole16(NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_STORED_LINK_KEY)); + cmd.hdr.length = sizeof(cmd.cp); + + switch (argc) { + case 1: + /* parse BD_ADDR */ + if (sscanf(argv[0], "%x:%x:%x:%x:%x:%x", &a5, &a4, &a3, &a2, + &a1, &a0) != 6) + return (USAGE); + + cmd.cp.bdaddr.b[0] = (a0 & 0xff); + cmd.cp.bdaddr.b[1] = (a1 & 0xff); + cmd.cp.bdaddr.b[2] = (a2 & 0xff); + cmd.cp.bdaddr.b[3] = (a3 & 0xff); + cmd.cp.bdaddr.b[4] = (a4 & 0xff); + cmd.cp.bdaddr.b[5] = (a5 & 0xff); + break; + + default: + cmd.cp.read_all = 1; + break; + } + + if (hci_send(s, (char const *) &cmd, sizeof(cmd)) != OK) + return (ERROR); + + /* Receive events */ +again: + memset(&event, 0, sizeof(event)); + n = sizeof(event); + if (hci_recv(s, (char *) &event, &n) != OK) + return (ERROR); + + if (n <= sizeof(event.hdr)) { + errno = EMSGSIZE; + return (ERROR); + } + + if (event.hdr.type != NG_HCI_EVENT_PKT) { + errno = EIO; + return (ERROR); + } + + /* Parse event */ + switch (event.hdr.event) { + case NG_HCI_EVENT_COMMAND_COMPL: { + ng_hci_read_stored_link_key_rp *rp = NULL; + + if (event.ep.cc.opcode == 0x0000 || + event.ep.cc.opcode != cmd.hdr.opcode) + goto again; + + rp = (ng_hci_read_stored_link_key_rp *)(event.ep.b + + sizeof(event.ep.cc)); + + fprintf(stdout, "Complete: Status: %s [%#x]\n", + hci_status2str(rp->status), rp->status); + fprintf(stdout, "Maximum Number of keys: %d\n", + le16toh(rp->max_num_keys)); + fprintf(stdout, "Number of keys read: %d\n", + le16toh(rp->num_keys_read)); + } break; + + case NG_HCI_EVENT_RETURN_LINK_KEYS: { + struct _key { + bdaddr_t bdaddr; + u_int8_t key[NG_HCI_KEY_SIZE]; + } __attribute__ ((packed)) *k = NULL; + + fprintf(stdout, "Event: Number of keys: %d\n", + event.ep.key.num_keys); + + k = (struct _key *)(event.ep.b + sizeof(event.ep.key)); + for (n = 0; n < event.ep.key.num_keys; n++) { + fprintf(stdout, "\t%d: %02x:%02x:%02x:%02x:%02x:%02x ", + n + 1, + k->bdaddr.b[5], k->bdaddr.b[4], k->bdaddr.b[3], + k->bdaddr.b[2], k->bdaddr.b[1], k->bdaddr.b[0]); + + for (a0 = 0; a0 < sizeof(k->key); a0++) + fprintf(stdout, "%02x", k->key[a0]); + fprintf(stdout, "\n"); + + k ++; + } + + goto again; + + } break; + + default: + goto again; + } + + return (OK); +} /* hci_read_store_link_key */ + +/* Send Write_Stored_Link_Key command to the unit */ +static int +hci_write_stored_link_key(int s, int argc, char **argv) +{ + struct { + ng_hci_write_stored_link_key_cp p; + bdaddr_t bdaddr; + u_int8_t key[NG_HCI_KEY_SIZE]; + } cp; + ng_hci_write_stored_link_key_rp rp; + int32_t n, a0, a1, a2, a3, a4, a5; + + memset(&cp, 0, sizeof(cp)); + + switch (argc) { + case 2: + cp.p.num_keys_write = 1; + + /* parse BD_ADDR */ + if (sscanf(argv[0], "%x:%x:%x:%x:%x:%x", + &a5, &a4, &a3, &a2, &a1, &a0) != 6) + return (USAGE); + + cp.bdaddr.b[0] = (a0 & 0xff); + cp.bdaddr.b[1] = (a1 & 0xff); + cp.bdaddr.b[2] = (a2 & 0xff); + cp.bdaddr.b[3] = (a3 & 0xff); + cp.bdaddr.b[4] = (a4 & 0xff); + cp.bdaddr.b[5] = (a5 & 0xff); + + /* parse key */ + if (hci_hexstring2array(argv[1], cp.key, sizeof(cp.key)) < 0) + return (USAGE); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_STORED_LINK_KEY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Number of keys written: %d\n", rp.num_keys_written); + + return (OK); +} /* hci_write_stored_link_key */ + + +/* Send Delete_Stored_Link_Key command to the unit */ +static int +hci_delete_stored_link_key(int s, int argc, char **argv) +{ + ng_hci_delete_stored_link_key_cp cp; + ng_hci_delete_stored_link_key_rp rp; + int32_t n, a0, a1, a2, a3, a4, a5; + + memset(&cp, 0, sizeof(cp)); + + switch (argc) { + case 1: + /* parse BD_ADDR */ + if (sscanf(argv[0], "%x:%x:%x:%x:%x:%x", + &a5, &a4, &a3, &a2, &a1, &a0) != 6) + return (USAGE); + + cp.bdaddr.b[0] = (a0 & 0xff); + cp.bdaddr.b[1] = (a1 & 0xff); + cp.bdaddr.b[2] = (a2 & 0xff); + cp.bdaddr.b[3] = (a3 & 0xff); + cp.bdaddr.b[4] = (a4 & 0xff); + cp.bdaddr.b[5] = (a5 & 0xff); + break; + + default: + cp.delete_all = 1; + break; + } + + /* send command */ + n = sizeof(cp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_DELETE_STORED_LINK_KEY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Number of keys deleted: %d\n", rp.num_keys_deleted); + + return (OK); +} /* hci_delete_stored_link_key */ + +/* Send Change_Local_Name command to the unit */ +static int +hci_change_local_name(int s, int argc, char **argv) +{ + ng_hci_change_local_name_cp cp; + ng_hci_change_local_name_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + snprintf(cp.name, sizeof(cp.name), "%s", argv[0]); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_CHANGE_LOCAL_NAME), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_change_local_name */ + +/* Send Read_Local_Name command to the unit */ +static int +hci_read_local_name(int s, int argc, char **argv) +{ + ng_hci_read_local_name_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_LOCAL_NAME), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Local name: %s\n", rp.name); + + return (OK); +} /* hci_read_local_name */ + +/* Send Read_Connection_Accept_Timeout to the unit */ +static int +hci_read_connection_accept_timeout(int s, int argc, char **argv) +{ + ng_hci_read_con_accept_timo_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_CON_ACCEPT_TIMO), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.timeout = le16toh(rp.timeout); + fprintf(stdout, "Connection accept timeout: %.2f msec [%d slots]\n", + rp.timeout * 0.625, rp.timeout); + + return (OK); +} /* hci_read_connection_accept_timeout */ + +/* Send Write_Connection_Accept_Timeout to the unit */ +static int +hci_write_connection_accept_timeout(int s, int argc, char **argv) +{ + ng_hci_write_con_accept_timo_cp cp; + ng_hci_write_con_accept_timo_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 1 || n > 0xb540) + return (USAGE); + + cp.timeout = (u_int16_t) n; + cp.timeout = htole16(cp.timeout); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_CON_ACCEPT_TIMO), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_connection_accept_timeout */ + +/* Send Read_Page_Timeout command to the unit */ +static int +hci_read_page_timeout(int s, int argc, char **argv) +{ + ng_hci_read_page_timo_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_PAGE_TIMO), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.timeout = le16toh(rp.timeout); + fprintf(stdout, "Page timeout: %.2f msec [%d slots]\n", + rp.timeout * 0.625, rp.timeout); + + return (OK); +} /* hci_read_page_timeoout */ + +/* Send Write_Page_Timeout command to the unit */ +static int +hci_write_page_timeout(int s, int argc, char **argv) +{ + ng_hci_write_page_timo_cp cp; + ng_hci_write_page_timo_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 1 || n > 0xffff) + return (USAGE); + + cp.timeout = (u_int16_t) n; + cp.timeout = htole16(cp.timeout); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_PAGE_TIMO), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_page_timeout */ + +/* Send Read_Scan_Enable command to the unit */ +static int +hci_read_scan_enable(int s, int argc, char **argv) +{ + ng_hci_read_scan_enable_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_SCAN_ENABLE), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Scan enable: %s [%#02x]\n", + hci_scan2str(rp.scan_enable), rp.scan_enable); + + return (OK); +} /* hci_read_scan_enable */ + +/* Send Write_Scan_Enable command to the unit */ +static int +hci_write_scan_enable(int s, int argc, char **argv) +{ + ng_hci_write_scan_enable_cp cp; + ng_hci_write_scan_enable_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 3) + return (USAGE); + + cp.scan_enable = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_SCAN_ENABLE), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_scan_enable */ + +/* Send Read_Page_Scan_Activity command to the unit */ +static int +hci_read_page_scan_activity(int s, int argc, char **argv) +{ + ng_hci_read_page_scan_activity_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_PAGE_SCAN_ACTIVITY), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.page_scan_interval = le16toh(rp.page_scan_interval); + rp.page_scan_window = le16toh(rp.page_scan_window); + + fprintf(stdout, "Page Scan Interval: %.2f msec [%d slots]\n", + rp.page_scan_interval * 0.625, rp.page_scan_interval); + fprintf(stdout, "Page Scan Window: %.2f msec [%d slots]\n", + rp.page_scan_window * 0.625, rp.page_scan_window); + + return (OK); +} /* hci_read_page_scan_activity */ + +/* Send Write_Page_Scan_Activity command to the unit */ +static int +hci_write_page_scan_activity(int s, int argc, char **argv) +{ + ng_hci_write_page_scan_activity_cp cp; + ng_hci_write_page_scan_activity_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 2: + /* page scan interval */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0x12 || n > 0x1000) + return (USAGE); + + cp.page_scan_interval = (u_int16_t) n; + + /* page scan window */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0x12 || n > 0x1000) + return (USAGE); + + cp.page_scan_window = (u_int16_t) n; + + if (cp.page_scan_window > cp.page_scan_interval) + return (USAGE); + + cp.page_scan_interval = htole16(cp.page_scan_interval); + cp.page_scan_window = htole16(cp.page_scan_window); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_PAGE_SCAN_ACTIVITY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_page_scan_activity */ + +/* Send Read_Inquiry_Scan_Activity command to the unit */ +static int +hci_read_inquiry_scan_activity(int s, int argc, char **argv) +{ + ng_hci_read_inquiry_scan_activity_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_INQUIRY_SCAN_ACTIVITY), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.inquiry_scan_interval = le16toh(rp.inquiry_scan_interval); + rp.inquiry_scan_window = le16toh(rp.inquiry_scan_window); + + fprintf(stdout, "Inquiry Scan Interval: %.2f msec [%d slots]\n", + rp.inquiry_scan_interval * 0.625, rp.inquiry_scan_interval); + fprintf(stdout, "Inquiry Scan Window: %.2f msec [%d slots]\n", + rp.inquiry_scan_window * 0.625, rp.inquiry_scan_interval); + + return (OK); +} /* hci_read_inquiry_scan_activity */ + +/* Send Write_Inquiry_Scan_Activity command to the unit */ +static int +hci_write_inquiry_scan_activity(int s, int argc, char **argv) +{ + ng_hci_write_inquiry_scan_activity_cp cp; + ng_hci_write_inquiry_scan_activity_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 2: + /* inquiry scan interval */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0x12 || n > 0x1000) + return (USAGE); + + cp.inquiry_scan_interval = (u_int16_t) n; + + /* inquiry scan window */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0x12 || n > 0x1000) + return (USAGE); + + cp.inquiry_scan_window = (u_int16_t) n; + + if (cp.inquiry_scan_window > cp.inquiry_scan_interval) + return (USAGE); + + cp.inquiry_scan_interval = + htole16(cp.inquiry_scan_interval); + cp.inquiry_scan_window = htole16(cp.inquiry_scan_window); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_INQUIRY_SCAN_ACTIVITY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_inquiry_scan_activity */ + +/* Send Read_Authentication_Enable command to the unit */ +static int +hci_read_authentication_enable(int s, int argc, char **argv) +{ + ng_hci_read_auth_enable_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_AUTH_ENABLE), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Authentication Enable: %s [%d]\n", + rp.auth_enable? "Enabled" : "Disabled", rp.auth_enable); + + return (OK); +} /* hci_read_authentication_enable */ + +/* Send Write_Authentication_Enable command to the unit */ +static int +hci_write_authentication_enable(int s, int argc, char **argv) +{ + ng_hci_write_auth_enable_cp cp; + ng_hci_write_auth_enable_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 1) + return (USAGE); + + cp.auth_enable = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_AUTH_ENABLE), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_authentication_enable */ + +/* Send Read_Encryption_Mode command to the unit */ +static int +hci_read_encryption_mode(int s, int argc, char **argv) +{ + ng_hci_read_encryption_mode_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_ENCRYPTION_MODE), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Encryption mode: %s [%#02x]\n", + hci_encrypt2str(rp.encryption_mode, 0), rp.encryption_mode); + + return (OK); +} /* hci_read_encryption_mode */ + +/* Send Write_Encryption_Mode command to the unit */ +static int +hci_write_encryption_mode(int s, int argc, char **argv) +{ + ng_hci_write_encryption_mode_cp cp; + ng_hci_write_encryption_mode_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 2) + return (USAGE); + + cp.encryption_mode = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_ENCRYPTION_MODE), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_encryption_mode */ + +/* Send Read_Class_Of_Device command to the unit */ +static int +hci_read_class_of_device(int s, int argc, char **argv) +{ + ng_hci_read_unit_class_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_UNIT_CLASS), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Class: %02x:%02x:%02x\n", + rp.uclass[2], rp.uclass[1], rp.uclass[0]); + + return (0); +} /* hci_read_class_of_device */ + +/* Send Write_Class_Of_Device command to the unit */ +static int +hci_write_class_of_device(int s, int argc, char **argv) +{ + ng_hci_write_unit_class_cp cp; + ng_hci_write_unit_class_rp rp; + int n0, n1, n2; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%x:%x:%x", &n2, &n1, &n0) != 3) + return (USAGE); + + cp.uclass[0] = (n0 & 0xff); + cp.uclass[1] = (n1 & 0xff); + cp.uclass[2] = (n2 & 0xff); + break; + + default: + return (USAGE); + } + + /* send command */ + n0 = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_UNIT_CLASS), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n0) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_class_of_device */ + +/* Send Read_Voice_Settings command to the unit */ +static int +hci_read_voice_settings(int s, int argc, char **argv) +{ + ng_hci_read_voice_settings_rp rp; + int n, + input_coding, + input_data_format, + input_sample_size; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_VOICE_SETTINGS), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.settings = le16toh(rp.settings); + + input_coding = (rp.settings & 0x0300) >> 8; + input_data_format = (rp.settings & 0x00c0) >> 6; + input_sample_size = (rp.settings & 0x0020) >> 5; + + fprintf(stdout, "Voice settings: %#04x\n", rp.settings); + fprintf(stdout, "Input coding: %s [%d]\n", + hci_coding2str(input_coding), input_coding); + fprintf(stdout, "Input data format: %s [%d]\n", + hci_vdata2str(input_data_format), input_data_format); + + if (input_coding == 0x00) /* Only for Linear PCM */ + fprintf(stdout, "Input sample size: %d bit [%d]\n", + input_sample_size? 16 : 8, input_sample_size); + + return (OK); +} /* hci_read_voice_settings */ + +/* Send Write_Voice_Settings command to the unit */ +static int +hci_write_voice_settings(int s, int argc, char **argv) +{ + ng_hci_write_voice_settings_cp cp; + ng_hci_write_voice_settings_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%x", &n) != 1) + return (USAGE); + + cp.settings = (u_int16_t) n; + cp.settings = htole16(cp.settings); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_VOICE_SETTINGS), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_voice_settings */ + +/* Send Read_Number_Broadcast_Restransmissions */ +static int +hci_read_number_broadcast_retransmissions(int s, int argc, char **argv) +{ + ng_hci_read_num_broadcast_retrans_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_NUM_BROADCAST_RETRANS), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Number of broadcast retransmissions: %d\n", + rp.counter); + + return (OK); +} /* hci_read_number_broadcast_retransmissions */ + +/* Send Write_Number_Broadcast_Restransmissions */ +static int +hci_write_number_broadcast_retransmissions(int s, int argc, char **argv) +{ + ng_hci_write_num_broadcast_retrans_cp cp; + ng_hci_write_num_broadcast_retrans_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0xff) + return (USAGE); + + cp.counter = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_NUM_BROADCAST_RETRANS), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_number_broadcast_retransmissions */ + +/* Send Read_Hold_Mode_Activity command to the unit */ +static int +hci_read_hold_mode_activity(int s, int argc, char **argv) +{ + ng_hci_read_hold_mode_activity_rp rp; + int n; + char buffer[1024]; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_HOLD_MODE_ACTIVITY), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Hold Mode Activities: %#02x\n", rp.hold_mode_activity); + if (rp.hold_mode_activity == 0) + fprintf(stdout, "Maintain current Power State"); + else + fprintf(stdout, "%s", hci_hmode2str(rp.hold_mode_activity, + buffer, sizeof(buffer))); + + fprintf(stdout, "\n"); + + return (OK); +} /* hci_read_hold_mode_activity */ + +/* Send Write_Hold_Mode_Activity command to the unit */ +static int +hci_write_hold_mode_activity(int s, int argc, char **argv) +{ + ng_hci_write_hold_mode_activity_cp cp; + ng_hci_write_hold_mode_activity_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 4) + return (USAGE); + + cp.hold_mode_activity = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_HOLD_MODE_ACTIVITY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_hold_mode_activity */ + +/* Send Read_SCO_Flow_Control_Enable command to the unit */ +static int +hci_read_sco_flow_control_enable(int s, int argc, char **argv) +{ + ng_hci_read_sco_flow_control_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_SCO_FLOW_CONTROL), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "SCO flow control %s [%d]\n", + rp.flow_control? "enabled" : "disabled", rp.flow_control); + + return (OK); +} /* hci_read_sco_flow_control_enable */ + +/* Send Write_SCO_Flow_Control_Enable command to the unit */ +static int +hci_write_sco_flow_control_enable(int s, int argc, char **argv) +{ + ng_hci_write_sco_flow_control_cp cp; + ng_hci_write_sco_flow_control_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 1) + return (USAGE); + + cp.flow_control = (u_int8_t) n; + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_SCO_FLOW_CONTROL), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_sco_flow_control_enable */ + +/* Send Read_Link_Supervision_Timeout command to the unit */ +static int +hci_read_link_supervision_timeout(int s, int argc, char **argv) +{ + ng_hci_read_link_supervision_timo_cp cp; + ng_hci_read_link_supervision_timo_rp rp; + int n; + + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_READ_LINK_SUPERVISION_TIMO), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.timeout = le16toh(rp.timeout); + + fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); + fprintf(stdout, "Link supervision timeout: %.2f msec [%d slots]\n", + rp.timeout * 0.625, rp.timeout); + + return (OK); +} /* hci_read_link_supervision_timeout */ + +/* Send Write_Link_Supervision_Timeout command to the unit */ +static int +hci_write_link_supervision_timeout(int s, int argc, char **argv) +{ + ng_hci_write_link_supervision_timo_cp cp; + ng_hci_write_link_supervision_timo_rp rp; + int n; + + switch (argc) { + case 2: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + + /* link supervision timeout */ + if (sscanf(argv[1], "%d", &n) != 1 || n < 0 || n > 0xeff) + return (USAGE); + + cp.timeout = (u_int16_t) (n & 0x0fff); + cp.timeout = htole16(cp.timeout); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, + NG_HCI_OCF_WRITE_LINK_SUPERVISION_TIMO), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_link_supervision_timeout */ + +struct hci_command host_controller_baseband_commands[] = { +{ +"reset", +"\nThe Reset command will reset the Host Controller and the Link Manager.\n" \ +"After the reset is completed, the current operational state will be lost,\n" \ +"the Bluetooth unit will enter standby mode and the Host Controller will\n" \ +"automatically revert to the default values for the parameters for which\n" \ +"default values are defined in the specification.", +&hci_reset +}, +{ +"read_pin_type", +"\nThe Read_PIN_Type command is used for the Host to read whether the Link\n" \ +"Manager assumes that the Host supports variable PIN codes only a fixed PIN\n" \ +"code.", +&hci_read_pin_type +}, +{ +"write_pin_type <pin_type>", +"\nThe Write_PIN_Type command is used for the Host to write to the Host\n" \ +"Controller whether the Host supports variable PIN codes or only a fixed PIN\n"\ +"code.\n\n" \ +"\t<pin_type> - dd; 0 - Variable; 1 - Fixed", +&hci_write_pin_type +}, +{ +"read_stored_link_key [<bdaddr>]", +"\nThe Read_Stored_Link_Key command provides the ability to read one or\n" \ +"more link keys stored in the Bluetooth Host Controller. The Bluetooth Host\n" \ +"Controller can store a limited number of link keys for other Bluetooth\n" \ +"devices.\n\n" \ +"\t<bdaddr> - xx:xx:xx:xx:xx:xx BD_ADDR", +&hci_read_stored_link_key +}, +{ +"write_stored_link_key <bdaddr> <key>", +"\nThe Write_Stored_Link_Key command provides the ability to write one\n" \ +"or more link keys to be stored in the Bluetooth Host Controller. The\n" \ +"Bluetooth Host Controller can store a limited number of link keys for other\n"\ +"Bluetooth devices. If no additional space is available in the Bluetooth\n"\ +"Host Controller then no additional link keys will be stored.\n\n" \ +"\t<bdaddr> - xx:xx:xx:xx:xx:xx BD_ADDR\n" \ +"\t<key> - xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx up to 16 bytes link key", +&hci_write_stored_link_key +}, +{ +"delete_stored_link_key [<bdaddr>]", +"\nThe Delete_Stored_Link_Key command provides the ability to remove one\n" \ +"or more of the link keys stored in the Bluetooth Host Controller. The\n" \ +"Bluetooth Host Controller can store a limited number of link keys for other\n"\ +"Bluetooth devices.\n\n" \ +"\t<bdaddr> - xx:xx:xx:xx:xx:xx BD_ADDR", +&hci_delete_stored_link_key +}, +{ +"change_local_name <name>", +"\nThe Change_Local_Name command provides the ability to modify the user\n" \ +"friendly name for the Bluetooth unit.\n\n" \ +"\t<name> - string", +&hci_change_local_name +}, +{ +"read_local_name", +"\nThe Read_Local_Name command provides the ability to read the\n" \ +"stored user-friendly name for the Bluetooth unit.", +&hci_read_local_name +}, +{ +"read_connection_accept_timeout", +"\nThis command will read the value for the Connection_Accept_Timeout\n" \ +"configuration parameter. The Connection_Accept_Timeout configuration\n" \ +"parameter allows the Bluetooth hardware to automatically deny a\n" \ +"connection request after a specified time period has occurred and\n" \ +"the new connection is not accepted. Connection Accept Timeout\n" \ +"measured in Number of Baseband slots.", +&hci_read_connection_accept_timeout +}, +{ +"write_connection_accept_timeout <timeout>", +"\nThis command will write the value for the Connection_Accept_Timeout\n" \ +"configuration parameter.\n\n" \ +"\t<timeout> - dddd; measured in number of baseband slots.", +&hci_write_connection_accept_timeout +}, +{ +"read_page_timeout", +"\nThis command will read the value for the Page_Timeout configuration\n" \ +"parameter. The Page_Timeout configuration parameter defines the\n" \ +"maximum time the local Link Manager will wait for a baseband page\n" \ +"response from the remote unit at a locally initiated connection\n" \ +"attempt. Page Timeout measured in Number of Baseband slots.", +&hci_read_page_timeout +}, +{ +"write_page_timeout <timeout>", +"\nThis command will write the value for the Page_Timeout configuration\n" \ +"parameter.\n\n" \ +"\t<timeout> - dddd; measured in number of baseband slots.", +&hci_write_page_timeout +}, +{ +"read_scan_enable", +"\nThis command will read the value for the Scan_Enable parameter. The\n" \ +"Scan_Enable parameter controls whether or not the Bluetooth uint\n" \ +"will periodically scan for page attempts and/or inquiry requests\n" \ +"from other Bluetooth unit.\n\n" \ +"\t0x00 - No Scans enabled.\n" \ +"\t0x01 - Inquiry Scan enabled. Page Scan disabled.\n" \ +"\t0x02 - Inquiry Scan disabled. Page Scan enabled.\n" \ +"\t0x03 - Inquiry Scan enabled. Page Scan enabled.", +&hci_read_scan_enable +}, +{ +"write_scan_enable <scan_enable>", +"\nThis command will write the value for the Scan_Enable parameter.\n" \ +"The Scan_Enable parameter controls whether or not the Bluetooth\n" \ +"unit will periodically scan for page attempts and/or inquiry\n" \ +"requests from other Bluetooth unit.\n\n" \ +"\t<scan_enable> - dd;\n" \ +"\t0 - No Scans enabled.\n" \ +"\t1 - Inquiry Scan enabled. Page Scan disabled.\n" \ +"\t2 - Inquiry Scan disabled. Page Scan enabled.\n" \ +"\t3 - Inquiry Scan enabled. Page Scan enabled.", +&hci_write_scan_enable +}, +{ +"read_page_scan_activity", +"\nThis command will read the value for Page_Scan_Activity configuration\n" \ +"parameters. The Page_Scan_Interval configuration parameter defines the\n" \ +"amount of time between consecutive page scans. This time interval is \n" \ +"defined from when the Host Controller started its last page scan until\n" \ +"it begins the next page scan. The Page_Scan_Window configuration parameter\n" \ +"defines the amount of time for the duration of the page scan. The\n" \ +"Page_Scan_Window can only be less than or equal to the Page_Scan_Interval.", +&hci_read_page_scan_activity +}, +{ +"write_page_scan_activity interval(dddd) window(dddd)", +"\nThis command will write the value for Page_Scan_Activity configuration\n" \ +"parameter. The Page_Scan_Interval configuration parameter defines the\n" \ +"amount of time between consecutive page scans. This is defined as the time\n" \ +"interval from when the Host Controller started its last page scan until it\n" \ +"begins the next page scan. The Page_Scan_Window configuration parameter\n" \ +"defines the amount of time for the duration of the page scan. \n" \ +"The Page_Scan_Window can only be less than or equal to the Page_Scan_Interval.\n\n" \ +"\t<interval> - Range: 0x0012 -– 0x100, Time = N * 0.625 msec\n" \ +"\t<window> - Range: 0x0012 -– 0x100, Time = N * 0.625 msen", +&hci_write_page_scan_activity +}, +{ +"read_inquiry_scan_activity", +"\nThis command will read the value for Inquiry_Scan_Activity configuration\n" \ +"parameter. The Inquiry_Scan_Interval configuration parameter defines the\n" \ +"amount of time between consecutive inquiry scans. This is defined as the\n" \ +"time interval from when the Host Controller started its last inquiry scan\n" \ +"until it begins the next inquiry scan.", +&hci_read_inquiry_scan_activity +}, +{ +"write_inquiry_scan_activity interval(dddd) window(dddd)", +"\nThis command will write the value for Inquiry_Scan_Activity configuration\n"\ +"parameter. The Inquiry_Scan_Interval configuration parameter defines the\n" \ +"amount of time between consecutive inquiry scans. This is defined as the\n" \ +"time interval from when the Host Controller started its last inquiry scan\n" \ +"until it begins the next inquiry scan. The Inquiry_Scan_Window configuration\n" \ +"parameter defines the amount of time for the duration of the inquiry scan.\n" \ +"The Inquiry_Scan_Window can only be less than or equal to the Inquiry_Scan_Interval.\n\n" \ +"\t<interval> - Range: 0x0012 -– 0x100, Time = N * 0.625 msec\n" \ +"\t<window> - Range: 0x0012 -– 0x100, Time = N * 0.625 msen", +&hci_write_inquiry_scan_activity +}, +{ +"read_authentication_enable", +"\nThis command will read the value for the Authentication_Enable parameter.\n"\ +"The Authentication_Enable parameter controls if the local unit requires\n"\ +"to authenticate the remote unit at connection setup (between the\n" \ +"Create_Connection command or acceptance of an incoming ACL connection\n"\ +"and the corresponding Connection Complete event). At connection setup, only\n"\ +"the unit(s) with the Authentication_Enable parameter enabled will try to\n"\ +"authenticate the other unit.", +&hci_read_authentication_enable +}, +{ +"write_authentication_enable enable(0|1)", +"\nThis command will write the value for the Authentication_Enable parameter.\n"\ +"The Authentication_Enable parameter controls if the local unit requires to\n"\ +"authenticate the remote unit at connection setup (between the\n" \ +"Create_Connection command or acceptance of an incoming ACL connection\n" \ +"and the corresponding Connection Complete event). At connection setup, only\n"\ +"the unit(s) with the Authentication_Enable parameter enabled will try to\n"\ +"authenticate the other unit.", +&hci_write_authentication_enable +}, +{ +"read_encryption_mode", +"\nThis command will read the value for the Encryption_Mode parameter. The\n" \ +"Encryption_Mode parameter controls if the local unit requires encryption\n" \ +"to the remote unit at connection setup (between the Create_Connection\n" \ +"command or acceptance of an incoming ACL connection and the corresponding\n" \ +"Connection Complete event). At connection setup, only the unit(s) with\n" \ +"the Authentication_Enable parameter enabled and Encryption_Mode parameter\n" \ +"enabled will try to encrypt the connection to the other unit.\n\n" \ +"\t<encryption_mode>:\n" \ +"\t0x00 - Encryption disabled.\n" \ +"\t0x01 - Encryption only for point-to-point packets.\n" \ +"\t0x02 - Encryption for both point-to-point and broadcast packets.", +&hci_read_encryption_mode +}, +{ +"write_encryption_mode mode(0|1|2)", +"\tThis command will write the value for the Encryption_Mode parameter.\n" \ +"The Encryption_Mode parameter controls if the local unit requires\n" \ +"encryption to the remote unit at connection setup (between the\n" \ +"Create_Connection command or acceptance of an incoming ACL connection\n" \ +"and the corresponding Connection Complete event). At connection setup,\n" \ +"only the unit(s) with the Authentication_Enable parameter enabled and\n" \ +"Encryption_Mode parameter enabled will try to encrypt the connection to\n" \ +"the other unit.\n\n" \ +"\t<encryption_mode> (dd)\n" \ +"\t0 - Encryption disabled.\n" \ +"\t1 - Encryption only for point-to-point packets.\n" \ +"\t2 - Encryption for both point-to-point and broadcast packets.", +&hci_write_encryption_mode +}, +{ +"read_class_of_device", +"\nThis command will read the value for the Class_of_Device parameter.\n" \ +"The Class_of_Device parameter is used to indicate the capabilities of\n" \ +"the local unit to other units.", +&hci_read_class_of_device +}, +{ +"write_class_of_device class(xx:xx:xx)", +"\nThis command will write the value for the Class_of_Device parameter.\n" \ +"The Class_of_Device parameter is used to indicate the capabilities of \n" \ +"the local unit to other units.\n\n" \ +"\t<class> (xx:xx:xx) - class of device", +&hci_write_class_of_device +}, +{ +"read_voice_settings", +"\nThis command will read the values for the Voice_Setting parameter.\n" \ +"The Voice_Setting parameter controls all the various settings for voice\n" \ +"connections. These settings apply to all voice connections, and cannot be\n" \ +"set for individual voice connections. The Voice_Setting parameter controls\n" \ +"the configuration for voice connections: Input Coding, Air coding format,\n" \ +"input data format, Input sample size, and linear PCM parameter.", +&hci_read_voice_settings +}, +{ +"write_voice_settings settings(xxxx)", +"\nThis command will write the values for the Voice_Setting parameter.\n" \ +"The Voice_Setting parameter controls all the various settings for voice\n" \ +"connections. These settings apply to all voice connections, and cannot be\n" \ +"set for individual voice connections. The Voice_Setting parameter controls\n" \ +"the configuration for voice connections: Input Coding, Air coding format,\n" \ +"input data format, Input sample size, and linear PCM parameter.\n\n" \ +"\t<voice_settings> (xxxx) - voice settings", +&hci_write_voice_settings +}, +{ +"read_number_broadcast_retransmissions", +"\nThis command will read the unit's parameter value for the Number of\n" \ +"Broadcast Retransmissions. Broadcast packets are not acknowledged and are\n" \ +"unreliable.", +&hci_read_number_broadcast_retransmissions +}, +{ +"write_number_broadcast_retransmissions count(dd)", +"\nThis command will write the unit's parameter value for the Number of\n" \ +"Broadcast Retransmissions. Broadcast packets are not acknowledged and are\n" \ +"unreliable.\n\n" \ +"\t<count> (dd) - number of broadcast retransimissions", +&hci_write_number_broadcast_retransmissions +}, +{ +"read_hold_mode_activity", +"\nThis command will read the value for the Hold_Mode_Activity parameter.\n" \ +"The Hold_Mode_Activity value is used to determine what activities should\n" \ +"be suspended when the unit is in hold mode.", +&hci_read_hold_mode_activity +}, +{ +"write_hold_mode_activity settings(0|1|2|4)", +"\nThis command will write the value for the Hold_Mode_Activity parameter.\n" \ +"The Hold_Mode_Activity value is used to determine what activities should\n" \ +"be suspended when the unit is in hold mode.\n\n" \ +"\t<settings> (dd) - bit mask:\n" \ +"\t0 - Maintain current Power State. Default\n" \ +"\t1 - Suspend Page Scan.\n" \ +"\t2 - Suspend Inquiry Scan.\n" \ +"\t4 - Suspend Periodic Inquiries.", +&hci_write_hold_mode_activity +}, +{ +"read_sco_flow_control_enable", +"\nThe Read_SCO_Flow_Control_Enable command provides the ability to read\n" \ +"the SCO_Flow_Control_Enable setting. By using this setting, the Host can\n" \ +"decide if the Host Controller will send Number Of Completed Packets events\n" \ +"for SCO Connection Handles. This setting allows the Host to enable and\n" \ +"disable SCO flow control.", +&hci_read_sco_flow_control_enable +}, +{ +"write_sco_flow_control_enable enable(0|1)", +"\nThe Write_SCO_Flow_Control_Enable command provides the ability to write\n" \ +"the SCO_Flow_Control_Enable setting. By using this setting, the Host can\n" \ +"decide if the Host Controller will send Number Of Completed Packets events\n" \ +"for SCO Connection Handles. This setting allows the Host to enable and\n" \ +"disable SCO flow control. The SCO_Flow_Control_Enable setting can only be\n" \ +"changed if no connections exist.", +&hci_write_sco_flow_control_enable +}, +{ +"read_link_supervision_timeout <connection_handle>", +"\nThis command will read the value for the Link_Supervision_Timeout\n" \ +"parameter for the device. The Link_Supervision_Timeout parameter is used\n" \ +"by the master or slave Bluetooth device to monitor link loss. If, for any\n" \ +"reason, no Baseband packets are received from that Connection Handle for a\n" \ +"duration longer than the Link_Supervision_Timeout, the connection is\n" +"disconnected.\n\n" \ +"\t<connection_handle> - dddd; connection handle\n", +&hci_read_link_supervision_timeout +}, +{ +"write_link_supervision_timeout <connection_handle> <timeout>", +"\nThis command will write the value for the Link_Supervision_Timeout\n" \ +"parameter for the device. The Link_Supervision_Timeout parameter is used\n" \ +"by the master or slave Bluetooth device to monitor link loss. If, for any\n" \ +"reason, no Baseband packets are received from that connection handle for a\n" \ +"duration longer than the Link_Supervision_Timeout, the connection is\n" \ +"disconnected.\n\n" \ +"\t<connection_handle> - dddd; connection handle\n" \ +"\t<timeout> - dddd; timeout measured in number of baseband slots\n", +&hci_write_link_supervision_timeout +}, +{ NULL, } +}; + diff --git a/usr.sbin/bluetooth/hccontrol/info.c b/usr.sbin/bluetooth/hccontrol/info.c new file mode 100644 index 0000000..447a493 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/info.c @@ -0,0 +1,219 @@ +/* + * info.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: info.c,v 1.7 2002/09/06 18:52:41 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/endian.h> +#include <errno.h> +#include <ng_hci.h> +#include <stdio.h> +#include <string.h> +#include "hccontrol.h" + +/* Send Read_Local_Version_Information command to the unit */ +static int +hci_read_local_version_information(int s, int argc, char **argv) +{ + ng_hci_read_local_ver_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_INFO, + NG_HCI_OCF_READ_LOCAL_VER), (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + rp.manufacturer = le16toh(rp.manufacturer); + + fprintf(stdout, "HCI version: %s [%#02x]\n", + hci_ver2str(rp.hci_version), rp.hci_version); + fprintf(stdout, "HCI revision: %#04x\n", + le16toh(rp.hci_revision)); + fprintf(stdout, "LMP version: %#02x\n", rp.lmp_version); + fprintf(stdout, "LMP sub-version: %#04x\n", + le16toh(rp.lmp_subversion)); + fprintf(stdout, "Manufacturer: %s [%#04x]\n", + hci_manufacturer2str(rp.manufacturer), rp.manufacturer); + + return (OK); +} /* hci_read_local_version_information */ + +/* Send Read_Local_Supported_Features command to the unit */ +static int +hci_read_local_supported_features(int s, int argc, char **argv) +{ + ng_hci_read_local_features_rp rp; + int n; + char buffer[1024]; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_INFO, + NG_HCI_OCF_READ_LOCAL_FEATURES), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Features: "); + for (n = 0; n < sizeof(rp.features); n++) + fprintf(stdout, "%#02x ", rp.features[n]); + fprintf(stdout, "\n%s\n", hci_features2str(rp.features, + buffer, sizeof(buffer))); + + return (OK); +} /* hci_read_local_supported_features */ + +/* Sent Read_Buffer_Size command to the unit */ +static int +hci_read_buffer_size(int s, int argc, char **argv) +{ + ng_hci_read_buffer_size_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_INFO, + NG_HCI_OCF_READ_BUFFER_SIZE), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Max. ACL packet size: %d bytes\n", + le16toh(rp.max_acl_size)); + fprintf(stdout, "Number of ACL packets: %d\n", + le16toh(rp.num_acl_pkt)); + fprintf(stdout, "Max. SCO packet size: %d bytes\n", + rp.max_sco_size); + fprintf(stdout, "Number of SCO packets: %d\n", + le16toh(rp.num_sco_pkt)); + + return (OK); +} /* hci_read_buffer_size */ + +/* Send Read_Country_Code command to the unit */ +static int +hci_read_country_code(int s, int argc, char **argv) +{ + ng_hci_read_country_code_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_INFO, + NG_HCI_OCF_READ_COUNTRY_CODE), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Country code: %s [%#02x]\n", + hci_cc2str(rp.country_code), rp.country_code); + + return (OK); +} /* hci_read_country_code */ + +/* Send Read_BD_ADDR command to the unit */ +static int +hci_read_bd_addr(int s, int argc, char **argv) +{ + ng_hci_read_bdaddr_rp rp; + int n; + + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_INFO, + NG_HCI_OCF_READ_BDADDR), (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "BD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + rp.bdaddr.b[5], rp.bdaddr.b[4], rp.bdaddr.b[3], + rp.bdaddr.b[2], rp.bdaddr.b[1], rp.bdaddr.b[0]); + + return (OK); +} /* hci_read_bd_addr */ + +struct hci_command info_commands[] = { +{ +"read_local_version_information", +"\nThis command will read the values for the version information for the\n" \ +"local Bluetooth unit.", +&hci_read_local_version_information +}, +{ +"read_local_supported_features", +"\nThis command requests a list of the supported features for the local\n" \ +"unit. This command will return a list of the LMP features.", +&hci_read_local_supported_features +}, +{ +"read_buffer_size", +"\nThe Read_Buffer_Size command is used to read the maximum size of the\n" \ +"data portion of HCI ACL and SCO Data Packets sent from the Host to the\n" \ +"Host Controller.", +&hci_read_buffer_size +}, +{ +"read_country_code", +"\nThis command will read the value for the Country_Code return parameter.\n" \ +"The Country_Code defines which range of frequency band of the ISM 2.4 GHz\n" \ +"band will be used by the unit.", +&hci_read_country_code +}, +{ +"read_bd_addr", +"\nThis command will read the value for the BD_ADDR parameter. The BD_ADDR\n" \ +"is a 48-bit unique identifier for a Bluetooth unit.", +&hci_read_bd_addr +}, +{ +NULL, +}}; + diff --git a/usr.sbin/bluetooth/hccontrol/link_control.c b/usr.sbin/bluetooth/hccontrol/link_control.c new file mode 100644 index 0000000..68bf35f --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/link_control.c @@ -0,0 +1,973 @@ +/* + * link_control.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: link_control.c,v 1.12 2002/09/17 16:36:46 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/endian.h> +#include <errno.h> +#include <ng_hci.h> +#include <stdio.h> +#include <string.h> +#include "hccontrol.h" + +static void hci_inquiry_response (int n, u_int8_t **b); + +/* Send Inquiry command to the unit */ +static int +hci_inquiry(int s, int argc, char **argv) +{ + int n0, n1, n2, timo; + u_int8_t b[512]; + ng_hci_inquiry_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* set defaults */ + cp.lap[2] = 0x9e; + cp.lap[1] = 0x8b; + cp.lap[0] = 0x33; + cp.inquiry_length = 5; + cp.num_responses = 8; + + /* parse command parameters */ + switch (argc) { + case 3: + /* LAP */ + if (sscanf(argv[0], "%x:%x:%x", &n2, &n1, &n0) != 3) + return (USAGE); + + cp.lap[0] = (n0 & 0xff); + cp.lap[1] = (n1 & 0xff); + cp.lap[2] = (n2 & 0xff); + + /* inquiry length (N * 1.28) sec, range 0x01 - 0x30 */ + case 2: + if (sscanf(argv[1], "%d", &n0) != 1 || n0 < 0x1 || n0 > 0x30) + return (USAGE); + + cp.inquiry_length = (n0 & 0xff); + + /* number of responses, range 0x00 - 0xff */ + case 1: + if (sscanf(argv[2], "%d", &n0) != 1 || n0 > 0xff) + return (USAGE); + + cp.num_responses = (n0 & 0xff); + + /* use defaults */ + case 0: + break; + + default: + return (USAGE); + } + + /* send request and expect status back */ + n0 = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_INQUIRY), (char const *) &cp, sizeof(cp), + b, &n0) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + timo = timeout; + timeout = cp.inquiry_length * 1.28 + 1; + +wait_for_more: + /* wait for inquiry events */ + n0 = sizeof(b); + if (hci_recv(s, b, &n0) == ERROR) { + timeout = timo; + return (ERROR); + } + + if (n0 < sizeof(*e)) { + timeout = timo; + errno = EIO; + return (ERROR); + } + + switch (e->event) { + case NG_HCI_EVENT_INQUIRY_RESULT: { + ng_hci_inquiry_result_ep *ir = + (ng_hci_inquiry_result_ep *)(e + 1); + u_int8_t *r = (u_int8_t *)(ir + 1); + + fprintf(stdout, "Inquiry result, num_responses=%d\n", + ir->num_responses); + + for (n0 = 0; n0 < ir->num_responses; n0++) + hci_inquiry_response(n0, &r); + + goto wait_for_more; + } + + case NG_HCI_EVENT_INQUIRY_COMPL: + fprintf(stdout, "Inquiry complete. Status: %s [%#02x]\n", + hci_status2str(*(b + sizeof(*e))), *(b + sizeof(*e))); + break; + + default: + goto wait_for_more; + } + + timeout = timo; + + return (OK); +} /* hci_inquiry */ + +/* Print Inquiry_Result event */ +static void +hci_inquiry_response(int n, u_int8_t **b) +{ + struct inquiry_response { + bdaddr_t bdaddr; + u_int8_t page_scan_rep_mode; + u_int8_t page_scan_period_mode; + u_int8_t page_scan_mode; + u_int8_t class[NG_HCI_CLASS_SIZE]; + u_int16_t clock_offset; + } *ir = (struct inquiry_response *)(*b); + + fprintf(stdout, "Inquiry result #%d\n", n); + fprintf(stdout, "\tBD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + ir->bdaddr.b[5], ir->bdaddr.b[4], ir->bdaddr.b[3], + ir->bdaddr.b[2], ir->bdaddr.b[1], ir->bdaddr.b[0]); + fprintf(stdout, "\tPage Scan Rep. Mode: %#02x\n", + ir->page_scan_rep_mode); + fprintf(stdout, "\tPage Scan Period Mode: %#02x\n", + ir->page_scan_period_mode); + fprintf(stdout, "\tPage Scan Mode: %#02x\n", + ir->page_scan_mode); + fprintf(stdout, "\tClass: %02x:%02x:%02x\n", + ir->class[2], ir->class[1], ir->class[0]); + fprintf(stdout, "\tClock offset: %#04x\n", + le16toh(ir->clock_offset)); + + *b += sizeof(*ir); +} /* hci_inquiry_response */ + +/* Send Create_Connection command to the unit */ +static int +hci_create_connection(int s, int argc, char **argv) +{ + int n0, n1, n2, n3, n4, n5; + char b[512]; + ng_hci_create_con_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* Set defaults */ + memset(&cp, 0, sizeof(cp)); + cp.pkt_type = htole16( NG_HCI_PKT_DM1 | NG_HCI_PKT_DH1 | + NG_HCI_PKT_DM3 | NG_HCI_PKT_DH3 | + NG_HCI_PKT_DM5); + cp.page_scan_rep_mode = NG_HCI_SCAN_REP_MODE0; + cp.page_scan_mode = NG_HCI_MANDATORY_PAGE_SCAN_MODE; + cp.clock_offset = 0; + cp.accept_role_switch = 1; + + /* parse command parameters */ + switch (argc) { + case 6: + /* accept role switch */ + if (sscanf(argv[2], "%d", &n0) != 1) + return (USAGE); + + cp.accept_role_switch = n0 ? 1 : 0; + + case 5: + /* clock offset */ + if (sscanf(argv[2], "%d", &n0) != 1) + return (USAGE); + + cp.clock_offset = (n0 & 0xffff); + cp.clock_offset = htole16(cp.clock_offset); + + case 4: + /* page scan mode */ + if (sscanf(argv[2], "%d", &n0) != 1 || n0 < 0 || n0 > 3) + return (USAGE); + + cp.page_scan_mode = (n0 & 0xff); + + case 3: + /* page scan rep mode */ + if (sscanf(argv[2], "%d", &n0) != 1 || n0 < 0 || n0 > 2) + return (USAGE); + + cp.page_scan_rep_mode = (n0 & 0xff); + + case 2: + /* packet type */ + if (sscanf(argv[1], "%x", &n0) != 1) + return (USAGE); + + n0 &= ( NG_HCI_PKT_DM1 | NG_HCI_PKT_DH1 | + NG_HCI_PKT_DM3 | NG_HCI_PKT_DH3 | + NG_HCI_PKT_DM5); + if (n0 == 0) + return (USAGE); + + cp.pkt_type = (n0 & 0xffff); + cp.pkt_type = htole16(cp.pkt_type); + + case 1: + /* BD_ADDR */ + if (sscanf(argv[0], "%x:%x:%x:%x:%x:%x", + &n5, &n4, &n3, &n2, &n1, &n0) != 6) + return (USAGE); + + cp.bdaddr.b[0] = (n0 & 0xff); + cp.bdaddr.b[1] = (n1 & 0xff); + cp.bdaddr.b[2] = (n2 & 0xff); + cp.bdaddr.b[3] = (n3 & 0xff); + cp.bdaddr.b[4] = (n4 & 0xff); + cp.bdaddr.b[5] = (n5 & 0xff); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n0 = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_CREATE_CON), + (char const *) &cp, sizeof(cp), b, &n0) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n0 = sizeof(b); + if (hci_recv(s, b, &n0) == ERROR) + return (ERROR); + if (n0 < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_CON_COMPL) { + ng_hci_con_compl_ep *ep = (ng_hci_con_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "BD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3], + ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]); + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "Encryption mode: %s [%d]\n", + hci_encrypt2str(ep->encryption_mode, 0), + ep->encryption_mode); + } else + goto again; + + return (OK); +} /* hci_create_connection */ + +/* Send Disconnect command to the unit */ +static int +hci_disconnect(int s, int argc, char **argv) +{ + int n; + char b[512]; + ng_hci_discon_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* Set defaults */ + memset(&cp, 0, sizeof(cp)); + cp.reason = 0x13; + + /* parse command parameters */ + switch (argc) { + case 2: + /* reason */ + if (sscanf(argv[1], "%d", &n) != 1 || n <= 0x00 || n > 0xff) + return (USAGE); + + cp.reason = (u_int8_t) (n & 0xff); + + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_DISCON), + (char const *) &cp, sizeof(cp), b, &n) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n = sizeof(b); + if (hci_recv(s, b, &n) == ERROR) + return (ERROR); + if (n < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_DISCON_COMPL) { + ng_hci_discon_compl_ep *ep = (ng_hci_discon_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "Reason: %s [%#02x]\n", + hci_status2str(ep->reason), ep->reason); + } else + goto again; + + return (OK); +} /* hci_diconnect */ + +/* Send Add_SCO_Connection command to the unit */ +static int +hci_add_sco_connection(int s, int argc, char **argv) +{ + int n; + char b[512]; + ng_hci_add_sco_con_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* Set defaults */ + memset(&cp, 0, sizeof(cp)); + cp.pkt_type = htole16(NG_HCI_PKT_HV1 | NG_HCI_PKT_HV2 | NG_HCI_PKT_HV3); + + /* parse command parameters */ + switch (argc) { + case 2: + /* packet type */ + if (sscanf(argv[0], "%x", &n) != 1) + return (USAGE); + + n &= (NG_HCI_PKT_HV1 | NG_HCI_PKT_HV2 | NG_HCI_PKT_HV3); + if (n == 0) + return (USAGE); + + cp.pkt_type = (u_int16_t) (n & 0x0fff); + cp.pkt_type = htole16(cp.pkt_type); + + case 1: + /* acl connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_ADD_SCO_CON), + (char const *) &cp, sizeof(cp), b, &n) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n = sizeof(b); + if (hci_recv(s, b, &n) == ERROR) + return (ERROR); + if (n < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_CON_COMPL) { + ng_hci_con_compl_ep *ep = (ng_hci_con_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "BD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3], + ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]); + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "Encryption mode: %s [%d]\n", + hci_encrypt2str(ep->encryption_mode, 0), + ep->encryption_mode); + } else + goto again; + + return (OK); +} /* Add_SCO_Connection */ + +/* Send Change_Connection_Packet_Type command to the unit */ +static int +hci_change_connection_packet_type(int s, int argc, char **argv) +{ + int n; + char b[512]; + ng_hci_change_con_pkt_type_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + switch (argc) { + case 2: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + + /* packet type */ + if (sscanf(argv[1], "%x", &n) != 1) + return (USAGE); + + cp.pkt_type = (u_int16_t) (n & 0xffff); + cp.pkt_type = htole16(cp.pkt_type); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_CHANGE_CON_PKT_TYPE), + (char const *) &cp, sizeof(cp), b, &n) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n = sizeof(b); + if (hci_recv(s, b, &n) == ERROR) + return (ERROR); + if (n < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_CON_PKT_TYPE_CHANGED) { + ng_hci_con_pkt_type_changed_ep *ep = + (ng_hci_con_pkt_type_changed_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "Packet type: %#04x\n", + le16toh(ep->pkt_type)); + } else + goto again; + + return (OK); +} /* hci_change_connection_packet_type */ + +/* Send Remote_Name_Request command to the unit */ +static int +hci_remote_name_request(int s, int argc, char **argv) +{ + int n0, n1, n2, n3, n4, n5; + char b[512]; + ng_hci_remote_name_req_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* parse command parameters */ + switch (argc) { + case 4: + /* BD_ADDR */ + if (sscanf(argv[0], "%x:%x:%x:%x:%x:%x", + &n5, &n4, &n3, &n2, &n1, &n0) != 6) + return (USAGE); + + cp.bdaddr.b[0] = (n0 & 0xff); + cp.bdaddr.b[1] = (n1 & 0xff); + cp.bdaddr.b[2] = (n2 & 0xff); + cp.bdaddr.b[3] = (n3 & 0xff); + cp.bdaddr.b[4] = (n4 & 0xff); + cp.bdaddr.b[5] = (n5 & 0xff); + + /* page_scan_rep_mode */ + if (sscanf(argv[1], "%d", &n0) != 1 || n0 < 0x00 || n0 > 0x02) + return (USAGE); + + cp.page_scan_rep_mode = (n0 & 0xff); + + /* page_scan_mode */ + if (sscanf(argv[2], "%d", &n0) != 1 || n0 < 0x00 || n0 > 0x03) + return (USAGE); + + cp.page_scan_mode = (n0 & 0xff); + + /* clock_offset */ + if (sscanf(argv[3], "%x", &n0) != 1) + return (USAGE); + + cp.clock_offset = (n0 & 0xffff); + cp.clock_offset = htole16(cp.clock_offset); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n0 = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_REMOTE_NAME_REQ), + (char const *) &cp, sizeof(cp), b, &n0) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n0 = sizeof(b); + if (hci_recv(s, b, &n0) == ERROR) + return (ERROR); + if (n0 < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL) { + ng_hci_remote_name_req_compl_ep *ep = + (ng_hci_remote_name_req_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "BD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3], + ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]); + fprintf(stdout, "Name: %s\n", ep->name); + } else + goto again; + + return (OK); +} /* hci_remote_name_request */ + +/* Send Read_Remote_Supported_Features command to the unit */ +static int +hci_read_remote_supported_features(int s, int argc, char **argv) +{ + int n; + char b[512]; + ng_hci_read_remote_features_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + char buffer[1024]; + + /* parse command parameters */ + switch (argc) { + case 1: + /* connecton handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_READ_REMOTE_FEATURES), + (char const *) &cp, sizeof(cp), b, &n) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n = sizeof(b); + if (hci_recv(s, b, &n) == ERROR) + return (ERROR); + + if (n < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL) { + ng_hci_read_remote_features_compl_ep *ep = + (ng_hci_read_remote_features_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "Features: "); + for (n = 0; n < sizeof(ep->features); n++) + fprintf(stdout, "%#02x ", ep->features[n]); + fprintf(stdout, "\n%s\n", hci_features2str(ep->features, + buffer, sizeof(buffer))); + } else + goto again; + + return (OK); +} /* hci_read_remote_supported_features */ + +/* Send Read_Remote_Version_Information command to the unit */ +static int +hci_read_remote_version_information(int s, int argc, char **argv) +{ + int n; + char b[512]; + ng_hci_read_remote_ver_info_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* parse command parameters */ + switch (argc) { + case 1: + /* connecton handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_READ_REMOTE_VER_INFO), + (char const *) &cp, sizeof(cp), b, &n) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n = sizeof(b); + if (hci_recv(s, b, &n) == ERROR) + return (ERROR); + + if (n < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL) { + ng_hci_read_remote_ver_info_compl_ep *ep = + (ng_hci_read_remote_ver_info_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + ep->manufacturer = le16toh(ep->manufacturer); + + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "LMP version: %#02x\n", ep->lmp_version); + fprintf(stdout, "LMP sub-version: %#04x\n", + le16toh(ep->lmp_subversion)); + fprintf(stdout, "Manufacturer: %s [%#04x]\n", + hci_manufacturer2str(ep->manufacturer), + ep->manufacturer); + } else + goto again; + + return (OK); +} /* hci_read_remote_version_information */ + +/* Send Read_Clock_Offset command to the unit */ +static int +hci_read_clock_offset(int s, int argc, char **argv) +{ + int n; + char b[512]; + ng_hci_read_clock_offset_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* parse command parameters */ + switch (argc) { + case 1: + /* connecton handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, + NG_HCI_OCF_READ_CLOCK_OFFSET), + (char const *) &cp, sizeof(cp), b, &n) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n = sizeof(b); + if (hci_recv(s, b, &n) == ERROR) + return (ERROR); + + if (n < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL) { + ng_hci_read_clock_offset_compl_ep *ep = + (ng_hci_read_clock_offset_compl_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", + le16toh(ep->con_handle)); + fprintf(stdout, "Clock offset: %#04x\n", + le16toh(ep->clock_offset)); + } else + goto again; + + return (OK); +} /* hci_read_clock_offset */ + +struct hci_command link_control_commands[] = { +{ +"inquiry <LAP> <inquiry_length> <num_reponses>", +"\nThis command will cause the Bluetooth unit to enter Inquiry Mode.\n" \ +"Inquiry Mode is used to discover other nearby Bluetooth units. The LAP\n" \ +"input parameter contains the LAP from which the inquiry access code shall\n" \ +"be derived when the inquiry procedure is made. The Inquiry_Length parameter\n"\ +"specifies the total duration of the Inquiry Mode and, when this time\n" \ +"expires, Inquiry will be halted. The Num_Responses parameter specifies the\n" \ +"number of responses that can be received before the Inquiry is halted.\n\n" \ +"\t<LAP> - xx:xx:xx; 9e:8b:33 (GIAC), 93:8b:00 (LDIAC)\n" \ +"\t<inquiry_length> - dd; total length == dd * 1.28 sec\n" \ +"\t<num_responses> - dd", +&hci_inquiry +}, +{ +"create_connection <BD_ADDR> <pkt> <rep_mode> <ps_mode> <clck_off> <role_sw>", +"" \ +"\t<BD_ADDR> - remote unit address\n\n" \ +"\t<pkt> - xxxx; packet type\n" \ +"" \ +"\t\tACL packets\n" \ +"\t\t-----------\n" \ +"\t\t0x0008 DM1\n" \ +"\t\t0x0010 DH1\n" \ +"\t\t0x0400 DM3\n" \ +"\t\t0x0800 DH3\n" \ +"\t\t0x4000 DM5\n" \ +"\t\t0x8000 DH5\n\n" \ +"" \ +"\trep_mode - d; page scan repetition mode\n" \ +"" \ +"\t\tPage scan repetition modes\n" \ +"\t\t--------------------------\n" \ +"\t\t0 Page scan repetition mode 0\n" \ +"\t\t1 Page scan repetition mode 1\n" \ +"\t\t2 Page scan repetition mode 2\n" \ +"\n" \ +"\tps_mode - d; Page scan mode\n" \ +"" \ +"\t\tPage scan modes\n" \ +"\t\t---------------\n" \ +"\t\t0 Mandatory page scan mode\n" \ +"\t\t1 Optional page scan mode1\n" \ +"\t\t2 Optional page scan mode2\n" \ +"\t\t3 Optional page scan mode3\n" \ +"\n" \ +"\tclck_off - dddd; clock offset. Use 0 if unknown\n\n" \ +"\trole_sw - d; allow (1) or deny role switch\n", +&hci_create_connection +}, +{ +"disconnect <connection_handle> <reason>", +"\nThe Disconnection command is used to terminate an existing connection.\n" \ +"The connection handle command parameter indicates which connection is to\n" \ +"be disconnected. The Reason command parameter indicates the reason for\n" \ +"ending the connection.\n\n" \ +"\t<connection_handle> - dddd; connection handle\n" \ +"\t<reason> - dd; reason; usually 19 (0x13) - user ended;\n" \ +"\t also 0x05, 0x13-0x15, 0x1A, 0x29", +&hci_disconnect +}, +{ +"add_sco_connection <acl connection handle> <packet type>", +"This command will cause the link manager to create a SCO connection using\n" \ +"the ACL connection specified by the connection handle command parameter.\n" \ +"The Link Manager will determine how the new connection is established. This\n"\ +"connection is determined by the current state of the device, its piconet,\n" \ +"and the state of the device to be connected. The packet type command parameter\n" \ +"specifies which packet types the Link Manager should use for the connection.\n"\ +"The Link Manager must only use the packet type(s) specified by the packet\n" \ +"type command parameter for sending HCI SCO data packets. Multiple packet\n" \ +"types may be specified for the packet type command parameter by performing\n" \ +"a bitwise OR operation of the different packet types. Note: An SCO connection\n" \ +"can only be created when an ACL connection already exists and when it is\n" \ +"not put in park mode.\n\n" \ +"\t<connection_handle> - dddd; ACL connection handle\n" \ +"\t<packet_type> - xxxx; packet type\n" \ +"" \ +"\t\tSCO packets\n" \ +"\t\t-----------\n" \ +"\t\t0x0020 HV1\n" \ +"\t\t0x0040 HV2\n" \ +"\t\t0x0080 HV3\n", +&hci_add_sco_connection +}, +{ +"change_connection_packet_type <connection_hande> <packet_type>", +"The Change_Connection_Packet_Type command is used to change which packet\n" \ +"types can be used for a connection that is currently established. This\n" \ +"allows current connections to be dynamically modified to support different\n" \ +"types of user data. The Packet_Type command parameter specifies which\n" \ +"packet types the Link Manager can use for the connection. Multiple packet\n" \ +"types may be specified for the Packet_Type command parameter by bitwise OR\n" \ +"operation of the different packet types.\n\n" \ +"\t<connection_handle> - dddd; connection handle\n" \ +"\t<packet_type> - xxxx; packet type mask\n" \ +"" \ +"\t\tACL packets\n" \ +"\t\t-----------\n" \ +"\t\t0x0008 DM1\n" \ +"\t\t0x0010 DH1\n" \ +"\t\t0x0400 DM3\n" \ +"\t\t0x0800 DH3\n" \ +"\t\t0x4000 DM5\n" \ +"\t\t0x8000 DH5\n\n" \ +"" \ +"\t\tSCO packets\n" \ +"\t\t-----------\n" \ +"\t\t0x0020 HV1\n" \ +"\t\t0x0040 HV2\n" \ +"\t\t0x0080 HV3\n" \ +"", +&hci_change_connection_packet_type +}, +{ +"remote_name_request <bdaddr> <ps_rep_mode> <ps_mode> <clock_offset>", +"\nThe Remote_Name_Request command is used to obtain the user-friendly\n" \ +"name of another Bluetooth unit.\n\n" \ +"\t<bdaddr> - xx:xx:xx:xx:xx:xx remote unit BD_ADDR\n" \ +"\t<ps_rep_mode> - dd; page scan repetition mode [0-2]\n" \ +"\t<ps_mode> - dd; page scan mode [0-3]\n" \ +"\t<clock_offset> - xxxx; clock offset [0 - 0xffff]", +&hci_remote_name_request +}, +{ +"read_remote_supported_features <connection_handle>", +"\nThis command requests a list of the supported features for the remote\n" \ +"unit identified by the connection handle parameter. The connection handle\n" \ +"must be a connection handle for an ACL connection.\n\n" \ +"\t<connection_handle> - dddd; connection handle", +&hci_read_remote_supported_features +}, +{ +"read_remote_version_information <connection_handle>", +"\nThis command will obtain the values for the version information for the\n" \ +"remote Bluetooth unit identified by the connection handle parameter. The\n" \ +"connection handle must be a connection handle for an ACL connection.\n\n" \ +"\t<conneciton_handle> - dddd; connection handle", +&hci_read_remote_version_information +}, +{ +"read_clock_offset <connection_handle>", +"\nThis command allows the Host to read clock offset to remote unit.\n" \ +"\t<conneciton_handle> - dddd; connection handle", +&hci_read_clock_offset +}, +{ +NULL, +}}; + diff --git a/usr.sbin/bluetooth/hccontrol/link_policy.c b/usr.sbin/bluetooth/hccontrol/link_policy.c new file mode 100644 index 0000000..dec9259 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/link_policy.c @@ -0,0 +1,310 @@ +/* + * link_policy.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: link_policy.c,v 1.3 2002/09/17 16:33:44 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/endian.h> +#include <errno.h> +#include <ng_hci.h> +#include <stdio.h> +#include "hccontrol.h" + +/* Send Role Discovery to the unit */ +static int +hci_role_discovery(int s, int argc, char **argv) +{ + ng_hci_role_discovery_cp cp; + ng_hci_role_discovery_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_POLICY, + NG_HCI_OCF_ROLE_DISCOVERY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); + fprintf(stdout, "Role: %s [%#x]\n", + (rp.role == NG_HCI_ROLE_MASTER)? "Master" : "Slave", rp.role); + + return (OK); +} /* hci_role_discovery */ + +/* Send Swith Role to the unit */ +static int +hci_switch_role(int s, int argc, char **argv) +{ + int n0, n1, n2, n3, n4, n5; + char b[512]; + ng_hci_switch_role_cp cp; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; + + /* parse command parameters */ + switch (argc) { + case 2: + /* bdaddr */ + if (sscanf(argv[0], "%x:%x:%x:%x:%x:%x", + &n5, &n4, &n3, &n2, &n1, &n0) != 6) + return (USAGE); + + cp.bdaddr.b[0] = n0 & 0xff; + cp.bdaddr.b[1] = n1 & 0xff; + cp.bdaddr.b[2] = n2 & 0xff; + cp.bdaddr.b[3] = n3 & 0xff; + cp.bdaddr.b[4] = n4 & 0xff; + cp.bdaddr.b[5] = n5 & 0xff; + + /* role */ + if (sscanf(argv[1], "%d", &n0) != 1) + return (USAGE); + + cp.role = n0? NG_HCI_ROLE_SLAVE : NG_HCI_ROLE_MASTER; + break; + + default: + return (USAGE); + } + + /* send request and expect status response */ + n0 = sizeof(b); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_POLICY, + NG_HCI_OCF_SWITCH_ROLE), + (char const *) &cp, sizeof(cp), b, &n0) == ERROR) + return (ERROR); + + if (*b != 0x00) + return (FAILED); + + /* wait for event */ +again: + n0 = sizeof(b); + if (hci_recv(s, b, &n0) == ERROR) + return (ERROR); + if (n0 < sizeof(*e)) { + errno = EIO; + return (ERROR); + } + + if (e->event == NG_HCI_EVENT_ROLE_CHANGE) { + ng_hci_role_change_ep *ep = (ng_hci_role_change_ep *)(e + 1); + + if (ep->status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(ep->status), ep->status); + return (FAILED); + } + + fprintf(stdout, "BD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + ep->bdaddr.b[5], ep->bdaddr.b[4], ep->bdaddr.b[3], + ep->bdaddr.b[2], ep->bdaddr.b[1], ep->bdaddr.b[0]); + fprintf(stdout, "Role: %s [%#x]\n", + (ep->role == NG_HCI_ROLE_MASTER)? "Master" : "Slave", + ep->role); + } else + goto again; + + return (OK); +} /* hci_switch_role */ + +/* Send Read_Link_Policy_Settings command to the unit */ +static int +hci_read_link_policy_settings(int s, int argc, char **argv) +{ + ng_hci_read_link_policy_settings_cp cp; + ng_hci_read_link_policy_settings_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send request */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_POLICY, + NG_HCI_OCF_READ_LINK_POLICY_SETTINGS), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); + fprintf(stdout, "Link policy settings: %#x\n", le16toh(rp.settings)); + + return (OK); +} /* hci_read_link_policy_settings */ + +/* Send Write_Link_Policy_Settings command to the unit */ +static int +hci_write_link_policy_settings(int s, int argc, char **argv) +{ + ng_hci_write_link_policy_settings_cp cp; + ng_hci_write_link_policy_settings_rp rp; + int n; + + /* parse command parameters */ + switch (argc) { + case 2: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + + /* link policy settings */ + if (sscanf(argv[1], "%x", &n) != 1) + return (USAGE); + + cp.settings = (u_int16_t) (n & 0x0ffff); + cp.settings = htole16(cp.settings); + break; + + default: + return (USAGE); + } + + /* send request */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_POLICY, + NG_HCI_OCF_WRITE_LINK_POLICY_SETTINGS), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_write_link_policy_settings */ + +struct hci_command link_policy_commands[] = { +{ +"role_discovery <conection_handle>", +"\nThe Role_Discovery command is used for a Bluetooth device to determine\n" \ +"which role the device is performing for a particular Connection Handle.\n" \ +"The connection handle must be a connection handle for an ACL connection.\n\n" \ +"\t<connection_handle> - dddd; connection handle", +&hci_role_discovery +}, +{ +"switch_role <bdaddr> <role>", +"\nThe Switch_Role command is used for a Bluetooth device to switch the\n" \ +"current role the device is performing for a particular connection with\n" \ +"another specified Bluetooth device. The BD_ADDR command parameter indicates\n"\ +"for which connection the role switch is to be performed. The Role indicates\n"\ +"the requested new role that the local device performs. Note: the BD_ADDR\n" \ +"command parameter must specify a Bluetooth device for which a connection\n" +"already exists.\n\n" \ +"\t<bdaddr> - xx:xx:xx:xx:xx:xx; device bdaddr\n" \ +"\t<role> - dd; role; 0 - Master, 1 - Slave", +&hci_switch_role +}, +{ +"read_link_policy_settings <connection_handle>", +"\nThis command will read the Link Policy setting for the specified connection\n"\ +"handle. The link policy settings parameter determines the behavior of the\n" \ +"local Link Manager when it receives a request from a remote device or it\n" \ +"determines itself to change the master-slave role or to enter the hold,\n" \ +"sniff, or park mode. The local Link Manager will automatically accept or\n" \ +"reject such a request from the remote device, and may even autonomously\n" \ +"request itself, depending on the value of the link policy settings parameter\n"\ +"for the corresponding connection handle. The connection handle must be a\n" \ +"connection handle for an ACL connection.\n\n" \ +"\t<connection_handle> - dddd; connection handle", +&hci_read_link_policy_settings +}, +{ +"write_link_policy_settings <connection_handle> <settings>", +"\nThis command will write the Link Policy setting for the specified connection\n"\ +"handle. The link policy settings parameter determines the behavior of the\n" \ +"local Link Manager when it receives a request from a remote device or it\n" \ +"determines itself to change the master-slave role or to enter the hold,\n" \ +"sniff, or park mode. The local Link Manager will automatically accept or\n" \ +"reject such a request from the remote device, and may even autonomously\n" \ +"request itself, depending on the value of the link policy settings parameter\n"\ +"for the corresponding connection handle. The connection handle must be a\n" \ +"connection handle for an ACL connection. Multiple Link Manager policies may\n"\ +"be specified for the link policy settings parameter by performing a bitwise\n"\ +"OR operation of the different activity types.\n\n" \ +"\t<connection_handle> - dddd; connection handle\n" \ +"\t<settings> - xxxx; settings\n" \ +"\t\t0x0000 - Disable All LM Modes (Default)\n" \ +"\t\t0x0001 - Enable Master Slave Switch\n" \ +"\t\t0x0002 - Enable Hold Mode\n" \ +"\t\t0x0004 - Enable Sniff Mode\n" \ +"\t\t0x0008 - Enable Park Mode\n", +&hci_write_link_policy_settings +}, +{ +NULL, +}}; + diff --git a/usr.sbin/bluetooth/hccontrol/node.c b/usr.sbin/bluetooth/hccontrol/node.c new file mode 100644 index 0000000..b7ff33a --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/node.c @@ -0,0 +1,518 @@ +/* + * node.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: node.c,v 1.8 2002/11/12 22:33:17 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/ioctl.h> +#include <bitstring.h> +#include <errno.h> +#include <ng_hci.h> +#include <ng_l2cap.h> +#include <ng_btsocket.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "hccontrol.h" + +/* Send Read_Node_State command to the node */ +static int +hci_read_node_state(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_state r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_STATE, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\nState: %#x\n", r.hci_node, r.state); + + return (OK); +} /* hci_read_node_state */ + +/* Send Intitialize command to the node */ +static int +hci_node_initialize(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_init r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_INIT, &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* hci_node_initialize */ + +/* Send Read_Debug_Level command to the node */ +static int +hci_read_debug_level(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_debug r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_DEBUG, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\nDebug level: %d\n", r.hci_node, r.debug); + + return (OK); +} /* hci_read_debug_level */ + +/* Send Write_Debug_Level command to the node */ +static int +hci_write_debug_level(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_debug r; + + memset(&r, 0, sizeof(r)); + switch (argc) { + case 1: + r.debug = atoi(argv[0]); + break; + + default: + return (USAGE); + } + + if (ioctl(s, SIOC_HCI_RAW_NODE_SET_DEBUG, &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* hci_write_debug_level */ + +/* Send Read_Node_Buffer_Size command to the node */ +static int +hci_read_node_buffer_size(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_buffer r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_BUFFER, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\n", + r.hci_node); + fprintf(stdout, "Number of free command buffers: %d\n", + r.buffer.cmd_free); + fprintf(stdout, "Max. ACL packet size: %d\n", + r.buffer.acl_size); + fprintf(stdout, "Numbef of free ACL buffers: %d\n", + r.buffer.acl_free); + fprintf(stdout, "Total number of ACL buffers: %d\n", + r.buffer.acl_pkts); + fprintf(stdout, "Max. SCO packet size: %d\n", + r.buffer.sco_size); + fprintf(stdout, "Numbef of free SCO buffers: %d\n", + r.buffer.sco_free); + fprintf(stdout, "Total number of SCO buffers: %d\n", + r.buffer.sco_pkts); + + return (OK); +} /* hci_read_node_buffer_size */ + +/* Send Read_Node_BD_ADDR command to the node */ +static int +hci_read_node_bd_addr(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_bdaddr r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_BDADDR, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\n", r.hci_node); + fprintf(stdout, "BD_ADDR: %02x:%02x:%02x:%02x:%02x:%02x\n", + r.bdaddr.b[5], r.bdaddr.b[4], r.bdaddr.b[3], + r.bdaddr.b[2], r.bdaddr.b[1], r.bdaddr.b[0]); + + return (OK); +} /* hci_read_node_bd_addr */ + +/* Send Read_Node_Features command to the node */ +static int +hci_read_node_features(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_features r; + int n; + char buffer[1024]; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_FEATURES, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\nFeatures: ", r.hci_node); + for (n = 0; n < sizeof(r.features)/sizeof(r.features[0]); n++) + fprintf(stdout, "%#02x ", r.features[n]); + fprintf(stdout, "\n%s\n", hci_features2str(r.features, + buffer, sizeof(buffer))); + + return (OK); +} /* hci_read_node_features */ + +/* Send Read_Node_Stat command to the node */ +static int +hci_read_node_stat(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_stat r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_STAT, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\n", r.hci_node); + fprintf(stdout, "Commands sent: %d\n", r.stat.cmd_sent); + fprintf(stdout, "Events received: %d\n", r.stat.evnt_recv); + fprintf(stdout, "ACL packets received: %d\n", r.stat.acl_recv); + fprintf(stdout, "ACL packets sent: %d\n", r.stat.acl_sent); + fprintf(stdout, "SCO packets received: %d\n", r.stat.sco_recv); + fprintf(stdout, "SCO packets sent: %d\n", r.stat.sco_sent); + fprintf(stdout, "Bytes received: %d\n", r.stat.bytes_recv); + fprintf(stdout, "Bytes sent: %d\n", r.stat.bytes_sent); + + return (OK); +} /* hci_read_node_stat */ + +/* Send Reset_Node_Stat command to the node */ +static int +hci_reset_node_stat(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_reset_stat r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_RESET_STAT, &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* hci_reset_node_stat */ + +/* Send Flush_Neighbor_Cache command to the node */ +static int +hci_flush_neighbor_cache(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_flush_neighbor_cache r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_FLUSH_NEIGHBOR_CACHE, + &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* hci_flush_neighbor_cache */ + +/* Send Read_Neighbor_Cache command to the node */ +static int +hci_read_neighbor_cache(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_neighbor_cache r; + int n, error = OK; + + memset(&r, 0, sizeof(r)); + r.num_entries = NG_HCI_MAX_NEIGHBOR_NUM; + r.entries = calloc(NG_HCI_MAX_NEIGHBOR_NUM, + sizeof(ng_hci_node_neighbor_cache_entry_ep)); + if (r.entries == NULL) { + errno = ENOMEM; + return (ERROR); + } + + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_NEIGHBOR_CACHE, &r, + sizeof(r)) < 0) { + error = ERROR; + goto out; + } + + fprintf(stdout, "Neighbor cache for the node: %s\n", r.hci_node); + fprintf(stdout, +"BD_ADDR " \ +"Features " \ +"Clock offset " \ +"Page scan " \ +"Rep. scan\n"); + + for (n = 0; n < r.num_entries; n++) { + fprintf(stdout, +"%02x:%02x:%02x:%02x:%02x:%02x " \ +"%02x %02x %02x %02x %02x %02x %02x %02x " \ +"%#12x " \ +"%#9x " \ +"%#9x\n", + r.entries[n].bdaddr.b[5], r.entries[n].bdaddr.b[4], + r.entries[n].bdaddr.b[3], r.entries[n].bdaddr.b[2], + r.entries[n].bdaddr.b[1], r.entries[n].bdaddr.b[0], + r.entries[n].features[0], r.entries[n].features[1], + r.entries[n].features[2], r.entries[n].features[3], + r.entries[n].features[4], r.entries[n].features[5], + r.entries[n].features[6], r.entries[n].features[7], + r.entries[n].clock_offset, r.entries[n].page_scan_mode, + r.entries[n].page_scan_rep_mode); + } +out: + free(r.entries); + + return (error); +} /* hci_read_neightbor_cache */ + +/* Send Read_Connection_List command to the node */ +static int +hci_read_connection_list(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_con_list r; + int n, error = OK; + + memset(&r, 0, sizeof(r)); + r.num_connections = NG_HCI_MAX_CON_NUM; + r.connections = calloc(NG_HCI_MAX_CON_NUM, sizeof(ng_hci_node_con_ep)); + if (r.connections == NULL) { + errno = ENOMEM; + return (ERROR); + } + + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_CON_LIST, &r, sizeof(r)) < 0) { + error = ERROR; + goto out; + } + + fprintf(stdout, "Connections list for the node: %s\n", r.hci_node); + fprintf(stdout, +"Remote BD_ADDR " \ +"Handle " \ +"Type " \ +"Mode " \ +"Role " \ +"Encrypt " \ +"Pending " \ +"Queue " \ +"State\n"); + + for (n = 0; n < r.num_connections; n++) { + fprintf(stdout, +"%02x:%02x:%02x:%02x:%02x:%02x " \ +"%6d " \ +"%4.4s " \ +"%4d " \ +"%4.4s " \ +"%7.7s " \ +"%7d " \ +"%5d " \ +"%s\n", + r.connections[n].bdaddr.b[5], + r.connections[n].bdaddr.b[4], + r.connections[n].bdaddr.b[3], + r.connections[n].bdaddr.b[2], + r.connections[n].bdaddr.b[1], + r.connections[n].bdaddr.b[0], + r.connections[n].con_handle, + (r.connections[n].link_type == NG_HCI_LINK_ACL)? + "ACL" : "SCO", + r.connections[n].mode, + (r.connections[n].role == NG_HCI_ROLE_MASTER)? + "MAST" : "SLAV", + hci_encrypt2str(r.connections[n].encryption_mode, 1), + r.connections[n].pending, + r.connections[n].queue_len, + hci_con_state2str(r.connections[n].state)); + } +out: + free(r.connections); + + return (error); +} /* hci_read_connection_list */ + +/* Send Read_Link_Policy_Settings_Mask command to the node */ +int +hci_read_link_policy_settings_mask(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_link_policy_mask r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\nLink Policy Settings mask: %#04x\n", + r.hci_node, r.policy_mask); + + return (OK); +} /* hci_read_link_policy_settings_mask */ + +/* Send Write_Link_Policy_Settings_Mask command to the node */ +int +hci_write_link_policy_settings_mask(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_link_policy_mask r; + int m; + + memset(&r, 0, sizeof(r)); + + switch (argc) { + case 1: + if (sscanf(argv[0], "%x", &m) != 1) + return (USAGE); + + r.policy_mask = (m & 0xffff); + break; + + default: + return (USAGE); + } + + if (ioctl(s, SIOC_HCI_RAW_NODE_SET_LINK_POLICY_MASK, &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* hci_write_link_policy_settings_mask */ + +/* Send Read_Packet_Mask command to the node */ +int +hci_read_packet_mask(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_packet_mask r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_HCI_RAW_NODE_GET_PACKET_MASK, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "Node: %s\nPacket mask: %#04x\n", + r.hci_node, r.packet_mask); + + return (OK); +} /* hci_read_packet_mask */ + +/* Send Write_Packet_Mask command to the node */ +int +hci_write_packet_mask(int s, int argc, char **argv) +{ + struct ng_btsocket_hci_raw_node_packet_mask r; + int m; + + memset(&r, 0, sizeof(r)); + + switch (argc) { + case 1: + if (sscanf(argv[0], "%x", &m) != 1) + return (USAGE); + + r.packet_mask = (m & 0xffff); + break; + + default: + return (USAGE); + } + + if (ioctl(s, SIOC_HCI_RAW_NODE_SET_PACKET_MASK, &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* hci_write_packet_mask */ + +struct hci_command node_commands[] = { +{ +"read_node_state", +"Get HCI node state", +&hci_read_node_state +}, +{ +"initialize", +"Initialize HCI node", +&hci_node_initialize +}, +{ +"read_debug_level", +"Read HCI node debug level", +&hci_read_debug_level +}, +{ +"write_debug_level <level>", +"Write HCI node debug level", +&hci_write_debug_level +}, +{ +"read_node_buffer_size", +"Read HCI node buffer information", +&hci_read_node_buffer_size +}, +{ +"read_node_bd_addr", +"Read HCI node BD_ADDR", +&hci_read_node_bd_addr +}, +{ +"read_node_features", +"Read HCI node features", +&hci_read_node_features +}, +{ +"read_node_stat", +"Read HCI node statistic information", +&hci_read_node_stat +}, +{ +"reset_node_stat", +"Reset HCI node statistic information", +&hci_reset_node_stat +}, +{ +"flush_neighbor_cache", +"Flush HCI node neighbor cache", +&hci_flush_neighbor_cache +}, +{ +"read_neighbor_cache", +"Read HCI node neighbor cache", +&hci_read_neighbor_cache +}, +{ +"read_connection_list", +"Read connection list", +&hci_read_connection_list +}, +{ +"read_node_link_policy_settings_mask", +"Read Link Policy Settinngs mask for the node", +&hci_read_link_policy_settings_mask +}, +{ +"write_node_link_policy_settings_mask <policy_mask>", +"Write Link Policy Settinngs mask for the node. Policy mask - xxxx", +&hci_write_link_policy_settings_mask +}, +{ +"read_node_packet_mask", +"Read Packet mask for the node", +&hci_read_packet_mask +}, +{ +"write_node_packet_mask <packet_mask>", +"Write Packet mask for the node. Packet mask - xxxx", +&hci_write_packet_mask +}, +{ +NULL, +}}; + diff --git a/usr.sbin/bluetooth/hccontrol/send_recv.c b/usr.sbin/bluetooth/hccontrol/send_recv.c new file mode 100644 index 0000000..aff6f93 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/send_recv.c @@ -0,0 +1,184 @@ +/* + * send_recv.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: send_recv.c,v 1.4 2002/09/04 21:31:30 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/time.h> +#include <sys/endian.h> +#include <assert.h> +#include <errno.h> +#include <ng_hci.h> +#include <string.h> +#include <unistd.h> +#include "hccontrol.h" + +/* Send HCI request to the unit */ +int +hci_request(int s, int opcode, char const *cp, int cp_size, char *rp, int *rp_size) +{ + char buffer[512]; + int n; + ng_hci_cmd_pkt_t *c = (ng_hci_cmd_pkt_t *) buffer; + ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) buffer; + + assert(rp != NULL); + assert(*rp_size != NULL); + assert(*rp_size > 0); + + c->type = NG_HCI_CMD_PKT; + c->opcode = (u_int16_t) opcode; + c->opcode = htole16(c->opcode); + + if (cp != NULL) { + assert(0 < cp_size && cp_size <= NG_HCI_CMD_PKT_SIZE); + + c->length = (u_int8_t) cp_size; + memcpy(buffer + sizeof(*c), cp, cp_size); + } else + c->length = 0; + + if (hci_send(s, buffer, sizeof(*c) + cp_size) == ERROR) + return (ERROR); + +again: + n = sizeof(buffer); + if (hci_recv(s, buffer, &n) == ERROR) + return (ERROR); + + if (n < sizeof(*e)) { + errno = EMSGSIZE; + return (ERROR); + } + + if (e->type != NG_HCI_EVENT_PKT) { + errno = EIO; + return (ERROR); + } + + switch (e->event) { + case NG_HCI_EVENT_COMMAND_COMPL: { + ng_hci_command_compl_ep *cc = + (ng_hci_command_compl_ep *)(e + 1); + + cc->opcode = le16toh(cc->opcode); + + if (cc->opcode == 0x0000 || cc->opcode != opcode) + goto again; + + n -= (sizeof(*e) + sizeof(*cc)); + if (n < *rp_size) + *rp_size = n; + + memcpy(rp, buffer + sizeof(*e) + sizeof(*cc), *rp_size); + } break; + + case NG_HCI_EVENT_COMMAND_STATUS: { + ng_hci_command_status_ep *cs = + (ng_hci_command_status_ep *)(e + 1); + + cs->opcode = le16toh(cs->opcode); + + if (cs->opcode == 0x0000 || cs->opcode != opcode) + goto again; + + *rp_size = 1; + *rp = cs->status; + } break; + + default: + goto again; + } + + return (OK); +} /* hci_request */ + +/* Send simple HCI request - Just HCI command packet (no parameters) */ +int +hci_simple_request(int s, int opcode, char *rp, int *rp_size) +{ + return (hci_request(s, opcode, NULL, 0, rp, rp_size)); +} /* hci_simple_request */ + +/* Send HCI data to the unit */ +int +hci_send(int s, char const *buffer, int size) +{ + assert(buffer != NULL); + assert(size >= sizeof(ng_hci_cmd_pkt_t)); + assert(size <= sizeof(ng_hci_cmd_pkt_t) + NG_HCI_CMD_PKT_SIZE); + + if (send(s, buffer, size, 0) < 0) + return (ERROR); + + return (OK); +} /* hci_send */ + +/* Receive HCI data from the unit */ +int +hci_recv(int s, char *buffer, int *size) +{ + struct timeval tv; + fd_set rfd; + int n; + + assert(buffer != NULL); + assert(size != NULL); + assert(*size > sizeof(ng_hci_event_pkt_t)); + +again: + FD_ZERO(&rfd); + FD_SET(s, &rfd); + + tv.tv_sec = timeout; + tv.tv_usec = 0; + + n = select(s + 1, &rfd, NULL, NULL, &tv); + if (n <= 0) { + if (n < 0) { + if (errno == EINTR) + goto again; + } else + errno = ETIMEDOUT; + + return (ERROR); + } + + assert(FD_ISSET(s, &rfd)); + + n = recv(s, buffer, *size, 0); + if (n < 0) + return (ERROR); + + *size = n; + + return (OK); +} /* hci_recv */ + diff --git a/usr.sbin/bluetooth/hccontrol/status.c b/usr.sbin/bluetooth/hccontrol/status.c new file mode 100644 index 0000000..c857349 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/status.c @@ -0,0 +1,245 @@ +/* + * status.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: status.c,v 1.2 2002/09/06 18:52:41 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/endian.h> +#include <errno.h> +#include <ng_hci.h> +#include <stdio.h> +#include "hccontrol.h" + +/* Send Read_Failed_Contact_Counter command to the unit */ +static int +hci_read_failed_contact_counter(int s, int argc, char **argv) +{ + ng_hci_read_failed_contact_cntr_cp cp; + ng_hci_read_failed_contact_cntr_rp rp; + int n; + + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_STATUS, + NG_HCI_OCF_READ_FAILED_CONTACT_CNTR), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); + fprintf(stdout, "Failed contact counter: %d\n", le16toh(rp.counter)); + + return (OK); +} /* hci_read_failed_contact_counter */ + +/* Send Reset_Failed_Contact_Counter command to the unit */ +static int +hci_reset_failed_contact_counter(int s, int argc, char **argv) +{ + ng_hci_reset_failed_contact_cntr_cp cp; + ng_hci_reset_failed_contact_cntr_rp rp; + int n; + + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_STATUS, + NG_HCI_OCF_RESET_FAILED_CONTACT_CNTR), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + return (OK); +} /* hci_reset_failed_contact_counter */ + +/* Sent Get_Link_Quality command to the unit */ +static int +hci_get_link_quality(int s, int argc, char **argv) +{ + ng_hci_get_link_quality_cp cp; + ng_hci_get_link_quality_rp rp; + int n; + + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_STATUS, + NG_HCI_OCF_GET_LINK_QUALITY), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); + fprintf(stdout, "Link quality: %d\n", le16toh(rp.quality)); + + return (OK); +} /* hci_get_link_quality */ + +/* Send Read_RSSI command to the unit */ +static int +hci_read_rssi(int s, int argc, char **argv) +{ + ng_hci_read_rssi_cp cp; + ng_hci_read_rssi_rp rp; + int n; + + switch (argc) { + case 1: + /* connection handle */ + if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) + return (USAGE); + + cp.con_handle = (u_int16_t) (n & 0x0fff); + cp.con_handle = htole16(cp.con_handle); + break; + + default: + return (USAGE); + } + + /* send command */ + n = sizeof(rp); + if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_STATUS, + NG_HCI_OCF_READ_RSSI), + (char const *) &cp, sizeof(cp), + (char *) &rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, "Connection handle: %d\n", le16toh(rp.con_handle)); + fprintf(stdout, "RSSI: %d dB\n", (int) rp.rssi); + + return (OK); +} /* hci_read_rssi */ + +struct hci_command status_commands[] = { +{ +"read_failed_contact_counter <connection_handle>", +"\nThis command will read the value for the Failed_Contact_Counter\n" \ +"parameter for a particular ACL connection to another device.\n\n" \ +"\t<connection_handle> - dddd; ACL connection handle\n", +&hci_read_failed_contact_counter +}, +{ +"reset_failed_contact_counter <connection_handle>", +"\nThis command will reset the value for the Failed_Contact_Counter\n" \ +"parameter for a particular ACL connection to another device.\n\n" \ +"\t<connection_handle> - dddd; ACL connection handle\n", +&hci_reset_failed_contact_counter +}, +{ +"get_link_quality <connection_handle>", +"\nThis command will return the value for the Link_Quality for the\n" \ +"specified ACL connection handle. This command will return a Link_Quality\n" \ +"value from 0-255, which represents the quality of the link between two\n" \ +"Bluetooth devices. The higher the value, the better the link quality is.\n" \ +"Each Bluetooth module vendor will determine how to measure the link quality." \ +"\n\n" \ +"\t<connection_handle> - dddd; ACL connection handle\n", +&hci_get_link_quality +}, +{ +"read_rssi <connection_handle>", +"\nThis command will read the value for the difference between the\n" \ +"measured Received Signal Strength Indication (RSSI) and the limits of\n" \ +"the Golden Receive Power Range for a ACL connection handle to another\n" \ +"Bluetooth device. Any positive RSSI value returned by the Host Controller\n" \ +"indicates how many dB the RSSI is above the upper limit, any negative\n" \ +"value indicates how many dB the RSSI is below the lower limit. The value\n" \ +"zero indicates that the RSSI is inside the Golden Receive Power Range.\n\n" \ +"\t<connection_handle> - dddd; ACL connection handle\n", +&hci_read_rssi +}, +{ +NULL, +}}; + diff --git a/usr.sbin/bluetooth/hccontrol/util.c b/usr.sbin/bluetooth/hccontrol/util.c new file mode 100644 index 0000000..51868b4 --- /dev/null +++ b/usr.sbin/bluetooth/hccontrol/util.c @@ -0,0 +1,350 @@ +/* + * util.c + * + * Copyright (c) 2001 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: util.c,v 1.2 2002/09/12 18:19:43 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <string.h> + +#define SIZE(x) (sizeof((x))/sizeof((x)[0])) + +char const * const +hci_link2str(int link_type) +{ + static char const * const t[] = { + /* NG_HCI_LINK_SCO */ "SCO", + /* NG_HCI_LINK_ACL */ "ACL" + }; + + return (link_type >= SIZE(t)? "?" : t[link_type]); +} /* hci_link2str */ + +char const * const +hci_pin2str(int type) +{ + static char const * const t[] = { + /* 0x00 */ "Variable PIN", + /* 0x01 */ "Fixed PIN" + }; + + return (type >= SIZE(t)? "?" : t[type]); +} /* hci_pin2str */ + +char const * const +hci_scan2str(int scan) +{ + static char const * const t[] = { + /* 0x00 */ "No Scan enabled", + /* 0x01 */ "Inquiry Scan enabled. Page Scan disabled", + /* 0x02 */ "Inquiry Scan disabled. Page Scan enabled", + /* 0x03 */ "Inquiry Scan enabled. Page Scan enabled" + }; + + return (scan >= SIZE(t)? "?" : t[scan]); +} /* hci_scan2str */ + +char const * const +hci_encrypt2str(int encrypt, int brief) +{ + static char const * const t[] = { + /* 0x00 */ "Disabled", + /* 0x01 */ "Only for point-to-point packets", + /* 0x02 */ "Both point-to-point and broadcast packets" + }; + + static char const * const t1[] = { + /* NG_HCI_ENCRYPTION_MODE_NONE */ "NONE", + /* NG_HCI_ENCRYPTION_MODE_P2P */ "P2P", + /* NG_HCI_ENCRYPTION_MODE_ALL */ "ALL", + }; + + if (brief) + return (encrypt >= SIZE(t1)? "?" : t1[encrypt]); + + return (encrypt >= SIZE(t)? "?" : t[encrypt]); +} /* hci_encrypt2str */ + +char const * const +hci_coding2str(int coding) +{ + static char const * const t[] = { + /* 0x00 */ "Linear", + /* 0x01 */ "u-law", + /* 0x02 */ "A-law", + /* 0x03 */ "Reserved" + }; + + return (coding >= SIZE(t)? "?" : t[coding]); +} /* hci_coding2str */ + +char const * const +hci_vdata2str(int data) +{ + static char const * const t[] = { + /* 0x00 */ "1's complement", + /* 0x01 */ "2's complement", + /* 0x02 */ "Sign-Magnitude", + /* 0x03 */ "Reserved" + }; + + return (data >= SIZE(t)? "?" : t[data]); +} /* hci_vdata2str */ + +char const * const +hci_hmode2str(int mode, char *buffer, int size) +{ + static char const * const t[] = { + /* 0x01 */ "Suspend Page Scan ", + /* 0x02 */ "Suspend Inquiry Scan ", + /* 0x04 */ "Suspend Periodic Inquiries " + }; + + if (buffer != NULL && size > 0) { + int n; + + memset(buffer, 0, size); + for (n = 0; n < SIZE(t); n++) { + int len = strlen(buffer); + + if (len >= size) + break; + if (mode & (1 << n)) + strncat(buffer, t[n], size - len); + } + } + + return (buffer); +} /* hci_hmode2str */ + +char const * const +hci_ver2str(int ver) +{ + static char const * const t[] = { + /* 0x00 */ "v1.0B", + /* 0x01 */ "v1.1" + }; + + return (ver >= SIZE(t)? "?" : t[ver]); +} /* hci_ver2str */ + +char const * const +hci_manufacturer2str(int m) +{ + static char const * const t[] = { + /* 0000 */ "Ericsson Mobile Comunications", + /* 0001 */ "Nokia Mobile Phones", + /* 0002 */ "Intel Corp.", + /* 0003 */ "IBM Corp.", + /* 0004 */ "Toshiba Corp.", + /* 0005 */ "3Com", + /* 0006 */ "Microsoft", + /* 0007 */ "Lucent", + /* 0008 */ "Motorola", + /* 0009 */ "Infineon Technologies AG", + /* 0010 */ "Cambridge Silicon Radio", + /* 0011 */ "Silicon Wave", + /* 0012 */ "Digianswer A/S", + /* 0013 */ "Texas Instruments Inc.", + /* 0014 */ "Parthus Technologies Inc.", + /* 0015 */ "Broadcom Corporation", + /* 0016 */ "Mitel Semiconductor", + /* 0017 */ "Widcomm, Inc.", + /* 0018 */ "Telencomm Inc.", + /* 0019 */ "Atmel Corporation", + /* 0020 */ "Mitsubishi Electric Corporation", + /* 0021 */ "RTX Telecom A/S", + /* 0022 */ "KC Technology Inc.", + /* 0023 */ "Newlogic", + /* 0024 */ "Transilica, Inc.", + /* 0025 */ "Rohde & Schwartz GmbH & Co. KG", + /* 0026 */ "TTPCom Limited", + /* 0027 */ "Signia Technologies, Inc.", + /* 0028 */ "Conexant Systems Inc.", + /* 0029 */ "Qualcomm", + /* 0030 */ "Inventel", + /* 0031 */ "AVM Berlin", + /* 0032 */ "BandSpeed, Inc.", + /* 0033 */ "Mansella Ltd", + /* 0034 */ "NEC Corporation", + /* 0035 */ "WavePlus Technology Co., Ltd.", + /* 0036 */ "Alcatel", + /* 0037 */ "Philips Semiconductors", + /* 0038 */ "C Technologies", + /* 0039 */ "Open Interface", + /* 0040 */ "R F Micro Devices", + /* 0041 */ "Hitachi Ltd", + /* 0042 */ "Symbol Technologies, Inc.", + /* 0043 */ "Tenovis", + /* 0044 */ "Macronix International Co. Ltd.", + /* 0045 */ "GCT Semiconductor", + /* 0046 */ "Norwood Systems", + /* 0047 */ "MewTel Technology Inc." + }; + + return (m >= SIZE(t)? "?" : t[m]); +} /* hci_manufacturer2str */ + +char const * const +hci_features2str(u_int8_t *features, char *buffer, int size) +{ + static char const * const t[][8] = { + { /* byte 0 */ + /* 0 */ "<3-Slot> ", + /* 1 */ "<5-Slot> ", + /* 2 */ "<Encryption> ", + /* 3 */ "<Slot offset> ", + /* 4 */ "<Timing accuracy> ", + /* 5 */ "<Switch> ", + /* 6 */ "<Hold mode> ", + /* 7 */ "<Sniff mode> " + }, + { /* byte 1 */ + /* 0 */ "<Park mode> ", + /* 1 */ "<RSSI> ", + /* 2 */ "<Channel quality> ", + /* 3 */ "<SCO link> ", + /* 4 */ "<HV2 packets> ", + /* 5 */ "<HV3 packets> ", + /* 6 */ "<u-law log> ", + /* 7 */ "<A-law log> " + }, + { /* byte 2 */ + /* 0 */ "<CVSD> ", + /* 1 */ "<Paging scheme> ", + /* 2 */ "<Power control> ", + /* 3 */ "<Transparent SCO data> ", + /* 4 */ "<Flow control lag (bit0)> ", + /* 5 */ "<Flow control lag (bit1)> ", + /* 6 */ "<Flow control lag (bit2)> ", + /* 7 */ "<Unknown2.7> " + }}; + + if (buffer != NULL && size > 0) { + int n, i, len0, len1; + + memset(buffer, 0, size); + len1 = 0; + + for (n = 0; n < SIZE(t); n++) { + for (i = 0; i < SIZE(t[n]); i++) { + len0 = strlen(buffer); + if (len0 >= size) + goto done; + + if (features[n] & (1 << i)) { + if (len1 + strlen(t[n][i]) > 60) { + len1 = 0; + buffer[len0 - 1] = '\n'; + } + + len1 += strlen(t[n][i]); + strncat(buffer, t[n][i], size - len0); + } + } + } + } +done: + return (buffer); +} /* hci_features2str */ + +char const * const +hci_cc2str(int cc) +{ + static char const * const t[] = { + /* 0x00 */ "North America, Europe, Japan", + /* 0x01 */ "France" + }; + + return (cc >= SIZE(t)? "?" : t[cc]); +} /* hci_cc2str */ + +char const * const +hci_con_state2str(int state) +{ + static char const * const t[] = { + /* NG_HCI_CON_CLOSED */ "CLOSED", + /* NG_HCI_CON_W4_LP_CON_RSP */ "W4_LP_CON_RSP", + /* NG_HCI_CON_W4_CONN_COMPLETE */ "W4_CONN_COMPLETE", + /* NG_HCI_CON_OPEN */ "OPEN" + }; + + return (state >= SIZE(t)? "UNKNOWN" : t[state]); +} /* hci_con_state2str */ + +char const * const +hci_status2str(int status) +{ + static char const * const t[] = { + /* 0x00 */ "No error", + /* 0x01 */ "Unknown HCI command", + /* 0x02 */ "No connection", + /* 0x03 */ "Hardware failure", + /* 0x04 */ "Page timeout", + /* 0x05 */ "Authentication failure", + /* 0x06 */ "Key missing", + /* 0x07 */ "Memory full", + /* 0x08 */ "Connection timeout", + /* 0x09 */ "Max number of connections", + /* 0x0a */ "Max number of SCO connections to a unit", + /* 0x0b */ "ACL connection already exists", + /* 0x0c */ "Command disallowed", + /* 0x0d */ "Host rejected due to limited resources", + /* 0x0e */ "Host rejected due to securiity reasons", + /* 0x0f */ "Host rejected due to remote unit is a personal unit", + /* 0x10 */ "Host timeout", + /* 0x11 */ "Unsupported feature or parameter value", + /* 0x12 */ "Invalid HCI command parameter", + /* 0x13 */ "Other end terminated connection: User ended connection", + /* 0x14 */ "Other end terminated connection: Low resources", + /* 0x15 */ "Other end terminated connection: About to power off", + /* 0x16 */ "Connection terminated by local host", + /* 0x17 */ "Repeated attempts", + /* 0x18 */ "Pairing not allowed", + /* 0x19 */ "Unknown LMP PDU", + /* 0x1a */ "Unsupported remote feature", + /* 0x1b */ "SCO offset rejected", + /* 0x1c */ "SCO interval rejected", + /* 0x1d */ "SCO air mode rejected", + /* 0x1e */ "Invalid LMP parameters", + /* 0x1f */ "Unspecified error", + /* 0x20 */ "Unsupported LMP parameter value", + /* 0x21 */ "Role change not allowed", + /* 0x22 */ "LMP response timeout", + /* 0x23 */ "LMP error transaction collision", + /* 0x24 */ "LMP PSU not allowed", + /* 0x25 */ "Encryption mode not acceptable", + /* 0x26 */ "Unit key used", + /* 0x27 */ "QoS is not supported", + /* 0x28 */ "Instant passed", + /* 0x29 */ "Paring with unit key not supported" + }; + + return (status >= SIZE(t)? "Unknown error" : t[status]); +} /* hci_status2str */ + diff --git a/usr.sbin/bluetooth/hcseriald/Makefile b/usr.sbin/bluetooth/hcseriald/Makefile new file mode 100644 index 0000000..4153cd6 --- /dev/null +++ b/usr.sbin/bluetooth/hcseriald/Makefile @@ -0,0 +1,17 @@ +# $Id: Makefile,v 1.4 2002/09/04 21:29:58 max Exp $ +# $FreeBSD$ + +DESTDIR= /usr/sbin/ +MANDIR= ../share/man/man + +PROG= hcseriald +MAN8= hcseriald.8 + +WARNS?= 2 +CFLAGS+= -Wall -O2 -I../../../sys/netgraph/bluetooth/include +SRCS= hcseriald.c + +DPADD= ${LIBNETGRAPH} +LDADD= -lnetgraph + +.include <bsd.prog.mk> diff --git a/usr.sbin/bluetooth/hcseriald/hcseriald.8 b/usr.sbin/bluetooth/hcseriald/hcseriald.8 new file mode 100644 index 0000000..d4b641d --- /dev/null +++ b/usr.sbin/bluetooth/hcseriald/hcseriald.8 @@ -0,0 +1,81 @@ +.\" hcseriald.8 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: hcseriald.8,v 1.3 2002/11/09 19:16:50 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt HCSERIALD 8 +.Os +.Sh NAME +.Nm hcseriald +.Nd supervise serial Bluetooth devices +.Sh SYNOPSIS +.Nm +.Op Fl f Ar device +.Op Fl n Ar node name +.Op Fl s Ar speed +.Op Fl d +.Sh DESCRIPTION +The +.Nm +handles serial Bluetooth devices. It does one simple thing. It opens +specified serial device, sets device parameters and pushes +.Em H4 +line discipline. +.Pp +The options are as follows: +.Bl -tag -width indent +.It Fl f Ar device +Callout device name. Example: +.Fl f +.Pa /dev/cuaa0 . +.It Fl n Ar node name +Set H4 Netgraph node name. Example: +.Fl n Ar sio0 . +.It Fl s Ar speed +Set serial device speed to +.Em speed . +Example: +.Fl s Ar 115200 . +.It Fl d +Do not disassociate from the controlling terminal, i.e. run in foreground. +.El +.Sh FILES +.Bl -tag -width /dev/consolectl -compact +.It Pa /var/run/hcserial.*.pid +process id of the currently running +.Nm +daemon. Where +.Dq * +is a H4 Netgraph node name. +.El +.Sh SEE ALSO +.Xr tty 4 , +.Xr ng_h4 4 , +.Xr ng_hci 4 , +.Xr hccontrol 8 +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/usr.sbin/bluetooth/hcseriald/hcseriald.c b/usr.sbin/bluetooth/hcseriald/hcseriald.c new file mode 100644 index 0000000..bb0e819 --- /dev/null +++ b/usr.sbin/bluetooth/hcseriald/hcseriald.c @@ -0,0 +1,279 @@ +/* + * hcseriald.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: hcseriald.c,v 1.4 2002/09/04 21:29:58 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/ioctl.h> + +#include <netgraph/ng_message.h> +#include <netgraph.h> +#include <ng_h4.h> + +#include <errno.h> +#include <fcntl.h> +#include <signal.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <syslog.h> +#include <termios.h> +#include <unistd.h> + +/* Prototypes */ +static int open_device (char const *, speed_t, char const *); +static void sighandler (int); +static void usage (); + +static char const * const hcseriald = "hcseriald"; +static int done = 0; + +int +main(int argc, char *argv[]) +{ + char *device = NULL, *name = NULL; + speed_t speed = 115200; + int n, detach = 1; + char p[FILENAME_MAX]; + FILE *f = NULL; + struct sigaction sa; + + /* Process command line arguments */ + while ((n = getopt(argc, argv, "df:n:s:")) != -1) { + switch (n) { + case 'd': + detach = 0; + break; + + case 'f': + device = optarg; + break; + + case 'n': + name = optarg; + break; + + case 's': + speed = atoi(optarg); + if (speed < 0) + usage(argv[0]); + break; + + default: + usage(argv[0]); + break; + } + } + + if (device == NULL || name == NULL) + usage(argv[0]); + + openlog(hcseriald, LOG_PID | LOG_NDELAY, LOG_USER); + + /* Open device */ + n = open_device(device, speed, name); + + if (detach) { + pid_t pid = fork(); + + if (pid == (pid_t) -1) { + syslog(LOG_ERR, "Could not fork(). %s (%d)", + strerror(errno), errno); + exit(1); + } + + if (pid != 0) + exit(0); + + if (daemon(0, 0) < 0) { + syslog(LOG_ERR, "Could not daemon(0, 0). %s (%d)", + strerror(errno), errno); + exit(1); + } + } + + /* Write PID file */ + snprintf(p, sizeof(p), "/var/run/%s.%s.pid", hcseriald, name); + f = fopen(p, "w"); + if (f == NULL) { + syslog(LOG_ERR, "Could not fopen(%s). %s (%d)", + p, strerror(errno), errno); + exit(1); + } + fprintf(f, "%d", getpid()); + fclose(f); + + /* Install signal handler */ + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = sighandler; + + if (sigaction(SIGTERM, &sa, NULL) < 0) { + syslog(LOG_ERR, "Could not sigaction(SIGTERM). %s (%d)", + strerror(errno), errno); + exit(1); + } + + if (sigaction(SIGHUP, &sa, NULL) < 0) { + syslog(LOG_ERR, "Could not sigaction(SIGHUP). %s (%d)", + strerror(errno), errno); + exit(1); + } + + if (sigaction(SIGINT, &sa, NULL) < 0) { + syslog(LOG_ERR, "Could not sigaction(SIGINT). %s (%d)", + strerror(errno), errno); + exit(1); + } + + /* Keep running */ + while (!done) + select(0, NULL, NULL, NULL, NULL); + + /* Remove PID file and close device */ + unlink(p); + close(n); + closelog(); + + return (0); +} /* main */ + +/* Open terminal, set settings, push H4 line discipline and set node name */ +static int +open_device(char const *device, speed_t speed, char const *name) +{ + int fd, disc, cs, ds; + struct termios t; + struct nodeinfo ni; + struct ngm_name n; + char p[NG_NODELEN + 1]; + + /* Open terminal device and setup H4 line discipline */ + fd = open(device, O_RDWR|O_NOCTTY); + if (fd < 0) { + syslog(LOG_ERR, "Could not open(%s). %s (%d)", + device, strerror(errno), errno); + exit(1); + } + + tcflush(fd, TCIOFLUSH); + + if (tcgetattr(fd, &t) < 0) { + syslog(LOG_ERR, "Could not tcgetattr(%s). %s (%d)", + device, strerror(errno), errno); + exit(1); + } + + cfmakeraw(&t); + + t.c_cflag |= CLOCAL; /* clocal */ + t.c_cflag &= ~CSIZE; /* cs8 */ + t.c_cflag |= CS8; /* cs8 */ + t.c_cflag &= ~PARENB; /* -parenb */ + t.c_cflag &= ~CSTOPB; /* -cstopb */ + t.c_cflag |= CRTSCTS; /* crtscts */ + + if (tcsetattr(fd, TCSANOW, &t) < 0) { + syslog(LOG_ERR, "Could not tcsetattr(%s). %s (%d)", + device, strerror(errno), errno); + exit(1); + } + + tcflush(fd, TCIOFLUSH); + + if (cfsetspeed(&t, speed) < 0) { + syslog(LOG_ERR, "Could not cfsetspeed(%s). %s (%d)", + device, strerror(errno), errno); + exit(1); + } + + if (tcsetattr(fd, TCSANOW, &t) < 0) { + syslog(LOG_ERR, "Could not tcsetattr(%s). %s (%d)", + device, strerror(errno), errno); + exit(1); + } + + disc = H4DISC; + if (ioctl(fd, TIOCSETD, &disc) < 0) { + syslog(LOG_ERR, "Could not ioctl(%s, TIOCSETD, %d). %s (%d)", + device, disc, strerror(errno), errno); + exit(1); + } + + /* Get default name of the Netgraph node */ + memset(&ni, 0, sizeof(ni)); + if (ioctl(fd, NGIOCGINFO, &ni) < 0) { + syslog(LOG_ERR, "Could not ioctl(%d, NGIOGINFO). %s (%d)", + fd, strerror(errno), errno); + exit(1); + } + + /* Assign new name to the Netgraph node */ + snprintf(p, sizeof(p), "%s:", ni.name); + snprintf(n.name, sizeof(n.name), "%s", name); + + if (NgMkSockNode(NULL, &cs, &ds) < 0) { + syslog(LOG_ERR, "Could not NgMkSockNode(). %s (%d)", + strerror(errno), errno); + exit(1); + } + + if (NgSendMsg(cs, p, NGM_GENERIC_COOKIE, NGM_NAME, &n, sizeof(n)) < 0) { + syslog(LOG_ERR, "Could not NgSendMsg(%d, %s, NGM_NAME, %s). " \ + "%s (%d)", cs, p, n.name, strerror(errno), errno); + exit(1); + } + + close(cs); + close(ds); + + return (fd); +} /* open_device */ + +/* Signal handler */ +static void +sighandler(int s) +{ + done = 1; +} /* sighandler */ + +/* Usage */ +static void +usage(void) +{ + fprintf(stderr, "Usage: %s -f device -n node_name [-s speed -d]\n" \ + "Where:\n" \ + "\t-f device tty device name, ex. /dev/cuaa1\n" \ + "\t-n node_name set Netgraph node name to node_name\n" \ + "\t-s speed set tty speed, ex. 115200\n" \ + "\t-d run in foreground\n", + hcseriald); + exit(255); +} /* usage */ + diff --git a/usr.sbin/bluetooth/l2control/Makefile b/usr.sbin/bluetooth/l2control/Makefile new file mode 100644 index 0000000..b098874 --- /dev/null +++ b/usr.sbin/bluetooth/l2control/Makefile @@ -0,0 +1,12 @@ +# $Id: Makefile,v 1.3 2002/09/04 21:30:40 max Exp $ +# $FreeBSD$ + +DESTDIR= /usr/sbin/ +MANDIR= ../share/man/man +PROG= l2control +MAN8= l2control.8 +WARNS?= 2 +CFLAGS+= -g -I../../../sys/netgraph/bluetooth/include +SRCS= l2cap.c l2control.c + +.include <bsd.prog.mk> diff --git a/usr.sbin/bluetooth/l2control/l2cap.c b/usr.sbin/bluetooth/l2control/l2cap.c new file mode 100644 index 0000000..a0f2d24 --- /dev/null +++ b/usr.sbin/bluetooth/l2control/l2cap.c @@ -0,0 +1,256 @@ +/* + * l2cap.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: l2cap.c,v 1.6 2002/09/04 21:30:40 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <bitstring.h> +#include <errno.h> +#include <ng_hci.h> +#include <ng_l2cap.h> +#include <ng_btsocket.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "l2control.h" + +#define SIZE(x) (sizeof((x))/sizeof((x)[0])) + +/* Send read_node_flags command to the node */ +static int +l2cap_read_node_flags(int s, int argc, char **argv) +{ + struct ng_btsocket_l2cap_raw_node_flags r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_L2CAP_NODE_GET_FLAGS, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "BD_ADDR: %x:%x:%x:%x:%x:%x\n", + r.src.b[5], r.src.b[4], r.src.b[3], + r.src.b[2], r.src.b[1], r.src.b[0]); + fprintf(stdout, "Connectionless traffic flags:\n"); + fprintf(stdout, "\tSDP: %s\n", + (r.flags & NG_L2CAP_CLT_SDP_DISABLED)? "disabled" : "enabled"); + fprintf(stdout, "\tRFCOMM: %s\n", + (r.flags & NG_L2CAP_CLT_RFCOMM_DISABLED)? "disabled":"enabled"); + fprintf(stdout, "\tTCP: %s\n", + (r.flags & NG_L2CAP_CLT_TCP_DISABLED)? "disabled" : "enabled"); + + return (OK); +} /* l2cap_read_node_flags */ + +/* Send read_debug_level command to the node */ +static int +l2cap_read_debug_level(int s, int argc, char **argv) +{ + struct ng_btsocket_l2cap_raw_node_debug r; + + memset(&r, 0, sizeof(r)); + if (ioctl(s, SIOC_L2CAP_NODE_GET_DEBUG, &r, sizeof(r)) < 0) + return (ERROR); + + fprintf(stdout, "BD_ADDR: %x:%x:%x:%x:%x:%x\n", + r.src.b[5], r.src.b[4], r.src.b[3], + r.src.b[2], r.src.b[1], r.src.b[0]); + fprintf(stdout, "Debug level: %d\n", r.debug); + + return (OK); +} /* l2cap_read_debug_level */ + +/* Send write_debug_level command to the node */ +static int +l2cap_write_debug_level(int s, int argc, char **argv) +{ + struct ng_btsocket_l2cap_raw_node_debug r; + + memset(&r, 0, sizeof(r)); + switch (argc) { + case 1: + r.debug = atoi(argv[0]); + break; + + default: + return (USAGE); + } + + if (ioctl(s, SIOC_L2CAP_NODE_SET_DEBUG, &r, sizeof(r)) < 0) + return (ERROR); + + return (OK); +} /* l2cap_write_debug_level */ + +/* Send read_connection_list command to the node */ +static int +l2cap_read_connection_list(int s, int argc, char **argv) +{ + static char const * const state[] = { + /* NG_L2CAP_CON_CLOSED */ "CLOSED", + /* NG_L2CAP_W4_LP_CON_CFM */ "W4_LP_CON_CFM", + /* NG_L2CAP_CON_OPEN */ "OPEN" + }; +#define con_state2str(x) ((x) >= SIZE(state)? "UNKNOWN" : state[(x)]) + + struct ng_btsocket_l2cap_raw_con_list r; + int n, error = OK; + + memset(&r, 0, sizeof(r)); + r.num_connections = NG_L2CAP_MAX_CON_NUM; + r.connections = calloc(NG_L2CAP_MAX_CON_NUM, + sizeof(ng_l2cap_node_con_ep)); + if (r.connections == NULL) { + errno = ENOMEM; + return (ERROR); + } + + if (ioctl(s, SIOC_L2CAP_NODE_GET_CON_LIST, &r, sizeof(r)) < 0) { + error = ERROR; + goto out; + } + + fprintf(stdout, "BD_ADDR: %x:%x:%x:%x:%x:%x\n", + r.src.b[5], r.src.b[4], r.src.b[3], + r.src.b[2], r.src.b[1], r.src.b[0]); + fprintf(stdout, "L2CAP connections:\n"); + fprintf(stdout, +"Remote BD_ADDR Handle Flags Pending State\n"); + for (n = 0; n < r.num_connections; n++) { + fprintf(stdout, + "%02x:%02x:%02x:%02x:%02x:%02x " \ + " %5d " \ + "%2.2s %2.2s " \ + "%7d " \ + "%s\n", + r.connections[n].remote.b[5], + r.connections[n].remote.b[4], + r.connections[n].remote.b[3], + r.connections[n].remote.b[2], + r.connections[n].remote.b[1], + r.connections[n].remote.b[0], + r.connections[n].con_handle, + ((r.connections[n].flags & NG_L2CAP_CON_TX)? "TX" : ""), + ((r.connections[n].flags & NG_L2CAP_CON_RX)? "RX" : ""), + r.connections[n].pending, + con_state2str(r.connections[n].state)); + } +out: + free(r.connections); + + return (error); +} /* l2cap_read_connection_list */ + +/* Send read_channel_list command to the node */ +static int +l2cap_read_channel_list(int s, int argc, char **argv) +{ + static char const * const state[] = { + /* NG_L2CAP_CLOSED */ "CLOSED", + /* NG_L2CAP_W4_L2CAP_CON_RSP */ "W4_L2CAP_CON_RSP", + /* NG_L2CAP_W4_L2CA_CON_RSP */ "W4_L2CA_CON_RSP", + /* NG_L2CAP_CONFIG */ "CONFIG", + /* NG_L2CAP_OPEN */ "OPEN", + /* NG_L2CAP_W4_L2CAP_DISCON_RSP */ "W4_L2CAP_DISCON_RSP", + /* NG_L2CAP_W4_L2CA_DISCON_RSP */ "W4_L2CA_DISCON_RSP" + }; +#define ch_state2str(x) ((x) >= SIZE(state)? "UNKNOWN" : state[(x)]) + + struct ng_btsocket_l2cap_raw_chan_list r; + int n, error = OK; + + memset(&r, 0, sizeof(r)); + r.num_channels = NG_L2CAP_MAX_CHAN_NUM; + r.channels = calloc(NG_L2CAP_MAX_CHAN_NUM, + sizeof(ng_l2cap_node_chan_ep)); + if (r.channels == NULL) { + errno = ENOMEM; + return (ERROR); + } + + if (ioctl(s, SIOC_L2CAP_NODE_GET_CHAN_LIST, &r, sizeof(r)) < 0) { + error = ERROR; + goto out; + } + + fprintf(stdout, "BD_ADDR: %x:%x:%x:%x:%x:%x\n", + r.src.b[5], r.src.b[4], r.src.b[3], + r.src.b[2], r.src.b[1], r.src.b[0]); + fprintf(stdout, "L2CAP channels:\n"); + fprintf(stdout, +"Remote BD_ADDR SCID/ DCID PSM IMTU/ OMTU State\n"); + for (n = 0; n < r.num_channels; n++) { + fprintf(stdout, + "%02x:%02x:%02x:%02x:%02x:%02x " \ + "%5d/%5d %5d " \ + "%5d/%5d " \ + "%s\n", + r.channels[n].remote.b[5], r.channels[n].remote.b[4], + r.channels[n].remote.b[3], r.channels[n].remote.b[2], + r.channels[n].remote.b[1], r.channels[n].remote.b[0], + r.channels[n].scid, r.channels[n].dcid, + r.channels[n].psm, r.channels[n].imtu, + r.channels[n].omtu, + ch_state2str(r.channels[n].state)); + } +out: + free(r.channels); + + return (error); +} /* l2cap_read_channel_list */ + +struct l2cap_command l2cap_commands[] = { +{ +"read_node_flags", +"Get L2CAP node flags", +&l2cap_read_node_flags +}, +{ +"read_debug_level", +"Get L2CAP node debug level", +&l2cap_read_debug_level +}, +{ +"write_debug_level <level>", +"Set L2CAP node debug level", +&l2cap_write_debug_level +}, +{ +"read_connection_list", +"Read list of the L2CAP connections", +&l2cap_read_connection_list +}, +{ +"read_channel_list", +"Read list of the L2CAP channels", +&l2cap_read_channel_list +}, +{ +NULL, +}}; + diff --git a/usr.sbin/bluetooth/l2control/l2control.8 b/usr.sbin/bluetooth/l2control/l2control.8 new file mode 100644 index 0000000..9efa251 --- /dev/null +++ b/usr.sbin/bluetooth/l2control/l2control.8 @@ -0,0 +1,84 @@ +.\" l2control.8 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: l2control.8,v 1.4 2002/11/09 19:18:16 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt L2CONTROL 8 +.Os +.Sh NAME +.Nm l2control +.Nd L2CAP configuration utility +.Sh SYNOPSIS +.Nm +.Op Fl a Ar local BD_ADDR +.Op Ar command +.Op Ar parameters ... +.Sh DESCRIPTION +The +.Nm +utility connects to the local device with specified BD_ADDR and attempts +to send specified command. +.Nm +will print results to the standard output and error messages to +the standard error. +.Pp +The options are as follows: +.Bl -tag -width indent +.It Fl a Ar local BD_ADDR +Connect to the local device with specified BD_ADDR. Example: +.Fl a Ar 00:01:02:03:04:05 . +.It command +One of the supported commands (see below). Special command +.Dq help +can be used to obtain the list of all supported commands. To get more +information about specific command use +.Dq help command . +.It parameters +One or more optional space separated command parameters. +.El +.Sh COMMANDS +The currently supported node commands in +.Nm +are: +.Pp +.Bd -literal -offset indent -compact +Read_Node_Flags +Read_Debug_Level +Write_Debug_Level +Read_Connection_List +Read_Channel_List +.Ed +.Pp +.Sh DIAGNOSTICS +.Ex -std +.Sh SEE ALSO +.Xr netgraph 3 , +.Xr netgraph 4 , +.Xr ng_l2cap 4 , +.Xr l2ping 8 +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/usr.sbin/bluetooth/l2control/l2control.c b/usr.sbin/bluetooth/l2control/l2control.c new file mode 100644 index 0000000..ef65826 --- /dev/null +++ b/usr.sbin/bluetooth/l2control/l2control.c @@ -0,0 +1,226 @@ +/* + * l2control.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: l2control.c,v 1.5 2002/09/04 21:30:40 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/socket.h> +#include <bitstring.h> +#include <assert.h> +#include <err.h> +#include <errno.h> +#include <ng_hci.h> +#include <ng_l2cap.h> +#include <ng_btsocket.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include "l2control.h" + +/* Prototypes */ +static int do_l2cap_command (bdaddr_p, int, char **); +static struct l2cap_command * find_l2cap_command (char const *, + struct l2cap_command *); +static void print_l2cap_command (struct l2cap_command *); +static void usage (void); + +/* Main */ +int +main(int argc, char *argv[]) +{ + int n; + bdaddr_t bdaddr; + + memset(&bdaddr, 0, sizeof(bdaddr)); + + /* Process command line arguments */ + while ((n = getopt(argc, argv, "a:")) != -1) { + switch (n) { + case 'a': { + int a0, a1, a2, a3, a4, a5; + + if (sscanf(optarg, "%x:%x:%x:%x:%x:%x", + &a5, &a4, &a3, &a2, &a1, &a0) != 6) { + usage(); + break; + } + + bdaddr.b[0] = (a0 & 0xff); + bdaddr.b[1] = (a1 & 0xff); + bdaddr.b[2] = (a2 & 0xff); + bdaddr.b[3] = (a3 & 0xff); + bdaddr.b[4] = (a4 & 0xff); + bdaddr.b[5] = (a5 & 0xff); + } break; + + default: + usage(); + break; + } + } + + argc -= optind; + argv += optind; + + if (*argv == NULL) + usage(); + + return (do_l2cap_command(&bdaddr, argc, argv)); +} /* main */ + +/* Execute commands */ +static int +do_l2cap_command(bdaddr_p bdaddr, int argc, char **argv) +{ + char *cmd = argv[0]; + struct l2cap_command *c = NULL; + struct sockaddr_l2cap sa; + int s, e, help; + + help = 0; + if (strcasecmp(cmd, "help") == 0) { + argc --; + argv ++; + + if (argc <= 0) { + fprintf(stdout, "Supported commands:\n"); + print_l2cap_command(l2cap_commands); + fprintf(stdout, "\nFor more information use " \ + "'help command'\n"); + + return (OK); + } + + help = 1; + cmd = argv[0]; + } + + c = find_l2cap_command(cmd, l2cap_commands); + if (c == NULL) { + fprintf(stdout, "Unknown command: \"%s\"\n", cmd); + return (ERROR); + } + + if (!help) { + if (memcmp(bdaddr, NG_HCI_BDADDR_ANY, sizeof(*bdaddr)) == 0) + usage(); + + memset(&sa, 0, sizeof(sa)); + sa.l2cap_len = sizeof(sa); + sa.l2cap_family = AF_BLUETOOTH; + memcpy(&sa.l2cap_bdaddr, bdaddr, sizeof(sa.l2cap_bdaddr)); + + s = socket(PF_BLUETOOTH, SOCK_RAW, BLUETOOTH_PROTO_L2CAP); + if (s < 0) + err(1, "Could not create socket"); + + if (bind(s, (struct sockaddr *) &sa, sizeof(sa)) < 0) + err(2, +"Could not bind socket, bdaddr=%x:%x:%x:%x:%x:%x", + sa.l2cap_bdaddr.b[5], sa.l2cap_bdaddr.b[4], + sa.l2cap_bdaddr.b[3], sa.l2cap_bdaddr.b[2], + sa.l2cap_bdaddr.b[1], sa.l2cap_bdaddr.b[0]); + + if (connect(s, (struct sockaddr *) &sa, sizeof(sa)) < 0) + err(2, +"Could not connect socket, bdaddr=%x:%x:%x:%x:%x:%x", + sa.l2cap_bdaddr.b[5], sa.l2cap_bdaddr.b[4], + sa.l2cap_bdaddr.b[3], sa.l2cap_bdaddr.b[2], + sa.l2cap_bdaddr.b[1], sa.l2cap_bdaddr.b[0]); + + e = 0x0ffff; + if (setsockopt(s, SOL_SOCKET, SO_RCVBUF, &e, sizeof(e)) < 0) + err(3, "Coult not setsockopt(RCVBUF, %d)", e); + + e = (c->handler)(s, -- argc, ++ argv); + + close(s); + } else + e = USAGE; + + switch (e) { + case OK: + case FAILED: + break; + + case ERROR: + fprintf(stdout, "Could not execute command \"%s\". %s\n", + cmd, strerror(errno)); + break; + + case USAGE: + fprintf(stdout, "Usage: %s\n%s\n", c->command, c->description); + break; + + default: assert(0); break; + } + + return (e); +} /* do_l2cap_command */ + +/* Try to find command in specified category */ +static struct l2cap_command * +find_l2cap_command(char const *command, struct l2cap_command *category) +{ + struct l2cap_command *c = NULL; + + for (c = category; c->command != NULL; c++) { + char *c_end = strchr(c->command, ' '); + + if (c_end != NULL) { + int len = c_end - c->command; + + if (strncasecmp(command, c->command, len) == 0) + return (c); + } else if (strcasecmp(command, c->command) == 0) + return (c); + } + + return (NULL); +} /* find_l2cap_command */ + +/* Try to find command in specified category */ +static void +print_l2cap_command(struct l2cap_command *category) +{ + struct l2cap_command *c = NULL; + + for (c = category; c->command != NULL; c++) + fprintf(stdout, "\t%s\n", c->command); +} /* print_l2cap_command */ + +/* Usage */ +static void +usage(void) +{ + fprintf(stdout, "Usage: l2control -a BD_ADDR cmd [p1] [..]]\n"); + exit(255); +} /* usage */ + diff --git a/usr.sbin/bluetooth/l2control/l2control.h b/usr.sbin/bluetooth/l2control/l2control.h new file mode 100644 index 0000000..0f6e5dc --- /dev/null +++ b/usr.sbin/bluetooth/l2control/l2control.h @@ -0,0 +1,49 @@ +/* + * l2control.h + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: l2control.h,v 1.2 2002/09/04 21:30:40 max Exp $ + * $FreeBSD$ + */ + +#ifndef _L2CONTROL_H_ +#define _L2CONTROL_H_ + +#define OK 0 /* everything was OK */ +#define ERROR 1 /* could not execute command */ +#define FAILED 2 /* error was reported */ +#define USAGE 3 /* invalid parameters */ + +struct l2cap_command { + char const *command; + char const *description; + int (*handler)(int, int, char **); +}; + +extern struct l2cap_command l2cap_commands[]; + +#endif /* _L2CONTROL_H_ */ + diff --git a/usr.sbin/bluetooth/l2ping/Makefile b/usr.sbin/bluetooth/l2ping/Makefile new file mode 100644 index 0000000..f2dad31 --- /dev/null +++ b/usr.sbin/bluetooth/l2ping/Makefile @@ -0,0 +1,12 @@ +# $Id: Makefile,v 1.4 2002/09/04 21:28:05 max Exp $ +# $FreeBSD$ + +DESTDIR= /usr/sbin/ +MANDIR= ../share/man/man +PROG= l2ping +MAN8= l2ping.8 +SRCS= l2ping.c +WARNS?= 2 +CFLAGS+= -g -I../../../sys/netgraph/bluetooth/include + +.include <bsd.prog.mk> diff --git a/usr.sbin/bluetooth/l2ping/l2ping.8 b/usr.sbin/bluetooth/l2ping/l2ping.8 new file mode 100644 index 0000000..aa79ad9 --- /dev/null +++ b/usr.sbin/bluetooth/l2ping/l2ping.8 @@ -0,0 +1,87 @@ +.\" l2ping.8 +.\" +.\" Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> +.\" All rights reserved. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $Id: l2ping.8,v 1.4 2002/11/09 19:20:09 max Exp $ +.\" $FreeBSD$ +.Dd June 14, 2002 +.Dt L2PING 8 +.Os +.Sh NAME +.Nm l2ping +.Nd send L2CAP ECHO_REQUEST to remote devices +.Sh SYNOPSIS +.Nm +.Op Fl a Ar remote BD_ADDR +.Op Fl S Ar source BD_ADDR +.Op Fl c Ar count +.Op Fl f +.Op Fl i Ar delay +.Op Fl s Ar size +.Sh DESCRIPTION +The +.Nm +uses L2CAP ECHO_REQUEST datagram to elicit a L2CAP ECHO_RESPONSE from a +remote device. +.Pp +The options are as follows: +.Bl -tag -width indent +.It Fl a Ar remote BD_ADDR +Address of remote device to ping. Example: +.Fl a Ar 00:01:02:03:04:05 . +.It Fl S Ar source BD_ADDR +Send L2CAP ECHO_REQUEST from local device that has BD_ADDR. Example: +.Fl S Ar 00:05:04:03:02:01 . +.It Fl c Ar count +Number of packets to send. If this option is not specified, +.Nm +will operate until interrupted. +.It Fl f +.Dq Flood +ping, i.e. no delay between packets. +.It Fl i Ar wait +Wait +.Em wait +seconds between sending each packet. The default is to wait for one +second between each packet. This option is ignored if +.Fl f +has been specified. +.It Fl s Ar size +Specify the number of payload bytes to be sent. The default is 64. The +maximum size is 65531. Use this option with caution. Some implementations +may not like large sizes and may hang or even crash. +.El +.Sh BUGS +Could collect more statistic. Could check for duplicated, corrupted +and lost packets. +.Sh DIAGNOSTICS +.Ex -std +.Sh SEE ALSO +.Xr netgraph 3 , +.Xr netgraph 4 , +.Xr ng_l2cap 4 , +.Xr l2control 8 +.Sh AUTHORS +.An Maksim Yevmenkin Aq m_evmenkin@yahoo.com diff --git a/usr.sbin/bluetooth/l2ping/l2ping.c b/usr.sbin/bluetooth/l2ping/l2ping.c new file mode 100644 index 0000000..a7ffd37 --- /dev/null +++ b/usr.sbin/bluetooth/l2ping/l2ping.c @@ -0,0 +1,279 @@ +/* + * l2ping.c + * + * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $Id: l2ping.c,v 1.9 2002/09/04 21:28:05 max Exp $ + * $FreeBSD$ + */ + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/socket.h> +#include <sys/time.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <assert.h> +#include <bitstring.h> +#include <err.h> +#include <errno.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <ng_hci.h> +#include <ng_l2cap.h> +#include <ng_btsocket.h> + +static void usage (void); +static void tv_sub (struct timeval *, struct timeval const *); +static double tv2msec (struct timeval const *); + +#undef min +#define min(x, y) (((x) > (y))? (y) : (x)) + +static char const pattern[] = "1234567890-"; +#define PATTERN_SIZE (sizeof(pattern) - 1) + +/* + * Main + */ + +int +main(int argc, char *argv[]) +{ + struct ng_btsocket_l2cap_raw_ping r; + int n, s, count, wait, flood, fail; + struct timeval a, b; + + /* Set defaults */ + memset(&r, 0, sizeof(r)); + r.echo_data = calloc(NG_L2CAP_MAX_ECHO_SIZE, sizeof(u_int8_t)); + if (r.echo_data == NULL) { + fprintf(stderr, "Failed to allocate echo data buffer"); + exit(1); + } + + r.echo_size = 64; /* bytes */ + count = -1; /* unlimited */ + wait = 1; /* sec */ + flood = 0; + + /* Parse command line arguments */ + while ((n = getopt(argc, argv, "a:c:fi:n:s:S:")) != -1) { + switch (n) { + case 'a': + case 'S': { + int a0, a1, a2, a3, a4, a5; + + if (sscanf(optarg, "%x:%x:%x:%x:%x:%x", + &a5, &a4, &a3, &a2, &a1, &a0) != 6) + usage(); + + if (n == 'a') { + /* destination bdaddr */ + r.echo_dst.b[0] = (a0 & 0xff); + r.echo_dst.b[1] = (a1 & 0xff); + r.echo_dst.b[2] = (a2 & 0xff); + r.echo_dst.b[3] = (a3 & 0xff); + r.echo_dst.b[4] = (a4 & 0xff); + r.echo_dst.b[5] = (a5 & 0xff); + } else { + /* source bdaddr */ + r.echo_src.b[0] = (a0 & 0xff); + r.echo_src.b[1] = (a1 & 0xff); + r.echo_src.b[2] = (a2 & 0xff); + r.echo_src.b[3] = (a3 & 0xff); + r.echo_src.b[4] = (a4 & 0xff); + r.echo_src.b[5] = (a5 & 0xff); + } + } break; + + case 'c': + count = atoi(optarg); + if (count <= 0) + usage(); + break; + + case 'f': + flood = 1; + break; + + case 'i': + wait = atoi(optarg); + if (wait <= 0) + usage(); + break; + + case 's': + r.echo_size = atoi(optarg); + if ((int) r.echo_size < sizeof(int)) + usage(); + + if (r.echo_size > NG_L2CAP_MAX_ECHO_SIZE) + r.echo_size = NG_L2CAP_MAX_ECHO_SIZE; + break; + + default: + usage(); + break; + } + } + + if (memcmp(&r.echo_dst, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) == 0) + usage(); + + s = socket(PF_BLUETOOTH, SOCK_RAW, BLUETOOTH_PROTO_L2CAP); + if (s < 0) + err(2, "Could not create socket"); + + if (memcmp(&r.echo_src, NG_HCI_BDADDR_ANY, sizeof(bdaddr_t)) != 0) { + struct sockaddr_l2cap sa; + + memset(&sa, 0, sizeof(sa)); + sa.l2cap_len = sizeof(sa); + sa.l2cap_family = AF_BLUETOOTH; + memcpy(&sa.l2cap_bdaddr, &r.echo_src, sizeof(bdaddr_t)); + + if (bind(s, (struct sockaddr *) &sa, sizeof(sa)) < 0) + err(3, +"Could not bind socket, src bdaddr=%x:%x:%x:%x:%x:%x", + sa.l2cap_bdaddr.b[5], sa.l2cap_bdaddr.b[4], + sa.l2cap_bdaddr.b[3], sa.l2cap_bdaddr.b[2], + sa.l2cap_bdaddr.b[1], sa.l2cap_bdaddr.b[0]); + + if (connect(s, (struct sockaddr *) &sa, sizeof(sa)) < 0) + err(4, +"Could not connect socket, src bdaddr=%x:%x:%x:%x:%x:%x", + sa.l2cap_bdaddr.b[5], sa.l2cap_bdaddr.b[4], + sa.l2cap_bdaddr.b[3], sa.l2cap_bdaddr.b[2], + sa.l2cap_bdaddr.b[1], sa.l2cap_bdaddr.b[0]); + } + + /* Fill pattern */ + for (n = 0; n < r.echo_size; ) { + int avail = min(r.echo_size - n, PATTERN_SIZE); + + memcpy(r.echo_data + n, pattern, avail); + n += avail; + } + + /* Start ping'ing */ + for (n = 0; count == -1 || count > 0; n ++) { + if (gettimeofday(&a, NULL) < 0) + err(5, "Could not gettimeofday(a)"); + + fail = 0; + *((int *)(r.echo_data)) = htonl(n); + if (ioctl(s, SIOC_L2CAP_L2CA_PING, &r, sizeof(r)) < 0) { + r.result = errno; + fail = 1; +/* + warn("Could not ping, dst bdaddr=%x:%x:%x:%x:%x:%x", + r.echo_dst.b[5], r.echo_dst.b[4], + r.echo_dst.b[3], r.echo_dst.b[2], + r.echo_dst.b[1], r.echo_dst.b[0]); +*/ + } + + if (gettimeofday(&b, NULL) < 0) + err(7, "Could not gettimeofday(b)"); + + tv_sub(&b, &a); + + fprintf(stdout, +"%d bytes from %x:%x:%x:%x:%x:%x seq_no=%d time=%.3f ms result=%#x %s\n", + r.echo_size, + r.echo_dst.b[5], r.echo_dst.b[4], + r.echo_dst.b[3], r.echo_dst.b[2], + r.echo_dst.b[1], r.echo_dst.b[0], + ntohl(*((int *)(r.echo_data))), + tv2msec(&b), r.result, + ((fail == 0)? "" : strerror(errno))); + + if (!flood) { + /* Wait */ + a.tv_sec = wait; + a.tv_usec = 0; + select(0, NULL, NULL, NULL, &a); + } + + if (count != -1) + count --; + } + + free(r.echo_data); + close(s); + + return (0); +} /* main */ + +/* + * a -= b, for timevals + */ + +static void +tv_sub(struct timeval *a, struct timeval const *b) +{ + if (a->tv_usec < b->tv_usec) { + a->tv_usec += 1000000; + a->tv_sec -= 1; + } + + a->tv_usec -= b->tv_usec; + a->tv_sec -= b->tv_sec; +} /* tv_sub */ + +/* + * convert tv to msec + */ + +static double +tv2msec(struct timeval const *tvp) +{ + return(((double)tvp->tv_usec)/1000.0 + ((double)tvp->tv_sec)*1000.0); +} /* tv2msec */ + +/* + * Usage + */ + +static void +usage(void) +{ + fprintf(stderr, "Usage: l2ping -a bd_addr " \ + "[-S bd_addr -c count -i wait -s size]\n"); + fprintf(stderr, "Where:\n"); + fprintf(stderr, "\t-S bd_addr - Source BD_ADDR\n"); + fprintf(stderr, "\t-a bd_addr - Remote BD_ADDR to ping\n"); + fprintf(stderr, "\t-c count - Number of packets to send\n"); + fprintf(stderr, "\t-f - No delay (soft of flood)\n"); + fprintf(stderr, "\t-i wait - Delay between packets (sec)\n"); + fprintf(stderr, "\t-s size - Packet size (bytes), " \ + "between %d and %d\n", sizeof(int), NG_L2CAP_MAX_ECHO_SIZE); + + exit(255); +} /* usage */ + |
