forked from Minki/linux
3bcacd1e06
When calling debugfs functions, there is no need to ever check the return value. The function can work or not, but the code logic should never do something different based on this. Because we don't care if debugfs works or not, this trickles back a bit so we can clean things up by making some functions return void instead of an error value that is never going to fail. Cc: Marek Lindner <mareklindner@neomailbox.ch> Cc: Simon Wunderlich <sw@simonwunderlich.de> Cc: Antonio Quartulli <a@unstable.cc> Cc: "David S. Miller" <davem@davemloft.net> Cc: b.a.t.m.a.n@lists.open-mesh.org Cc: netdev@vger.kernel.org Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> [sven@narfation.org: drop unused variables] Signed-off-by: Sven Eckelmann <sven@narfation.org> Signed-off-by: Simon Wunderlich <sw@simonwunderlich.de>
396 lines
10 KiB
C
396 lines
10 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/* Copyright (C) 2007-2019 B.A.T.M.A.N. contributors:
|
|
*
|
|
* Marek Lindner
|
|
*/
|
|
|
|
#include "icmp_socket.h"
|
|
#include "main.h"
|
|
|
|
#include <linux/atomic.h>
|
|
#include <linux/compiler.h>
|
|
#include <linux/debugfs.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/eventpoll.h>
|
|
#include <linux/export.h>
|
|
#include <linux/fcntl.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/gfp.h>
|
|
#include <linux/if_ether.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/list.h>
|
|
#include <linux/module.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/pkt_sched.h>
|
|
#include <linux/poll.h>
|
|
#include <linux/printk.h>
|
|
#include <linux/sched.h> /* for linux/wait.h */
|
|
#include <linux/skbuff.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/stddef.h>
|
|
#include <linux/string.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/wait.h>
|
|
#include <uapi/linux/batadv_packet.h>
|
|
|
|
#include "debugfs.h"
|
|
#include "hard-interface.h"
|
|
#include "log.h"
|
|
#include "originator.h"
|
|
#include "send.h"
|
|
|
|
static struct batadv_socket_client *batadv_socket_client_hash[256];
|
|
|
|
static void batadv_socket_add_packet(struct batadv_socket_client *socket_client,
|
|
struct batadv_icmp_header *icmph,
|
|
size_t icmp_len);
|
|
|
|
/**
|
|
* batadv_socket_init() - Initialize soft interface independent socket data
|
|
*/
|
|
void batadv_socket_init(void)
|
|
{
|
|
memset(batadv_socket_client_hash, 0, sizeof(batadv_socket_client_hash));
|
|
}
|
|
|
|
static int batadv_socket_open(struct inode *inode, struct file *file)
|
|
{
|
|
unsigned int i;
|
|
struct batadv_socket_client *socket_client;
|
|
|
|
if (!try_module_get(THIS_MODULE))
|
|
return -EBUSY;
|
|
|
|
batadv_debugfs_deprecated(file, "");
|
|
|
|
stream_open(inode, file);
|
|
|
|
socket_client = kmalloc(sizeof(*socket_client), GFP_KERNEL);
|
|
if (!socket_client) {
|
|
module_put(THIS_MODULE);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
for (i = 0; i < ARRAY_SIZE(batadv_socket_client_hash); i++) {
|
|
if (!batadv_socket_client_hash[i]) {
|
|
batadv_socket_client_hash[i] = socket_client;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (i == ARRAY_SIZE(batadv_socket_client_hash)) {
|
|
pr_err("Error - can't add another packet client: maximum number of clients reached\n");
|
|
kfree(socket_client);
|
|
module_put(THIS_MODULE);
|
|
return -EXFULL;
|
|
}
|
|
|
|
INIT_LIST_HEAD(&socket_client->queue_list);
|
|
socket_client->queue_len = 0;
|
|
socket_client->index = i;
|
|
socket_client->bat_priv = inode->i_private;
|
|
spin_lock_init(&socket_client->lock);
|
|
init_waitqueue_head(&socket_client->queue_wait);
|
|
|
|
file->private_data = socket_client;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int batadv_socket_release(struct inode *inode, struct file *file)
|
|
{
|
|
struct batadv_socket_client *client = file->private_data;
|
|
struct batadv_socket_packet *packet, *tmp;
|
|
|
|
spin_lock_bh(&client->lock);
|
|
|
|
/* for all packets in the queue ... */
|
|
list_for_each_entry_safe(packet, tmp, &client->queue_list, list) {
|
|
list_del(&packet->list);
|
|
kfree(packet);
|
|
}
|
|
|
|
batadv_socket_client_hash[client->index] = NULL;
|
|
spin_unlock_bh(&client->lock);
|
|
|
|
kfree(client);
|
|
module_put(THIS_MODULE);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static ssize_t batadv_socket_read(struct file *file, char __user *buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct batadv_socket_client *socket_client = file->private_data;
|
|
struct batadv_socket_packet *socket_packet;
|
|
size_t packet_len;
|
|
int error;
|
|
|
|
if ((file->f_flags & O_NONBLOCK) && socket_client->queue_len == 0)
|
|
return -EAGAIN;
|
|
|
|
if (!buf || count < sizeof(struct batadv_icmp_packet))
|
|
return -EINVAL;
|
|
|
|
if (!access_ok(buf, count))
|
|
return -EFAULT;
|
|
|
|
error = wait_event_interruptible(socket_client->queue_wait,
|
|
socket_client->queue_len);
|
|
|
|
if (error)
|
|
return error;
|
|
|
|
spin_lock_bh(&socket_client->lock);
|
|
|
|
socket_packet = list_first_entry(&socket_client->queue_list,
|
|
struct batadv_socket_packet, list);
|
|
list_del(&socket_packet->list);
|
|
socket_client->queue_len--;
|
|
|
|
spin_unlock_bh(&socket_client->lock);
|
|
|
|
packet_len = min(count, socket_packet->icmp_len);
|
|
error = copy_to_user(buf, &socket_packet->icmp_packet, packet_len);
|
|
|
|
kfree(socket_packet);
|
|
|
|
if (error)
|
|
return -EFAULT;
|
|
|
|
return packet_len;
|
|
}
|
|
|
|
static ssize_t batadv_socket_write(struct file *file, const char __user *buff,
|
|
size_t len, loff_t *off)
|
|
{
|
|
struct batadv_socket_client *socket_client = file->private_data;
|
|
struct batadv_priv *bat_priv = socket_client->bat_priv;
|
|
struct batadv_hard_iface *primary_if = NULL;
|
|
struct sk_buff *skb;
|
|
struct batadv_icmp_packet_rr *icmp_packet_rr;
|
|
struct batadv_icmp_header *icmp_header;
|
|
struct batadv_orig_node *orig_node = NULL;
|
|
struct batadv_neigh_node *neigh_node = NULL;
|
|
size_t packet_len = sizeof(struct batadv_icmp_packet);
|
|
u8 *addr;
|
|
|
|
if (len < sizeof(struct batadv_icmp_header)) {
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
|
"Error - can't send packet from char device: invalid packet size\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
primary_if = batadv_primary_if_get_selected(bat_priv);
|
|
|
|
if (!primary_if) {
|
|
len = -EFAULT;
|
|
goto out;
|
|
}
|
|
|
|
if (len >= BATADV_ICMP_MAX_PACKET_SIZE)
|
|
packet_len = BATADV_ICMP_MAX_PACKET_SIZE;
|
|
else
|
|
packet_len = len;
|
|
|
|
skb = netdev_alloc_skb_ip_align(NULL, packet_len + ETH_HLEN);
|
|
if (!skb) {
|
|
len = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
skb->priority = TC_PRIO_CONTROL;
|
|
skb_reserve(skb, ETH_HLEN);
|
|
icmp_header = skb_put(skb, packet_len);
|
|
|
|
if (copy_from_user(icmp_header, buff, packet_len)) {
|
|
len = -EFAULT;
|
|
goto free_skb;
|
|
}
|
|
|
|
if (icmp_header->packet_type != BATADV_ICMP) {
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
|
"Error - can't send packet from char device: got bogus packet type (expected: BAT_ICMP)\n");
|
|
len = -EINVAL;
|
|
goto free_skb;
|
|
}
|
|
|
|
switch (icmp_header->msg_type) {
|
|
case BATADV_ECHO_REQUEST:
|
|
if (len < sizeof(struct batadv_icmp_packet)) {
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
|
"Error - can't send packet from char device: invalid packet size\n");
|
|
len = -EINVAL;
|
|
goto free_skb;
|
|
}
|
|
|
|
if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
|
|
goto dst_unreach;
|
|
|
|
orig_node = batadv_orig_hash_find(bat_priv, icmp_header->dst);
|
|
if (!orig_node)
|
|
goto dst_unreach;
|
|
|
|
neigh_node = batadv_orig_router_get(orig_node,
|
|
BATADV_IF_DEFAULT);
|
|
if (!neigh_node)
|
|
goto dst_unreach;
|
|
|
|
if (!neigh_node->if_incoming)
|
|
goto dst_unreach;
|
|
|
|
if (neigh_node->if_incoming->if_status != BATADV_IF_ACTIVE)
|
|
goto dst_unreach;
|
|
|
|
icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmp_header;
|
|
if (packet_len == sizeof(*icmp_packet_rr)) {
|
|
addr = neigh_node->if_incoming->net_dev->dev_addr;
|
|
ether_addr_copy(icmp_packet_rr->rr[0], addr);
|
|
}
|
|
|
|
break;
|
|
default:
|
|
batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
|
|
"Error - can't send packet from char device: got unknown message type\n");
|
|
len = -EINVAL;
|
|
goto free_skb;
|
|
}
|
|
|
|
icmp_header->uid = socket_client->index;
|
|
|
|
if (icmp_header->version != BATADV_COMPAT_VERSION) {
|
|
icmp_header->msg_type = BATADV_PARAMETER_PROBLEM;
|
|
icmp_header->version = BATADV_COMPAT_VERSION;
|
|
batadv_socket_add_packet(socket_client, icmp_header,
|
|
packet_len);
|
|
goto free_skb;
|
|
}
|
|
|
|
ether_addr_copy(icmp_header->orig, primary_if->net_dev->dev_addr);
|
|
|
|
batadv_send_unicast_skb(skb, neigh_node);
|
|
goto out;
|
|
|
|
dst_unreach:
|
|
icmp_header->msg_type = BATADV_DESTINATION_UNREACHABLE;
|
|
batadv_socket_add_packet(socket_client, icmp_header, packet_len);
|
|
free_skb:
|
|
kfree_skb(skb);
|
|
out:
|
|
if (primary_if)
|
|
batadv_hardif_put(primary_if);
|
|
if (neigh_node)
|
|
batadv_neigh_node_put(neigh_node);
|
|
if (orig_node)
|
|
batadv_orig_node_put(orig_node);
|
|
return len;
|
|
}
|
|
|
|
static __poll_t batadv_socket_poll(struct file *file, poll_table *wait)
|
|
{
|
|
struct batadv_socket_client *socket_client = file->private_data;
|
|
|
|
poll_wait(file, &socket_client->queue_wait, wait);
|
|
|
|
if (socket_client->queue_len > 0)
|
|
return EPOLLIN | EPOLLRDNORM;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct file_operations batadv_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = batadv_socket_open,
|
|
.release = batadv_socket_release,
|
|
.read = batadv_socket_read,
|
|
.write = batadv_socket_write,
|
|
.poll = batadv_socket_poll,
|
|
.llseek = no_llseek,
|
|
};
|
|
|
|
/**
|
|
* batadv_socket_setup() - Create debugfs "socket" file
|
|
* @bat_priv: the bat priv with all the soft interface information
|
|
*/
|
|
void batadv_socket_setup(struct batadv_priv *bat_priv)
|
|
{
|
|
debugfs_create_file(BATADV_ICMP_SOCKET, 0600, bat_priv->debug_dir,
|
|
bat_priv, &batadv_fops);
|
|
}
|
|
|
|
/**
|
|
* batadv_socket_add_packet() - schedule an icmp packet to be sent to
|
|
* userspace on an icmp socket.
|
|
* @socket_client: the socket this packet belongs to
|
|
* @icmph: pointer to the header of the icmp packet
|
|
* @icmp_len: total length of the icmp packet
|
|
*/
|
|
static void batadv_socket_add_packet(struct batadv_socket_client *socket_client,
|
|
struct batadv_icmp_header *icmph,
|
|
size_t icmp_len)
|
|
{
|
|
struct batadv_socket_packet *socket_packet;
|
|
size_t len;
|
|
|
|
socket_packet = kmalloc(sizeof(*socket_packet), GFP_ATOMIC);
|
|
|
|
if (!socket_packet)
|
|
return;
|
|
|
|
len = icmp_len;
|
|
/* check the maximum length before filling the buffer */
|
|
if (len > sizeof(socket_packet->icmp_packet))
|
|
len = sizeof(socket_packet->icmp_packet);
|
|
|
|
INIT_LIST_HEAD(&socket_packet->list);
|
|
memcpy(&socket_packet->icmp_packet, icmph, len);
|
|
socket_packet->icmp_len = len;
|
|
|
|
spin_lock_bh(&socket_client->lock);
|
|
|
|
/* while waiting for the lock the socket_client could have been
|
|
* deleted
|
|
*/
|
|
if (!batadv_socket_client_hash[icmph->uid]) {
|
|
spin_unlock_bh(&socket_client->lock);
|
|
kfree(socket_packet);
|
|
return;
|
|
}
|
|
|
|
list_add_tail(&socket_packet->list, &socket_client->queue_list);
|
|
socket_client->queue_len++;
|
|
|
|
if (socket_client->queue_len > 100) {
|
|
socket_packet = list_first_entry(&socket_client->queue_list,
|
|
struct batadv_socket_packet,
|
|
list);
|
|
|
|
list_del(&socket_packet->list);
|
|
kfree(socket_packet);
|
|
socket_client->queue_len--;
|
|
}
|
|
|
|
spin_unlock_bh(&socket_client->lock);
|
|
|
|
wake_up(&socket_client->queue_wait);
|
|
}
|
|
|
|
/**
|
|
* batadv_socket_receive_packet() - schedule an icmp packet to be received
|
|
* locally and sent to userspace.
|
|
* @icmph: pointer to the header of the icmp packet
|
|
* @icmp_len: total length of the icmp packet
|
|
*/
|
|
void batadv_socket_receive_packet(struct batadv_icmp_header *icmph,
|
|
size_t icmp_len)
|
|
{
|
|
struct batadv_socket_client *hash;
|
|
|
|
hash = batadv_socket_client_hash[icmph->uid];
|
|
if (hash)
|
|
batadv_socket_add_packet(hash, icmph, icmp_len);
|
|
}
|