+ if (self->prefix > other->prefix)
+ return 1;
+
+ // Dunno
+ 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)
+ return 1;
+
+ if (loc_network_match_address(self, &other->last_address) == 0)
+ return 1;
+
+ if (loc_network_match_address(other, &self->first_address) == 0)
+ return 1;
+
+ if (loc_network_match_address(other, &self->last_address) == 0)
+ return 1;
+
+ return 0;
+}
+
+LOC_EXPORT int loc_network_is_subnet(struct loc_network* self, struct loc_network* other) {
+ // Check family
+ if (self->family != other->family)
+ return 0;
+
+ // 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 0;
+
+ // If the end address of the other network is greater than this network,
+ // it cannot be a subnet.
+ if (in6_addr_cmp(&self->last_address, &other->last_address) < 0)
+ return 0;
+
+ return 1;
+}
+
+LOC_EXPORT int loc_network_subnets(struct loc_network* network,
+ struct loc_network** subnet1, struct loc_network** subnet2) {
+ int r;
+ *subnet1 = NULL;
+ *subnet2 = NULL;
+
+ // New prefix length
+ unsigned int prefix = network->prefix + 1;
+
+ // Check if the new prefix is valid
+ if (valid_prefix(&network->first_address, prefix))
+ return -1;
+
+ // Create the first half of the network
+ r = loc_network_new(network->ctx, subnet1, &network->first_address, prefix);
+ if (r)
+ return r;
+
+ // The next subnet starts after the first one
+ struct in6_addr first_address = address_increment(&(*subnet1)->last_address);
+
+ // Create the second half of the network
+ r = loc_network_new(network->ctx, subnet2, &first_address, prefix);
+ if (r)
+ return r;
+
+ // Copy country code
+ const char* country_code = loc_network_get_country_code(network);
+ if (country_code) {
+ loc_network_set_country_code(*subnet1, country_code);
+ loc_network_set_country_code(*subnet2, country_code);
+ }
+
+ // Copy ASN
+ uint32_t asn = loc_network_get_asn(network);
+ if (asn) {
+ loc_network_set_asn(*subnet1, asn);
+ loc_network_set_asn(*subnet2, asn);
+ }
+
+ return 0;
+}
+
+static int __loc_network_exclude(struct loc_network* network,
+ struct loc_network* other, struct loc_network_list* list) {
+ struct loc_network* subnet1 = NULL;
+ struct loc_network* subnet2 = NULL;
+
+ int r = loc_network_subnets(network, &subnet1, &subnet2);
+ if (r)
+ goto ERROR;
+
+ if (loc_network_eq(other, subnet1)) {
+ r = loc_network_list_push(list, subnet2);
+ if (r)
+ goto ERROR;
+
+ } else if (loc_network_eq(other, subnet2)) {
+ r = loc_network_list_push(list, subnet1);
+ if (r)
+ goto ERROR;
+
+ } else if (loc_network_is_subnet(subnet1, other)) {
+ r = loc_network_list_push(list, subnet2);
+ if (r)
+ goto ERROR;
+
+ r = __loc_network_exclude(subnet1, other, list);
+ if (r)
+ goto ERROR;
+
+ } else if (loc_network_is_subnet(subnet2, other)) {
+ r = loc_network_list_push(list, subnet1);
+ if (r)
+ goto ERROR;
+
+ r = __loc_network_exclude(subnet2, other, list);
+ if (r)
+ goto ERROR;
+
+ } else {
+ ERROR(network->ctx, "We should never get here\n");
+ r = 1;
+ goto ERROR;
+ }
+
+ERROR:
+ if (subnet1)
+ loc_network_unref(subnet1);
+
+ if (subnet2)
+ loc_network_unref(subnet2);
+
+ return r;
+}
+
+LOC_EXPORT struct loc_network_list* loc_network_exclude(
+ struct loc_network* self, struct loc_network* other) {
+ struct loc_network_list* list;
+
+#ifdef ENABLE_DEBUG
+ char* n1 = loc_network_str(self);
+ char* n2 = loc_network_str(other);
+
+ DEBUG(self->ctx, "Returning %s excluding %s...\n", n1, n2);
+
+ free(n1);
+ 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(self, other)) {
+ 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);
+ if (r) {
+ loc_network_list_unref(list);
+
+ return NULL;
+ }
+
+ // Return the result
+ return list;
+}
+
+LOC_EXPORT struct loc_network_list* loc_network_exclude_list(
+ struct loc_network* network, struct loc_network_list* list) {
+ struct loc_network_list* to_check;
+
+ // Create a new list with all networks to look at
+ int r = loc_network_list_new(network->ctx, &to_check);
+ if (r)
+ return NULL;
+
+ struct loc_network* subnet = NULL;
+ struct loc_network_list* subnets = NULL;
+
+ for (unsigned int i = 0; i < loc_network_list_size(list); i++) {
+ 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);
+ }
+
+ // Cleanup
+ loc_network_unref(subnet);
+ }
+
+ r = loc_network_list_new(network->ctx, &subnets);
+ if (r) {
+ loc_network_list_unref(to_check);
+ return NULL;
+ }
+
+ while (!loc_network_list_empty(to_check)) {
+ struct loc_network* subnet_to_check = loc_network_list_pop(to_check);
+
+ // 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(subnet_to_check, subnet)) {
+ passed = 0;
+ loc_network_unref(subnet);
+ break;
+ }
+
+ // Break it down if it overlaps
+ if (loc_network_overlaps(subnet_to_check, subnet)) {
+ passed = 0;
+
+ struct loc_network_list* excluded = loc_network_exclude(subnet_to_check, subnet);
+ if (excluded) {
+ loc_network_list_merge(to_check, excluded);
+ loc_network_list_unref(excluded);
+ }
+
+ loc_network_unref(subnet);
+ break;
+ }
+
+ loc_network_unref(subnet);
+ }
+
+ if (passed) {
+ r = loc_network_list_push(subnets, subnet_to_check);
+ }
+
+ loc_network_unref(subnet_to_check);
+ }
+
+ loc_network_list_unref(to_check);
+
+ // Sort the result
+ loc_network_list_sort(subnets);
+
+ return subnets;
+}
+
+LOC_EXPORT int loc_network_to_database_v1(struct loc_network* network, struct loc_database_network_v1* dbobj) {
+ // Add country code
+ loc_country_code_copy(dbobj->country_code, network->country_code);
+