static PyObject * GeoIP_time_zone_by_country_and_region_Py(PyObject *self, PyObject * args) {
char * country_code, *region;
if (!PyArg_ParseTuple(args, "ss", &country_code, ®ion)) {
return NULL;
}
return Py_BuildValue("s", GeoIP_time_zone_by_country_and_region(country_code, region));
}
static PyObject *GeoIP_populate_dict(GeoIP * gi, GeoIPRecord * gir)
{
PyObject *retval;
retval = PyDict_New();
GeoIP_SetItemString(retval, "country_code", gir->country_code);
GeoIP_SetItemString(retval, "country_code3", gir->country_code3);
GeoIP_SetItemString(retval, "country_name", gir->country_name);
GeoIP_SetItemString(retval, "region", gir->region);
GeoIP_SetItemString(retval, "city", gir->city);
GeoIP_SetItemString(retval, "postal_code", gir->postal_code);
GeoIP_SetItemFloat(retval, "latitude", gir->latitude);
GeoIP_SetItemFloat(retval, "longitude", gir->longitude);
GeoIP_SetItemString(retval, "region_name",
GeoIP_region_name_by_code(gir->country_code,
gir->region));
GeoIP_SetItemString(retval, "time_zone",
GeoIP_time_zone_by_country_and_region(gir->country_code,
gir->region));
if (gi->databaseType != GEOIP_CITY_EDITION_REV0) {
/*
* metro_code is a alias for the depreciated dma_code.
* we use the depreciated gir->dma_code since the CAPI
* wrapper might be outdated and does not supply metro_code
*/
GeoIP_SetItemInt(retval, "dma_code", gir->dma_code);
/* we did __NOT__ use gir->metro_code here, since metro_code is
* somewhat new */
GeoIP_SetItemInt(retval, "metro_code", gir->dma_code);
GeoIP_SetItemInt(retval, "area_code", gir->area_code);
}
GeoIPRecord_delete(gir);
return retval;
}
static char *
city_string(GeoIPRecord *record, dns_geoip_subtype_t subtype, int *maxlen) {
const char *s;
char *deconst;
REQUIRE(record != NULL);
REQUIRE(maxlen != NULL);
/* Set '*maxlen' to the maximum length of this subtype, if any */
switch (subtype) {
case dns_geoip_city_countrycode:
case dns_geoip_city_region:
case dns_geoip_city_continentcode:
*maxlen = 2;
break;
case dns_geoip_city_countrycode3:
*maxlen = 3;
break;
default:
/* No fixed length; just use strcasecmp() for comparison */
*maxlen = 255;
}
switch (subtype) {
case dns_geoip_city_countrycode:
return (record->country_code);
case dns_geoip_city_countrycode3:
return (record->country_code3);
case dns_geoip_city_countryname:
return (record->country_name);
case dns_geoip_city_region:
return (record->region);
case dns_geoip_city_regionname:
s = GeoIP_region_name_by_code(record->country_code,
record->region);
DE_CONST(s, deconst);
return (deconst);
case dns_geoip_city_name:
return (record->city);
case dns_geoip_city_postalcode:
return (record->postal_code);
case dns_geoip_city_continentcode:
return (record->continent_code);
case dns_geoip_city_timezonecode:
s = GeoIP_time_zone_by_country_and_region(record->country_code,
record->region);
DE_CONST(s, deconst);
return (deconst);
default:
INSIST(0);
}
}
int main(int argc, char *argv[])
{
FILE *f;
GeoIP *gi;
GeoIPRecord *gir;
int generate = 0;
char host[50];
const char *time_zone = NULL;
char **ret;
if (argc == 2) {
if (!strcmp(argv[1], "gen")) {
generate = 1;
}
}
gi = GeoIP_open("../data/GeoIPCity.dat", GEOIP_INDEX_CACHE);
if (gi == NULL) {
fprintf(stderr, "Error opening database\n");
exit(1);
}
f = fopen("city_test.txt", "r");
if (f == NULL) {
fprintf(stderr, "Error opening city_test.txt\n");
exit(1);
}
while (fscanf(f, "%s", host) != EOF) {
gir = GeoIP_record_by_name(gi, (const char *)host);
if (gir != NULL) {
ret = GeoIP_range_by_ip(gi, (const char *)host);
time_zone =
GeoIP_time_zone_by_country_and_region(gir->country_code,
gir->region);
printf("%s\t%s\t%s\t%s\t%s\t%s\t%f\t%f\t%d\t%d\t%s\t%s\t%s\n", host,
_mk_NA(gir->country_code), _mk_NA(gir->region),
_mk_NA(GeoIP_region_name_by_code
(gir->country_code,
gir->region)), _mk_NA(gir->city),
_mk_NA(gir->postal_code), gir->latitude, gir->longitude,
gir->metro_code, gir->area_code, _mk_NA(time_zone), ret[0],
ret[1]);
GeoIP_range_by_ip_delete(ret);
GeoIPRecord_delete(gir);
}
}
GeoIP_delete(gi);
fclose(f);
return 0;
}
Variant f_geoip_time_zone_by_country_and_region(CStrRef country_code, CStrRef region_code /* = null */) {
check_enabled();
if (country_code.empty()) {
raise_warning("You need to specify at least the country code.");
return false;
}
const char *timezone = GeoIP_time_zone_by_country_and_region(country_code.data(), region_code.data());
if (timezone == NULL) {
return false;
}
return String(timezone, CopyString);
}
static int
mmg_lookup_cmd(struct sip_msg *msg, char *_fields_pv, char *_ipaddr_pv, char *_dst_spec)
{
pv_elem_t *fields_pv=(pv_elem_t*)_fields_pv, *ipaddr_pv=(pv_elem_t*)_ipaddr_pv;
pv_spec_t *dst_spec=(pv_spec_t*)_dst_spec;
GeoIPRecord *gir=0;
str field_str, ipaddr_str;
char rslt_buf[256], ipaddr_buf[256], field_buf[256];
char *token=0, *saveptr=0;
int dst_name=-1;
int_str rslt=(int_str)0;
unsigned short dstType=0;
/* Sanity checks */
if(!(ipaddr_pv && fields_pv && dst_spec)) {
LM_ERR("Missing argument(s).\n");
return -1;
}
if(dst_spec->type != PVT_AVP) {
LM_ERR("Invalid destination spec -- expected AVP.\n");
return -1;
}
if(pv_get_avp_name(msg, &(dst_spec->pvp), &dst_name, &dstType)!=0) {
LM_ERR("Internal error getting AVP name.\n");
return -1;
}
/* Expand input args: lookup field list and IP address.*/
*ipaddr_buf=0;
ipaddr_str.s=ipaddr_buf;
ipaddr_str.len=sizeof ipaddr_buf;
if(pv_printf(msg, ipaddr_pv, ipaddr_buf, &ipaddr_str.len) || ipaddr_str.len==0) {
LM_ERR("Internal error parsing IP address.\n");
return -1;
}
*field_buf=0;
field_str.s=field_buf;
field_str.len=sizeof field_buf;
if(pv_printf(msg, fields_pv, field_buf, &field_str.len) || field_str.len==0) {
LM_ERR("Internal error parsing lookup fields.\n");
return -1;
}
/* Attempt lookup */
if(!(gir=GeoIP_record_by_name (MMG_gi,ipaddr_buf))){
LM_DBG("'%s'--> 'Unknown'.\n", *ipaddr_buf?ipaddr_buf:"Undefined");
return -1;
}
/* Construct return data. Know fields are: */
/* lat - latitude */
/* lon - longitude */
/* cont - continent */
/* cc - country code */
/* reg - region */
/* city - city */
/* pc - postal code */
/* dma - dma code */
/* ac - area code */
/* tz - timezone */
#define MMG_FAIL_EXIT if(gir) GeoIPRecord_delete(gir); return -1
LM_DBG("ipaddr:'%.*s'; fields:'%.*s'.\n",
ipaddr_str.len, ipaddr_str.s, field_str.len, field_str.s);
*rslt_buf=0;
rslt.s.s=rslt_buf;
token=strtok_r(field_buf,MMG_OP_DELIMS,&saveptr);
while (token) {
if(!strcmp(token,"lat")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%f",gir->latitude); }
else if(!strcmp(token,"lon")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%f",gir->longitude); }
else if(!strcmp(token,"cont")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->continent_code); }
else if(!strcmp(token,"cc")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->country_code); }
else if(!strcmp(token,"reg")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->region); }
else if(!strcmp(token,"city")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->city); }
else if(!strcmp(token,"pc")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->postal_code); }
else if(!strcmp(token,"dma")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%d",gir->dma_code); }
else if(!strcmp(token,"ac")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%d",gir->area_code); }
else if(!strcmp(token,"rbc")) {
rslt.s.len=snprintf(
rslt_buf,sizeof rslt_buf,"%s",GeoIP_region_name_by_code(gir->country_code, gir->region));
}
else if(!strcmp(token,"tz")) {
rslt.s.len=snprintf(
rslt_buf,sizeof rslt_buf,"%s",GeoIP_time_zone_by_country_and_region(gir->country_code, gir->region));
} else {
LM_ERR("unknown field:'%s'\n",token);
MMG_FAIL_EXIT;
}
if(rslt.s.len<0 || rslt.s.len>sizeof rslt_buf ||
add_avp(dstType|AVP_VAL_STR,dst_name,rslt)==-1 ) {
LM_ERR("Internal error processing field/IP '%s/%s'.\n",
token,ipaddr_buf);
MMG_FAIL_EXIT;
}
LM_DBG("field %s[%s] %.*s\n",ipaddr_buf,token,rslt.s.len,rslt.s.s);
token=strtok_r(0,MMG_OP_DELIMS,&saveptr);
}
GeoIPRecord_delete(gir);
return 1;
}
int pv_get_geoip(struct sip_msg *msg, pv_param_t *param,
pv_value_t *res)
{
geoip_pv_t *gpv;
if(msg==NULL || param==NULL)
return -1;
gpv = (geoip_pv_t*)param->pvn.u.dname;
if(gpv==NULL)
return -1;
if(gpv->item==NULL)
return pv_get_null(msg, param, res);
switch(gpv->type)
{
case 1: /* tz */
if(gpv->item->r.time_zone==NULL)
{
if(gpv->item->r.flags&1)
return pv_get_null(msg, param, res);
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
gpv->item->r.time_zone
= (char*)GeoIP_time_zone_by_country_and_region(
gpv->item->r.record->country_code,
gpv->item->r.record->region);
gpv->item->r.flags |= 1;
}
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.time_zone);
case 2: /* zip */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.record->postal_code);
case 3: /* lat */
if((gpv->item->r.flags&2)==0)
{
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
snprintf(gpv->item->r.latitude, 15, "%f",
gpv->item->r.record->latitude);
gpv->item->r.flags |= 2;
}
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.latitude);
case 4: /* lon */
if((gpv->item->r.flags&4)==0)
{
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
snprintf(gpv->item->r.longitude, 15, "%f",
gpv->item->r.record->longitude);
gpv->item->r.flags |= 4;
}
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.longitude);
case 5: /* dma */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_get_sintval(msg, param, res,
gpv->item->r.record->dma_code);
case 6: /* ips */
case 7: /* ipe */
if((gpv->item->r.flags&8)==0)
{
gpv->item->r.range = GeoIP_range_by_ip(_handle_GeoIP,
gpv->item->r.tomatch);
gpv->item->r.flags |= 8;
}
if(gpv->item->r.range==NULL)
return pv_get_null(msg, param, res);
if(gpv->type==6)
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.range[0]);
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.range[1]);
case 8: /* city */
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.record->city);
case 9: /* area */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_get_sintval(msg, param, res,
gpv->item->r.record->area_code);
case 10: /* regc */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.record->region);
case 11: /* regn */
if((gpv->item->r.flags&16)==0)
{
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
gpv->item->r.region_name
= (char*)GeoIP_region_name_by_code(
gpv->item->r.record->country_code,
gpv->item->r.record->region);
gpv->item->r.flags |= 16;
}
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.region_name);
case 12: /* metro */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_get_sintval(msg, param, res,
gpv->item->r.record->metro_code);
case 13: /* contc */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.record->continent_code);
default: /* cc */
if(gpv->item->r.record==NULL)
return pv_get_null(msg, param, res);
return pv_geoip_get_strzval(msg, param, res,
gpv->item->r.record->country_code);
}
}
int main()
{
GeoIP *gi;
GeoIPRegion *gir, giRegion;
FILE *f;
char ipAddress[30];
char expectedCountry[3];
char expectedCountry3[4];
const char *time_zone;
gi = GeoIP_open("../data/GeoIPRegion.dat", GEOIP_MEMORY_CACHE);
if (gi == NULL) {
fprintf(stderr, "Error opening database\n");
exit(1);
}
f = fopen("region_test.txt", "r");
if (f == NULL) {
fprintf(stderr, "Error opening region_test.txt\n");
exit(1);
}
gir = GeoIP_region_by_addr(gi, "10.0.0.0");
if (gir != NULL) {
printf("lookup of private IP address: country = %s, region = %s\n",
gir->country_code, gir->region);
}
while (fscanf(f, "%s%s%s", ipAddress, expectedCountry, expectedCountry3) !=
EOF) {
printf("ip = %s\n", ipAddress);
gir = GeoIP_region_by_name(gi, ipAddress);
if (gir != NULL) {
time_zone =
GeoIP_time_zone_by_country_and_region(gir->country_code,
gir->region);
printf("%s, %s, %s, %s\n",
gir->country_code,
(!gir->region[0]) ? "N/A" : gir->region,
_mk_NA(GeoIP_region_name_by_code
(gir->country_code,
gir->region)), _mk_NA(time_zone));
} else {
printf("NULL!\n");
}
GeoIP_assign_region_by_inetaddr(gi, inetaddr(ipAddress), &giRegion);
if (gir != NULL) {
assert(giRegion.country_code[0]);
assert(!strcmp(gir->country_code, giRegion.country_code));
if (gir->region[0]) {
assert(giRegion.region[0]);
assert(!strcmp(gir->region, giRegion.region));
} else {
assert(!giRegion.region[0]);
}
} else {
assert(!giRegion.country_code[0]);
}
if (gir != NULL) {
GeoIPRegion_delete(gir);
}
}
GeoIP_delete(gi);
fclose(f);
return 0;
}
