Example #1
0
int GeoIPLocIP(ftval *ip, enum ftype itype, float *latitude, float *longitude, char **country_code)
{
    GeoIPRecord *gir;
    geoipv6_t gv6;
    const char *ccode;

    gir = NULL;
    ccode = NULL;
    switch (itype) {
    case FT_IPv4:
        if (gi == NULL)
            return -1;
        pthread_mutex_lock(&atom);
        if (city) {
            gir = GeoIP_record_by_ipnum(gi, ntohl(ip->uint32));
            if (gir != NULL) {
                ccode = gir->country_code;
            }
        }
        else {
            ccode = GeoIP_country_code_by_ipnum(gi, ntohl(ip->uint32));
        }
        pthread_mutex_unlock(&atom);
        break;
        
    case FT_IPv6:
        if (giv6 == NULL)
            return -1;
        memcpy(gv6.s6_addr, ip->ipv6, 16);
        pthread_mutex_lock(&atom6);
        if (cityv6) {
            gir = GeoIP_record_by_ipnum_v6(giv6, gv6);
            if (gir != NULL)
                ccode = gir->country_code;
        }
        else {
            ccode = GeoIP_country_code_by_ipnum_v6(giv6, gv6);
        }
        pthread_mutex_unlock(&atom6);
        break;

    default:
        LogPrintf(LV_ERROR, "GeoIP IP type error");
    }

    if (gir != NULL) {
        *latitude = gir->latitude;
        *longitude = gir->longitude;
        if (country_code != NULL)
            *country_code = (char *)ccode;
        GeoIPRecord_delete(gir);
        return 0;
    }
    if (country_code != NULL && ccode != NULL) {
        *country_code = (char *)ccode;
        return 0;
    }

    return -1;
}
Example #2
0
const char* CslGeoIP::GetCountryCodeByIPnum(const unsigned long ipnum)
{
    CslGeoIP& self = GetInstance();

    if (!g_geoIP)
        return NULL;

    GeoIPRecord *r = NULL;
    const char *code = NULL;

    switch (self.m_type)
    {
        case GEOIP_COUNTRY:
            code = GeoIP_country_code_by_ipnum(g_geoIP, wxUINT32_SWAP_ON_LE(ipnum));
            break;
        case GEOIP_CITY:
            if ((r = GeoIP_record_by_ipnum(g_geoIP, wxUINT32_SWAP_ON_LE(ipnum))))
            {
                code = r->country_code;
                GeoIPRecord_delete(r);
            }
            break;
    }

    return code;
}
Example #3
0
static ret_t
match (cherokee_rule_t         *rule_,
       cherokee_connection_t   *conn,
       cherokee_config_entry_t *ret_conf)
{
	ret_t                  ret;
	void                  *foo;
	const char            *country;
	cherokee_rule_geoip_t *rule = RULE_GEOIP(rule_);

	UNUSED(ret_conf);

	country = GeoIP_country_code_by_ipnum (rule->geoip, SOCKET_ADDRESS_IPv4(&conn->socket));
	if (country == NULL) {
		TRACE(ENTRIES, "Rule geoip did found the country for ip='%lu'\n",
			SOCKET_ADDRESS_IPv4(&conn->socket));
		return ret_not_found;
	}

	ret = cherokee_avl_get_ptr (&rule->countries, country, &foo);
        if (ret != ret_ok) {
		TRACE(ENTRIES, "Rule geoip did not match '%s'\n", country);
		return ret;
	}

	TRACE(ENTRIES, "Match geoip did match: '%s'\n", country);
	return ret_ok;
}
Example #4
0
/*
 * Country lookups are performed if the previous lookup was from a
 * different IP address than the current, or was for a search of a
 * different subtype.
 */
static const char *
country_lookup(GeoIP *db, dns_geoip_subtype_t subtype,
	       unsigned int family,
	       isc_uint32_t ipnum, const geoipv6_t *ipnum6)
{
	geoip_state_t *prev_state = NULL;
	const char *text = NULL;

	REQUIRE(db != NULL);

#ifndef HAVE_GEOIP_V6
	/* no IPv6 support? give up now */
	if (family == AF_INET6)
		return (NULL);
#endif

	prev_state = get_state_for(family, ipnum, ipnum6);
	if (prev_state != NULL && prev_state->subtype == subtype)
		text = prev_state->text;

	if (text == NULL) {
		switch (subtype) {
		case dns_geoip_country_code:
			if (family == AF_INET)
				text = GeoIP_country_code_by_ipnum(db, ipnum);
#ifdef HAVE_GEOIP_V6
			else
				text = GeoIP_country_code_by_ipnum_v6(db,
								      *ipnum6);
#endif
			break;
		case dns_geoip_country_code3:
			if (family == AF_INET)
				text = GeoIP_country_code3_by_ipnum(db, ipnum);
#ifdef HAVE_GEOIP_V6
			else
				text = GeoIP_country_code3_by_ipnum_v6(db,
								       *ipnum6);
#endif
			break;
		case dns_geoip_country_name:
			if (family == AF_INET)
				text = GeoIP_country_name_by_ipnum(db, ipnum);
#ifdef HAVE_GEOIP_V6
			else
				text = GeoIP_country_name_by_ipnum_v6(db,
								      *ipnum6);
#endif
			break;
		default:
			INSIST(0);
		}

		set_state(family, ipnum, ipnum6, subtype,
			  NULL, NULL, NULL, text, 0);
	}

	return (text);
}
Example #5
0
/**
 * \internal
 * \brief This function is used to geolocate the IP using the MaxMind libraries
 *
 * \param ip IP to geolocate (uint32_t ip)
 *
 * \retval NULL if it couldn't be geolocated
 * \retval ptr (const char *) to the country code string
 */
static const char *GeolocateIPv4(GeoIP *geoengine, uint32_t ip)
{
    if (geoengine != NULL)
        return GeoIP_country_code_by_ipnum(geoengine,  ntohl(ip));
    return NULL;
}
Example #6
0
uint32_t getip(uint32_t ip)
{
    if (!geoip) return 0u;
    ip = ENET_NET_TO_HOST_32(ip);
    return getip(GeoIP_country_code_by_ipnum(geoip, ip));
}