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