src/network/networkd-address-pool.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include "alloc-util.h"
   4 #include "networkd-address-pool.h"
   5 #include "networkd-address.h"
   6 #include "networkd-manager.h"
   7 #include "networkd-queue.h"
   8 #include "string-util.h"
   9
  10 #define RANDOM_PREFIX_TRIAL_MAX  1024
  11
  12 static int address_pool_new(
  13                 Manager *m,
  14                 int family,
  15                 const union in_addr_union *u,
  16                 unsigned prefixlen) {
  17
  18         _cleanup_free_ AddressPool *p = NULL;
  19         int r;
  20
  21         assert(m);
  22         assert(u);
  23
  24         p = new(AddressPool, 1);
  25         if (!p)
  26                 return -ENOMEM;
  27
  28         *p = (AddressPool) {
  29                 .manager = m,
  30                 .family = family,
  31                 .prefixlen = prefixlen,
  32                 .in_addr = *u,
  33         };
  34
  35         r = ordered_set_ensure_put(&m->address_pools, NULL, p);
  36         if (r < 0)
  37                 return r;
  38
  39         TAKE_PTR(p);
  40         return 0;
  41 }
  42
  43 static int address_pool_new_from_string(
  44                 Manager *m,
  45                 int family,
  46                 const char *p,
  47                 unsigned prefixlen) {
  48
  49         union in_addr_union u;
  50         int r;
  51
  52         assert(m);
  53         assert(p);
  54
  55         r = in_addr_from_string(family, p, &u);
  56         if (r < 0)
  57                 return r;
  58
  59         return address_pool_new(m, family, &u, prefixlen);
  60 }
  61
  62 int address_pool_setup_default(Manager *m) {
  63         int r;
  64
  65         assert(m);
  66
  67         /* Add in the well-known private address ranges. */
  68         r = address_pool_new_from_string(m, AF_INET6, "fd00::", 8);
  69         if (r < 0)
  70                 return r;
  71
  72         r = address_pool_new_from_string(m, AF_INET, "192.168.0.0", 16);
  73         if (r < 0)
  74                 return r;
  75
  76         r = address_pool_new_from_string(m, AF_INET, "172.16.0.0", 12);
  77         if (r < 0)
  78                 return r;
  79
  80         r = address_pool_new_from_string(m, AF_INET, "10.0.0.0", 8);
  81         if (r < 0)
  82                 return r;
  83
  84         return 0;
  85 }
  86
  87 static bool address_intersect(
  88                 const Address *a,
  89                 int family,
  90                 const union in_addr_union *u,
  91                 unsigned prefixlen) {
  92
  93         assert(a);
  94         assert(u);
  95
  96         if (a->family != family)
  97                 return false;
  98
  99         return in_addr_prefix_intersect(family, u, prefixlen, &a->in_addr, a->prefixlen);
 100 }
 101
 102 static bool address_pool_prefix_is_taken(
 103                 AddressPool *p,
 104                 const union in_addr_union *u,
 105                 unsigned prefixlen) {
 106
 107         Address *a;
 108         Link *l;
 109         Network *n;
 110         Request *req;
 111
 112         assert(p);
 113         assert(u);
 114
 115         /* Don't clash with assigned addresses. */
 116         HASHMAP_FOREACH(l, p->manager->links_by_index)
 117                 SET_FOREACH(a, l->addresses)
 118                         if (address_intersect(a, p->family, u, prefixlen))
 119                                 return true;
 120
 121         /* And don't clash with configured but un-assigned addresses either. */
 122         ORDERED_HASHMAP_FOREACH(n, p->manager->networks)
 123                 ORDERED_HASHMAP_FOREACH(a, n->addresses_by_section)
 124                         if (address_intersect(a, p->family, u, prefixlen))
 125                                 return true;
 126
 127         /* Also check queued addresses. */
 128         ORDERED_SET_FOREACH(req, p->manager->request_queue) {
 129                 if (req->type != REQUEST_TYPE_ADDRESS)
 130                         continue;
 131
 132                 if (address_intersect(req->userdata, p->family, u, prefixlen))
 133                         return true;
 134         }
 135
 136         return false;
 137 }
 138
 139 static int address_pool_acquire_one(AddressPool *p, int family, unsigned prefixlen, union in_addr_union *found) {
 140         union in_addr_union u;
 141         int r;
 142
 143         assert(p);
 144         assert(prefixlen > 0);
 145         assert(found);
 146
 147         if (p->family != family)
 148                 return 0;
 149
 150         if (p->prefixlen >= prefixlen)
 151                 return 0;
 152
 153         u = p->in_addr;
 154
 155         for (unsigned i = 0; i < RANDOM_PREFIX_TRIAL_MAX; i++) {
 156                 r = in_addr_random_prefix(p->family, &u, p->prefixlen, prefixlen);
 157                 if (r <= 0)
 158                         return r;
 159
 160                 if (!address_pool_prefix_is_taken(p, &u, prefixlen)) {
 161                         log_debug("Found range %s", IN_ADDR_PREFIX_TO_STRING(p->family, &u, prefixlen));
 162
 163                         *found = u;
 164                         return 1;
 165                 }
 166         }
 167
 168         return 0;
 169 }
 170
 171 int address_pool_acquire(Manager *m, int family, unsigned prefixlen, union in_addr_union *found) {
 172         AddressPool *p;
 173         int r;
 174
 175         assert(m);
 176         assert(IN_SET(family, AF_INET, AF_INET6));
 177         assert(prefixlen > 0);
 178         assert(found);
 179
 180         ORDERED_SET_FOREACH(p, m->address_pools) {
 181                 r = address_pool_acquire_one(p, family, prefixlen, found);
 182                 if (r != 0)
 183                         return r;
 184         }
 185
 186         return 0;
 187 }