1 /* Copyright (C) 2007-2017 B.A.T.M.A.N. contributors:
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of version 2 of the GNU General Public
7 * License as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 #include "icmp_socket.h"
21 #include <linux/atomic.h>
22 #include <linux/compiler.h>
23 #include <linux/debugfs.h>
24 #include <linux/errno.h>
25 #include <linux/etherdevice.h>
26 #include <linux/export.h>
27 #include <linux/fcntl.h>
29 #include <linux/if_ether.h>
30 #include <linux/kernel.h>
31 #include <linux/list.h>
32 #include <linux/module.h>
33 #include <linux/netdevice.h>
34 #include <linux/pkt_sched.h>
35 #include <linux/poll.h>
36 #include <linux/printk.h>
37 #include <linux/sched.h> /* for linux/wait.h */
38 #include <linux/skbuff.h>
39 #include <linux/slab.h>
40 #include <linux/spinlock.h>
41 #include <linux/stddef.h>
42 #include <linux/string.h>
43 #include <linux/uaccess.h>
44 #include <linux/wait.h>
46 #include "hard-interface.h"
48 #include "originator.h"
52 static struct batadv_socket_client
*batadv_socket_client_hash
[256];
54 static void batadv_socket_add_packet(struct batadv_socket_client
*socket_client
,
55 struct batadv_icmp_header
*icmph
,
58 void batadv_socket_init(void)
60 memset(batadv_socket_client_hash
, 0, sizeof(batadv_socket_client_hash
));
63 static int batadv_socket_open(struct inode
*inode
, struct file
*file
)
66 struct batadv_socket_client
*socket_client
;
68 if (!try_module_get(THIS_MODULE
))
71 nonseekable_open(inode
, file
);
73 socket_client
= kmalloc(sizeof(*socket_client
), GFP_KERNEL
);
75 module_put(THIS_MODULE
);
79 for (i
= 0; i
< ARRAY_SIZE(batadv_socket_client_hash
); i
++) {
80 if (!batadv_socket_client_hash
[i
]) {
81 batadv_socket_client_hash
[i
] = socket_client
;
86 if (i
== ARRAY_SIZE(batadv_socket_client_hash
)) {
87 pr_err("Error - can't add another packet client: maximum number of clients reached\n");
89 module_put(THIS_MODULE
);
93 INIT_LIST_HEAD(&socket_client
->queue_list
);
94 socket_client
->queue_len
= 0;
95 socket_client
->index
= i
;
96 socket_client
->bat_priv
= inode
->i_private
;
97 spin_lock_init(&socket_client
->lock
);
98 init_waitqueue_head(&socket_client
->queue_wait
);
100 file
->private_data
= socket_client
;
105 static int batadv_socket_release(struct inode
*inode
, struct file
*file
)
107 struct batadv_socket_client
*client
= file
->private_data
;
108 struct batadv_socket_packet
*packet
, *tmp
;
110 spin_lock_bh(&client
->lock
);
112 /* for all packets in the queue ... */
113 list_for_each_entry_safe(packet
, tmp
, &client
->queue_list
, list
) {
114 list_del(&packet
->list
);
118 batadv_socket_client_hash
[client
->index
] = NULL
;
119 spin_unlock_bh(&client
->lock
);
122 module_put(THIS_MODULE
);
127 static ssize_t
batadv_socket_read(struct file
*file
, char __user
*buf
,
128 size_t count
, loff_t
*ppos
)
130 struct batadv_socket_client
*socket_client
= file
->private_data
;
131 struct batadv_socket_packet
*socket_packet
;
135 if ((file
->f_flags
& O_NONBLOCK
) && (socket_client
->queue_len
== 0))
138 if ((!buf
) || (count
< sizeof(struct batadv_icmp_packet
)))
141 if (!access_ok(VERIFY_WRITE
, buf
, count
))
144 error
= wait_event_interruptible(socket_client
->queue_wait
,
145 socket_client
->queue_len
);
150 spin_lock_bh(&socket_client
->lock
);
152 socket_packet
= list_first_entry(&socket_client
->queue_list
,
153 struct batadv_socket_packet
, list
);
154 list_del(&socket_packet
->list
);
155 socket_client
->queue_len
--;
157 spin_unlock_bh(&socket_client
->lock
);
159 packet_len
= min(count
, socket_packet
->icmp_len
);
160 error
= copy_to_user(buf
, &socket_packet
->icmp_packet
, packet_len
);
162 kfree(socket_packet
);
170 static ssize_t
batadv_socket_write(struct file
*file
, const char __user
*buff
,
171 size_t len
, loff_t
*off
)
173 struct batadv_socket_client
*socket_client
= file
->private_data
;
174 struct batadv_priv
*bat_priv
= socket_client
->bat_priv
;
175 struct batadv_hard_iface
*primary_if
= NULL
;
177 struct batadv_icmp_packet_rr
*icmp_packet_rr
;
178 struct batadv_icmp_header
*icmp_header
;
179 struct batadv_orig_node
*orig_node
= NULL
;
180 struct batadv_neigh_node
*neigh_node
= NULL
;
181 size_t packet_len
= sizeof(struct batadv_icmp_packet
);
184 if (len
< sizeof(struct batadv_icmp_header
)) {
185 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
186 "Error - can't send packet from char device: invalid packet size\n");
190 primary_if
= batadv_primary_if_get_selected(bat_priv
);
197 if (len
>= BATADV_ICMP_MAX_PACKET_SIZE
)
198 packet_len
= BATADV_ICMP_MAX_PACKET_SIZE
;
202 skb
= netdev_alloc_skb_ip_align(NULL
, packet_len
+ ETH_HLEN
);
208 skb
->priority
= TC_PRIO_CONTROL
;
209 skb_reserve(skb
, ETH_HLEN
);
210 icmp_header
= skb_put(skb
, packet_len
);
212 if (copy_from_user(icmp_header
, buff
, packet_len
)) {
217 if (icmp_header
->packet_type
!= BATADV_ICMP
) {
218 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
219 "Error - can't send packet from char device: got bogus packet type (expected: BAT_ICMP)\n");
224 switch (icmp_header
->msg_type
) {
225 case BATADV_ECHO_REQUEST
:
226 if (len
< sizeof(struct batadv_icmp_packet
)) {
227 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
228 "Error - can't send packet from char device: invalid packet size\n");
233 if (atomic_read(&bat_priv
->mesh_state
) != BATADV_MESH_ACTIVE
)
236 orig_node
= batadv_orig_hash_find(bat_priv
, icmp_header
->dst
);
240 neigh_node
= batadv_orig_router_get(orig_node
,
245 if (!neigh_node
->if_incoming
)
248 if (neigh_node
->if_incoming
->if_status
!= BATADV_IF_ACTIVE
)
251 icmp_packet_rr
= (struct batadv_icmp_packet_rr
*)icmp_header
;
252 if (packet_len
== sizeof(*icmp_packet_rr
)) {
253 addr
= neigh_node
->if_incoming
->net_dev
->dev_addr
;
254 ether_addr_copy(icmp_packet_rr
->rr
[0], addr
);
259 batadv_dbg(BATADV_DBG_BATMAN
, bat_priv
,
260 "Error - can't send packet from char device: got unknown message type\n");
265 icmp_header
->uid
= socket_client
->index
;
267 if (icmp_header
->version
!= BATADV_COMPAT_VERSION
) {
268 icmp_header
->msg_type
= BATADV_PARAMETER_PROBLEM
;
269 icmp_header
->version
= BATADV_COMPAT_VERSION
;
270 batadv_socket_add_packet(socket_client
, icmp_header
,
275 ether_addr_copy(icmp_header
->orig
, primary_if
->net_dev
->dev_addr
);
277 batadv_send_unicast_skb(skb
, neigh_node
);
281 icmp_header
->msg_type
= BATADV_DESTINATION_UNREACHABLE
;
282 batadv_socket_add_packet(socket_client
, icmp_header
, packet_len
);
287 batadv_hardif_put(primary_if
);
289 batadv_neigh_node_put(neigh_node
);
291 batadv_orig_node_put(orig_node
);
295 static unsigned int batadv_socket_poll(struct file
*file
, poll_table
*wait
)
297 struct batadv_socket_client
*socket_client
= file
->private_data
;
299 poll_wait(file
, &socket_client
->queue_wait
, wait
);
301 if (socket_client
->queue_len
> 0)
302 return POLLIN
| POLLRDNORM
;
307 static const struct file_operations batadv_fops
= {
308 .owner
= THIS_MODULE
,
309 .open
= batadv_socket_open
,
310 .release
= batadv_socket_release
,
311 .read
= batadv_socket_read
,
312 .write
= batadv_socket_write
,
313 .poll
= batadv_socket_poll
,
317 int batadv_socket_setup(struct batadv_priv
*bat_priv
)
321 if (!bat_priv
->debug_dir
)
324 d
= debugfs_create_file(BATADV_ICMP_SOCKET
, 0600, bat_priv
->debug_dir
,
325 bat_priv
, &batadv_fops
);
336 * batadv_socket_add_packet - schedule an icmp packet to be sent to
337 * userspace on an icmp socket.
338 * @socket_client: the socket this packet belongs to
339 * @icmph: pointer to the header of the icmp packet
340 * @icmp_len: total length of the icmp packet
342 static void batadv_socket_add_packet(struct batadv_socket_client
*socket_client
,
343 struct batadv_icmp_header
*icmph
,
346 struct batadv_socket_packet
*socket_packet
;
349 socket_packet
= kmalloc(sizeof(*socket_packet
), GFP_ATOMIC
);
355 /* check the maximum length before filling the buffer */
356 if (len
> sizeof(socket_packet
->icmp_packet
))
357 len
= sizeof(socket_packet
->icmp_packet
);
359 INIT_LIST_HEAD(&socket_packet
->list
);
360 memcpy(&socket_packet
->icmp_packet
, icmph
, len
);
361 socket_packet
->icmp_len
= len
;
363 spin_lock_bh(&socket_client
->lock
);
365 /* while waiting for the lock the socket_client could have been
368 if (!batadv_socket_client_hash
[icmph
->uid
]) {
369 spin_unlock_bh(&socket_client
->lock
);
370 kfree(socket_packet
);
374 list_add_tail(&socket_packet
->list
, &socket_client
->queue_list
);
375 socket_client
->queue_len
++;
377 if (socket_client
->queue_len
> 100) {
378 socket_packet
= list_first_entry(&socket_client
->queue_list
,
379 struct batadv_socket_packet
,
382 list_del(&socket_packet
->list
);
383 kfree(socket_packet
);
384 socket_client
->queue_len
--;
387 spin_unlock_bh(&socket_client
->lock
);
389 wake_up(&socket_client
->queue_wait
);
393 * batadv_socket_receive_packet - schedule an icmp packet to be received
394 * locally and sent to userspace.
395 * @icmph: pointer to the header of the icmp packet
396 * @icmp_len: total length of the icmp packet
398 void batadv_socket_receive_packet(struct batadv_icmp_header
*icmph
,
401 struct batadv_socket_client
*hash
;
403 hash
= batadv_socket_client_hash
[icmph
->uid
];
405 batadv_socket_add_packet(hash
, icmph
, icmp_len
);