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::/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         struct loc_network* network2;
  69         err = loc_network_new_from_string(ctx, &network2, "2001:db8:ffff::/48");
  70         if (err) {
  71                 fprintf(stderr, "Could not create the network\n");
  72                 exit(EXIT_FAILURE);
  73         }
  74
  75         err = loc_network_set_country_code(network2, "XY");
  76         if (err) {
  77                 fprintf(stderr, "Could not set country code\n");
  78                 exit(EXIT_FAILURE);
  79         }
  80
  81         // Adding network to the tree
  82         err = loc_network_tree_add_network(tree, network2);
  83         if (err) {
  84                 fprintf(stderr, "Could not add network to the tree\n");
  85                 exit(EXIT_FAILURE);
  86         }
  87
  88         // Dump the tree
  89         err = loc_network_tree_dump(tree);
  90         if (err) {
  91                 fprintf(stderr, "Error dumping tree: %d\n", err);
  92                 exit(EXIT_FAILURE);
  93         }
  94
  95         size_t nodes = loc_network_tree_count_nodes(tree);
  96         printf("The tree has %zu nodes\n", nodes);
  97
  98         // Create a database
  99         struct loc_writer* writer;
 100         err = loc_writer_new(ctx, &writer, NULL, NULL);
 101         if (err < 0)
 102                 exit(EXIT_FAILURE);
 103
 104         struct loc_network* network3;
 105         err = loc_writer_add_network(writer, &network3, "2001:db8::/64");
 106         if (err) {
 107                 fprintf(stderr, "Could not add network\n");
 108                 exit(EXIT_FAILURE);
 109         }
 110
 111         // Set country code
 112         loc_network_set_country_code(network3, "XX");
 113
 114         struct loc_network* network4;
 115         err = loc_writer_add_network(writer, &network4, "2001:db8:ffff::/64");
 116         if (err) {
 117                 fprintf(stderr, "Could not add network\n");
 118                 exit(EXIT_FAILURE);
 119         }
 120
 121         // Set country code
 122         loc_network_set_country_code(network4, "XY");
 123
 124         // Set ASN
 125         loc_network_set_asn(network4, 1024);
 126
 127         FILE* f = tmpfile();
 128         if (!f) {
 129                 fprintf(stderr, "Could not open file for writing: %s\n", strerror(errno));
 130                 exit(EXIT_FAILURE);
 131         }
 132
 133         err = loc_writer_write(writer, f, LOC_DATABASE_VERSION_UNSET);
 134         if (err) {
 135                 fprintf(stderr, "Could not write database: %s\n", strerror(-err));
 136                 exit(EXIT_FAILURE);
 137         }
 138         loc_writer_unref(writer);
 139
 140         loc_network_unref(network1);
 141         loc_network_unref(network2);
 142         loc_network_unref(network3);
 143         loc_network_unref(network4);
 144         loc_network_tree_unref(tree);
 145
 146         // And open it again from disk
 147         struct loc_database* db;
 148         err = loc_database_new(ctx, &db, f);
 149         if (err) {
 150                 fprintf(stderr, "Could not open database: %s\n", strerror(-err));
 151                 exit(EXIT_FAILURE);
 152         }
 153
 154         // Lookup an address in the subnet
 155         err = loc_database_lookup_from_string(db, "2001:db8::", &network1);
 156         if (err) {
 157                 fprintf(stderr, "Could not look up 2001:db8::\n");
 158                 exit(EXIT_FAILURE);
 159         }
 160         loc_network_unref(network1);
 161
 162         // Lookup an address outside the subnet
 163         err = loc_database_lookup_from_string(db, "2001:db8:fffe:1::", &network1);
 164         if (err == 0) {
 165                 fprintf(stderr, "Could look up 2001:db8:fffe:1::, but I shouldn't\n");
 166                 exit(EXIT_FAILURE);
 167         }
 168         loc_network_unref(network1);
 169
 170         loc_unref(ctx);
 171         fclose(f);
 172
 173         return EXIT_SUCCESS;
 174 }