net/cor/config.c

   1 /**
   2  *      Connection oriented routing
   3  *      Copyright (C) 2007-2021 Michael Blizek
   4  *
   5  *      This program is free software; you can redistribute it and/or
   6  *      modify it under the terms of the GNU General Public License
   7  *      as published by the Free Software Foundation; either version 2
   8  *      of the License, or (at your option) any later version.
   9  *
  10  *      This program is distributed in the hope that it will be useful,
  11  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *      GNU General Public License for more details.
  14  */
  15
  16 #include "cor.h"
  17
  18 static DEFINE_MUTEX(cor_config_lock);
  19
  20 DEFINE_SPINLOCK(cor_local_addr_lock);
  21 __u8 cor_local_has_addr = 0;
  22 __be64 cor_local_addr;
  23 __be32 cor_local_addr_sessionid;
  24
  25
  26 static DEFINE_SPINLOCK(cor_interface_config_lock);
  27 static struct cor_interface_config *cor_interface_config = 0;
  28 static __u32 cor_num_interfaces = 0;
  29 static int cor_all_interfaces = 0;
  30
  31
  32 int cor_is_device_configurated(struct net_device *dev)
  33 {
  34         int ret = 0;
  35
  36         unsigned long iflags;
  37
  38         __u32 i;
  39
  40         spin_lock_irqsave(&cor_interface_config_lock, iflags);
  41
  42         if (cor_all_interfaces != 0) {
  43                 ret = 1;
  44                 goto out;
  45         }
  46
  47         BUG_ON(cor_num_interfaces > 65536);
  48         for (i = 0; i < cor_num_interfaces; i++) {
  49                 struct cor_interface_config *curr = &(cor_interface_config[i]);
  50                 __u32 j;
  51
  52                 BUG_ON(curr->name == 0);
  53
  54                 for (j = 0;; j++) {
  55                         if (j >= sizeof(dev->name))
  56                                 break;
  57
  58                         if (dev->name[j] == 0 && j == curr->name_len) {
  59                                 ret = 1;
  60                                 goto out;
  61                         }
  62
  63                         if (dev->name[j] == 0 || j >= curr->name_len)
  64                                 break;
  65
  66                         if (dev->name[j] != curr->name[j])
  67                                 break;
  68                 }
  69         }
  70
  71 out:
  72         spin_unlock_irqrestore(&cor_interface_config_lock, iflags);
  73
  74         return ret;
  75 }
  76
  77 void cor_set_interface_config(struct cor_interface_config *new_config,
  78                 __u32 new_num_interfaces, int new_all_interfaces)
  79 {
  80         unsigned long iflags;
  81         __u32 i;
  82
  83         spin_lock_irqsave(&cor_interface_config_lock, iflags);
  84
  85         BUG_ON(cor_num_interfaces > 65536);
  86         for (i = 0; i < cor_num_interfaces; i++) {
  87                 struct cor_interface_config *curr = &(cor_interface_config[i]);
  88
  89                 BUG_ON(curr->name == 0);
  90                 kfree(curr->name);
  91                 curr->name = 0;
  92         }
  93
  94         kfree(cor_interface_config);
  95         cor_interface_config = 0;
  96         cor_num_interfaces = 0;
  97         cor_all_interfaces = 0;
  98
  99
 100         cor_interface_config = new_config;
 101         cor_num_interfaces = new_num_interfaces;
 102         cor_all_interfaces = new_all_interfaces;
 103
 104         spin_unlock_irqrestore(&cor_interface_config_lock, iflags);
 105 }
 106
 107
 108 void _cor_config_down(void)
 109 {
 110         cor_dev_down();
 111
 112         spin_lock_bh(&cor_local_addr_lock);
 113         cor_local_has_addr = 0;
 114         cor_local_addr = 0;
 115         spin_unlock_bh(&cor_local_addr_lock);
 116
 117         cor_reset_neighbors(0);
 118         cor_reset_neighbors(0);
 119         cor_destroy_queue(0);
 120
 121         cor_announce_send_stop(0, 0, ANNOUNCE_TYPE_BROADCAST);
 122 }
 123
 124 void cor_config_down(void)
 125 {
 126         mutex_lock(&cor_config_lock);
 127         _cor_config_down();
 128         mutex_unlock(&cor_config_lock);
 129 }
 130
 131 int cor_config_up(__u8 has_addr, __be64 addr)
 132 {
 133         int rc = 0;
 134
 135         if (has_addr != 0 && be64_to_cpu(addr) == 0)
 136                 return 1;
 137
 138         mutex_lock(&cor_config_lock);
 139
 140         _cor_config_down();
 141
 142         spin_lock_bh(&cor_local_addr_lock);
 143
 144         BUG_ON(cor_local_has_addr != 0);
 145         BUG_ON(cor_local_addr != 0);
 146
 147         cor_local_has_addr = has_addr;
 148         cor_local_addr = addr;
 149         get_random_bytes((char *) &cor_local_addr_sessionid,
 150                         sizeof(cor_local_addr_sessionid));
 151
 152         spin_unlock_bh(&cor_local_addr_lock);
 153
 154         if (cor_dev_up() != 0) {
 155                 spin_lock_bh(&cor_local_addr_lock);
 156                 cor_local_has_addr = 0;
 157                 cor_local_addr = 0;
 158                 spin_unlock_bh(&cor_local_addr_lock);
 159                 rc = 1;
 160         }
 161
 162         mutex_unlock(&(cor_config_lock));
 163
 164         return rc;
 165 }
 166
 167 int cor_is_clientmode(void)
 168 {
 169         int rc;
 170
 171         spin_lock_bh(&cor_local_addr_lock);
 172         rc = (cor_local_has_addr == 0);
 173         spin_unlock_bh(&cor_local_addr_lock);
 174         return rc;
 175 }
 176
 177 MODULE_LICENSE("GPL");