intersect.c

   1 #include <errno.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <arpa/inet.h> /* ntohl */
   5 #include <string.h>
   6
   7 #include "reglib.h"
   8
   9 /* Intersects regulatory domains, this will skip any regulatory marked with
  10  * an alpha2 of '00', which is used to indicate a regulatory domain */
  11
  12 #define BUG_ON(foo) do { \
  13         if (foo) { \
  14                 printf("BUG\n"); \
  15                 exit(-1); \
  16         } \
  17         } while (0)
  18
  19 /* Sanity check on a regulatory rule */
  20 static int is_valid_reg_rule(const struct ieee80211_reg_rule *rule)
  21 {
  22         const struct ieee80211_freq_range *freq_range = &rule->freq_range;
  23         uint32_t freq_diff;
  24
  25         if (freq_range->start_freq_khz == 0 || freq_range->end_freq_khz == 0)
  26                 return 0;
  27
  28         if (freq_range->start_freq_khz > freq_range->end_freq_khz)
  29                 return 0;
  30
  31         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
  32
  33         if (freq_diff == 0 || freq_range->max_bandwidth_khz > freq_diff)
  34                 return 0;
  35
  36         return 1;
  37 }
  38
  39 /* Helper for regdom_intersect(), this does the real
  40  * mathematical intersection fun */
  41 static int reg_rules_intersect(
  42         struct ieee80211_reg_rule *rule1,
  43         struct ieee80211_reg_rule *rule2,
  44         struct ieee80211_reg_rule *intersected_rule)
  45 {
  46         struct ieee80211_freq_range *freq_range1, *freq_range2, *freq_range;
  47         struct ieee80211_power_rule *power_rule1, *power_rule2, *power_rule;
  48         uint32_t freq_diff;
  49
  50         freq_range1 = &rule1->freq_range;
  51         freq_range2 = &rule2->freq_range;
  52         freq_range = &intersected_rule->freq_range;
  53
  54         power_rule1 = &rule1->power_rule;
  55         power_rule2 = &rule2->power_rule;
  56         power_rule = &intersected_rule->power_rule;
  57
  58         freq_range->start_freq_khz = max(freq_range1->start_freq_khz,
  59                 freq_range2->start_freq_khz);
  60         freq_range->end_freq_khz = min(freq_range1->end_freq_khz,
  61                 freq_range2->end_freq_khz);
  62         freq_range->max_bandwidth_khz = min(freq_range1->max_bandwidth_khz,
  63                 freq_range2->max_bandwidth_khz);
  64
  65         freq_diff = freq_range->end_freq_khz - freq_range->start_freq_khz;
  66         if (freq_range->max_bandwidth_khz > freq_diff)
  67                 freq_range->max_bandwidth_khz = freq_diff;
  68
  69         power_rule->max_eirp = min(power_rule1->max_eirp,
  70                 power_rule2->max_eirp);
  71         power_rule->max_antenna_gain = min(power_rule1->max_antenna_gain,
  72                 power_rule2->max_antenna_gain);
  73
  74         intersected_rule->flags = (rule1->flags | rule2->flags);
  75
  76         if (!is_valid_reg_rule(intersected_rule))
  77                 return -EINVAL;
  78
  79         return 0;
  80 }
  81
  82 /**
  83  * regdom_intersect - do the intersection between two regulatory domains
  84  * @rd1: first regulatory domain
  85  * @rd2: second regulatory domain
  86  *
  87  * Use this function to get the intersection between two regulatory domains.
  88  * Once completed we will mark the alpha2 for the rd as intersected, "98",
  89  * as no one single alpha2 can represent this regulatory domain.
  90  *
  91  * Returns a pointer to the regulatory domain structure which will hold the
  92  * resulting intersection of rules between rd1 and rd2. We will
  93  * malloc() this structure for you.
  94  */
  95 static struct ieee80211_regdomain *regdom_intersect(
  96         struct ieee80211_regdomain *rd1,
  97         struct ieee80211_regdomain *rd2)
  98 {
  99         int r, size_of_regd;
 100         unsigned int x, y;
 101         unsigned int num_rules = 0, rule_idx = 0;
 102         struct ieee80211_reg_rule *rule1, *rule2, *intersected_rule;
 103         struct ieee80211_regdomain *rd;
 104         /* This is just a dummy holder to help us count */
 105         struct ieee80211_reg_rule irule;
 106
 107         /* Uses the stack temporarily for counter arithmetic */
 108         intersected_rule = &irule;
 109
 110         memset(intersected_rule, 0, sizeof(struct ieee80211_reg_rule));
 111
 112         if (!rd1 || !rd2) {
 113                 fprintf(stderr, "rd1 or or rd2 is null\n");
 114                 return NULL;
 115         }
 116
 117         /* First we get a count of the rules we'll need, then we actually
 118          * build them. This is to so we can malloc() and free() a
 119          * regdomain once. The reason we use reg_rules_intersect() here
 120          * is it will return -EINVAL if the rule computed makes no sense.
 121          * All rules that do check out OK are valid. */
 122
 123         for (x = 0; x < rd1->n_reg_rules; x++) {
 124                 rule1 = &rd1->reg_rules[x];
 125                 for (y = 0; y < rd2->n_reg_rules; y++) {
 126                         rule2 = &rd2->reg_rules[y];
 127                         if (!reg_rules_intersect(rule1, rule2,
 128                                         intersected_rule))
 129                                 num_rules++;
 130                         memset(intersected_rule, 0,
 131                                         sizeof(struct ieee80211_reg_rule));
 132                 }
 133         }
 134
 135         if (!num_rules) {
 136                 fprintf(stderr, "error: num_rules == 0\n");
 137                 return NULL;
 138         }
 139
 140         size_of_regd = sizeof(struct ieee80211_regdomain) +
 141                 ((num_rules + 1) * sizeof(struct ieee80211_reg_rule));
 142
 143         rd = malloc(size_of_regd);
 144         if (!rd) {
 145                 fprintf(stderr, "no memory left\n");
 146                 return NULL;
 147         }
 148
 149         memset(rd, 0, size_of_regd);
 150
 151         for (x = 0; x < rd1->n_reg_rules; x++) {
 152                 rule1 = &rd1->reg_rules[x];
 153                 for (y = 0; y < rd2->n_reg_rules; y++) {
 154                         rule2 = &rd2->reg_rules[y];
 155                         /* This time around instead of using the stack lets
 156                          * write to the target rule directly saving ourselves
 157                          * a memcpy() */
 158                         intersected_rule = &rd->reg_rules[rule_idx];
 159                         r = reg_rules_intersect(rule1, rule2,
 160                                 intersected_rule);
 161                         if (r)
 162                                 continue;
 163                         rule_idx++;
 164                 }
 165         }
 166
 167         if (rule_idx != num_rules) {
 168                 fprintf(stderr, "Error while doing regdom interesection :(\n");
 169                 free(rd);
 170                 return NULL;
 171         }
 172
 173         rd->n_reg_rules = num_rules;
 174         rd->alpha2[0] = '9';
 175         rd->alpha2[1] = '9';
 176
 177         return rd;
 178 }
 179
 180 int main(int argc, char **argv)
 181 {
 182         int r = 0;
 183         struct ieee80211_regdomain *prev_world = NULL, *rd = NULL, *world = NULL;
 184         int intersected = 0;
 185         unsigned int idx = 0;
 186
 187         if (argc != 2) {
 188                 fprintf(stderr, "You must specify a file\n");
 189                 return -EINVAL;
 190         }
 191
 192         /* We intersect only when we have to rd structures ready */
 193         reglib_for_each_country(rd, idx, argv[1]) {
 194                 if (is_world_regdom((const char *) rd->alpha2))
 195                         continue;
 196
 197                 if (!prev_world) {
 198                         prev_world = rd;
 199                         continue;
 200                 }
 201
 202                 if (world) {
 203                         free(prev_world);
 204                         prev_world = world;
 205                 }
 206
 207                 world = regdom_intersect(prev_world, rd);
 208                 if (!world) {
 209                         /* Could be something else but we'll live with this */
 210                         r = -ENOMEM;
 211                         if (intersected)
 212                                 fprintf(stderr, "Could not intersect world "
 213                                         "with country (%.2s)\n",
 214                                         rd->alpha2);
 215                         else
 216                                 fprintf(stderr, "Could not intersect country (%.2s) "
 217                                         "with country (%.2s)\n",
 218                                         prev_world->alpha2,
 219                                         rd->alpha2);
 220                         goto out;
 221                 }
 222
 223                 if (intersected)
 224                         /* Use UTF-8 Intersection symbol ? (0xE2,0x88,0xA9) :) */
 225                         printf("WW (%d) intersect %c%c (%d) ==> %d rules\n",
 226                                 prev_world->n_reg_rules,
 227                                 rd->alpha2[0],
 228                                 rd->alpha2[1],
 229                                 rd->n_reg_rules,
 230                                 world->n_reg_rules);
 231                 else
 232                         printf("%c%c (%d) intersect %c%c (%d) ==> %d rules\n",
 233                                 prev_world->alpha2[0],
 234                                 prev_world->alpha2[1],
 235                                 prev_world->n_reg_rules,
 236                                 rd->alpha2[0],
 237                                 rd->alpha2[1],
 238                                 rd->n_reg_rules,
 239                                 world->n_reg_rules);
 240                 intersected++;
 241         }
 242
 243         if (idx == 1) {
 244                 world = rd;
 245                 rd = NULL;
 246         }
 247
 248
 249         if (intersected > 1)
 250                 printf("%d regulatory domains intersected\n", intersected);
 251         else
 252                 printf("Only one intersection completed\n");
 253
 254         /* Tada! */
 255         printf("== World regulatory domain: ==\n");
 256         print_regdom(world);
 257
 258 out:
 259         if (!intersected) {
 260                 free(world);
 261                 return r;
 262         }
 263         if (intersected > 1) {
 264                 free(rd);
 265                 free(prev_world);
 266         }
 267         free(world);
 268         return r;
 269 }