| /* |
| * Copyright (C) 2007-2009 B.A.T.M.A.N. contributors: |
| * |
| * Marek Lindner, Simon Wunderlich |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of version 2 of the GNU General Public |
| * License as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| * 02110-1301, USA |
| * |
| */ |
| |
| #include "main.h" |
| #include "proc.h" |
| #include "routing.h" |
| #include "translation-table.h" |
| #include "hard-interface.h" |
| #include "types.h" |
| #include "hash.h" |
| #include "vis.h" |
| |
| static struct proc_dir_entry *proc_batman_dir, *proc_interface_file; |
| static struct proc_dir_entry *proc_orig_interval_file, *proc_originators_file; |
| static struct proc_dir_entry *proc_transt_local_file; |
| static struct proc_dir_entry *proc_transt_global_file; |
| static struct proc_dir_entry *proc_vis_srv_file, *proc_vis_data_file; |
| static struct proc_dir_entry *proc_aggr_file; |
| |
| static int proc_interfaces_read(struct seq_file *seq, void *offset) |
| { |
| struct batman_if *batman_if; |
| |
| rcu_read_lock(); |
| list_for_each_entry_rcu(batman_if, &if_list, list) { |
| seq_printf(seq, "[%8s] %s %s \n", |
| (batman_if->if_active == IF_ACTIVE ? |
| "active" : "inactive"), |
| batman_if->dev, |
| (batman_if->if_active == IF_ACTIVE ? |
| batman_if->addr_str : " ")); |
| } |
| rcu_read_unlock(); |
| |
| return 0; |
| } |
| |
| static int proc_interfaces_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_interfaces_read, NULL); |
| } |
| |
| static ssize_t proc_interfaces_write(struct file *instance, |
| const char __user *userbuffer, |
| size_t count, loff_t *data) |
| { |
| char *if_string, *colon_ptr = NULL, *cr_ptr = NULL; |
| int not_copied = 0, if_num = 0, add_success; |
| struct batman_if *batman_if = NULL; |
| |
| if_string = kmalloc(count, GFP_KERNEL); |
| |
| if (!if_string) |
| return -ENOMEM; |
| |
| if (count > IFNAMSIZ - 1) { |
| printk(KERN_WARNING "batman-adv:Can't add interface: device name is too long\n"); |
| goto end; |
| } |
| |
| not_copied = copy_from_user(if_string, userbuffer, count); |
| if_string[count - not_copied - 1] = 0; |
| |
| colon_ptr = strchr(if_string, ':'); |
| if (colon_ptr) |
| *colon_ptr = 0; |
| |
| if (!colon_ptr) { |
| cr_ptr = strchr(if_string, '\n'); |
| if (cr_ptr) |
| *cr_ptr = 0; |
| } |
| |
| if (strlen(if_string) == 0) { |
| shutdown_module(); |
| num_ifs = 0; |
| goto end; |
| } |
| |
| /* add interface */ |
| rcu_read_lock(); |
| list_for_each_entry_rcu(batman_if, &if_list, list) { |
| if (strncmp(batman_if->dev, if_string, count) == 0) { |
| printk(KERN_ERR "batman-adv:Given interface is already active: %s\n", if_string); |
| rcu_read_unlock(); |
| goto end; |
| |
| } |
| |
| if_num++; |
| } |
| rcu_read_unlock(); |
| |
| add_success = hardif_add_interface(if_string, if_num); |
| if (add_success < 0) |
| goto end; |
| |
| num_ifs = if_num + 1; |
| |
| if ((atomic_read(&module_state) == MODULE_INACTIVE) && |
| (hardif_get_active_if_num() > 0)) |
| activate_module(); |
| |
| return count; |
| end: |
| kfree(if_string); |
| return count; |
| } |
| |
| static int proc_orig_interval_read(struct seq_file *seq, void *offset) |
| { |
| seq_printf(seq, "%i\n", atomic_read(&originator_interval)); |
| |
| return 0; |
| } |
| |
| static ssize_t proc_orig_interval_write(struct file *file, |
| const char __user *buffer, |
| size_t count, loff_t *ppos) |
| { |
| char *interval_string; |
| int not_copied = 0; |
| unsigned long originator_interval_tmp; |
| int retval; |
| |
| interval_string = kmalloc(count, GFP_KERNEL); |
| |
| if (!interval_string) |
| return -ENOMEM; |
| |
| not_copied = copy_from_user(interval_string, buffer, count); |
| interval_string[count - not_copied - 1] = 0; |
| |
| retval = strict_strtoul(interval_string, 10, &originator_interval_tmp); |
| if (retval) { |
| printk(KERN_ERR "batman-adv:New originator interval invalid\n"); |
| goto end; |
| } |
| |
| if (originator_interval_tmp <= JITTER * 2) { |
| printk(KERN_WARNING "batman-adv:New originator interval too small: %li (min: %i)\n", |
| originator_interval_tmp, JITTER * 2); |
| goto end; |
| } |
| |
| printk(KERN_INFO "batman-adv:Changing originator interval from: %i to: %li\n", |
| atomic_read(&originator_interval), originator_interval_tmp); |
| |
| atomic_set(&originator_interval, originator_interval_tmp); |
| |
| end: |
| kfree(interval_string); |
| return count; |
| } |
| |
| static int proc_orig_interval_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_orig_interval_read, NULL); |
| } |
| |
| static int proc_originators_read(struct seq_file *seq, void *offset) |
| { |
| HASHIT(hashit); |
| struct orig_node *orig_node; |
| struct neigh_node *neigh_node; |
| int batman_count = 0; |
| char orig_str[ETH_STR_LEN], router_str[ETH_STR_LEN]; |
| unsigned long flags; |
| |
| rcu_read_lock(); |
| if (list_empty(&if_list)) { |
| rcu_read_unlock(); |
| seq_printf(seq, "BATMAN disabled - please specify interfaces to enable it \n"); |
| goto end; |
| } |
| |
| if (((struct batman_if *)if_list.next)->if_active != IF_ACTIVE) { |
| rcu_read_unlock(); |
| seq_printf(seq, "BATMAN disabled - primary interface not active \n"); |
| goto end; |
| } |
| |
| seq_printf(seq, |
| " %-14s (%s/%i) %17s [%10s]: %20s ... [B.A.T.M.A.N. adv %s%s, MainIF/MAC: %s/%s] \n", |
| "Originator", "#", TQ_MAX_VALUE, "Nexthop", "outgoingIF", |
| "Potential nexthops", SOURCE_VERSION, REVISION_VERSION_STR, |
| ((struct batman_if *)if_list.next)->dev, |
| ((struct batman_if *)if_list.next)->addr_str); |
| |
| rcu_read_unlock(); |
| spin_lock_irqsave(&orig_hash_lock, flags); |
| |
| while (hash_iterate(orig_hash, &hashit)) { |
| |
| orig_node = hashit.bucket->data; |
| |
| if (!orig_node->router) |
| continue; |
| |
| if (orig_node->router->tq_avg == 0) |
| continue; |
| |
| batman_count++; |
| |
| addr_to_string(orig_str, orig_node->orig); |
| addr_to_string(router_str, orig_node->router->addr); |
| |
| seq_printf(seq, "%-17s (%3i) %17s [%10s]:", |
| orig_str, orig_node->router->tq_avg, |
| router_str, orig_node->router->if_incoming->dev); |
| |
| list_for_each_entry(neigh_node, &orig_node->neigh_list, list) { |
| addr_to_string(orig_str, neigh_node->addr); |
| seq_printf(seq, " %17s (%3i)", |
| orig_str, neigh_node->tq_avg); |
| } |
| |
| seq_printf(seq, "\n"); |
| |
| } |
| |
| spin_unlock_irqrestore(&orig_hash_lock, flags); |
| |
| if (batman_count == 0) |
| seq_printf(seq, "No batman nodes in range ... \n"); |
| |
| end: |
| return 0; |
| } |
| |
| static int proc_originators_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_originators_read, NULL); |
| } |
| |
| static int proc_transt_local_read(struct seq_file *seq, void *offset) |
| { |
| char *buf; |
| |
| buf = kmalloc(4096, GFP_KERNEL); |
| if (!buf) |
| return 0; |
| |
| rcu_read_lock(); |
| if (list_empty(&if_list)) { |
| rcu_read_unlock(); |
| seq_printf(seq, "BATMAN disabled - please specify interfaces to enable it \n"); |
| goto end; |
| } |
| |
| rcu_read_unlock(); |
| |
| seq_printf(seq, "Locally retrieved addresses (from %s) announced via HNA:\n", soft_device->name); |
| |
| hna_local_fill_buffer_text(buf, 4096); |
| seq_printf(seq, "%s", buf); |
| |
| end: |
| kfree(buf); |
| return 0; |
| } |
| |
| static int proc_transt_local_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_transt_local_read, NULL); |
| } |
| |
| static int proc_transt_global_read(struct seq_file *seq, void *offset) |
| { |
| char *buf; |
| |
| buf = kmalloc(4096, GFP_KERNEL); |
| if (!buf) |
| return 0; |
| |
| rcu_read_lock(); |
| if (list_empty(&if_list)) { |
| rcu_read_unlock(); |
| seq_printf(seq, "BATMAN disabled - please specify interfaces to enable it \n"); |
| goto end; |
| } |
| rcu_read_unlock(); |
| |
| |
| seq_printf(seq, "Globally announced HNAs received via the mesh (translation table):\n"); |
| |
| hna_global_fill_buffer_text(buf, 4096); |
| seq_printf(seq, "%s", buf); |
| |
| end: |
| kfree(buf); |
| return 0; |
| } |
| |
| static int proc_transt_global_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_transt_global_read, NULL); |
| } |
| |
| /* setting the mode of the vis server by the user */ |
| static ssize_t proc_vis_srv_write(struct file *file, const char __user * buffer, |
| size_t count, loff_t *ppos) |
| { |
| char *vis_mode_string; |
| int not_copied = 0; |
| |
| vis_mode_string = kmalloc(count, GFP_KERNEL); |
| |
| if (!vis_mode_string) |
| return -ENOMEM; |
| |
| not_copied = copy_from_user(vis_mode_string, buffer, count); |
| vis_mode_string[count - not_copied - 1] = 0; |
| |
| if ((strcmp(vis_mode_string, "client") == 0) || |
| (strcmp(vis_mode_string, "disabled") == 0)) { |
| printk(KERN_INFO "batman-adv:Setting VIS mode to client (disabling vis server)\n"); |
| atomic_set(&vis_mode, VIS_TYPE_CLIENT_UPDATE); |
| } else if ((strcmp(vis_mode_string, "server") == 0) || |
| (strcmp(vis_mode_string, "enabled") == 0)) { |
| printk(KERN_INFO "batman-adv:Setting VIS mode to server (enabling vis server)\n"); |
| atomic_set(&vis_mode, VIS_TYPE_SERVER_SYNC); |
| } else |
| printk(KERN_ERR "batman-adv:Unknown VIS mode: %s\n", |
| vis_mode_string); |
| |
| kfree(vis_mode_string); |
| return count; |
| } |
| |
| static int proc_vis_srv_read(struct seq_file *seq, void *offset) |
| { |
| int vis_server = atomic_read(&vis_mode); |
| |
| seq_printf(seq, "[%c] client mode (server disabled) \n", |
| (vis_server == VIS_TYPE_CLIENT_UPDATE) ? 'x' : ' '); |
| seq_printf(seq, "[%c] server mode (server enabled) \n", |
| (vis_server == VIS_TYPE_SERVER_SYNC) ? 'x' : ' '); |
| |
| return 0; |
| } |
| |
| static int proc_vis_srv_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_vis_srv_read, NULL); |
| } |
| |
| static int proc_vis_data_read(struct seq_file *seq, void *offset) |
| { |
| HASHIT(hashit); |
| struct vis_info *info; |
| struct vis_info_entry *entries; |
| HLIST_HEAD(vis_if_list); |
| int i; |
| char tmp_addr_str[ETH_STR_LEN]; |
| unsigned long flags; |
| int vis_server = atomic_read(&vis_mode); |
| |
| rcu_read_lock(); |
| if (list_empty(&if_list) || (vis_server == VIS_TYPE_CLIENT_UPDATE)) { |
| rcu_read_unlock(); |
| goto end; |
| } |
| |
| rcu_read_unlock(); |
| |
| spin_lock_irqsave(&vis_hash_lock, flags); |
| while (hash_iterate(vis_hash, &hashit)) { |
| info = hashit.bucket->data; |
| entries = (struct vis_info_entry *) |
| ((char *)info + sizeof(struct vis_info)); |
| addr_to_string(tmp_addr_str, info->packet.vis_orig); |
| seq_printf(seq, "%s,", tmp_addr_str); |
| |
| for (i = 0; i < info->packet.entries; i++) { |
| proc_vis_read_entry(seq, &entries[i], &vis_if_list, |
| info->packet.vis_orig); |
| } |
| |
| /* add primary/secondary records */ |
| proc_vis_read_prim_sec(seq, &vis_if_list); |
| seq_printf(seq, "\n"); |
| } |
| spin_unlock_irqrestore(&vis_hash_lock, flags); |
| |
| end: |
| return 0; |
| } |
| |
| static int proc_vis_data_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_vis_data_read, NULL); |
| } |
| |
| static int proc_aggr_read(struct seq_file *seq, void *offset) |
| { |
| seq_printf(seq, "%i\n", atomic_read(&aggregation_enabled)); |
| |
| return 0; |
| } |
| |
| static ssize_t proc_aggr_write(struct file *file, const char __user *buffer, |
| size_t count, loff_t *ppos) |
| { |
| char *aggr_string; |
| int not_copied = 0; |
| unsigned long aggregation_enabled_tmp; |
| int retval; |
| |
| aggr_string = kmalloc(count, GFP_KERNEL); |
| |
| if (!aggr_string) |
| return -ENOMEM; |
| |
| not_copied = copy_from_user(aggr_string, buffer, count); |
| aggr_string[count - not_copied - 1] = 0; |
| |
| retval = strict_strtoul(aggr_string, 10, &aggregation_enabled_tmp); |
| |
| if (retval || aggregation_enabled_tmp > 1) { |
| printk(KERN_ERR "batman-adv:Aggregation can only be enabled (1) or disabled (0), given value: %li\n", aggregation_enabled_tmp); |
| } else { |
| printk(KERN_INFO "batman-adv:Changing aggregation from: %s (%i) to: %s (%li)\n", |
| (atomic_read(&aggregation_enabled) == 1 ? |
| "enabled" : "disabled"), |
| atomic_read(&aggregation_enabled), |
| (aggregation_enabled_tmp == 1 ? "enabled" : "disabled"), |
| aggregation_enabled_tmp); |
| atomic_set(&aggregation_enabled, |
| (unsigned)aggregation_enabled_tmp); |
| } |
| |
| kfree(aggr_string); |
| return count; |
| } |
| |
| static int proc_aggr_open(struct inode *inode, struct file *file) |
| { |
| return single_open(file, proc_aggr_read, NULL); |
| } |
| |
| /* satisfying different prototypes ... */ |
| static ssize_t proc_dummy_write(struct file *file, const char __user *buffer, |
| size_t count, loff_t *ppos) |
| { |
| return count; |
| } |
| |
| static const struct file_operations proc_aggr_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_aggr_open, |
| .read = seq_read, |
| .write = proc_aggr_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_vis_srv_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_vis_srv_open, |
| .read = seq_read, |
| .write = proc_vis_srv_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_vis_data_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_vis_data_open, |
| .read = seq_read, |
| .write = proc_dummy_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_originators_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_originators_open, |
| .read = seq_read, |
| .write = proc_dummy_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_transt_local_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_transt_local_open, |
| .read = seq_read, |
| .write = proc_dummy_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_transt_global_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_transt_global_open, |
| .read = seq_read, |
| .write = proc_dummy_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_interfaces_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_interfaces_open, |
| .read = seq_read, |
| .write = proc_interfaces_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| static const struct file_operations proc_orig_interval_fops = { |
| .owner = THIS_MODULE, |
| .open = proc_orig_interval_open, |
| .read = seq_read, |
| .write = proc_orig_interval_write, |
| .llseek = seq_lseek, |
| .release = single_release, |
| }; |
| |
| void cleanup_procfs(void) |
| { |
| if (proc_transt_global_file) |
| remove_proc_entry(PROC_FILE_TRANST_GLOBAL, proc_batman_dir); |
| |
| if (proc_transt_local_file) |
| remove_proc_entry(PROC_FILE_TRANST_LOCAL, proc_batman_dir); |
| |
| if (proc_originators_file) |
| remove_proc_entry(PROC_FILE_ORIGINATORS, proc_batman_dir); |
| |
| if (proc_orig_interval_file) |
| remove_proc_entry(PROC_FILE_ORIG_INTERVAL, proc_batman_dir); |
| |
| if (proc_interface_file) |
| remove_proc_entry(PROC_FILE_INTERFACES, proc_batman_dir); |
| |
| if (proc_vis_data_file) |
| remove_proc_entry(PROC_FILE_VIS_DATA, proc_batman_dir); |
| |
| if (proc_vis_srv_file) |
| remove_proc_entry(PROC_FILE_VIS_SRV, proc_batman_dir); |
| |
| if (proc_aggr_file) |
| remove_proc_entry(PROC_FILE_AGGR, proc_batman_dir); |
| |
| if (proc_batman_dir) |
| #ifdef __NET_NET_NAMESPACE_H |
| remove_proc_entry(PROC_ROOT_DIR, init_net.proc_net); |
| #else |
| remove_proc_entry(PROC_ROOT_DIR, proc_net); |
| #endif |
| } |
| |
| int setup_procfs(void) |
| { |
| #ifdef __NET_NET_NAMESPACE_H |
| proc_batman_dir = proc_mkdir(PROC_ROOT_DIR, init_net.proc_net); |
| #else |
| proc_batman_dir = proc_mkdir(PROC_ROOT_DIR, proc_net); |
| #endif |
| |
| if (!proc_batman_dir) { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s' folder failed\n", PROC_ROOT_DIR); |
| return -EFAULT; |
| } |
| |
| proc_interface_file = create_proc_entry(PROC_FILE_INTERFACES, |
| S_IWUSR | S_IRUGO, |
| proc_batman_dir); |
| if (proc_interface_file) { |
| proc_interface_file->proc_fops = &proc_interfaces_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_INTERFACES); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_orig_interval_file = create_proc_entry(PROC_FILE_ORIG_INTERVAL, |
| S_IWUSR | S_IRUGO, |
| proc_batman_dir); |
| if (proc_orig_interval_file) { |
| proc_orig_interval_file->proc_fops = &proc_orig_interval_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_ORIG_INTERVAL); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_originators_file = create_proc_entry(PROC_FILE_ORIGINATORS, |
| S_IRUGO, proc_batman_dir); |
| if (proc_originators_file) { |
| proc_originators_file->proc_fops = &proc_originators_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_ORIGINATORS); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_transt_local_file = create_proc_entry(PROC_FILE_TRANST_LOCAL, |
| S_IRUGO, proc_batman_dir); |
| if (proc_transt_local_file) { |
| proc_transt_local_file->proc_fops = &proc_transt_local_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_TRANST_LOCAL); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_transt_global_file = create_proc_entry(PROC_FILE_TRANST_GLOBAL, |
| S_IRUGO, proc_batman_dir); |
| if (proc_transt_global_file) { |
| proc_transt_global_file->proc_fops = &proc_transt_global_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_TRANST_GLOBAL); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_vis_srv_file = create_proc_entry(PROC_FILE_VIS_SRV, |
| S_IWUSR | S_IRUGO, |
| proc_batman_dir); |
| if (proc_vis_srv_file) { |
| proc_vis_srv_file->proc_fops = &proc_vis_srv_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_VIS_SRV); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_vis_data_file = create_proc_entry(PROC_FILE_VIS_DATA, S_IRUGO, |
| proc_batman_dir); |
| if (proc_vis_data_file) { |
| proc_vis_data_file->proc_fops = &proc_vis_data_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_VIS_DATA); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| proc_aggr_file = create_proc_entry(PROC_FILE_AGGR, S_IWUSR | S_IRUGO, |
| proc_batman_dir); |
| if (proc_aggr_file) { |
| proc_aggr_file->proc_fops = &proc_aggr_fops; |
| } else { |
| printk(KERN_ERR "batman-adv: Registering the '/proc/net/%s/%s' file failed\n", PROC_ROOT_DIR, PROC_FILE_AGGR); |
| cleanup_procfs(); |
| return -EFAULT; |
| } |
| |
| return 0; |
| } |