LOC_EXPORT int loc_network_match_address(struct loc_network* network, const struct in6_addr* address) {
// Address must be larger than the start address
if (in6_addr_cmp(&network->first_address, address) > 0)
- return 1;
+ return 0;
// Address must be smaller than the last address
if (in6_addr_cmp(&network->last_address, address) < 0)
- return 1;
+ return 0;
// The address is inside this network
- return 0;
+ return 1;
}
LOC_EXPORT const char* loc_network_get_country_code(struct loc_network* network) {
return loc_network_has_flag(network, flag);
}
-LOC_EXPORT int loc_network_eq(struct loc_network* self, struct loc_network* other) {
- // Family must be the same
- if (self->family != other->family)
- return 0;
-
- // The start address must be the same
- if (in6_addr_cmp(&self->first_address, &other->first_address) != 0)
- return 0;
-
- // The prefix length must be the same
- if (self->prefix != other->prefix)
- return 0;
-
- return 1;
-}
-
-LOC_EXPORT int loc_network_gt(struct loc_network* self, struct loc_network* other) {
- // Families must match
- if (self->family != other->family)
- return -1;
-
+LOC_EXPORT int loc_network_cmp(struct loc_network* self, struct loc_network* other) {
+ // Compare address
int r = in6_addr_cmp(&self->first_address, &other->first_address);
+ if (r)
+ return r;
- switch (r) {
- // Smaller
- case -1:
- return 0;
-
- // Larger
- case 1:
- return 1;
-
- default:
- break;
- }
-
+ // Compare prefix
if (self->prefix > other->prefix)
return 1;
+ else if (self->prefix < other->prefix)
+ return -1;
- // Dunno
+ // Both networks are equal
return 0;
}
LOC_EXPORT int loc_network_overlaps(struct loc_network* self, struct loc_network* other) {
- if (loc_network_match_address(self, &other->first_address) == 0)
+ // Either of the start addresses must be in the other subnet
+ if (loc_network_match_address(self, &other->first_address))
return 1;
- if (loc_network_match_address(self, &other->last_address) == 0)
+ if (loc_network_match_address(other, &self->first_address))
return 1;
- if (loc_network_match_address(other, &self->first_address) == 0)
+ // Or either of the end addresses is in the other subnet
+ if (loc_network_match_address(self, &other->last_address))
return 1;
- if (loc_network_match_address(other, &self->last_address) == 0)
+ if (loc_network_match_address(other, &self->last_address))
return 1;
return 0;
}
LOC_EXPORT int loc_network_is_subnet(struct loc_network* self, struct loc_network* other) {
+ // The prefix must be smaller (this avoids the more complex comparisons later)
+ if (self->prefix > other->prefix)
+ return 0;
+
// If the start address of the other network is smaller than this network,
// it cannot be a subnet.
if (in6_addr_cmp(&self->first_address, &other->first_address) > 0)
return 1;
}
-// XXX DEPRECATED - I find this too difficult to use
-LOC_EXPORT int loc_network_is_subnet_of(struct loc_network* self, struct loc_network* other) {
- return loc_network_is_subnet(other, self);
-}
-
LOC_EXPORT int loc_network_subnets(struct loc_network* network,
struct loc_network** subnet1, struct loc_network** subnet2) {
int r;
if (r)
goto ERROR;
- if (loc_network_eq(other, subnet1)) {
+ if (loc_network_cmp(other, subnet1) == 0) {
r = loc_network_list_push(list, subnet2);
if (r)
goto ERROR;
- } else if (loc_network_eq(other, subnet2)) {
+ } else if (loc_network_cmp(other, subnet2) == 0) {
r = loc_network_list_push(list, subnet1);
if (r)
goto ERROR;
- } else if (loc_network_is_subnet_of(other, subnet1)) {
+ } else if (loc_network_is_subnet(subnet1, other)) {
r = loc_network_list_push(list, subnet2);
if (r)
goto ERROR;
if (r)
goto ERROR;
- } else if (loc_network_is_subnet_of(other, subnet2)) {
+ } else if (loc_network_is_subnet(subnet2, other)) {
r = loc_network_list_push(list, subnet1);
if (r)
goto ERROR;
return r;
}
+static int __loc_network_exclude_to_list(struct loc_network* self,
+ struct loc_network* other, struct loc_network_list* list) {
+ // Other must be a subnet of self
+ if (!loc_network_is_subnet(self, other)) {
+ DEBUG(self->ctx, "Network %p is not contained in network %p\n", other, self);
+
+ // Exit silently
+ return 0;
+ }
+
+ // We cannot perform this operation if both networks equal
+ if (loc_network_cmp(self, other) == 0) {
+ DEBUG(self->ctx, "Networks %p and %p are equal\n", self, other);
+
+ // Exit silently
+ return 0;
+ }
+
+ return __loc_network_exclude(self, other, list);
+}
+
LOC_EXPORT struct loc_network_list* loc_network_exclude(
struct loc_network* self, struct loc_network* other) {
struct loc_network_list* list;
free(n2);
#endif
- // Family must match
- if (self->family != other->family) {
- DEBUG(self->ctx, "Family mismatch\n");
-
- return NULL;
- }
-
- // Other must be a subnet of self
- if (!loc_network_is_subnet_of(other, self)) {
- DEBUG(self->ctx, "Network %p is not contained in network %p\n", other, self);
-
- return NULL;
- }
-
- // We cannot perform this operation if both networks equal
- if (loc_network_eq(self, other)) {
- DEBUG(self->ctx, "Networks %p and %p are equal\n", self, other);
-
- return NULL;
- }
-
// Create a new list with the result
int r = loc_network_list_new(self->ctx, &list);
if (r) {
ERROR(self->ctx, "Could not create network list: %d\n", r);
+
return NULL;
}
- r = __loc_network_exclude(self, other, list);
+ r = __loc_network_exclude_to_list(self, other, list);
if (r) {
loc_network_list_unref(list);
subnet = loc_network_list_get(list, i);
// Find all excluded networks
- struct loc_network_list* excluded = loc_network_exclude(network, subnet);
- if (excluded) {
- // Add them all to the "to check" list
- loc_network_list_merge(to_check, excluded);
- loc_network_list_unref(excluded);
+ if (!loc_network_list_contains(to_check, subnet)) {
+ r = __loc_network_exclude_to_list(network, subnet, to_check);
+ if (r) {
+ loc_network_list_unref(to_check);
+ loc_network_unref(subnet);
+
+ return NULL;
+ }
}
// Cleanup
while (!loc_network_list_empty(to_check)) {
struct loc_network* subnet_to_check = loc_network_list_pop(to_check);
+ // Check whether the subnet to check is part of the input list
+ if (loc_network_list_contains(list, subnet_to_check)) {
+ loc_network_unref(subnet_to_check);
+ continue;
+ }
+
// Marks whether this subnet passed all checks
int passed = 1;
for (unsigned int i = 0; i < loc_network_list_size(list); i++) {
subnet = loc_network_list_get(list, i);
- // Drop this subnet if is is already in list
- if (loc_network_eq(subnet_to_check, subnet)) {
- passed = 0;
- loc_network_unref(subnet);
- break;
- }
-
// Drop this subnet if is a subnet of another subnet
- if (loc_network_is_subnet_of(subnet, subnet_to_check)) {
+ if (loc_network_is_subnet(subnet_to_check, subnet)) {
passed = 0;
loc_network_unref(subnet);
break;