src/network/networkd-address-pool.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2014 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include "alloc-util.h"
  21 #include "networkd-address-pool.h"
  22 #include "networkd.h"
  23 #include "set.h"
  24 #include "string-util.h"
  25
  26 int address_pool_new(
  27                 Manager *m,
  28                 AddressPool **ret,
  29                 int family,
  30                 const union in_addr_union *u,
  31                 unsigned prefixlen) {
  32
  33         AddressPool *p;
  34
  35         assert(m);
  36         assert(ret);
  37         assert(u);
  38
  39         p = new0(AddressPool, 1);
  40         if (!p)
  41                 return -ENOMEM;
  42
  43         p->manager = m;
  44         p->family = family;
  45         p->prefixlen = prefixlen;
  46         p->in_addr = *u;
  47
  48         LIST_PREPEND(address_pools, m->address_pools, p);
  49
  50         *ret = p;
  51         return 0;
  52 }
  53
  54 int address_pool_new_from_string(
  55                 Manager *m,
  56                 AddressPool **ret,
  57                 int family,
  58                 const char *p,
  59                 unsigned prefixlen) {
  60
  61         union in_addr_union u;
  62         int r;
  63
  64         assert(m);
  65         assert(ret);
  66         assert(p);
  67
  68         r = in_addr_from_string(family, p, &u);
  69         if (r < 0)
  70                 return r;
  71
  72         return address_pool_new(m, ret, family, &u, prefixlen);
  73 }
  74
  75 void address_pool_free(AddressPool *p) {
  76
  77         if (!p)
  78                 return;
  79
  80         if (p->manager)
  81                 LIST_REMOVE(address_pools, p->manager->address_pools, p);
  82
  83         free(p);
  84 }
  85
  86 static bool address_pool_prefix_is_taken(
  87                 AddressPool *p,
  88                 const union in_addr_union *u,
  89                 unsigned prefixlen) {
  90
  91         Iterator i;
  92         Link *l;
  93         Network *n;
  94
  95         assert(p);
  96         assert(u);
  97
  98         HASHMAP_FOREACH(l, p->manager->links, i) {
  99                 Address *a;
 100                 Iterator j;
 101
 102                 /* Don't clash with assigned addresses */
 103                 SET_FOREACH(a, l->addresses, j) {
 104                         if (a->family != p->family)
 105                                 continue;
 106
 107                         if (in_addr_prefix_intersect(p->family, u, prefixlen, &a->in_addr, a->prefixlen))
 108                                 return true;
 109                 }
 110
 111                 /* Don't clash with addresses already pulled from the pool, but not assigned yet */
 112                 LIST_FOREACH(addresses, a, l->pool_addresses) {
 113                         if (a->family != p->family)
 114                                 continue;
 115
 116                         if (in_addr_prefix_intersect(p->family, u, prefixlen, &a->in_addr, a->prefixlen))
 117                                 return true;
 118                 }
 119         }
 120
 121         /* And don't clash with configured but un-assigned addresses either */
 122         LIST_FOREACH(networks, n, p->manager->networks) {
 123                 Address *a;
 124
 125                 LIST_FOREACH(addresses, a, n->static_addresses) {
 126                         if (a->family != p->family)
 127                                 continue;
 128
 129                         if (in_addr_prefix_intersect(p->family, u, prefixlen, &a->in_addr, a->prefixlen))
 130                                 return true;
 131                 }
 132         }
 133
 134         return false;
 135 }
 136
 137 int address_pool_acquire(AddressPool *p, unsigned prefixlen, union in_addr_union *found) {
 138         union in_addr_union u;
 139
 140         assert(p);
 141         assert(prefixlen > 0);
 142         assert(found);
 143
 144         if (p->prefixlen > prefixlen)
 145                 return 0;
 146
 147         u = p->in_addr;
 148         for (;;) {
 149                 if (!address_pool_prefix_is_taken(p, &u, prefixlen)) {
 150                         _cleanup_free_ char *s = NULL;
 151                         int r;
 152
 153                         r = in_addr_to_string(p->family, &u, &s);
 154                         if (r < 0)
 155                                 return r;
 156
 157                         log_debug("Found range %s/%u", strna(s), prefixlen);
 158
 159                         *found = u;
 160                         return 1;
 161                 }
 162
 163                 if (!in_addr_prefix_next(p->family, &u, prefixlen))
 164                         return 0;
 165
 166                 if (!in_addr_prefix_intersect(p->family, &p->in_addr, p->prefixlen, &u, prefixlen))
 167                         return 0;
 168         }
 169
 170         return 0;
 171 }