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 #if 0
  41         struct loc_network_tree* tree;
  42         err = loc_network_tree_new(ctx, &tree);
  43         if (err) {
  44                 fprintf(stderr, "Could not create the network tree\n");
  45                 exit(EXIT_FAILURE);
  46         }
  47 #endif
  48
  49         // Create a network
  50         struct loc_network* network1;
  51         err = loc_network_new_from_string(ctx, &network1, "2001:db8::1/32");
  52         if (err) {
  53                 fprintf(stderr, "Could not create the network\n");
  54                 exit(EXIT_FAILURE);
  55         }
  56
  57         err = loc_network_set_country_code(network1, "XX");
  58         if (err) {
  59                 fprintf(stderr, "Could not set country code\n");
  60                 exit(EXIT_FAILURE);
  61         }
  62
  63 #if 0
  64         // Adding network to the tree
  65         err = loc_network_tree_add_network(tree, network1);
  66         if (err) {
  67                 fprintf(stderr, "Could not add network to the tree\n");
  68                 exit(EXIT_FAILURE);
  69         }
  70 #endif
  71
  72         // Check if the first and last addresses are correct
  73         char* string = loc_network_format_first_address(network1);
  74         if (!string) {
  75                 fprintf(stderr, "Did get NULL instead of a string for the first address\n");
  76                 exit(EXIT_FAILURE);
  77         }
  78
  79         if (strcmp(string, "2001:db8::") != 0) {
  80                 fprintf(stderr, "Got an incorrect first address: %s\n", string);
  81                 exit(EXIT_FAILURE);
  82         }
  83
  84         string = loc_network_format_last_address(network1);
  85         if (!string) {
  86                 fprintf(stderr, "Did get NULL instead of a string for the last address\n");
  87                 exit(EXIT_FAILURE);
  88         }
  89
  90         if (strcmp(string, "2001:db8:ffff:ffff:ffff:ffff:ffff:ffff") != 0) {
  91                 fprintf(stderr, "Got an incorrect last address: %s\n", string);
  92                 exit(EXIT_FAILURE);
  93         }
  94
  95         struct loc_network* network2;
  96         err = loc_network_new_from_string(ctx, &network2, "2001:db8:ffff::/48");
  97         if (err) {
  98                 fprintf(stderr, "Could not create the network\n");
  99                 exit(EXIT_FAILURE);
 100         }
 101
 102         err = loc_network_set_country_code(network2, "XY");
 103         if (err) {
 104                 fprintf(stderr, "Could not set country code\n");
 105                 exit(EXIT_FAILURE);
 106         }
 107
 108 #if 0
 109         // Adding network to the tree
 110         err = loc_network_tree_add_network(tree, network2);
 111         if (err) {
 112                 fprintf(stderr, "Could not add network to the tree\n");
 113                 exit(EXIT_FAILURE);
 114         }
 115
 116         // Dump the tree
 117         err = loc_network_tree_dump(tree);
 118         if (err) {
 119                 fprintf(stderr, "Error dumping tree: %d\n", err);
 120                 exit(EXIT_FAILURE);
 121         }
 122
 123         size_t nodes = loc_network_tree_count_nodes(tree);
 124         printf("The tree has %zu nodes\n", nodes);
 125 #endif
 126
 127         // Check equals function
 128         err = loc_network_eq(network1, network1);
 129         if (!err) {
 130                 fprintf(stderr, "Network is not equal with itself\n");
 131                 exit(EXIT_FAILURE);
 132         }
 133
 134         err = loc_network_eq(network1, network2);
 135         if (err) {
 136                 fprintf(stderr, "Networks equal unexpectedly\n");
 137                 exit(EXIT_FAILURE);
 138         }
 139
 140         // Check subnet function
 141         err = loc_network_is_subnet(network1, network2);
 142         if (!err) {
 143                 fprintf(stderr, "Subnet check 1 failed: %d\n", err);
 144                 exit(EXIT_FAILURE);
 145         }
 146
 147         err = loc_network_is_subnet(network2, network1);
 148         if (err) {
 149                 fprintf(stderr, "Subnet check 2 failed: %d\n", err);
 150                 exit(EXIT_FAILURE);
 151         }
 152
 153         // Make subnets
 154         struct loc_network* subnet1 = NULL;
 155         struct loc_network* subnet2 = NULL;
 156
 157         err  = loc_network_subnets(network1, &subnet1, &subnet2);
 158         if (err || !subnet1 || !subnet2) {
 159                 fprintf(stderr, "Could not find subnets of network: %d\n", err);
 160                 exit(EXIT_FAILURE);
 161         }
 162
 163         char* s = loc_network_str(subnet1);
 164         printf("Received subnet1 = %s\n", s);
 165         free(s);
 166
 167         s = loc_network_str(subnet2);
 168         printf("Received subnet2 = %s\n", s);
 169         free(s);
 170
 171         if (!loc_network_is_subnet(network1, subnet1)) {
 172                 fprintf(stderr, "Subnet1 is not a subnet\n");
 173                 exit(EXIT_FAILURE);
 174         }
 175
 176         if (!loc_network_is_subnet(network1, subnet2)) {
 177                 fprintf(stderr, "Subnet2 is not a subnet\n");
 178                 exit(EXIT_FAILURE);
 179         }
 180
 181         loc_network_unref(subnet1);
 182         loc_network_unref(subnet2);
 183
 184         struct loc_network_list* excluded = loc_network_exclude(network1, network2);
 185         if (!excluded) {
 186                 fprintf(stderr, "Could not create excluded list\n");
 187                 exit(EXIT_FAILURE);
 188         }
 189
 190         loc_network_list_dump(excluded);
 191
 192         // Reverse it
 193         loc_network_list_reverse(excluded);
 194         loc_network_list_dump(excluded);
 195
 196         // Sort them and dump them again
 197         loc_network_list_sort(excluded);
 198         loc_network_list_dump(excluded);
 199
 200         loc_network_list_unref(excluded);
 201
 202         // Create a database
 203         struct loc_writer* writer;
 204         err = loc_writer_new(ctx, &writer, NULL, NULL);
 205         if (err < 0)
 206                 exit(EXIT_FAILURE);
 207
 208         struct loc_network* network3;
 209         err = loc_writer_add_network(writer, &network3, "2001:db8::/64");
 210         if (err) {
 211                 fprintf(stderr, "Could not add network\n");
 212                 exit(EXIT_FAILURE);
 213         }
 214
 215         // Set country code
 216         loc_network_set_country_code(network3, "XX");
 217
 218         struct loc_network* network4;
 219         err = loc_writer_add_network(writer, &network4, "2001:db8:ffff::/64");
 220         if (err) {
 221                 fprintf(stderr, "Could not add network\n");
 222                 exit(EXIT_FAILURE);
 223         }
 224
 225         // Set country code
 226         loc_network_set_country_code(network4, "XY");
 227
 228         // Set ASN
 229         loc_network_set_asn(network4, 1024);
 230
 231         // Try adding an invalid network
 232         struct loc_network* network;
 233         err = loc_writer_add_network(writer, &network, "xxxx:xxxx::/32");
 234         if (err != -EINVAL) {
 235                 fprintf(stderr, "It was possible to add an invalid network (err = %d)\n", err);
 236                 exit(EXIT_FAILURE);
 237         }
 238
 239         // Try adding a single address
 240         err = loc_writer_add_network(writer, &network, "2001:db8::");
 241         if (err) {
 242                 fprintf(stderr, "It was impossible to add an single IP address (err = %d)\n", err);
 243                 exit(EXIT_FAILURE);
 244         }
 245
 246         // Try adding localhost
 247         err = loc_writer_add_network(writer, &network, "::1/128");
 248         if (err != -EINVAL) {
 249                 fprintf(stderr, "It was possible to add localhost (::1/128): %d\n", err);
 250                 exit(EXIT_FAILURE);
 251         }
 252
 253         FILE* f = tmpfile();
 254         if (!f) {
 255                 fprintf(stderr, "Could not open file for writing: %s\n", strerror(errno));
 256                 exit(EXIT_FAILURE);
 257         }
 258
 259         err = loc_writer_write(writer, f, LOC_DATABASE_VERSION_UNSET);
 260         if (err) {
 261                 fprintf(stderr, "Could not write database: %s\n", strerror(-err));
 262                 exit(EXIT_FAILURE);
 263         }
 264         loc_writer_unref(writer);
 265
 266         loc_network_unref(network1);
 267         loc_network_unref(network2);
 268         loc_network_unref(network3);
 269         loc_network_unref(network4);
 270
 271 #if 0
 272         loc_network_tree_unref(tree);
 273 #endif
 274
 275         // And open it again from disk
 276         struct loc_database* db;
 277         err = loc_database_new(ctx, &db, f);
 278         if (err) {
 279                 fprintf(stderr, "Could not open database: %s\n", strerror(-err));
 280                 exit(EXIT_FAILURE);
 281         }
 282
 283         // Lookup an address in the subnet
 284         err = loc_database_lookup_from_string(db, "2001:db8::", &network1);
 285         if (err) {
 286                 fprintf(stderr, "Could not look up 2001:db8::\n");
 287                 exit(EXIT_FAILURE);
 288         }
 289         loc_network_unref(network1);
 290
 291         // Lookup an address outside the subnet
 292         err = loc_database_lookup_from_string(db, "2001:db8:fffe:1::", &network1);
 293         if (err == 0) {
 294                 fprintf(stderr, "Could look up 2001:db8:fffe:1::, but I shouldn't\n");
 295                 exit(EXIT_FAILURE);
 296         }
 297         loc_network_unref(network1);
 298
 299         loc_unref(ctx);
 300         fclose(f);
 301
 302         return EXIT_SUCCESS;
 303 }