src/test-network.c

   1 /*
   2         libloc - A library to determine the location of someone on the Internet
   3
   4         Copyright (C) 2017 IPFire Development Team <info@ipfire.org>
   5
   6         This program is free software; you can redistribute it and/or modify
   7         it under the terms of the GNU General Public License as published by
   8         the Free Software Foundation; either version 2 of the License, or
   9         (at your option) any later version.
  10
  11         This program is distributed in the hope that it will be useful,
  12         but WITHOUT ANY WARRANTY; without even the implied warranty of
  13         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14         GNU General Public License for more details.
  15 */
  16
  17 #include <errno.h>
  18 #include <stdio.h>
  19 #include <stddef.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <syslog.h>
  23
  24 #include <loc/libloc.h>
  25 #include <loc/database.h>
  26 #include <loc/network.h>
  27 #include <loc/writer.h>
  28
  29 int main(int argc, char** argv) {
  30         int err;
  31
  32         struct loc_ctx* ctx;
  33         err = loc_new(&ctx);
  34         if (err < 0)
  35                 exit(EXIT_FAILURE);
  36
  37         // Enable debug logging
  38         loc_set_log_priority(ctx, LOG_DEBUG);
  39
  40         struct loc_network_tree* tree;
  41         err = loc_network_tree_new(ctx, &tree);
  42         if (err) {
  43                 fprintf(stderr, "Could not create the network tree\n");
  44                 exit(EXIT_FAILURE);
  45         }
  46
  47         // Create a network
  48         struct loc_network* network1;
  49         err = loc_network_new_from_string(ctx, &network1, "2001:db8::1/32");
  50         if (err) {
  51                 fprintf(stderr, "Could not create the network\n");
  52                 exit(EXIT_FAILURE);
  53         }
  54
  55         err = loc_network_set_country_code(network1, "XX");
  56         if (err) {
  57                 fprintf(stderr, "Could not set country code\n");
  58                 exit(EXIT_FAILURE);
  59         }
  60
  61         // Adding network to the tree
  62         err = loc_network_tree_add_network(tree, network1);
  63         if (err) {
  64                 fprintf(stderr, "Could not add network to the tree\n");
  65                 exit(EXIT_FAILURE);
  66         }
  67
  68         // Check if the first and last addresses are correct
  69         char* string = loc_network_format_first_address(network1);
  70         if (!string) {
  71                 fprintf(stderr, "Did get NULL instead of a string for the first address\n");
  72                 exit(EXIT_FAILURE);
  73         }
  74
  75         if (strcmp(string, "2001:db8::") != 0) {
  76                 fprintf(stderr, "Got an incorrect first address: %s\n", string);
  77                 exit(EXIT_FAILURE);
  78         }
  79
  80         string = loc_network_format_last_address(network1);
  81         if (!string) {
  82                 fprintf(stderr, "Did get NULL instead of a string for the last address\n");
  83                 exit(EXIT_FAILURE);
  84         }
  85
  86         if (strcmp(string, "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff") != 0) {
  87                 fprintf(stderr, "Got an incorrect last address: %s\n", string);
  88                 exit(EXIT_FAILURE);
  89         }
  90
  91         struct loc_network* network2;
  92         err = loc_network_new_from_string(ctx, &network2, "2001:db8:ffff::/48");
  93         if (err) {
  94                 fprintf(stderr, "Could not create the network\n");
  95                 exit(EXIT_FAILURE);
  96         }
  97
  98         err = loc_network_set_country_code(network2, "XY");
  99         if (err) {
 100                 fprintf(stderr, "Could not set country code\n");
 101                 exit(EXIT_FAILURE);
 102         }
 103
 104         // Adding network to the tree
 105         err = loc_network_tree_add_network(tree, network2);
 106         if (err) {
 107                 fprintf(stderr, "Could not add network to the tree\n");
 108                 exit(EXIT_FAILURE);
 109         }
 110
 111         // Dump the tree
 112         err = loc_network_tree_dump(tree);
 113         if (err) {
 114                 fprintf(stderr, "Error dumping tree: %d\n", err);
 115                 exit(EXIT_FAILURE);
 116         }
 117
 118         size_t nodes = loc_network_tree_count_nodes(tree);
 119         printf("The tree has %zu nodes\n", nodes);
 120
 121         // Check subnet function
 122         err = loc_network_is_subnet_of(network1, network2);
 123         if (err != 0) {
 124                 fprintf(stderr, "Subnet check 1 failed: %d\n", err);
 125                 exit(EXIT_FAILURE);
 126         }
 127
 128         err = loc_network_is_subnet_of(network2, network1);
 129         if (err != 1) {
 130                 fprintf(stderr, "Subnet check 2 failed: %d\n", err);
 131                 exit(EXIT_FAILURE);
 132         }
 133
 134         // Create a database
 135         struct loc_writer* writer;
 136         err = loc_writer_new(ctx, &writer, NULL, NULL);
 137         if (err < 0)
 138                 exit(EXIT_FAILURE);
 139
 140         struct loc_network* network3;
 141         err = loc_writer_add_network(writer, &network3, "2001:db8::/64");
 142         if (err) {
 143                 fprintf(stderr, "Could not add network\n");
 144                 exit(EXIT_FAILURE);
 145         }
 146
 147         // Set country code
 148         loc_network_set_country_code(network3, "XX");
 149
 150         struct loc_network* network4;
 151         err = loc_writer_add_network(writer, &network4, "2001:db8:ffff::/64");
 152         if (err) {
 153                 fprintf(stderr, "Could not add network\n");
 154                 exit(EXIT_FAILURE);
 155         }
 156
 157         // Set country code
 158         loc_network_set_country_code(network4, "XY");
 159
 160         // Set ASN
 161         loc_network_set_asn(network4, 1024);
 162
 163         // Try adding an invalid network
 164         struct loc_network* network;
 165         err = loc_writer_add_network(writer, &network, "xxxx:xxxx::/32");
 166         if (err != -EINVAL) {
 167                 fprintf(stderr, "It was possible to add an invalid network (err = %d)\n", err);
 168                 exit(EXIT_FAILURE);
 169         }
 170
 171         FILE* f = tmpfile();
 172         if (!f) {
 173                 fprintf(stderr, "Could not open file for writing: %s\n", strerror(errno));
 174                 exit(EXIT_FAILURE);
 175         }
 176
 177         err = loc_writer_write(writer, f, LOC_DATABASE_VERSION_UNSET);
 178         if (err) {
 179                 fprintf(stderr, "Could not write database: %s\n", strerror(-err));
 180                 exit(EXIT_FAILURE);
 181         }
 182         loc_writer_unref(writer);
 183
 184         loc_network_unref(network1);
 185         loc_network_unref(network2);
 186         loc_network_unref(network3);
 187         loc_network_unref(network4);
 188         loc_network_tree_unref(tree);
 189
 190         // And open it again from disk
 191         struct loc_database* db;
 192         err = loc_database_new(ctx, &db, f);
 193         if (err) {
 194                 fprintf(stderr, "Could not open database: %s\n", strerror(-err));
 195                 exit(EXIT_FAILURE);
 196         }
 197
 198         // Lookup an address in the subnet
 199         err = loc_database_lookup_from_string(db, "2001:db8::", &network1);
 200         if (err) {
 201                 fprintf(stderr, "Could not look up 2001:db8::\n");
 202                 exit(EXIT_FAILURE);
 203         }
 204         loc_network_unref(network1);
 205
 206         // Lookup an address outside the subnet
 207         err = loc_database_lookup_from_string(db, "2001:db8:fffe:1::", &network1);
 208         if (err == 0) {
 209                 fprintf(stderr, "Could look up 2001:db8:fffe:1::, but I shouldn't\n");
 210                 exit(EXIT_FAILURE);
 211         }
 212         loc_network_unref(network1);
 213
 214         loc_unref(ctx);
 215         fclose(f);
 216
 217         return EXIT_SUCCESS;
 218 }