diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /net/bluetooth/bnep |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'net/bluetooth/bnep')
-rw-r--r-- | net/bluetooth/bnep/Kconfig | 24 | ||||
-rw-r--r-- | net/bluetooth/bnep/Makefile | 7 | ||||
-rw-r--r-- | net/bluetooth/bnep/bnep.h | 184 | ||||
-rw-r--r-- | net/bluetooth/bnep/core.c | 713 | ||||
-rw-r--r-- | net/bluetooth/bnep/netdev.c | 247 | ||||
-rw-r--r-- | net/bluetooth/bnep/sock.c | 237 |
6 files changed, 1412 insertions, 0 deletions
diff --git a/net/bluetooth/bnep/Kconfig b/net/bluetooth/bnep/Kconfig new file mode 100644 index 000000000000..35158b036d54 --- /dev/null +++ b/net/bluetooth/bnep/Kconfig | |||
@@ -0,0 +1,24 @@ | |||
1 | config BT_BNEP | ||
2 | tristate "BNEP protocol support" | ||
3 | depends on BT && BT_L2CAP | ||
4 | select CRC32 | ||
5 | help | ||
6 | BNEP (Bluetooth Network Encapsulation Protocol) is Ethernet | ||
7 | emulation layer on top of Bluetooth. BNEP is required for | ||
8 | Bluetooth PAN (Personal Area Network). | ||
9 | |||
10 | Say Y here to compile BNEP support into the kernel or say M to | ||
11 | compile it as module (bnep). | ||
12 | |||
13 | config BT_BNEP_MC_FILTER | ||
14 | bool "Multicast filter support" | ||
15 | depends on BT_BNEP | ||
16 | help | ||
17 | This option enables the multicast filter support for BNEP. | ||
18 | |||
19 | config BT_BNEP_PROTO_FILTER | ||
20 | bool "Protocol filter support" | ||
21 | depends on BT_BNEP | ||
22 | help | ||
23 | This option enables the protocol filter support for BNEP. | ||
24 | |||
diff --git a/net/bluetooth/bnep/Makefile b/net/bluetooth/bnep/Makefile new file mode 100644 index 000000000000..c7821e76ca56 --- /dev/null +++ b/net/bluetooth/bnep/Makefile | |||
@@ -0,0 +1,7 @@ | |||
1 | # | ||
2 | # Makefile for the Linux Bluetooth BNEP layer. | ||
3 | # | ||
4 | |||
5 | obj-$(CONFIG_BT_BNEP) += bnep.o | ||
6 | |||
7 | bnep-objs := core.o sock.o netdev.o | ||
diff --git a/net/bluetooth/bnep/bnep.h b/net/bluetooth/bnep/bnep.h new file mode 100644 index 000000000000..bbb1ed7097a9 --- /dev/null +++ b/net/bluetooth/bnep/bnep.h | |||
@@ -0,0 +1,184 @@ | |||
1 | /* | ||
2 | BNEP protocol definition for Linux Bluetooth stack (BlueZ). | ||
3 | Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com> | ||
4 | |||
5 | This program is free software; you can redistribute it and/or modify | ||
6 | it under the terms of the GNU General Public License, version 2, as | ||
7 | published by the Free Software Foundation. | ||
8 | |||
9 | This program is distributed in the hope that it will be useful, | ||
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
12 | GNU General Public License for more details. | ||
13 | |||
14 | You should have received a copy of the GNU General Public License | ||
15 | along with this program; if not, write to the Free Software | ||
16 | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
17 | */ | ||
18 | |||
19 | /* | ||
20 | * $Id: bnep.h,v 1.5 2002/08/04 21:23:58 maxk Exp $ | ||
21 | */ | ||
22 | |||
23 | #ifndef _BNEP_H | ||
24 | #define _BNEP_H | ||
25 | |||
26 | #include <linux/types.h> | ||
27 | #include <linux/crc32.h> | ||
28 | #include <net/bluetooth/bluetooth.h> | ||
29 | |||
30 | // Limits | ||
31 | #define BNEP_MAX_PROTO_FILTERS 5 | ||
32 | #define BNEP_MAX_MULTICAST_FILTERS 20 | ||
33 | |||
34 | // UUIDs | ||
35 | #define BNEP_BASE_UUID 0x0000000000001000800000805F9B34FB | ||
36 | #define BNEP_UUID16 0x02 | ||
37 | #define BNEP_UUID32 0x04 | ||
38 | #define BNEP_UUID128 0x16 | ||
39 | |||
40 | #define BNEP_SVC_PANU 0x1115 | ||
41 | #define BNEP_SVC_NAP 0x1116 | ||
42 | #define BNEP_SVC_GN 0x1117 | ||
43 | |||
44 | // Packet types | ||
45 | #define BNEP_GENERAL 0x00 | ||
46 | #define BNEP_CONTROL 0x01 | ||
47 | #define BNEP_COMPRESSED 0x02 | ||
48 | #define BNEP_COMPRESSED_SRC_ONLY 0x03 | ||
49 | #define BNEP_COMPRESSED_DST_ONLY 0x04 | ||
50 | |||
51 | // Control types | ||
52 | #define BNEP_CMD_NOT_UNDERSTOOD 0x00 | ||
53 | #define BNEP_SETUP_CONN_REQ 0x01 | ||
54 | #define BNEP_SETUP_CONN_RSP 0x02 | ||
55 | #define BNEP_FILTER_NET_TYPE_SET 0x03 | ||
56 | #define BNEP_FILTER_NET_TYPE_RSP 0x04 | ||
57 | #define BNEP_FILTER_MULTI_ADDR_SET 0x05 | ||
58 | #define BNEP_FILTER_MULTI_ADDR_RSP 0x06 | ||
59 | |||
60 | // Extension types | ||
61 | #define BNEP_EXT_CONTROL 0x00 | ||
62 | |||
63 | // Response messages | ||
64 | #define BNEP_SUCCESS 0x00 | ||
65 | |||
66 | #define BNEP_CONN_INVALID_DST 0x01 | ||
67 | #define BNEP_CONN_INVALID_SRC 0x02 | ||
68 | #define BNEP_CONN_INVALID_SVC 0x03 | ||
69 | #define BNEP_CONN_NOT_ALLOWED 0x04 | ||
70 | |||
71 | #define BNEP_FILTER_UNSUPPORTED_REQ 0x01 | ||
72 | #define BNEP_FILTER_INVALID_RANGE 0x02 | ||
73 | #define BNEP_FILTER_INVALID_MCADDR 0x02 | ||
74 | #define BNEP_FILTER_LIMIT_REACHED 0x03 | ||
75 | #define BNEP_FILTER_DENIED_SECURITY 0x04 | ||
76 | |||
77 | // L2CAP settings | ||
78 | #define BNEP_MTU 1691 | ||
79 | #define BNEP_PSM 0x0f | ||
80 | #define BNEP_FLUSH_TO 0xffff | ||
81 | #define BNEP_CONNECT_TO 15 | ||
82 | #define BNEP_FILTER_TO 15 | ||
83 | |||
84 | // Headers | ||
85 | #define BNEP_TYPE_MASK 0x7f | ||
86 | #define BNEP_EXT_HEADER 0x80 | ||
87 | |||
88 | struct bnep_setup_conn_req { | ||
89 | __u8 type; | ||
90 | __u8 ctrl; | ||
91 | __u8 uuid_size; | ||
92 | __u8 service[0]; | ||
93 | } __attribute__((packed)); | ||
94 | |||
95 | struct bnep_set_filter_req { | ||
96 | __u8 type; | ||
97 | __u8 ctrl; | ||
98 | __u16 len; | ||
99 | __u8 list[0]; | ||
100 | } __attribute__((packed)); | ||
101 | |||
102 | struct bnep_control_rsp { | ||
103 | __u8 type; | ||
104 | __u8 ctrl; | ||
105 | __u16 resp; | ||
106 | } __attribute__((packed)); | ||
107 | |||
108 | struct bnep_ext_hdr { | ||
109 | __u8 type; | ||
110 | __u8 len; | ||
111 | __u8 data[0]; | ||
112 | } __attribute__((packed)); | ||
113 | |||
114 | /* BNEP ioctl defines */ | ||
115 | #define BNEPCONNADD _IOW('B', 200, int) | ||
116 | #define BNEPCONNDEL _IOW('B', 201, int) | ||
117 | #define BNEPGETCONNLIST _IOR('B', 210, int) | ||
118 | #define BNEPGETCONNINFO _IOR('B', 211, int) | ||
119 | |||
120 | struct bnep_connadd_req { | ||
121 | int sock; // Connected socket | ||
122 | __u32 flags; | ||
123 | __u16 role; | ||
124 | char device[16]; // Name of the Ethernet device | ||
125 | }; | ||
126 | |||
127 | struct bnep_conndel_req { | ||
128 | __u32 flags; | ||
129 | __u8 dst[ETH_ALEN]; | ||
130 | }; | ||
131 | |||
132 | struct bnep_conninfo { | ||
133 | __u32 flags; | ||
134 | __u16 role; | ||
135 | __u16 state; | ||
136 | __u8 dst[ETH_ALEN]; | ||
137 | char device[16]; | ||
138 | }; | ||
139 | |||
140 | struct bnep_connlist_req { | ||
141 | __u32 cnum; | ||
142 | struct bnep_conninfo __user *ci; | ||
143 | }; | ||
144 | |||
145 | struct bnep_proto_filter { | ||
146 | __u16 start; | ||
147 | __u16 end; | ||
148 | }; | ||
149 | |||
150 | int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock); | ||
151 | int bnep_del_connection(struct bnep_conndel_req *req); | ||
152 | int bnep_get_connlist(struct bnep_connlist_req *req); | ||
153 | int bnep_get_conninfo(struct bnep_conninfo *ci); | ||
154 | |||
155 | // BNEP sessions | ||
156 | struct bnep_session { | ||
157 | struct list_head list; | ||
158 | |||
159 | unsigned int role; | ||
160 | unsigned long state; | ||
161 | unsigned long flags; | ||
162 | atomic_t killed; | ||
163 | |||
164 | struct ethhdr eh; | ||
165 | struct msghdr msg; | ||
166 | |||
167 | struct bnep_proto_filter proto_filter[BNEP_MAX_PROTO_FILTERS]; | ||
168 | u64 mc_filter; | ||
169 | |||
170 | struct socket *sock; | ||
171 | struct net_device *dev; | ||
172 | struct net_device_stats stats; | ||
173 | }; | ||
174 | |||
175 | void bnep_net_setup(struct net_device *dev); | ||
176 | int bnep_sock_init(void); | ||
177 | int bnep_sock_cleanup(void); | ||
178 | |||
179 | static inline int bnep_mc_hash(__u8 *addr) | ||
180 | { | ||
181 | return (crc32_be(~0, addr, ETH_ALEN) >> 26); | ||
182 | } | ||
183 | |||
184 | #endif | ||
diff --git a/net/bluetooth/bnep/core.c b/net/bluetooth/bnep/core.c new file mode 100644 index 000000000000..682bf20af52d --- /dev/null +++ b/net/bluetooth/bnep/core.c | |||
@@ -0,0 +1,713 @@ | |||
1 | /* | ||
2 | BNEP implementation for Linux Bluetooth stack (BlueZ). | ||
3 | Copyright (C) 2001-2002 Inventel Systemes | ||
4 | Written 2001-2002 by | ||
5 | Cl�ment Moreau <clement.moreau@inventel.fr> | ||
6 | David Libault <david.libault@inventel.fr> | ||
7 | |||
8 | Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com> | ||
9 | |||
10 | This program is free software; you can redistribute it and/or modify | ||
11 | it under the terms of the GNU General Public License version 2 as | ||
12 | published by the Free Software Foundation; | ||
13 | |||
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
15 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. | ||
17 | IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY | ||
18 | CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES | ||
19 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
20 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
21 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
22 | |||
23 | ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, | ||
24 | COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS | ||
25 | SOFTWARE IS DISCLAIMED. | ||
26 | */ | ||
27 | |||
28 | /* | ||
29 | * $Id: core.c,v 1.20 2002/08/04 21:23:58 maxk Exp $ | ||
30 | */ | ||
31 | |||
32 | #include <linux/config.h> | ||
33 | #include <linux/module.h> | ||
34 | |||
35 | #include <linux/kernel.h> | ||
36 | #include <linux/sched.h> | ||
37 | #include <linux/signal.h> | ||
38 | #include <linux/init.h> | ||
39 | #include <linux/wait.h> | ||
40 | #include <linux/errno.h> | ||
41 | #include <linux/smp_lock.h> | ||
42 | #include <linux/net.h> | ||
43 | #include <net/sock.h> | ||
44 | |||
45 | #include <linux/socket.h> | ||
46 | #include <linux/file.h> | ||
47 | |||
48 | #include <linux/netdevice.h> | ||
49 | #include <linux/etherdevice.h> | ||
50 | #include <linux/skbuff.h> | ||
51 | |||
52 | #include <asm/unaligned.h> | ||
53 | |||
54 | #include <net/bluetooth/bluetooth.h> | ||
55 | #include <net/bluetooth/l2cap.h> | ||
56 | |||
57 | #include "bnep.h" | ||
58 | |||
59 | #ifndef CONFIG_BT_BNEP_DEBUG | ||
60 | #undef BT_DBG | ||
61 | #define BT_DBG(D...) | ||
62 | #endif | ||
63 | |||
64 | #define VERSION "1.2" | ||
65 | |||
66 | static LIST_HEAD(bnep_session_list); | ||
67 | static DECLARE_RWSEM(bnep_session_sem); | ||
68 | |||
69 | static struct bnep_session *__bnep_get_session(u8 *dst) | ||
70 | { | ||
71 | struct bnep_session *s; | ||
72 | struct list_head *p; | ||
73 | |||
74 | BT_DBG(""); | ||
75 | |||
76 | list_for_each(p, &bnep_session_list) { | ||
77 | s = list_entry(p, struct bnep_session, list); | ||
78 | if (!memcmp(dst, s->eh.h_source, ETH_ALEN)) | ||
79 | return s; | ||
80 | } | ||
81 | return NULL; | ||
82 | } | ||
83 | |||
84 | static void __bnep_link_session(struct bnep_session *s) | ||
85 | { | ||
86 | /* It's safe to call __module_get() here because sessions are added | ||
87 | by the socket layer which has to hold the refference to this module. | ||
88 | */ | ||
89 | __module_get(THIS_MODULE); | ||
90 | list_add(&s->list, &bnep_session_list); | ||
91 | } | ||
92 | |||
93 | static void __bnep_unlink_session(struct bnep_session *s) | ||
94 | { | ||
95 | list_del(&s->list); | ||
96 | module_put(THIS_MODULE); | ||
97 | } | ||
98 | |||
99 | static int bnep_send(struct bnep_session *s, void *data, size_t len) | ||
100 | { | ||
101 | struct socket *sock = s->sock; | ||
102 | struct kvec iv = { data, len }; | ||
103 | |||
104 | return kernel_sendmsg(sock, &s->msg, &iv, 1, len); | ||
105 | } | ||
106 | |||
107 | static int bnep_send_rsp(struct bnep_session *s, u8 ctrl, u16 resp) | ||
108 | { | ||
109 | struct bnep_control_rsp rsp; | ||
110 | rsp.type = BNEP_CONTROL; | ||
111 | rsp.ctrl = ctrl; | ||
112 | rsp.resp = htons(resp); | ||
113 | return bnep_send(s, &rsp, sizeof(rsp)); | ||
114 | } | ||
115 | |||
116 | #ifdef CONFIG_BT_BNEP_PROTO_FILTER | ||
117 | static inline void bnep_set_default_proto_filter(struct bnep_session *s) | ||
118 | { | ||
119 | /* (IPv4, ARP) */ | ||
120 | s->proto_filter[0].start = htons(0x0800); | ||
121 | s->proto_filter[0].end = htons(0x0806); | ||
122 | /* (RARP, AppleTalk) */ | ||
123 | s->proto_filter[1].start = htons(0x8035); | ||
124 | s->proto_filter[1].end = htons(0x80F3); | ||
125 | /* (IPX, IPv6) */ | ||
126 | s->proto_filter[2].start = htons(0x8137); | ||
127 | s->proto_filter[2].end = htons(0x86DD); | ||
128 | } | ||
129 | #endif | ||
130 | |||
131 | static int bnep_ctrl_set_netfilter(struct bnep_session *s, u16 *data, int len) | ||
132 | { | ||
133 | int n; | ||
134 | |||
135 | if (len < 2) | ||
136 | return -EILSEQ; | ||
137 | |||
138 | n = ntohs(get_unaligned(data)); | ||
139 | data++; len -= 2; | ||
140 | |||
141 | if (len < n) | ||
142 | return -EILSEQ; | ||
143 | |||
144 | BT_DBG("filter len %d", n); | ||
145 | |||
146 | #ifdef CONFIG_BT_BNEP_PROTO_FILTER | ||
147 | n /= 4; | ||
148 | if (n <= BNEP_MAX_PROTO_FILTERS) { | ||
149 | struct bnep_proto_filter *f = s->proto_filter; | ||
150 | int i; | ||
151 | |||
152 | for (i = 0; i < n; i++) { | ||
153 | f[i].start = get_unaligned(data++); | ||
154 | f[i].end = get_unaligned(data++); | ||
155 | |||
156 | BT_DBG("proto filter start %d end %d", | ||
157 | f[i].start, f[i].end); | ||
158 | } | ||
159 | |||
160 | if (i < BNEP_MAX_PROTO_FILTERS) | ||
161 | memset(f + i, 0, sizeof(*f)); | ||
162 | |||
163 | if (n == 0) | ||
164 | bnep_set_default_proto_filter(s); | ||
165 | |||
166 | bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_SUCCESS); | ||
167 | } else { | ||
168 | bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_LIMIT_REACHED); | ||
169 | } | ||
170 | #else | ||
171 | bnep_send_rsp(s, BNEP_FILTER_NET_TYPE_RSP, BNEP_FILTER_UNSUPPORTED_REQ); | ||
172 | #endif | ||
173 | return 0; | ||
174 | } | ||
175 | |||
176 | static int bnep_ctrl_set_mcfilter(struct bnep_session *s, u8 *data, int len) | ||
177 | { | ||
178 | int n; | ||
179 | |||
180 | if (len < 2) | ||
181 | return -EILSEQ; | ||
182 | |||
183 | n = ntohs(get_unaligned((u16 *) data)); | ||
184 | data += 2; len -= 2; | ||
185 | |||
186 | if (len < n) | ||
187 | return -EILSEQ; | ||
188 | |||
189 | BT_DBG("filter len %d", n); | ||
190 | |||
191 | #ifdef CONFIG_BT_BNEP_MC_FILTER | ||
192 | n /= (ETH_ALEN * 2); | ||
193 | |||
194 | if (n > 0) { | ||
195 | s->mc_filter = 0; | ||
196 | |||
197 | /* Always send broadcast */ | ||
198 | set_bit(bnep_mc_hash(s->dev->broadcast), (ulong *) &s->mc_filter); | ||
199 | |||
200 | /* Add address ranges to the multicast hash */ | ||
201 | for (; n > 0; n--) { | ||
202 | u8 a1[6], *a2; | ||
203 | |||
204 | memcpy(a1, data, ETH_ALEN); data += ETH_ALEN; | ||
205 | a2 = data; data += ETH_ALEN; | ||
206 | |||
207 | BT_DBG("mc filter %s -> %s", | ||
208 | batostr((void *) a1), batostr((void *) a2)); | ||
209 | |||
210 | #define INCA(a) { int i = 5; while (i >=0 && ++a[i--] == 0); } | ||
211 | |||
212 | /* Iterate from a1 to a2 */ | ||
213 | set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter); | ||
214 | while (memcmp(a1, a2, 6) < 0 && s->mc_filter != ~0LL) { | ||
215 | INCA(a1); | ||
216 | set_bit(bnep_mc_hash(a1), (ulong *) &s->mc_filter); | ||
217 | } | ||
218 | } | ||
219 | } | ||
220 | |||
221 | BT_DBG("mc filter hash 0x%llx", s->mc_filter); | ||
222 | |||
223 | bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_SUCCESS); | ||
224 | #else | ||
225 | bnep_send_rsp(s, BNEP_FILTER_MULTI_ADDR_RSP, BNEP_FILTER_UNSUPPORTED_REQ); | ||
226 | #endif | ||
227 | return 0; | ||
228 | } | ||
229 | |||
230 | static int bnep_rx_control(struct bnep_session *s, void *data, int len) | ||
231 | { | ||
232 | u8 cmd = *(u8 *)data; | ||
233 | int err = 0; | ||
234 | |||
235 | data++; len--; | ||
236 | |||
237 | switch (cmd) { | ||
238 | case BNEP_CMD_NOT_UNDERSTOOD: | ||
239 | case BNEP_SETUP_CONN_REQ: | ||
240 | case BNEP_SETUP_CONN_RSP: | ||
241 | case BNEP_FILTER_NET_TYPE_RSP: | ||
242 | case BNEP_FILTER_MULTI_ADDR_RSP: | ||
243 | /* Ignore these for now */ | ||
244 | break; | ||
245 | |||
246 | case BNEP_FILTER_NET_TYPE_SET: | ||
247 | err = bnep_ctrl_set_netfilter(s, data, len); | ||
248 | break; | ||
249 | |||
250 | case BNEP_FILTER_MULTI_ADDR_SET: | ||
251 | err = bnep_ctrl_set_mcfilter(s, data, len); | ||
252 | break; | ||
253 | |||
254 | default: { | ||
255 | u8 pkt[3]; | ||
256 | pkt[0] = BNEP_CONTROL; | ||
257 | pkt[1] = BNEP_CMD_NOT_UNDERSTOOD; | ||
258 | pkt[2] = cmd; | ||
259 | bnep_send(s, pkt, sizeof(pkt)); | ||
260 | } | ||
261 | break; | ||
262 | } | ||
263 | |||
264 | return err; | ||
265 | } | ||
266 | |||
267 | static int bnep_rx_extension(struct bnep_session *s, struct sk_buff *skb) | ||
268 | { | ||
269 | struct bnep_ext_hdr *h; | ||
270 | int err = 0; | ||
271 | |||
272 | do { | ||
273 | h = (void *) skb->data; | ||
274 | if (!skb_pull(skb, sizeof(*h))) { | ||
275 | err = -EILSEQ; | ||
276 | break; | ||
277 | } | ||
278 | |||
279 | BT_DBG("type 0x%x len %d", h->type, h->len); | ||
280 | |||
281 | switch (h->type & BNEP_TYPE_MASK) { | ||
282 | case BNEP_EXT_CONTROL: | ||
283 | bnep_rx_control(s, skb->data, skb->len); | ||
284 | break; | ||
285 | |||
286 | default: | ||
287 | /* Unknown extension, skip it. */ | ||
288 | break; | ||
289 | } | ||
290 | |||
291 | if (!skb_pull(skb, h->len)) { | ||
292 | err = -EILSEQ; | ||
293 | break; | ||
294 | } | ||
295 | } while (!err && (h->type & BNEP_EXT_HEADER)); | ||
296 | |||
297 | return err; | ||
298 | } | ||
299 | |||
300 | static u8 __bnep_rx_hlen[] = { | ||
301 | ETH_HLEN, /* BNEP_GENERAL */ | ||
302 | 0, /* BNEP_CONTROL */ | ||
303 | 2, /* BNEP_COMPRESSED */ | ||
304 | ETH_ALEN + 2, /* BNEP_COMPRESSED_SRC_ONLY */ | ||
305 | ETH_ALEN + 2 /* BNEP_COMPRESSED_DST_ONLY */ | ||
306 | }; | ||
307 | #define BNEP_RX_TYPES (sizeof(__bnep_rx_hlen) - 1) | ||
308 | |||
309 | static inline int bnep_rx_frame(struct bnep_session *s, struct sk_buff *skb) | ||
310 | { | ||
311 | struct net_device *dev = s->dev; | ||
312 | struct sk_buff *nskb; | ||
313 | u8 type; | ||
314 | |||
315 | dev->last_rx = jiffies; | ||
316 | s->stats.rx_bytes += skb->len; | ||
317 | |||
318 | type = *(u8 *) skb->data; skb_pull(skb, 1); | ||
319 | |||
320 | if ((type & BNEP_TYPE_MASK) > BNEP_RX_TYPES) | ||
321 | goto badframe; | ||
322 | |||
323 | if ((type & BNEP_TYPE_MASK) == BNEP_CONTROL) { | ||
324 | bnep_rx_control(s, skb->data, skb->len); | ||
325 | kfree_skb(skb); | ||
326 | return 0; | ||
327 | } | ||
328 | |||
329 | skb->mac.raw = skb->data; | ||
330 | |||
331 | /* Verify and pull out header */ | ||
332 | if (!skb_pull(skb, __bnep_rx_hlen[type & BNEP_TYPE_MASK])) | ||
333 | goto badframe; | ||
334 | |||
335 | s->eh.h_proto = get_unaligned((u16 *) (skb->data - 2)); | ||
336 | |||
337 | if (type & BNEP_EXT_HEADER) { | ||
338 | if (bnep_rx_extension(s, skb) < 0) | ||
339 | goto badframe; | ||
340 | } | ||
341 | |||
342 | /* Strip 802.1p header */ | ||
343 | if (ntohs(s->eh.h_proto) == 0x8100) { | ||
344 | if (!skb_pull(skb, 4)) | ||
345 | goto badframe; | ||
346 | s->eh.h_proto = get_unaligned((u16 *) (skb->data - 2)); | ||
347 | } | ||
348 | |||
349 | /* We have to alloc new skb and copy data here :(. Because original skb | ||
350 | * may not be modified and because of the alignment requirements. */ | ||
351 | nskb = alloc_skb(2 + ETH_HLEN + skb->len, GFP_KERNEL); | ||
352 | if (!nskb) { | ||
353 | s->stats.rx_dropped++; | ||
354 | kfree_skb(skb); | ||
355 | return -ENOMEM; | ||
356 | } | ||
357 | skb_reserve(nskb, 2); | ||
358 | |||
359 | /* Decompress header and construct ether frame */ | ||
360 | switch (type & BNEP_TYPE_MASK) { | ||
361 | case BNEP_COMPRESSED: | ||
362 | memcpy(__skb_put(nskb, ETH_HLEN), &s->eh, ETH_HLEN); | ||
363 | break; | ||
364 | |||
365 | case BNEP_COMPRESSED_SRC_ONLY: | ||
366 | memcpy(__skb_put(nskb, ETH_ALEN), s->eh.h_dest, ETH_ALEN); | ||
367 | memcpy(__skb_put(nskb, ETH_ALEN), skb->mac.raw, ETH_ALEN); | ||
368 | put_unaligned(s->eh.h_proto, (u16 *) __skb_put(nskb, 2)); | ||
369 | break; | ||
370 | |||
371 | case BNEP_COMPRESSED_DST_ONLY: | ||
372 | memcpy(__skb_put(nskb, ETH_ALEN), skb->mac.raw, ETH_ALEN); | ||
373 | memcpy(__skb_put(nskb, ETH_ALEN + 2), s->eh.h_source, ETH_ALEN + 2); | ||
374 | break; | ||
375 | |||
376 | case BNEP_GENERAL: | ||
377 | memcpy(__skb_put(nskb, ETH_ALEN * 2), skb->mac.raw, ETH_ALEN * 2); | ||
378 | put_unaligned(s->eh.h_proto, (u16 *) __skb_put(nskb, 2)); | ||
379 | break; | ||
380 | } | ||
381 | |||
382 | memcpy(__skb_put(nskb, skb->len), skb->data, skb->len); | ||
383 | kfree_skb(skb); | ||
384 | |||
385 | s->stats.rx_packets++; | ||
386 | nskb->dev = dev; | ||
387 | nskb->ip_summed = CHECKSUM_NONE; | ||
388 | nskb->protocol = eth_type_trans(nskb, dev); | ||
389 | netif_rx_ni(nskb); | ||
390 | return 0; | ||
391 | |||
392 | badframe: | ||
393 | s->stats.rx_errors++; | ||
394 | kfree_skb(skb); | ||
395 | return 0; | ||
396 | } | ||
397 | |||
398 | static u8 __bnep_tx_types[] = { | ||
399 | BNEP_GENERAL, | ||
400 | BNEP_COMPRESSED_SRC_ONLY, | ||
401 | BNEP_COMPRESSED_DST_ONLY, | ||
402 | BNEP_COMPRESSED | ||
403 | }; | ||
404 | |||
405 | static inline int bnep_tx_frame(struct bnep_session *s, struct sk_buff *skb) | ||
406 | { | ||
407 | struct ethhdr *eh = (void *) skb->data; | ||
408 | struct socket *sock = s->sock; | ||
409 | struct kvec iv[3]; | ||
410 | int len = 0, il = 0; | ||
411 | u8 type = 0; | ||
412 | |||
413 | BT_DBG("skb %p dev %p type %d", skb, skb->dev, skb->pkt_type); | ||
414 | |||
415 | if (!skb->dev) { | ||
416 | /* Control frame sent by us */ | ||
417 | goto send; | ||
418 | } | ||
419 | |||
420 | iv[il++] = (struct kvec) { &type, 1 }; | ||
421 | len++; | ||
422 | |||
423 | if (!memcmp(eh->h_dest, s->eh.h_source, ETH_ALEN)) | ||
424 | type |= 0x01; | ||
425 | |||
426 | if (!memcmp(eh->h_source, s->eh.h_dest, ETH_ALEN)) | ||
427 | type |= 0x02; | ||
428 | |||
429 | if (type) | ||
430 | skb_pull(skb, ETH_ALEN * 2); | ||
431 | |||
432 | type = __bnep_tx_types[type]; | ||
433 | switch (type) { | ||
434 | case BNEP_COMPRESSED_SRC_ONLY: | ||
435 | iv[il++] = (struct kvec) { eh->h_source, ETH_ALEN }; | ||
436 | len += ETH_ALEN; | ||
437 | break; | ||
438 | |||
439 | case BNEP_COMPRESSED_DST_ONLY: | ||
440 | iv[il++] = (struct kvec) { eh->h_dest, ETH_ALEN }; | ||
441 | len += ETH_ALEN; | ||
442 | break; | ||
443 | } | ||
444 | |||
445 | send: | ||
446 | iv[il++] = (struct kvec) { skb->data, skb->len }; | ||
447 | len += skb->len; | ||
448 | |||
449 | /* FIXME: linearize skb */ | ||
450 | { | ||
451 | len = kernel_sendmsg(sock, &s->msg, iv, il, len); | ||
452 | } | ||
453 | kfree_skb(skb); | ||
454 | |||
455 | if (len > 0) { | ||
456 | s->stats.tx_bytes += len; | ||
457 | s->stats.tx_packets++; | ||
458 | return 0; | ||
459 | } | ||
460 | |||
461 | return len; | ||
462 | } | ||
463 | |||
464 | static int bnep_session(void *arg) | ||
465 | { | ||
466 | struct bnep_session *s = arg; | ||
467 | struct net_device *dev = s->dev; | ||
468 | struct sock *sk = s->sock->sk; | ||
469 | struct sk_buff *skb; | ||
470 | wait_queue_t wait; | ||
471 | |||
472 | BT_DBG(""); | ||
473 | |||
474 | daemonize("kbnepd %s", dev->name); | ||
475 | set_user_nice(current, -15); | ||
476 | current->flags |= PF_NOFREEZE; | ||
477 | |||
478 | init_waitqueue_entry(&wait, current); | ||
479 | add_wait_queue(sk->sk_sleep, &wait); | ||
480 | while (!atomic_read(&s->killed)) { | ||
481 | set_current_state(TASK_INTERRUPTIBLE); | ||
482 | |||
483 | // RX | ||
484 | while ((skb = skb_dequeue(&sk->sk_receive_queue))) { | ||
485 | skb_orphan(skb); | ||
486 | bnep_rx_frame(s, skb); | ||
487 | } | ||
488 | |||
489 | if (sk->sk_state != BT_CONNECTED) | ||
490 | break; | ||
491 | |||
492 | // TX | ||
493 | while ((skb = skb_dequeue(&sk->sk_write_queue))) | ||
494 | if (bnep_tx_frame(s, skb)) | ||
495 | break; | ||
496 | netif_wake_queue(dev); | ||
497 | |||
498 | schedule(); | ||
499 | } | ||
500 | set_current_state(TASK_RUNNING); | ||
501 | remove_wait_queue(sk->sk_sleep, &wait); | ||
502 | |||
503 | /* Cleanup session */ | ||
504 | down_write(&bnep_session_sem); | ||
505 | |||
506 | /* Delete network device */ | ||
507 | unregister_netdev(dev); | ||
508 | |||
509 | /* Release the socket */ | ||
510 | fput(s->sock->file); | ||
511 | |||
512 | __bnep_unlink_session(s); | ||
513 | |||
514 | up_write(&bnep_session_sem); | ||
515 | free_netdev(dev); | ||
516 | return 0; | ||
517 | } | ||
518 | |||
519 | int bnep_add_connection(struct bnep_connadd_req *req, struct socket *sock) | ||
520 | { | ||
521 | struct net_device *dev; | ||
522 | struct bnep_session *s, *ss; | ||
523 | u8 dst[ETH_ALEN], src[ETH_ALEN]; | ||
524 | int err; | ||
525 | |||
526 | BT_DBG(""); | ||
527 | |||
528 | baswap((void *) dst, &bt_sk(sock->sk)->dst); | ||
529 | baswap((void *) src, &bt_sk(sock->sk)->src); | ||
530 | |||
531 | /* session struct allocated as private part of net_device */ | ||
532 | dev = alloc_netdev(sizeof(struct bnep_session), | ||
533 | (*req->device) ? req->device : "bnep%d", | ||
534 | bnep_net_setup); | ||
535 | if (!dev) | ||
536 | return ENOMEM; | ||
537 | |||
538 | |||
539 | down_write(&bnep_session_sem); | ||
540 | |||
541 | ss = __bnep_get_session(dst); | ||
542 | if (ss && ss->state == BT_CONNECTED) { | ||
543 | err = -EEXIST; | ||
544 | goto failed; | ||
545 | } | ||
546 | |||
547 | s = dev->priv; | ||
548 | |||
549 | /* This is rx header therefore addresses are swapped. | ||
550 | * ie eh.h_dest is our local address. */ | ||
551 | memcpy(s->eh.h_dest, &src, ETH_ALEN); | ||
552 | memcpy(s->eh.h_source, &dst, ETH_ALEN); | ||
553 | memcpy(dev->dev_addr, s->eh.h_dest, ETH_ALEN); | ||
554 | |||
555 | s->dev = dev; | ||
556 | s->sock = sock; | ||
557 | s->role = req->role; | ||
558 | s->state = BT_CONNECTED; | ||
559 | |||
560 | s->msg.msg_flags = MSG_NOSIGNAL; | ||
561 | |||
562 | #ifdef CONFIG_BT_BNEP_MC_FILTER | ||
563 | /* Set default mc filter */ | ||
564 | set_bit(bnep_mc_hash(dev->broadcast), (ulong *) &s->mc_filter); | ||
565 | #endif | ||
566 | |||
567 | #ifdef CONFIG_BT_BNEP_PROTO_FILTER | ||
568 | /* Set default protocol filter */ | ||
569 | bnep_set_default_proto_filter(s); | ||
570 | #endif | ||
571 | |||
572 | err = register_netdev(dev); | ||
573 | if (err) { | ||
574 | goto failed; | ||
575 | } | ||
576 | |||
577 | __bnep_link_session(s); | ||
578 | |||
579 | err = kernel_thread(bnep_session, s, CLONE_KERNEL); | ||
580 | if (err < 0) { | ||
581 | /* Session thread start failed, gotta cleanup. */ | ||
582 | unregister_netdev(dev); | ||
583 | __bnep_unlink_session(s); | ||
584 | goto failed; | ||
585 | } | ||
586 | |||
587 | up_write(&bnep_session_sem); | ||
588 | strcpy(req->device, dev->name); | ||
589 | return 0; | ||
590 | |||
591 | failed: | ||
592 | up_write(&bnep_session_sem); | ||
593 | free_netdev(dev); | ||
594 | return err; | ||
595 | } | ||
596 | |||
597 | int bnep_del_connection(struct bnep_conndel_req *req) | ||
598 | { | ||
599 | struct bnep_session *s; | ||
600 | int err = 0; | ||
601 | |||
602 | BT_DBG(""); | ||
603 | |||
604 | down_read(&bnep_session_sem); | ||
605 | |||
606 | s = __bnep_get_session(req->dst); | ||
607 | if (s) { | ||
608 | /* Wakeup user-space which is polling for socket errors. | ||
609 | * This is temporary hack untill we have shutdown in L2CAP */ | ||
610 | s->sock->sk->sk_err = EUNATCH; | ||
611 | |||
612 | /* Kill session thread */ | ||
613 | atomic_inc(&s->killed); | ||
614 | wake_up_interruptible(s->sock->sk->sk_sleep); | ||
615 | } else | ||
616 | err = -ENOENT; | ||
617 | |||
618 | up_read(&bnep_session_sem); | ||
619 | return err; | ||
620 | } | ||
621 | |||
622 | static void __bnep_copy_ci(struct bnep_conninfo *ci, struct bnep_session *s) | ||
623 | { | ||
624 | memcpy(ci->dst, s->eh.h_source, ETH_ALEN); | ||
625 | strcpy(ci->device, s->dev->name); | ||
626 | ci->flags = s->flags; | ||
627 | ci->state = s->state; | ||
628 | ci->role = s->role; | ||
629 | } | ||
630 | |||
631 | int bnep_get_connlist(struct bnep_connlist_req *req) | ||
632 | { | ||
633 | struct list_head *p; | ||
634 | int err = 0, n = 0; | ||
635 | |||
636 | down_read(&bnep_session_sem); | ||
637 | |||
638 | list_for_each(p, &bnep_session_list) { | ||
639 | struct bnep_session *s; | ||
640 | struct bnep_conninfo ci; | ||
641 | |||
642 | s = list_entry(p, struct bnep_session, list); | ||
643 | |||
644 | __bnep_copy_ci(&ci, s); | ||
645 | |||
646 | if (copy_to_user(req->ci, &ci, sizeof(ci))) { | ||
647 | err = -EFAULT; | ||
648 | break; | ||
649 | } | ||
650 | |||
651 | if (++n >= req->cnum) | ||
652 | break; | ||
653 | |||
654 | req->ci++; | ||
655 | } | ||
656 | req->cnum = n; | ||
657 | |||
658 | up_read(&bnep_session_sem); | ||
659 | return err; | ||
660 | } | ||
661 | |||
662 | int bnep_get_conninfo(struct bnep_conninfo *ci) | ||
663 | { | ||
664 | struct bnep_session *s; | ||
665 | int err = 0; | ||
666 | |||
667 | down_read(&bnep_session_sem); | ||
668 | |||
669 | s = __bnep_get_session(ci->dst); | ||
670 | if (s) | ||
671 | __bnep_copy_ci(ci, s); | ||
672 | else | ||
673 | err = -ENOENT; | ||
674 | |||
675 | up_read(&bnep_session_sem); | ||
676 | return err; | ||
677 | } | ||
678 | |||
679 | static int __init bnep_init(void) | ||
680 | { | ||
681 | char flt[50] = ""; | ||
682 | |||
683 | l2cap_load(); | ||
684 | |||
685 | #ifdef CONFIG_BT_BNEP_PROTO_FILTER | ||
686 | strcat(flt, "protocol "); | ||
687 | #endif | ||
688 | |||
689 | #ifdef CONFIG_BT_BNEP_MC_FILTER | ||
690 | strcat(flt, "multicast"); | ||
691 | #endif | ||
692 | |||
693 | BT_INFO("BNEP (Ethernet Emulation) ver %s", VERSION); | ||
694 | if (flt[0]) | ||
695 | BT_INFO("BNEP filters: %s", flt); | ||
696 | |||
697 | bnep_sock_init(); | ||
698 | return 0; | ||
699 | } | ||
700 | |||
701 | static void __exit bnep_exit(void) | ||
702 | { | ||
703 | bnep_sock_cleanup(); | ||
704 | } | ||
705 | |||
706 | module_init(bnep_init); | ||
707 | module_exit(bnep_exit); | ||
708 | |||
709 | MODULE_AUTHOR("David Libault <david.libault@inventel.fr>, Maxim Krasnyansky <maxk@qualcomm.com>"); | ||
710 | MODULE_DESCRIPTION("Bluetooth BNEP ver " VERSION); | ||
711 | MODULE_VERSION(VERSION); | ||
712 | MODULE_LICENSE("GPL"); | ||
713 | MODULE_ALIAS("bt-proto-4"); | ||
diff --git a/net/bluetooth/bnep/netdev.c b/net/bluetooth/bnep/netdev.c new file mode 100644 index 000000000000..921204f95f4a --- /dev/null +++ b/net/bluetooth/bnep/netdev.c | |||
@@ -0,0 +1,247 @@ | |||
1 | /* | ||
2 | BNEP implementation for Linux Bluetooth stack (BlueZ). | ||
3 | Copyright (C) 2001-2002 Inventel Systemes | ||
4 | Written 2001-2002 by | ||
5 | Cl�ment Moreau <clement.moreau@inventel.fr> | ||
6 | David Libault <david.libault@inventel.fr> | ||
7 | |||
8 | Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com> | ||
9 | |||
10 | This program is free software; you can redistribute it and/or modify | ||
11 | it under the terms of the GNU General Public License version 2 as | ||
12 | published by the Free Software Foundation; | ||
13 | |||
14 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
15 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
16 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. | ||
17 | IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY | ||
18 | CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES | ||
19 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
20 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
21 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
22 | |||
23 | ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, | ||
24 | COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS | ||
25 | SOFTWARE IS DISCLAIMED. | ||
26 | */ | ||
27 | |||
28 | /* | ||
29 | * $Id: netdev.c,v 1.8 2002/08/04 21:23:58 maxk Exp $ | ||
30 | */ | ||
31 | |||
32 | #include <linux/config.h> | ||
33 | #include <linux/module.h> | ||
34 | |||
35 | #include <linux/socket.h> | ||
36 | #include <linux/netdevice.h> | ||
37 | #include <linux/etherdevice.h> | ||
38 | #include <linux/skbuff.h> | ||
39 | #include <linux/wait.h> | ||
40 | |||
41 | #include <asm/unaligned.h> | ||
42 | |||
43 | #include <net/bluetooth/bluetooth.h> | ||
44 | #include <net/bluetooth/hci_core.h> | ||
45 | #include <net/bluetooth/l2cap.h> | ||
46 | |||
47 | #include "bnep.h" | ||
48 | |||
49 | #ifndef CONFIG_BT_BNEP_DEBUG | ||
50 | #undef BT_DBG | ||
51 | #define BT_DBG( A... ) | ||
52 | #endif | ||
53 | |||
54 | #define BNEP_TX_QUEUE_LEN 20 | ||
55 | |||
56 | static int bnep_net_open(struct net_device *dev) | ||
57 | { | ||
58 | netif_start_queue(dev); | ||
59 | return 0; | ||
60 | } | ||
61 | |||
62 | static int bnep_net_close(struct net_device *dev) | ||
63 | { | ||
64 | netif_stop_queue(dev); | ||
65 | return 0; | ||
66 | } | ||
67 | |||
68 | static struct net_device_stats *bnep_net_get_stats(struct net_device *dev) | ||
69 | { | ||
70 | struct bnep_session *s = dev->priv; | ||
71 | return &s->stats; | ||
72 | } | ||
73 | |||
74 | static void bnep_net_set_mc_list(struct net_device *dev) | ||
75 | { | ||
76 | #ifdef CONFIG_BT_BNEP_MC_FILTER | ||
77 | struct bnep_session *s = dev->priv; | ||
78 | struct sock *sk = s->sock->sk; | ||
79 | struct bnep_set_filter_req *r; | ||
80 | struct sk_buff *skb; | ||
81 | int size; | ||
82 | |||
83 | BT_DBG("%s mc_count %d", dev->name, dev->mc_count); | ||
84 | |||
85 | size = sizeof(*r) + (BNEP_MAX_MULTICAST_FILTERS + 1) * ETH_ALEN * 2; | ||
86 | skb = alloc_skb(size, GFP_ATOMIC); | ||
87 | if (!skb) { | ||
88 | BT_ERR("%s Multicast list allocation failed", dev->name); | ||
89 | return; | ||
90 | } | ||
91 | |||
92 | r = (void *) skb->data; | ||
93 | __skb_put(skb, sizeof(*r)); | ||
94 | |||
95 | r->type = BNEP_CONTROL; | ||
96 | r->ctrl = BNEP_FILTER_MULTI_ADDR_SET; | ||
97 | |||
98 | if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) { | ||
99 | u8 start[ETH_ALEN] = { 0x01 }; | ||
100 | |||
101 | /* Request all addresses */ | ||
102 | memcpy(__skb_put(skb, ETH_ALEN), start, ETH_ALEN); | ||
103 | memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN); | ||
104 | r->len = htons(ETH_ALEN * 2); | ||
105 | } else { | ||
106 | struct dev_mc_list *dmi = dev->mc_list; | ||
107 | int i, len = skb->len; | ||
108 | |||
109 | if (dev->flags & IFF_BROADCAST) { | ||
110 | memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN); | ||
111 | memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN); | ||
112 | } | ||
113 | |||
114 | /* FIXME: We should group addresses here. */ | ||
115 | |||
116 | for (i = 0; i < dev->mc_count && i < BNEP_MAX_MULTICAST_FILTERS; i++) { | ||
117 | memcpy(__skb_put(skb, ETH_ALEN), dmi->dmi_addr, ETH_ALEN); | ||
118 | memcpy(__skb_put(skb, ETH_ALEN), dmi->dmi_addr, ETH_ALEN); | ||
119 | dmi = dmi->next; | ||
120 | } | ||
121 | r->len = htons(skb->len - len); | ||
122 | } | ||
123 | |||
124 | skb_queue_tail(&sk->sk_write_queue, skb); | ||
125 | wake_up_interruptible(sk->sk_sleep); | ||
126 | #endif | ||
127 | } | ||
128 | |||
129 | static int bnep_net_set_mac_addr(struct net_device *dev, void *arg) | ||
130 | { | ||
131 | BT_DBG("%s", dev->name); | ||
132 | return 0; | ||
133 | } | ||
134 | |||
135 | static void bnep_net_timeout(struct net_device *dev) | ||
136 | { | ||
137 | BT_DBG("net_timeout"); | ||
138 | netif_wake_queue(dev); | ||
139 | } | ||
140 | |||
141 | static int bnep_net_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) | ||
142 | { | ||
143 | return -EINVAL; | ||
144 | } | ||
145 | |||
146 | #ifdef CONFIG_BT_BNEP_MC_FILTER | ||
147 | static inline int bnep_net_mc_filter(struct sk_buff *skb, struct bnep_session *s) | ||
148 | { | ||
149 | struct ethhdr *eh = (void *) skb->data; | ||
150 | |||
151 | if ((eh->h_dest[0] & 1) && !test_bit(bnep_mc_hash(eh->h_dest), (ulong *) &s->mc_filter)) | ||
152 | return 1; | ||
153 | return 0; | ||
154 | } | ||
155 | #endif | ||
156 | |||
157 | #ifdef CONFIG_BT_BNEP_PROTO_FILTER | ||
158 | /* Determine ether protocol. Based on eth_type_trans. */ | ||
159 | static inline u16 bnep_net_eth_proto(struct sk_buff *skb) | ||
160 | { | ||
161 | struct ethhdr *eh = (void *) skb->data; | ||
162 | |||
163 | if (ntohs(eh->h_proto) >= 1536) | ||
164 | return eh->h_proto; | ||
165 | |||
166 | if (get_unaligned((u16 *) skb->data) == 0xFFFF) | ||
167 | return htons(ETH_P_802_3); | ||
168 | |||
169 | return htons(ETH_P_802_2); | ||
170 | } | ||
171 | |||
172 | static inline int bnep_net_proto_filter(struct sk_buff *skb, struct bnep_session *s) | ||
173 | { | ||
174 | u16 proto = bnep_net_eth_proto(skb); | ||
175 | struct bnep_proto_filter *f = s->proto_filter; | ||
176 | int i; | ||
177 | |||
178 | for (i = 0; i < BNEP_MAX_PROTO_FILTERS && f[i].end; i++) { | ||
179 | if (proto >= f[i].start && proto <= f[i].end) | ||
180 | return 0; | ||
181 | } | ||
182 | |||
183 | BT_DBG("BNEP: filtered skb %p, proto 0x%.4x", skb, proto); | ||
184 | return 1; | ||
185 | } | ||
186 | #endif | ||
187 | |||
188 | static int bnep_net_xmit(struct sk_buff *skb, struct net_device *dev) | ||
189 | { | ||
190 | struct bnep_session *s = dev->priv; | ||
191 | struct sock *sk = s->sock->sk; | ||
192 | |||
193 | BT_DBG("skb %p, dev %p", skb, dev); | ||
194 | |||
195 | #ifdef CONFIG_BT_BNEP_MC_FILTER | ||
196 | if (bnep_net_mc_filter(skb, s)) { | ||
197 | kfree_skb(skb); | ||
198 | return 0; | ||
199 | } | ||
200 | #endif | ||
201 | |||
202 | #ifdef CONFIG_BT_BNEP_PROTO_FILTER | ||
203 | if (bnep_net_proto_filter(skb, s)) { | ||
204 | kfree_skb(skb); | ||
205 | return 0; | ||
206 | } | ||
207 | #endif | ||
208 | |||
209 | /* | ||
210 | * We cannot send L2CAP packets from here as we are potentially in a bh. | ||
211 | * So we have to queue them and wake up session thread which is sleeping | ||
212 | * on the sk->sk_sleep. | ||
213 | */ | ||
214 | dev->trans_start = jiffies; | ||
215 | skb_queue_tail(&sk->sk_write_queue, skb); | ||
216 | wake_up_interruptible(sk->sk_sleep); | ||
217 | |||
218 | if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) { | ||
219 | BT_DBG("tx queue is full"); | ||
220 | |||
221 | /* Stop queuing. | ||
222 | * Session thread will do netif_wake_queue() */ | ||
223 | netif_stop_queue(dev); | ||
224 | } | ||
225 | |||
226 | return 0; | ||
227 | } | ||
228 | |||
229 | void bnep_net_setup(struct net_device *dev) | ||
230 | { | ||
231 | |||
232 | memset(dev->broadcast, 0xff, ETH_ALEN); | ||
233 | dev->addr_len = ETH_ALEN; | ||
234 | |||
235 | ether_setup(dev); | ||
236 | |||
237 | dev->open = bnep_net_open; | ||
238 | dev->stop = bnep_net_close; | ||
239 | dev->hard_start_xmit = bnep_net_xmit; | ||
240 | dev->get_stats = bnep_net_get_stats; | ||
241 | dev->do_ioctl = bnep_net_ioctl; | ||
242 | dev->set_mac_address = bnep_net_set_mac_addr; | ||
243 | dev->set_multicast_list = bnep_net_set_mc_list; | ||
244 | |||
245 | dev->watchdog_timeo = HZ * 2; | ||
246 | dev->tx_timeout = bnep_net_timeout; | ||
247 | } | ||
diff --git a/net/bluetooth/bnep/sock.c b/net/bluetooth/bnep/sock.c new file mode 100644 index 000000000000..9a8d99a39b6d --- /dev/null +++ b/net/bluetooth/bnep/sock.c | |||
@@ -0,0 +1,237 @@ | |||
1 | /* | ||
2 | BNEP implementation for Linux Bluetooth stack (BlueZ). | ||
3 | Copyright (C) 2001-2002 Inventel Systemes | ||
4 | Written 2001-2002 by | ||
5 | David Libault <david.libault@inventel.fr> | ||
6 | |||
7 | Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com> | ||
8 | |||
9 | This program is free software; you can redistribute it and/or modify | ||
10 | it under the terms of the GNU General Public License version 2 as | ||
11 | published by the Free Software Foundation; | ||
12 | |||
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS | ||
14 | OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | ||
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. | ||
16 | IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY | ||
17 | CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES | ||
18 | WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | ||
19 | ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | ||
20 | OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | ||
21 | |||
22 | ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, | ||
23 | COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS | ||
24 | SOFTWARE IS DISCLAIMED. | ||
25 | */ | ||
26 | |||
27 | /* | ||
28 | * $Id: sock.c,v 1.4 2002/08/04 21:23:58 maxk Exp $ | ||
29 | */ | ||
30 | |||
31 | #include <linux/config.h> | ||
32 | #include <linux/module.h> | ||
33 | |||
34 | #include <linux/types.h> | ||
35 | #include <linux/errno.h> | ||
36 | #include <linux/kernel.h> | ||
37 | #include <linux/major.h> | ||
38 | #include <linux/sched.h> | ||
39 | #include <linux/slab.h> | ||
40 | #include <linux/poll.h> | ||
41 | #include <linux/fcntl.h> | ||
42 | #include <linux/skbuff.h> | ||
43 | #include <linux/socket.h> | ||
44 | #include <linux/ioctl.h> | ||
45 | #include <linux/file.h> | ||
46 | #include <linux/init.h> | ||
47 | #include <net/sock.h> | ||
48 | |||
49 | #include <asm/system.h> | ||
50 | #include <asm/uaccess.h> | ||
51 | |||
52 | #include "bnep.h" | ||
53 | |||
54 | #ifndef CONFIG_BT_BNEP_DEBUG | ||
55 | #undef BT_DBG | ||
56 | #define BT_DBG( A... ) | ||
57 | #endif | ||
58 | |||
59 | static int bnep_sock_release(struct socket *sock) | ||
60 | { | ||
61 | struct sock *sk = sock->sk; | ||
62 | |||
63 | BT_DBG("sock %p sk %p", sock, sk); | ||
64 | |||
65 | if (!sk) | ||
66 | return 0; | ||
67 | |||
68 | sock_orphan(sk); | ||
69 | sock_put(sk); | ||
70 | return 0; | ||
71 | } | ||
72 | |||
73 | static int bnep_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) | ||
74 | { | ||
75 | struct bnep_connlist_req cl; | ||
76 | struct bnep_connadd_req ca; | ||
77 | struct bnep_conndel_req cd; | ||
78 | struct bnep_conninfo ci; | ||
79 | struct socket *nsock; | ||
80 | void __user *argp = (void __user *)arg; | ||
81 | int err; | ||
82 | |||
83 | BT_DBG("cmd %x arg %lx", cmd, arg); | ||
84 | |||
85 | switch (cmd) { | ||
86 | case BNEPCONNADD: | ||
87 | if (!capable(CAP_NET_ADMIN)) | ||
88 | return -EACCES; | ||
89 | |||
90 | if (copy_from_user(&ca, argp, sizeof(ca))) | ||
91 | return -EFAULT; | ||
92 | |||
93 | nsock = sockfd_lookup(ca.sock, &err); | ||
94 | if (!nsock) | ||
95 | return err; | ||
96 | |||
97 | if (nsock->sk->sk_state != BT_CONNECTED) { | ||
98 | fput(nsock->file); | ||
99 | return -EBADFD; | ||
100 | } | ||
101 | |||
102 | err = bnep_add_connection(&ca, nsock); | ||
103 | if (!err) { | ||
104 | if (copy_to_user(argp, &ca, sizeof(ca))) | ||
105 | err = -EFAULT; | ||
106 | } else | ||
107 | fput(nsock->file); | ||
108 | |||
109 | return err; | ||
110 | |||
111 | case BNEPCONNDEL: | ||
112 | if (!capable(CAP_NET_ADMIN)) | ||
113 | return -EACCES; | ||
114 | |||
115 | if (copy_from_user(&cd, argp, sizeof(cd))) | ||
116 | return -EFAULT; | ||
117 | |||
118 | return bnep_del_connection(&cd); | ||
119 | |||
120 | case BNEPGETCONNLIST: | ||
121 | if (copy_from_user(&cl, argp, sizeof(cl))) | ||
122 | return -EFAULT; | ||
123 | |||
124 | if (cl.cnum <= 0) | ||
125 | return -EINVAL; | ||
126 | |||
127 | err = bnep_get_connlist(&cl); | ||
128 | if (!err && copy_to_user(argp, &cl, sizeof(cl))) | ||
129 | return -EFAULT; | ||
130 | |||
131 | return err; | ||
132 | |||
133 | case BNEPGETCONNINFO: | ||
134 | if (copy_from_user(&ci, argp, sizeof(ci))) | ||
135 | return -EFAULT; | ||
136 | |||
137 | err = bnep_get_conninfo(&ci); | ||
138 | if (!err && copy_to_user(argp, &ci, sizeof(ci))) | ||
139 | return -EFAULT; | ||
140 | |||
141 | return err; | ||
142 | |||
143 | default: | ||
144 | return -EINVAL; | ||
145 | } | ||
146 | |||
147 | return 0; | ||
148 | } | ||
149 | |||
150 | static struct proto_ops bnep_sock_ops = { | ||
151 | .family = PF_BLUETOOTH, | ||
152 | .owner = THIS_MODULE, | ||
153 | .release = bnep_sock_release, | ||
154 | .ioctl = bnep_sock_ioctl, | ||
155 | .bind = sock_no_bind, | ||
156 | .getname = sock_no_getname, | ||
157 | .sendmsg = sock_no_sendmsg, | ||
158 | .recvmsg = sock_no_recvmsg, | ||
159 | .poll = sock_no_poll, | ||
160 | .listen = sock_no_listen, | ||
161 | .shutdown = sock_no_shutdown, | ||
162 | .setsockopt = sock_no_setsockopt, | ||
163 | .getsockopt = sock_no_getsockopt, | ||
164 | .connect = sock_no_connect, | ||
165 | .socketpair = sock_no_socketpair, | ||
166 | .accept = sock_no_accept, | ||
167 | .mmap = sock_no_mmap | ||
168 | }; | ||
169 | |||
170 | static struct proto bnep_proto = { | ||
171 | .name = "BNEP", | ||
172 | .owner = THIS_MODULE, | ||
173 | .obj_size = sizeof(struct bt_sock) | ||
174 | }; | ||
175 | |||
176 | static int bnep_sock_create(struct socket *sock, int protocol) | ||
177 | { | ||
178 | struct sock *sk; | ||
179 | |||
180 | BT_DBG("sock %p", sock); | ||
181 | |||
182 | if (sock->type != SOCK_RAW) | ||
183 | return -ESOCKTNOSUPPORT; | ||
184 | |||
185 | sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &bnep_proto, 1); | ||
186 | if (!sk) | ||
187 | return -ENOMEM; | ||
188 | |||
189 | sock_init_data(sock, sk); | ||
190 | |||
191 | sock->ops = &bnep_sock_ops; | ||
192 | |||
193 | sock->state = SS_UNCONNECTED; | ||
194 | |||
195 | sock_reset_flag(sk, SOCK_ZAPPED); | ||
196 | |||
197 | sk->sk_protocol = protocol; | ||
198 | sk->sk_state = BT_OPEN; | ||
199 | |||
200 | return 0; | ||
201 | } | ||
202 | |||
203 | static struct net_proto_family bnep_sock_family_ops = { | ||
204 | .family = PF_BLUETOOTH, | ||
205 | .owner = THIS_MODULE, | ||
206 | .create = bnep_sock_create | ||
207 | }; | ||
208 | |||
209 | int __init bnep_sock_init(void) | ||
210 | { | ||
211 | int err; | ||
212 | |||
213 | err = proto_register(&bnep_proto, 0); | ||
214 | if (err < 0) | ||
215 | return err; | ||
216 | |||
217 | err = bt_sock_register(BTPROTO_BNEP, &bnep_sock_family_ops); | ||
218 | if (err < 0) | ||
219 | goto error; | ||
220 | |||
221 | return 0; | ||
222 | |||
223 | error: | ||
224 | BT_ERR("Can't register BNEP socket"); | ||
225 | proto_unregister(&bnep_proto); | ||
226 | return err; | ||
227 | } | ||
228 | |||
229 | int __exit bnep_sock_cleanup(void) | ||
230 | { | ||
231 | if (bt_sock_unregister(BTPROTO_BNEP) < 0) | ||
232 | BT_ERR("Can't unregister BNEP socket"); | ||
233 | |||
234 | proto_unregister(&bnep_proto); | ||
235 | |||
236 | return 0; | ||
237 | } | ||