~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/batman-adv/icmp_socket.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* Copyright (C) 2007-2016  B.A.T.M.A.N. contributors:
  2  *
  3  * Marek Lindner
  4  *
  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.
  8  *
  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.
 13  *
 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/>.
 16  */
 17 
 18 #include "icmp_socket.h"
 19 #include "main.h"
 20 
 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>
 28 #include <linux/fs.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/stat.h>
 42 #include <linux/stddef.h>
 43 #include <linux/string.h>
 44 #include <linux/uaccess.h>
 45 #include <linux/wait.h>
 46 
 47 #include "hard-interface.h"
 48 #include "log.h"
 49 #include "originator.h"
 50 #include "packet.h"
 51 #include "send.h"
 52 
 53 static struct batadv_socket_client *batadv_socket_client_hash[256];
 54 
 55 static void batadv_socket_add_packet(struct batadv_socket_client *socket_client,
 56                                      struct batadv_icmp_header *icmph,
 57                                      size_t icmp_len);
 58 
 59 void batadv_socket_init(void)
 60 {
 61         memset(batadv_socket_client_hash, 0, sizeof(batadv_socket_client_hash));
 62 }
 63 
 64 static int batadv_socket_open(struct inode *inode, struct file *file)
 65 {
 66         unsigned int i;
 67         struct batadv_socket_client *socket_client;
 68 
 69         if (!try_module_get(THIS_MODULE))
 70                 return -EBUSY;
 71 
 72         nonseekable_open(inode, file);
 73 
 74         socket_client = kmalloc(sizeof(*socket_client), GFP_KERNEL);
 75         if (!socket_client) {
 76                 module_put(THIS_MODULE);
 77                 return -ENOMEM;
 78         }
 79 
 80         for (i = 0; i < ARRAY_SIZE(batadv_socket_client_hash); i++) {
 81                 if (!batadv_socket_client_hash[i]) {
 82                         batadv_socket_client_hash[i] = socket_client;
 83                         break;
 84                 }
 85         }
 86 
 87         if (i == ARRAY_SIZE(batadv_socket_client_hash)) {
 88                 pr_err("Error - can't add another packet client: maximum number of clients reached\n");
 89                 kfree(socket_client);
 90                 module_put(THIS_MODULE);
 91                 return -EXFULL;
 92         }
 93 
 94         INIT_LIST_HEAD(&socket_client->queue_list);
 95         socket_client->queue_len = 0;
 96         socket_client->index = i;
 97         socket_client->bat_priv = inode->i_private;
 98         spin_lock_init(&socket_client->lock);
 99         init_waitqueue_head(&socket_client->queue_wait);
100 
101         file->private_data = socket_client;
102 
103         return 0;
104 }
105 
106 static int batadv_socket_release(struct inode *inode, struct file *file)
107 {
108         struct batadv_socket_client *client = file->private_data;
109         struct batadv_socket_packet *packet, *tmp;
110 
111         spin_lock_bh(&client->lock);
112 
113         /* for all packets in the queue ... */
114         list_for_each_entry_safe(packet, tmp, &client->queue_list, list) {
115                 list_del(&packet->list);
116                 kfree(packet);
117         }
118 
119         batadv_socket_client_hash[client->index] = NULL;
120         spin_unlock_bh(&client->lock);
121 
122         kfree(client);
123         module_put(THIS_MODULE);
124 
125         return 0;
126 }
127 
128 static ssize_t batadv_socket_read(struct file *file, char __user *buf,
129                                   size_t count, loff_t *ppos)
130 {
131         struct batadv_socket_client *socket_client = file->private_data;
132         struct batadv_socket_packet *socket_packet;
133         size_t packet_len;
134         int error;
135 
136         if ((file->f_flags & O_NONBLOCK) && (socket_client->queue_len == 0))
137                 return -EAGAIN;
138 
139         if ((!buf) || (count < sizeof(struct batadv_icmp_packet)))
140                 return -EINVAL;
141 
142         if (!access_ok(VERIFY_WRITE, buf, count))
143                 return -EFAULT;
144 
145         error = wait_event_interruptible(socket_client->queue_wait,
146                                          socket_client->queue_len);
147 
148         if (error)
149                 return error;
150 
151         spin_lock_bh(&socket_client->lock);
152 
153         socket_packet = list_first_entry(&socket_client->queue_list,
154                                          struct batadv_socket_packet, list);
155         list_del(&socket_packet->list);
156         socket_client->queue_len--;
157 
158         spin_unlock_bh(&socket_client->lock);
159 
160         packet_len = min(count, socket_packet->icmp_len);
161         error = copy_to_user(buf, &socket_packet->icmp_packet, packet_len);
162 
163         kfree(socket_packet);
164 
165         if (error)
166                 return -EFAULT;
167 
168         return packet_len;
169 }
170 
171 static ssize_t batadv_socket_write(struct file *file, const char __user *buff,
172                                    size_t len, loff_t *off)
173 {
174         struct batadv_socket_client *socket_client = file->private_data;
175         struct batadv_priv *bat_priv = socket_client->bat_priv;
176         struct batadv_hard_iface *primary_if = NULL;
177         struct sk_buff *skb;
178         struct batadv_icmp_packet_rr *icmp_packet_rr;
179         struct batadv_icmp_header *icmp_header;
180         struct batadv_orig_node *orig_node = NULL;
181         struct batadv_neigh_node *neigh_node = NULL;
182         size_t packet_len = sizeof(struct batadv_icmp_packet);
183         u8 *addr;
184 
185         if (len < sizeof(struct batadv_icmp_header)) {
186                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
187                            "Error - can't send packet from char device: invalid packet size\n");
188                 return -EINVAL;
189         }
190 
191         primary_if = batadv_primary_if_get_selected(bat_priv);
192 
193         if (!primary_if) {
194                 len = -EFAULT;
195                 goto out;
196         }
197 
198         if (len >= BATADV_ICMP_MAX_PACKET_SIZE)
199                 packet_len = BATADV_ICMP_MAX_PACKET_SIZE;
200         else
201                 packet_len = len;
202 
203         skb = netdev_alloc_skb_ip_align(NULL, packet_len + ETH_HLEN);
204         if (!skb) {
205                 len = -ENOMEM;
206                 goto out;
207         }
208 
209         skb->priority = TC_PRIO_CONTROL;
210         skb_reserve(skb, ETH_HLEN);
211         icmp_header = (struct batadv_icmp_header *)skb_put(skb, packet_len);
212 
213         if (copy_from_user(icmp_header, buff, packet_len)) {
214                 len = -EFAULT;
215                 goto free_skb;
216         }
217 
218         if (icmp_header->packet_type != BATADV_ICMP) {
219                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
220                            "Error - can't send packet from char device: got bogus packet type (expected: BAT_ICMP)\n");
221                 len = -EINVAL;
222                 goto free_skb;
223         }
224 
225         switch (icmp_header->msg_type) {
226         case BATADV_ECHO_REQUEST:
227                 if (len < sizeof(struct batadv_icmp_packet)) {
228                         batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
229                                    "Error - can't send packet from char device: invalid packet size\n");
230                         len = -EINVAL;
231                         goto free_skb;
232                 }
233 
234                 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
235                         goto dst_unreach;
236 
237                 orig_node = batadv_orig_hash_find(bat_priv, icmp_header->dst);
238                 if (!orig_node)
239                         goto dst_unreach;
240 
241                 neigh_node = batadv_orig_router_get(orig_node,
242                                                     BATADV_IF_DEFAULT);
243                 if (!neigh_node)
244                         goto dst_unreach;
245 
246                 if (!neigh_node->if_incoming)
247                         goto dst_unreach;
248 
249                 if (neigh_node->if_incoming->if_status != BATADV_IF_ACTIVE)
250                         goto dst_unreach;
251 
252                 icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmp_header;
253                 if (packet_len == sizeof(*icmp_packet_rr)) {
254                         addr = neigh_node->if_incoming->net_dev->dev_addr;
255                         ether_addr_copy(icmp_packet_rr->rr[0], addr);
256                 }
257 
258                 break;
259         default:
260                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
261                            "Error - can't send packet from char device: got unknown message type\n");
262                 len = -EINVAL;
263                 goto free_skb;
264         }
265 
266         icmp_header->uid = socket_client->index;
267 
268         if (icmp_header->version != BATADV_COMPAT_VERSION) {
269                 icmp_header->msg_type = BATADV_PARAMETER_PROBLEM;
270                 icmp_header->version = BATADV_COMPAT_VERSION;
271                 batadv_socket_add_packet(socket_client, icmp_header,
272                                          packet_len);
273                 goto free_skb;
274         }
275 
276         ether_addr_copy(icmp_header->orig, primary_if->net_dev->dev_addr);
277 
278         batadv_send_unicast_skb(skb, neigh_node);
279         goto out;
280 
281 dst_unreach:
282         icmp_header->msg_type = BATADV_DESTINATION_UNREACHABLE;
283         batadv_socket_add_packet(socket_client, icmp_header, packet_len);
284 free_skb:
285         kfree_skb(skb);
286 out:
287         if (primary_if)
288                 batadv_hardif_put(primary_if);
289         if (neigh_node)
290                 batadv_neigh_node_put(neigh_node);
291         if (orig_node)
292                 batadv_orig_node_put(orig_node);
293         return len;
294 }
295 
296 static unsigned int batadv_socket_poll(struct file *file, poll_table *wait)
297 {
298         struct batadv_socket_client *socket_client = file->private_data;
299 
300         poll_wait(file, &socket_client->queue_wait, wait);
301 
302         if (socket_client->queue_len > 0)
303                 return POLLIN | POLLRDNORM;
304 
305         return 0;
306 }
307 
308 static const struct file_operations batadv_fops = {
309         .owner = THIS_MODULE,
310         .open = batadv_socket_open,
311         .release = batadv_socket_release,
312         .read = batadv_socket_read,
313         .write = batadv_socket_write,
314         .poll = batadv_socket_poll,
315         .llseek = no_llseek,
316 };
317 
318 int batadv_socket_setup(struct batadv_priv *bat_priv)
319 {
320         struct dentry *d;
321 
322         if (!bat_priv->debug_dir)
323                 goto err;
324 
325         d = debugfs_create_file(BATADV_ICMP_SOCKET, S_IFREG | S_IWUSR | S_IRUSR,
326                                 bat_priv->debug_dir, bat_priv, &batadv_fops);
327         if (!d)
328                 goto err;
329 
330         return 0;
331 
332 err:
333         return -ENOMEM;
334 }
335 
336 /**
337  * batadv_socket_add_packet - schedule an icmp packet to be sent to
338  *  userspace on an icmp socket.
339  * @socket_client: the socket this packet belongs to
340  * @icmph: pointer to the header of the icmp packet
341  * @icmp_len: total length of the icmp packet
342  */
343 static void batadv_socket_add_packet(struct batadv_socket_client *socket_client,
344                                      struct batadv_icmp_header *icmph,
345                                      size_t icmp_len)
346 {
347         struct batadv_socket_packet *socket_packet;
348         size_t len;
349 
350         socket_packet = kmalloc(sizeof(*socket_packet), GFP_ATOMIC);
351 
352         if (!socket_packet)
353                 return;
354 
355         len = icmp_len;
356         /* check the maximum length before filling the buffer */
357         if (len > sizeof(socket_packet->icmp_packet))
358                 len = sizeof(socket_packet->icmp_packet);
359 
360         INIT_LIST_HEAD(&socket_packet->list);
361         memcpy(&socket_packet->icmp_packet, icmph, len);
362         socket_packet->icmp_len = len;
363 
364         spin_lock_bh(&socket_client->lock);
365 
366         /* while waiting for the lock the socket_client could have been
367          * deleted
368          */
369         if (!batadv_socket_client_hash[icmph->uid]) {
370                 spin_unlock_bh(&socket_client->lock);
371                 kfree(socket_packet);
372                 return;
373         }
374 
375         list_add_tail(&socket_packet->list, &socket_client->queue_list);
376         socket_client->queue_len++;
377 
378         if (socket_client->queue_len > 100) {
379                 socket_packet = list_first_entry(&socket_client->queue_list,
380                                                  struct batadv_socket_packet,
381                                                  list);
382 
383                 list_del(&socket_packet->list);
384                 kfree(socket_packet);
385                 socket_client->queue_len--;
386         }
387 
388         spin_unlock_bh(&socket_client->lock);
389 
390         wake_up(&socket_client->queue_wait);
391 }
392 
393 /**
394  * batadv_socket_receive_packet - schedule an icmp packet to be received
395  *  locally and sent to userspace.
396  * @icmph: pointer to the header of the icmp packet
397  * @icmp_len: total length of the icmp packet
398  */
399 void batadv_socket_receive_packet(struct batadv_icmp_header *icmph,
400                                   size_t icmp_len)
401 {
402         struct batadv_socket_client *hash;
403 
404         hash = batadv_socket_client_hash[icmph->uid];
405         if (hash)
406                 batadv_socket_add_packet(hash, icmph, icmp_len);
407 }
408 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp