src/mod_geoip.c

   1 #include "first.h"
   2
   3 #include <GeoIP.h>
   4 #include <GeoIPCity.h>
   5
   6 #include "base.h"
   7 #include "log.h"
   8 #include "buffer.h"
   9 #include "plugin.h"
  10
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 /**
  15  *
  16  * $mod_geoip.c (v2.0) (13.09.2006 00:29:11)
  17  *
  18  * Name:
  19  *      mod_geoip.c
  20  *
  21  * Description:
  22  *      GeoIP module (plugin) for lighttpd.
  23  *      the module loads a geoip database of type "country" or "city" and
  24  *      sets new ENV vars based on ip record lookups.
  25  *
  26  *      country db env's:
  27  *              GEOIP_COUNTRY_CODE
  28  *              GEOIP_COUNTRY_CODE3
  29  *              GEOIP_COUNTRY_NAME
  30  *
  31  *      city db env's:
  32  *              GEOIP_COUNTRY_CODE
  33  *              GEOIP_COUNTRY_CODE3
  34  *              GEOIP_COUNTRY_NAME
  35  *              GEOIP_CITY_NAME
  36  *              GEOIP_CITY_POSTAL_CODE
  37  *              GEOIP_CITY_LATITUDE
  38  *              GEOIP_CITY_LONG_LATITUDE
  39  *              GEOIP_CITY_DMA_CODE
  40  *              GEOIP_CITY_AREA_CODE
  41  *
  42  * Usage (configuration options):
  43  *      geoip.db-filename = <path to the geoip or geocity database>
  44  *      geoip.memory-cache = <enable|disable> : default disabled
  45  *              if enabled, mod_geoip will load the database binary file to
  46  *              memory for very fast lookups. the only penalty is memory usage.
  47  *
  48  * Author:
  49  *      Ami E. Bizamcher (amix)
  50  *      duke.amix@gmail.com
  51  *
  52  * Note:
  53  *      GeoIP Library and API must be installed!
  54  */
  55
  56
  57 /* plugin config for all request/connections */
  58
  59 typedef struct {
  60         unsigned short mem_cache;
  61         buffer  *db_name;
  62         GeoIP   *gi;
  63 } plugin_config;
  64
  65 typedef struct {
  66         PLUGIN_DATA;
  67
  68         plugin_config **config_storage;
  69
  70         plugin_config conf;
  71 } plugin_data;
  72
  73 /* init the plugin data */
  74 INIT_FUNC(mod_geoip_init) {
  75         plugin_data *p;
  76
  77         p = calloc(1, sizeof(*p));
  78
  79         return p;
  80 }
  81
  82 /* destroy the plugin data */
  83 FREE_FUNC(mod_geoip_free) {
  84         plugin_data *p = p_d;
  85
  86         UNUSED(srv);
  87
  88         if (!p) return HANDLER_GO_ON;
  89
  90         if (p->config_storage) {
  91                 size_t i;
  92
  93                 for (i = 0; i < srv->config_context->used; i++) {
  94                         plugin_config *s = p->config_storage[i];
  95
  96                         if (!s) continue;
  97
  98                         buffer_free(s->db_name);
  99
 100                         /* clean up */
 101                         if (s->gi) GeoIP_delete(s->gi);
 102
 103                         free(s);
 104                 }
 105                 free(p->config_storage);
 106         }
 107
 108         free(p);
 109
 110         return HANDLER_GO_ON;
 111 }
 112
 113 /* handle plugin config and check values */
 114
 115 SETDEFAULTS_FUNC(mod_geoip_set_defaults) {
 116         plugin_data *p = p_d;
 117         size_t i = 0;
 118
 119         config_values_t cv[] = {
 120                 { "geoip.db-filename",  NULL, T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION },     /* 0 */
 121                 { "geoip.memory-cache", NULL, T_CONFIG_BOOLEAN, T_CONFIG_SCOPE_CONNECTION },    /* 1 */
 122                 { NULL,                 NULL, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET }
 123         };
 124
 125         if (!p) return HANDLER_ERROR;
 126
 127         p->config_storage = calloc(1, srv->config_context->used * sizeof(plugin_config *));
 128
 129         for (i = 0; i < srv->config_context->used; i++) {
 130                 data_config const* config = (data_config const*)srv->config_context->data[i];
 131                 plugin_config *s;
 132                 int mode;
 133
 134                 s = calloc(1, sizeof(plugin_config));
 135
 136                 s->db_name = buffer_init();
 137                 s->mem_cache = 0; /* default: do not load db to cache */
 138                 s->gi = NULL;
 139
 140                 cv[0].destination = s->db_name;
 141                 cv[1].destination = &(s->mem_cache);
 142
 143                 p->config_storage[i] = s;
 144
 145                 if (0 != config_insert_values_global(srv, config->value, cv, i == 0 ? T_CONFIG_SCOPE_SERVER : T_CONFIG_SCOPE_CONNECTION)) {
 146                         return HANDLER_ERROR;
 147                 }
 148
 149                 mode = GEOIP_STANDARD | GEOIP_CHECK_CACHE;
 150
 151                 /* country db filename is requeried! */
 152                 if (!buffer_is_empty(s->db_name)) {
 153
 154                         /* let's start cooking */
 155                         if (s->mem_cache != 0)
 156                                 mode = GEOIP_MEMORY_CACHE | GEOIP_CHECK_CACHE;
 157
 158                         if (NULL == (s->gi = GeoIP_open(s->db_name->ptr, mode))) {
 159                                 log_error_write(srv, __FILE__, __LINE__, "s",
 160                                         "failed to open GeoIP database!!!");
 161
 162                                 return HANDLER_ERROR;
 163                         }
 164
 165                         /* is the db supported ? */
 166                         if (s->gi->databaseType != GEOIP_COUNTRY_EDITION &&
 167                                 s->gi->databaseType != GEOIP_CITY_EDITION_REV0 &&
 168                                 s->gi->databaseType != GEOIP_CITY_EDITION_REV1) {
 169                                 log_error_write(srv, __FILE__, __LINE__, "s",
 170                                         "GeoIP database is of unsupported type!!!");
 171                         }
 172                 }
 173         }
 174
 175         return HANDLER_GO_ON;
 176 }
 177
 178 #define PATCH(x) \
 179         p->conf.x = s->x;
 180 static int mod_geoip_patch_connection(server *srv, connection *con, plugin_data *p) {
 181         size_t i, j;
 182         plugin_config *s = p->config_storage[0];
 183
 184         PATCH(db_name);
 185         PATCH(mem_cache);
 186         PATCH(gi);
 187
 188         /* skip the first, the global context */
 189         for (i = 1; i < srv->config_context->used; i++) {
 190                 data_config *dc = (data_config *)srv->config_context->data[i];
 191                 s = p->config_storage[i];
 192
 193                 /* condition didn't match */
 194                 if (!config_check_cond(srv, con, dc)) continue;
 195
 196                 /* merge config */
 197                 for (j = 0; j < dc->value->used; j++) {
 198                         data_unset *du = dc->value->data[j];
 199
 200                         if (buffer_is_equal_string(du->key, CONST_STR_LEN("geoip.db-filename"))) {
 201                                 PATCH(db_name);
 202                         }
 203
 204                         if (buffer_is_equal_string(du->key, CONST_STR_LEN("geoip.memory-cache"))) {
 205                                 PATCH(mem_cache);
 206                         }
 207                 }
 208         }
 209
 210         return 0;
 211 }
 212 #undef PATCH
 213
 214 URIHANDLER_FUNC(mod_geoip_subrequest) {
 215         plugin_data *p = p_d;
 216
 217         mod_geoip_patch_connection(srv, con, p);
 218
 219         if (!buffer_is_empty(p->conf.db_name)) {
 220                 const char *remote_ip;
 221                 data_string *ds;
 222                 GeoIPRecord *gir;
 223                 const char *returnedCountry;
 224
 225                 remote_ip = con->dst_addr_buf->ptr;
 226
 227                 if (p->conf.gi->databaseType == GEOIP_COUNTRY_EDITION) {
 228                         /* get the country code 2 chars */
 229                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_COUNTRY_CODE"))) {
 230                                 if (NULL != (returnedCountry = GeoIP_country_code_by_addr(p->conf.gi, remote_ip))) {
 231                                         if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 232                                                 ds = data_string_init();
 233                                         }
 234
 235                                         buffer_copy_string(ds->key, "GEOIP_COUNTRY_CODE");
 236                                         buffer_copy_string(ds->value, returnedCountry);
 237                                         array_insert_unique(con->environment, (data_unset *)ds);
 238                                 }
 239                         }
 240
 241                         /* get the country code 3 chars */
 242                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_COUNTRY_CODE3"))) {
 243                                 if (NULL != (returnedCountry = GeoIP_country_code3_by_addr(p->conf.gi, remote_ip))) {
 244                                         if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 245                                                 ds = data_string_init();
 246                                         }
 247
 248                                         buffer_copy_string(ds->key, "GEOIP_COUNTRY_CODE3");
 249                                         buffer_copy_string(ds->value, returnedCountry);
 250                                         array_insert_unique(con->environment, (data_unset *)ds);
 251                                 }
 252                         }
 253
 254                         /* get the country name */
 255                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_COUNTRY_NAME"))) {
 256                                 if (NULL != (returnedCountry = GeoIP_country_name_by_addr(p->conf.gi, remote_ip))) {
 257                                         if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 258                                                 ds = data_string_init();
 259                                         }
 260
 261                                         buffer_copy_string(ds->key, "GEOIP_COUNTRY_NAME");
 262                                         buffer_copy_string(ds->value, returnedCountry);
 263                                         array_insert_unique(con->environment, (data_unset *)ds);
 264                                 }
 265                         }
 266
 267                         /* go on... */
 268                         return HANDLER_GO_ON;
 269                 }
 270
 271                 /* if we are here, geo city is in use */
 272
 273                 if (NULL != (gir = GeoIP_record_by_addr(p->conf.gi, remote_ip))) {
 274                         /* get the country code 2 chars */
 275                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_COUNTRY_CODE"))) {
 276                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 277                                         ds = data_string_init();
 278                                 }
 279
 280                                 buffer_copy_string(ds->key, "GEOIP_COUNTRY_CODE");
 281                                 buffer_copy_string(ds->value, gir->country_code);
 282                                 array_insert_unique(con->environment, (data_unset *)ds);
 283                         }
 284
 285                         /* get the country code 3 chars */
 286                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_COUNTRY_CODE3"))) {
 287                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 288                                         ds = data_string_init();
 289                                 }
 290
 291                                 buffer_copy_string(ds->key, "GEOIP_COUNTRY_CODE3");
 292                                 buffer_copy_string(ds->value, gir->country_code3);
 293                                 array_insert_unique(con->environment, (data_unset *)ds);
 294                         }
 295
 296                         /* get the country name */
 297                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_COUNTRY_NAME"))) {
 298                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 299                                         ds = data_string_init();
 300                                 }
 301
 302                                 buffer_copy_string(ds->key, "GEOIP_COUNTRY_NAME");
 303                                 buffer_copy_string(ds->value, gir->country_name);
 304                                 array_insert_unique(con->environment, (data_unset *)ds);
 305                         }
 306
 307                         /* get the city region */
 308                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_REGION"))) {
 309                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 310                                         ds = data_string_init();
 311                                 }
 312
 313                                 buffer_copy_string(ds->key, "GEOIP_CITY_REGION");
 314                                 buffer_copy_string(ds->value, gir->region);
 315                                 array_insert_unique(con->environment, (data_unset *)ds);
 316                         }
 317
 318                         /* get the city */
 319                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_NAME"))) {
 320                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 321                                         ds = data_string_init();
 322                                 }
 323
 324                                 buffer_copy_string(ds->key, "GEOIP_CITY_NAME");
 325                                 buffer_copy_string(ds->value, gir->city);
 326                                 array_insert_unique(con->environment, (data_unset *)ds);
 327                         }
 328
 329                         /* get the postal code */
 330                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_POSTAL_CODE"))) {
 331                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 332                                         ds = data_string_init();
 333                                 }
 334
 335                                 buffer_copy_string(ds->key, "GEOIP_CITY_POSTAL_CODE");
 336                                 buffer_copy_string(ds->value, gir->postal_code);
 337                                 array_insert_unique(con->environment, (data_unset *)ds);
 338                         }
 339
 340                         /* get the latitude */
 341                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_LATITUDE"))) {
 342                                 char latitude[32];
 343                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 344                                         ds = data_string_init();
 345                                 }
 346
 347                                 snprintf(latitude, sizeof(latitude), "%f", gir->latitude);
 348                                 buffer_copy_string(ds->key, "GEOIP_CITY_LATITUDE");
 349                                 buffer_copy_string(ds->value, latitude);
 350                                 array_insert_unique(con->environment, (data_unset *)ds);
 351                         }
 352
 353                         /* get the long latitude */
 354                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_LONG_LATITUDE"))) {
 355                                 char long_latitude[32];
 356                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 357                                         ds = data_string_init();
 358                                 }
 359
 360                                 snprintf(long_latitude, sizeof(long_latitude), "%f", gir->longitude);
 361                                 buffer_copy_string(ds->key, "GEOIP_CITY_LONG_LATITUDE");
 362                                 buffer_copy_string(ds->value, long_latitude);
 363                                 array_insert_unique(con->environment, (data_unset *)ds);
 364                         }
 365
 366                         /* get the dma code */
 367                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_DMA_CODE"))) {
 368                                 char dc[5];
 369                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 370                                         ds = data_string_init();
 371                                 }
 372
 373                                 snprintf(dc, sizeof(dc), "%i", gir->dma_code);
 374                                 buffer_copy_string(ds->key, "GEOIP_CITY_DMA_CODE");
 375                                 buffer_copy_string(ds->value, dc);
 376                                 array_insert_unique(con->environment, (data_unset *)ds);
 377                         }
 378
 379                         /* get the area code */
 380                         if (NULL == (ds = (data_string *)array_get_element(con->environment, "GEOIP_CITY_AREA_CODE"))) {
 381                                 char ac[5];
 382                                 if (NULL == (ds = (data_string *)array_get_unused_element(con->environment, TYPE_STRING))) {
 383                                         ds = data_string_init();
 384                                 }
 385
 386                                 snprintf(ac, sizeof(ac), "%i", gir->area_code);
 387                                 buffer_copy_string(ds->key, "GEOIP_CITY_AREA_CODE");
 388                                 buffer_copy_string(ds->value, ac);
 389                                 array_insert_unique(con->environment, (data_unset *)ds);
 390                         }
 391
 392                         GeoIPRecord_delete(gir);
 393                 }
 394         }
 395
 396         /* keep walking... (johnnie walker style ;) */
 397         return HANDLER_GO_ON;
 398 }
 399
 400 /* this function is called at dlopen() time and inits the callbacks */
 401
 402 int mod_geoip_plugin_init(plugin *p);
 403 int mod_geoip_plugin_init(plugin *p) {
 404         p->version     = LIGHTTPD_VERSION_ID;
 405         p->name        = buffer_init_string("geoip");
 406
 407         p->init        = mod_geoip_init;
 408         p->handle_subrequest_start = mod_geoip_subrequest;
 409         p->set_defaults  = mod_geoip_set_defaults;
 410         p->cleanup     = mod_geoip_free;
 411
 412         p->data        = NULL;
 413
 414         return 0;
 415 }