src/perl/Location.xs

   1 #define PERL_NO_GET_CONTEXT
   2 #include "EXTERN.h"
   3 #include "perl.h"
   4 #include "XSUB.h"
   5
   6 #include <stdio.h>
   7 #include <string.h>
   8
   9 #include <loc/libloc.h>
  10 #include <loc/database.h>
  11 #include <loc/network.h>
  12 #include <loc/country.h>
  13
  14 MODULE = Location               PACKAGE = Location
  15
  16 struct loc_database *
  17 init(file)
  18         char* file;
  19
  20         CODE:
  21                 struct loc_ctx* ctx = NULL;
  22
  23                 // Initialise location context
  24                 int err = loc_new(&ctx);
  25                 if (err < 0)
  26                         croak("Could not initialize libloc context: %d\n", err);
  27
  28                 // Open the database file for reading
  29                 FILE* f = fopen(file, "r");
  30                 if (!f) {
  31                         loc_unref(ctx);
  32
  33                         croak("Could not open file for reading: %s: %s\n",
  34                                 file, strerror(errno));
  35                 }
  36
  37                 // Parse the database
  38                 struct loc_database* db = NULL;
  39                 err = loc_database_new(ctx, &db, f);
  40
  41                 // We can close the database file straight away
  42                 // because loc_database_new creates a copy of the file descriptor
  43                 fclose(f);
  44
  45                 if (err) {
  46                         loc_unref(ctx);
  47
  48                         croak("Could not read database: %s\n", file);
  49                 }
  50
  51                 // Cleanup
  52                 loc_unref(ctx);
  53
  54                 RETVAL = db;
  55         OUTPUT:
  56                 RETVAL
  57
  58 #
  59 # Database functions
  60 #
  61 bool
  62 verify(db, keyfile)
  63         struct loc_database* db;
  64         char* keyfile;
  65
  66         CODE:
  67                 // Try to open the keyfile
  68                 FILE* f = fopen(keyfile, "r");
  69                 if (!f) {
  70                         croak("Could not open keyfile %s: %s\n",
  71                                 keyfile, strerror(errno));
  72                 }
  73
  74                 // Verify the database
  75                 int status = loc_database_verify(db, f);
  76                 if (status) {
  77                         RETVAL = false;
  78                         fclose(f);
  79
  80                         croak("Could not verify the database signature\n");
  81                 }
  82
  83                 // Database was validated successfully
  84                 RETVAL = true;
  85
  86                 // Close the keyfile
  87                 fclose(f);
  88         OUTPUT:
  89                 RETVAL
  90
  91 const char*
  92 get_vendor(db)
  93         struct loc_database* db;
  94
  95         CODE:
  96                 // Get vendor
  97                 RETVAL = loc_database_get_vendor(db);
  98         OUTPUT:
  99                 RETVAL
 100
 101 const char*
 102 get_description(db)
 103         struct loc_database* db;
 104
 105         CODE:
 106                 // Get database description
 107                 RETVAL = loc_database_get_description(db);
 108         OUTPUT:
 109                 RETVAL
 110
 111 const char*
 112 get_license(db)
 113         struct loc_database* db;
 114
 115         CODE:
 116                 // Get database license
 117                 RETVAL = loc_database_get_license(db);
 118         OUTPUT:
 119                 RETVAL
 120
 121 void
 122 database_countries(db)
 123         struct loc_database* db;
 124
 125         PPCODE:
 126                 // Create Database enumerator
 127                 struct loc_database_enumerator* enumerator;
 128                 int err = loc_database_enumerator_new(&enumerator, db, LOC_DB_ENUMERATE_COUNTRIES);
 129
 130                 if (err) {
 131                         croak("Could not create a database enumerator\n");
 132                 }
 133
 134                 // Init and enumerate first country.
 135                 struct loc_country* country;
 136                 err = loc_database_enumerator_next_country(enumerator, &country);
 137                 if (err) {
 138                         croak("Could not enumerate next country\n");
 139                 }
 140
 141                 while (country) {
 142                         // Extract the country code.
 143                         const char* ccode = loc_country_get_code(country);
 144
 145                         // Push country code.
 146                         XPUSHs(sv_2mortal(newSVpv(ccode, 2)));
 147
 148                         // Unref country pointer.
 149                         loc_country_unref(country);
 150
 151                         // Enumerate next item.
 152                         err = loc_database_enumerator_next_country(enumerator, &country);
 153                         if (err) {
 154                                 croak("Could not enumerate next country\n");
 155                         }
 156                 }
 157
 158                 loc_database_enumerator_unref(enumerator);
 159
 160 #
 161 # Lookup functions
 162 #
 163 SV*
 164 lookup_country_code(db, address)
 165         struct loc_database* db;
 166         char* address;
 167
 168         CODE:
 169                 RETVAL = &PL_sv_undef;
 170
 171                 // Lookup network
 172                 struct loc_network *network;
 173                 int err = loc_database_lookup_from_string(db, address, &network);
 174                 if (!err) {
 175                         // Extract the country code
 176                         const char* country_code = loc_network_get_country_code(network);
 177                         RETVAL = newSVpv(country_code, strlen(country_code));
 178
 179                         loc_network_unref(network);
 180                 }
 181         OUTPUT:
 182                 RETVAL
 183
 184 SV*
 185 lookup_asn(db, address)
 186         struct loc_database* db;
 187         char* address;
 188
 189         CODE:
 190                 RETVAL = &PL_sv_undef;
 191
 192                 // Lookup network
 193                 struct loc_network *network;
 194                 int err = loc_database_lookup_from_string(db, address, &network);
 195                 if (!err) {
 196                         // Extract the ASN
 197                         unsigned int as_number = loc_network_get_asn(network);
 198                         if (as_number > 0) {
 199                                 RETVAL = newSViv(as_number);
 200                         }
 201
 202                         loc_network_unref(network);
 203                 }
 204         OUTPUT:
 205                 RETVAL
 206
 207 #
 208 # Get functions
 209 #
 210 SV*
 211 get_continent_code(db, ccode)
 212         struct loc_database* db;
 213         char* ccode;
 214
 215         CODE:
 216                 RETVAL = &PL_sv_undef;
 217
 218                 // Lookup country code
 219                 struct loc_country *country;
 220                 int err = loc_database_get_country(db, &country, ccode);
 221                 if(!err) {
 222                         //Extract the continent code for the given country code.
 223                         const char* continent_code =  loc_country_get_continent_code(country);
 224                         RETVAL = newSVpv(continent_code, strlen(continent_code));
 225
 226                         loc_country_unref(country);
 227                 }
 228
 229         OUTPUT:
 230                 RETVAL
 231
 232 void
 233 DESTROY(db)
 234         struct loc_database* db;
 235
 236         CODE:
 237                 // Close database
 238                 loc_database_unref(db);