自学教程：C++ GeoIP_open函数代码示例

/** Initialize GeoIP global states. */void geoip_init(void){#ifdef USE_GEOIP  if (gi4 != NULL)    GeoIP_delete(gi4);  if (gi6 != NULL)    GeoIP_delete(gi6);  gi4 = NULL;  gi6 = NULL;#endif /* USE_GEOIP */  if (!feature_bool(FEAT_GEOIP_ENABLE))    return;#ifdef USE_GEOIP  /* Load IPv4 GeoIP database */  if (feature_str(FEAT_GEOIP_FILE)) {    gi4 = GeoIP_open(feature_str(FEAT_GEOIP_FILE), GEOIP_STANDARD);  }  /* Try to load GeoIP.dat from lib/ if FEAT_GEOIP_FILE was not loaded. */  if (gi4 == NULL)    gi4 = GeoIP_open_type(GEOIP_COUNTRY_EDITION, GEOIP_STANDARD);  /* Load IPv6 GeoIP database */  if (feature_str(FEAT_GEOIP_IPV6_FILE)) {    gi6 = GeoIP_open(feature_str(FEAT_GEOIP_IPV6_FILE), GEOIP_STANDARD);  }  /* Try to load GeoIPv6.dat from lib/ if FEAT_GEOIP_IPV6_FILE was not loaded. */  if (gi6 == NULL)    gi6 = GeoIP_open_type(GEOIP_COUNTRY_EDITION_V6, GEOIP_STANDARD);#endif /* USE_GEOIP */}

voidset_geoip_info(struct userNode *user){    if(IsLocal(user))        return;/* Need the libs and the headers if this is going to compile properly */#if defined(HAVE_LIBGEOIP)&&defined(HAVE_GEOIP_H)&&defined(HAVE_GEOIPCITY_H)    GeoIPRecord * gir;    const char *geoip_data_file = NULL;    const char *geoip_city_file = NULL;    geoip_data_file = conf_get_data("services/opserv/geoip_data_file", RECDB_QSTRING);    geoip_city_file = conf_get_data("services/opserv/geoip_city_data_file", RECDB_QSTRING);    if ((!geoip_data_file && !geoip_city_file))        return; /* Admin doesnt want to use geoip functions */    if (geoip_data_file && !gi)        gi  = GeoIP_open(geoip_data_file, GEOIP_MEMORY_CACHE | GEOIP_CHECK_CACHE);    if (geoip_city_file && !cgi)        cgi = GeoIP_open(geoip_city_file, GEOIP_MEMORY_CACHE | GEOIP_CHECK_CACHE);    if (cgi) {        gir = GeoIP_record_by_name(cgi, user->hostname);        if (gir) {            user->country_name = strdup(gir->country_name ? gir->country_name : "");            user->country_code = strdup(gir->country_code ? gir->country_code : "");            user->city         = strdup(gir->city ? gir->city : "");            user->region       = strdup(gir->region ? gir->region : "");            user->postal_code  = strdup(gir->postal_code ? gir->postal_code : "");            user->latitude  = gir->latitude ? gir->latitude : 0;            user->longitude = gir->longitude ? gir->longitude : 0;            user->dma_code  = gir->dma_code ? gir->dma_code : 0;            user->area_code = gir->area_code ? gir->area_code : 0;            GeoIPRecord_delete(gir);        }        return;    } else if (gi) {        const char *country = GeoIP_country_name_by_name(gi, user->hostname);        user->country_name = strdup(country ? country : "");        return;    }    return;#endif}

intinit_function(struct vmod_priv *pp, const struct VCL_conf *conf){    pp->priv = malloc(sizeof(struct GeoIP_databases));    if (!pp->priv)        return 1;    struct GeoIP_databases* db = (struct GeoIP_databases*)pp->priv;    db->country = GeoIP_new(GEOIP_MMAP_CACHE);    db->org = GeoIP_open(GeoIPDBFileName[GEOIP_ORG_EDITION], GEOIP_MMAP_CACHE);    db->region = GeoIP_open(GeoIPDBFileName[GEOIP_REGION_EDITION_REV1], GEOIP_MMAP_CACHE);    pp->free = &free_databases;    return (0);}

static PyObject *GeoIP_open_Py(PyObject * self, PyObject * args){    GeoIP_GeoIPObject *GeoIP;    char *filename;    int flags;    if (!PyArg_ParseTuple(args, "si", &filename, &flags)) {        return NULL;    }    GeoIP = PyObject_New(GeoIP_GeoIPObject, &GeoIP_GeoIPType);    if (!GeoIP)        return NULL;    GeoIP->gi = GeoIP_open(filename, flags);    if (!GeoIP->gi) {        PyErr_SetString(PyGeoIPError, "Can't create GeoIP->gi object");        Py_DECREF(GeoIP);        return NULL;    }    return (PyObject *) GeoIP;}

intesgf_geolookup (char *hostname, struct geo_output_struct *geo_output){  char *db_info;  GeoIP *gi;  int i, ret_code;  char *custom_directory = NULL;  char *custom_file = NULL;  char geoipdat[1024] = { '/0' };  sprintf (geoipdat, "%s/share/GeoIP/%s", GEOIP_DATA_PATH, GEOIPIDATABASE);  pmesg(LOG_DEBUG,__FILE__,__LINE__,"Loading GeoLiteCity from %s.../n",geoipdat);  if (gi = GeoIP_open (geoipdat, GEOIP_STANDARD))    {      i = GeoIP_database_edition (gi);      pmesg(LOG_DEBUG,__FILE__,__LINE__," GeoIP database found [Ok]/n");      if (ret_code = geoiplookup (gi, hostname, i, geo_output))	{	GeoIP_delete (gi);	return ret_code;	}    }  else    {      pmesg(LOG_ERROR,__FILE__,__LINE__,"%s not available, skipping.Please check ! [Exit]/n",geoipdat);      GeoIP_delete (gi);      return (-4);    }  GeoIP_delete (gi);  pmesg(LOG_DEBUG,__FILE__,__LINE__,"Geoiplookup ok [code=%d]/n", ret_code);  return 0;}

/* Generic initializer */static VALUE rb_geoip_database_new(VALUE mGeoIP_Database_Class, int argc, VALUE *argv, VALUE self){  GeoIP *gi;  VALUE database = Qnil;  VALUE filename, load_option = Qnil, check_cache = Qnil;  int flag;  rb_scan_args(argc, argv, "12", &filename, &load_option, &check_cache);  if(NIL_P(load_option))    load_option = rb_geoip_memory;  if(NIL_P(check_cache))    check_cache = Qfalse;  Check_Type(load_option, T_SYMBOL);  if(flag = check_load_option(load_option)) flag;  if(RTEST(check_cache)) flag |= GEOIP_CHECK_CACHE;  if(gi = GeoIP_open(StringValuePtr(filename), flag)) {    database = Data_Wrap_Struct(mGeoIP_Database_Class, 0, GeoIP_delete, gi);    rb_obj_call_init(database, 0, 0);  } else {    rb_sys_fail("Problem opening database");  }  return database;}

int main(int argc, char *argv[]){    FILE *f;    GeoIP *gi;    char *org;    char host[50];    gi = GeoIP_open("../data/GeoIPISP.dat", GEOIP_STANDARD);    if (gi == NULL) {        fprintf(stderr, "Error opening database/n");        exit(1);    }    f = fopen("isp_test.txt", "r");    if (f == NULL) {        fprintf(stderr, "Error opening isp_test.txt/n");        exit(1);    }    while (fscanf(f, "%s", host) != EOF) {        org = GeoIP_org_by_name(gi, (const char *)host);        if (org != NULL) {            printf("%s/t%s/n", host, _mk_NA(org));            free(org);        }    }    fclose(f);    GeoIP_delete(gi);    return 0;}

static void loadGeoIP(void) {  int i;  struct stat statbuf;  /* Initialize GeoIP databases */  for(i=0; myGlobals.configFileDirs[i] != NULL; i++) {    char path[256];        safe_snprintf(__FILE__, __LINE__, path, sizeof(path),		  "%s%c%s",		  myGlobals.configFileDirs[i], 		  CONST_PATH_SEP, GEO_IP_FILE);    revertSlashIfWIN32(path, 0);    if(stat(path, &statbuf) == 0) {      if((myGlobals.geo_ip_db = GeoIP_open(path, GEOIP_CHECK_CACHE)) != NULL) {	traceEvent(CONST_TRACE_INFO, "GeoIP: loaded config file %s", path);	break;      }    }  }    if(myGlobals.geo_ip_db == NULL)    traceEvent(CONST_TRACE_ERROR, "GeoIP: unable to load file %s", GEO_IP_FILE);    /* *************************** */  for(i=0; myGlobals.configFileDirs[i] != NULL; i++) {    char path[256];        safe_snprintf(__FILE__, __LINE__, path, sizeof(path),		  "%s%c%s",		  myGlobals.configFileDirs[i], 		  CONST_PATH_SEP, GEO_IP_ASN_FILE);    revertSlashIfWIN32(path, 0);    if(stat(path, &statbuf) == 0) {      if((myGlobals.geo_ip_asn_db = GeoIP_open(path, GEOIP_CHECK_CACHE)) != NULL) {	traceEvent(CONST_TRACE_INFO, "GeoIP: loaded ASN config file %s", path);	break;      }    }  }    if(myGlobals.geo_ip_asn_db == NULL)    traceEvent(CONST_TRACE_ERROR, "GeoIP: unable to load ASN file %s", GEO_IP_ASN_FILE);  }

static char *ngx_stream_geoip_org(ngx_conf_t *cf, ngx_command_t *cmd, void *conf){    ngx_stream_geoip_conf_t  *gcf = conf;    ngx_str_t  *value;    if (gcf->org) {        return "is duplicate";    }    value = cf->args->elts;    gcf->org = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);    if (gcf->org == NULL) {        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,                           "GeoIP_open(/"%V/") failed", &value[1]);        return NGX_CONF_ERROR;    }    if (cf->args->nelts == 3) {        if (ngx_strcmp(value[2].data, "utf8") == 0) {            GeoIP_set_charset(gcf->org, GEOIP_CHARSET_UTF8);        } else {            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,                               "invalid parameter /"%V/"", &value[2]);            return NGX_CONF_ERROR;        }    }    switch (gcf->org->databaseType) {    case GEOIP_ISP_EDITION:    case GEOIP_ORG_EDITION:    case GEOIP_DOMAIN_EDITION:    case GEOIP_ASNUM_EDITION:        return NGX_CONF_OK;#if (NGX_HAVE_GEOIP_V6)    case GEOIP_ISP_EDITION_V6:    case GEOIP_ORG_EDITION_V6:    case GEOIP_DOMAIN_EDITION_V6:    case GEOIP_ASNUM_EDITION_V6:        gcf->org_v6 = 1;        return NGX_CONF_OK;#endif    default:        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,                           "invalid GeoIP database /"%V/" type:%d",                           &value[1], gcf->org->databaseType);        return NGX_CONF_ERROR;    }}

static ib_status_t geoip_database_file_dir_param1(ib_cfgparser_t *cp,        const char *name,        const char *p1,        void *cbdata){    IB_FTRACE_INIT();    assert(cp!=NULL);    assert(name!=NULL);    assert(p1!=NULL);    ib_status_t rc;    size_t p1_len = strlen(p1);    size_t p1_unescaped_len;    char *p1_unescaped = malloc(p1_len+1);    if ( p1_unescaped == NULL ) {        IB_FTRACE_RET_STATUS(IB_EALLOC);    }    rc = ib_util_unescape_string(p1_unescaped,                                 &p1_unescaped_len,                                 p1,                                 p1_len,                                 IB_UTIL_UNESCAPE_NULTERMINATE |                                 IB_UTIL_UNESCAPE_NONULL);    if (rc != IB_OK ) {        const char *msg = ( rc == IB_EBADVAL )?                          "GeoIP Database File /"%s/" contains nulls." :                          "GeoIP Database File /"%s/" is an invalid string.";        ib_log_debug(cp->ib, msg, p1);        free(p1_unescaped);        IB_FTRACE_RET_STATUS(rc);    }    if (geoip_db != NULL)    {        GeoIP_delete(geoip_db);        geoip_db = NULL;    }    IB_FTRACE_MSG("Initializing custom GeoIP database...");    IB_FTRACE_MSG(p1_unescaped);    geoip_db = GeoIP_open(p1_unescaped, GEOIP_MMAP_CACHE);    free(p1_unescaped);    if (geoip_db == NULL)    {        IB_FTRACE_MSG("Failed to initialize GeoIP database.");        IB_FTRACE_RET_STATUS(IB_EUNKNOWN);    }    IB_FTRACE_RET_STATUS(IB_OK);}

int main(int argc, char **argv) {	const char *geoipfilename = DEFAULT_GEOIPFILE;	GeoIP *gip = NULL;	GeoIPRecord *gir = NULL;	char *name;	const char *region_name;	int edition, i;	if ((argc != 2) && (argc != 4)) {		printf("Usage: geoiplookup_city [-f custom_file] <hostname_or_ip>/n");		return 1;	}	i = 1;	while (i < argc) {                if (strcmp(argv[i],"-f") == 0) {                        if ((i+1) < argc){                                i++;                                geoipfilename = argv[i];                        }                } else {			name = argv[i];		}                i++;        }	gip = GeoIP_open(geoipfilename, GEOIP_STANDARD);	edition = GeoIP_database_edition(gip);	if (edition == GEOIP_COUNTRY_EDITION) {		short int country_id = GeoIP_country_id_by_name(gip, name);		region_name = GeoIP_country_continent[country_id];		printf("%s/n", region_name);        } else if ((edition == GEOIP_CITY_EDITION_REV0) || 		   (edition == GEOIP_CITY_EDITION_REV1)) {                gir = GeoIP_record_by_name(gip, name);                if (NULL == gir) {                        printf("%s: IP Address not found/n", GeoIPDBDescription[edition]);			return 1;                } else {                        printf("Continent: %s/n"			       "Country:   %s/n"			       "Region id: %s/n"			       "Region:    %s/n"			       "City:      %s/n"			       "Latitude:  %f/n"			       "Longitude: %f/n", gir->continent_code, 			       			  gir->country_code, 						  gir->region, 						  GeoIP_region_name_by_code(gir->country_code, gir->region),						  gir->city, 						  gir->latitude, 						  gir->longitude);		}	} 	return 0;}

/* Use the GeoIP API to locate an IP address */char *GeoIPLookup(char *ip){	GeoIP	*gi;	GeoIPRecord	*gir;	char buffer[OS_SIZE_1024 +1];        unsigned long longip;	/* Dumb way to detect an IPv6 address */	if (strchr(ip, ':')) {		/* Use the IPv6 DB */		gi = GeoIP_open(Config.geoip_db_path, GEOIP_INDEX_CACHE);		if (gi == NULL) {			merror(INVALID_GEOIP_DB, ARGV0, Config.geoip6_db_path);			return("Unknown");		}		gir = GeoIP_record_by_name_v6(gi, (const char *)ip);	}	else {		/* Use the IPv4 DB */                /* If we have a RFC1918 IP, do not perform a DB lookup (performance) */                longip = StrIP2Int(ip);                if (longip == 0 ) return("Unknown");                if ((longip & NETMASK_8)  == RFC1918_10 ||                    (longip & NETMASK_12) == RFC1918_172 ||                    (longip & NETMASK_16) == RFC1918_192) return("");		gi = GeoIP_open(Config.geoip_db_path, GEOIP_INDEX_CACHE);		if (gi == NULL) {			merror(INVALID_GEOIP_DB, ARGV0, Config.geoip_db_path);			return("Unknown");		}		gir = GeoIP_record_by_name(gi, (const char *)ip);	}	if (gir != NULL) {		sprintf(buffer,"%s,%s,%s",				_mk_NA(gir->country_code),				_mk_NA(GeoIP_region_name_by_code(gir->country_code, gir->region)),				_mk_NA(gir->city)		);		GeoIP_delete(gi);		return(buffer);	}	GeoIP_delete(gi);	return("Unknown");}

/** Возвращает объект GeoIP для определения города по ip.    При первом вызове пытается открыть файл с базой данных, указанный в    параметре ``filename``. Если ``filename`` не задан */GeoIP *GeoCity(const char *filename){    static GeoIP *geo = 0;    static bool open_failed = false;    if (open_failed)        return 0;    if (geo)        return geo;    if (filename)        geo = GeoIP_open(filename, GEOIP_MEMORY_CACHE);    else        geo = GeoIP_open("/usr/share/GeoIP/GeoLiteCity.dat",                         GEOIP_MEMORY_CACHE);    open_failed = geo? false : true;    return geo;}

static int _tag_attr(char *tagname, char *attrname, char *attrvalue, XML_CONFIG *config) {	struct rdb_options_s *options = ((RDB *) config->backptr)->options;	if (strcasecmp(config->xpath, "/nnodes/options/listen") == 0) {		if (strcasecmp(attrname, "port") == 0 && attrvalue) {			curr_port = atoi(attrvalue);		}		else if (strcasecmp(attrname, "addr") == 0 && attrvalue) {			curr_addr = strdup(attrvalue);			}	} else if (strcasecmp(config->xpath, "/nnodes/options/user") == 0) {		if (strcasecmp(attrname, "uid") == 0 && attrvalue) {			options->uid = atoi(attrvalue);		} else if (strcasecmp(attrname, "gid") == 0 && attrvalue) {			options->gid = atoi(attrvalue);		}	} else if (strcasecmp(config->xpath, "/nnodes/options/pid") == 0) {		if (strcasecmp(attrname, "file") == 0 && attrvalue) {			options->pid = strdup(attrvalue);		}	} else if (strcasecmp(config->xpath, "/nnodes/options/threads") == 0) {		if (strcasecmp(attrname, "value") == 0 && attrvalue) {			options->nthreads = atoi(attrvalue);		}	} else if (strcasecmp(config->xpath, "/nnodes/options/log") == 0) {		if (strcasecmp(attrname, "file") == 0 && attrvalue) {			options->log_file = strdup(attrvalue);		}		else if (strcasecmp(attrname, "level") == 0 && attrvalue) {			options->log_level = atoi(attrvalue);		}		else if (strcasecmp(attrname, "maxfile") == 0 && attrvalue) {			options->log_maxfile = atoi(attrvalue);		}	} else if (strcasecmp(config->xpath, "/nnodes/options/websrv") == 0) {		if (strcasecmp(attrname, "xslt") == 0 && attrvalue) {			options->websrv_xslt = strdup(attrvalue);		}		else if (strcasecmp(attrname, "port") == 0 && attrvalue) {			options->websrv_port = atoi(attrvalue);		}	} else if (strcasecmp(config->xpath, "/nnodes/options/geoip") == 0) {#ifdef HAVE_GEOIP		if (strcasecmp(attrname, "database") == 0 && attrvalue) {			if ((options->gi = GeoIP_open(attrvalue, GEOIP_MEMORY_CACHE)) == NULL) {				LOG_ERR("error opening database %s", attrvalue);				return -1;			}		}#else		LOG_WARN ("%s/n", "not compiled with geoip");#endif	}	return 0;}

db_t *ipdata_dbinit(){  db_t *dbp = MALLOCORDIE(sizeof(db_t), "ipdata_dbinit()");  if(opts.flags & NOAS) /* AS db not requested. */    dbp->asgp = NULL;  else /* AS db requested. */  {    if(!opts.asdb) /* No db name specified. */    {      if(opts.family == AF_INET6) opts.asdb = ASDB_V6_DEFAULT;      else opts.asdb = ASDB_V4_DEFAULT;    }    dbp->asgp = GeoIP_open(opts.asdb, GEOIP_INDEX_CACHE);    if(!dbp->asgp)    {      fputs("ASNum DB requested but not found! "            "Proceeding without it./n", stderr);      opts.flags |= NOAS;    }  }  if(opts.flags & NOCITY) /* City db not requested. */    dbp->citygp = NULL;  else /* City db requested. */  {    if(!opts.citydb) /* No db name specified. */    {      if(opts.family == AF_INET6) opts.citydb = CITYDB_V6_DEFAULT;      else opts.citydb = CITYDB_V4_DEFAULT;    }    dbp->citygp = GeoIP_open(opts.citydb, GEOIP_INDEX_CACHE);    if(!dbp->citygp)    {      fputs("City DB requested but not found! "            "Proceeding without it./n", stderr);      opts.flags |= NOCITY;    }  }  return dbp;}

wxString LoadDatabase(const wxString& path, GeoIPDBTypes type, GeoIPOptions options){    if (::wxFileExists(path) && (g_geoIP = GeoIP_open(U2C(path), options)))    {        CSL_LOG_DEBUG("loaded GeoIP database: %s/n", U2C(path));        g_geoIP->charset = GEOIP_CHARSET_UTF8;    }    return g_geoIP ? path : wxT("");}

/* Geolocation data */GeoIP *geoip_open_db (const char *db){  GeoIP *geoip;  geoip = GeoIP_open (db, GEOIP_INDEX_CACHE);  if (geoip == NULL)    FATAL ("Unable to open GeoIP City database: %s/n", db);  LOG_DEBUG (("Opened GeoIP City database: %s/n", db));  return geoip;}

int geoip_init_pv(char *path){	_handle_GeoIP = GeoIP_open(path, GEOIP_MMAP_CACHE);	if(_handle_GeoIP==NULL)	{		LM_ERR("cannot open GeoIP database file at: %s/n", path);		return -1;	}	return 0;}

static GeoIP *NET_GeoIP_LoadData (int db){	GeoIP *data = GeoIP_open_type (db, GEOIP_MEMORY_CACHE);	if (data == nullptr)	{		if (db == GEOIP_COUNTRY_EDITION)		{			std::string dbPath = FS::Path::Build(FS::GetLibPath(), "GeoIP.dat");			data = GeoIP_open (dbPath.c_str(), GEOIP_MEMORY_CACHE);		}		else if (db == GEOIP_COUNTRY_EDITION_V6)		{			std::string dbPath = FS::Path::Build(FS::GetLibPath(), "GeoIPv6.dat");			data = GeoIP_open (dbPath.c_str(), GEOIP_MEMORY_CACHE);		}	}	return data;}

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;}

static ib_status_t geoip_database_file_dir_param1(ib_cfgparser_t *cp,                                                  const char *name,                                                  const char *p1,                                                  void *cbdata){    assert(cp!=NULL);    assert(name!=NULL);    assert(p1!=NULL);    ib_status_t rc;    size_t p1_len = strlen(p1);    size_t p1_unescaped_len;    char *p1_unescaped = malloc(p1_len+1);    if ( p1_unescaped == NULL ) {        return IB_EALLOC;    }    rc = ib_util_unescape_string(p1_unescaped,                                 &p1_unescaped_len,                                 p1,                                 p1_len,                                 IB_UTIL_UNESCAPE_NULTERMINATE |                                 IB_UTIL_UNESCAPE_NONULL);    if (rc != IB_OK ) {        const char *msg = ( rc == IB_EBADVAL )?                        "GeoIP Database File /"%s/" contains nulls." :                        "GeoIP Database File /"%s/" is an invalid string.";        ib_log_debug(cp->ib, msg, p1);        free(p1_unescaped);        return rc;    }    if (geoip_db != NULL)    {        GeoIP_delete(geoip_db);        geoip_db = NULL;    }            geoip_db = GeoIP_open(p1_unescaped, GEOIP_MMAP_CACHE);    free(p1_unescaped);    if (geoip_db == NULL)    {                return IB_EUNKNOWN;    }    return IB_OK;}

/* Open the given GeoLocation database and set its charset. * * On error, it aborts. * On success, a new geolocation structure is returned. */GeoIP *geoip_open_db (const char *db){  GeoIP *geoip;  geoip = GeoIP_open (db, GEOIP_MEMORY_CACHE);  if (geoip == NULL)    FATAL ("Unable to open GeoIP database: %s/n", db);  GeoIP_set_charset (geoip, GEOIP_CHARSET_UTF8);  LOG_DEBUG (("Opened GeoIP City database: %s/n", db));  return geoip;}

int main(void){      const char *ipAddress = "193.140.74.29";      char expectedCountry[3];      const char *returnedCountry;      GeoIP *gi;      int i;       if (0 == i) {	  /* Read from filesystem, check for updated file */	  gi = GeoIP_open("/usr/share/GeoIP/GeoIP.dat",  GEOIP_STANDARD | GEOIP_CHECK_CACHE);      } else {	  /* Read from memory, faster but takes up more memory */	  gi = GeoIP_open("/usr/share/GeoIP/GeoIP.dat", GEOIP_MEMORY_CACHE);      }      if (gi == NULL) {	fprintf(stderr, "Error opening database/n");	exit(1);      }        returnedCountry = GeoIP_country_code_by_addr(gi, NULL);      if (returnedCountry != NULL) {	  fprintf(stderr, "Invalid Query test failed, got non NULL, expected NULL/n");	  exit(EXIT_FAILURE);        }        returnedCountry = GeoIP_country_code_by_name(gi, NULL);      if (returnedCountry != NULL) {	fprintf(stderr,"Invalid Query test failed, got non NULL, expected NULL/n");      }        returnedCountry = GeoIP_country_code3_by_addr(gi, ipAddress);      printf("%s => %s/n", ipAddress, returnedCountry);            return 0;}

void CIP2Country::Enable(){	Disable();	if (m_CountryDataMap.empty()) {		LoadFlags();	}	if (!CPath::FileExists(m_DataBasePath)) {		Update();		return;	}	m_geoip = GeoIP_open(unicode2char(m_DataBasePath), GEOIP_STANDARD);}

static char *ngx_http_geoip_country(ngx_conf_t *cf, ngx_command_t *cmd, void *conf){    ngx_http_geoip_conf_t  *gcf = conf;    ngx_str_t  *value;    if (gcf->country) {        return "is duplicate";    }    value = cf->args->elts;    gcf->country = GeoIP_open((char *) value[1].data, GEOIP_MEMORY_CACHE);    if (gcf->country == NULL) {        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,                           "GeoIP_open(/"%V/") failed", &value[1]);        return NGX_CONF_ERROR;    }    if (cf->args->nelts == 3) {        if (ngx_strcmp(value[2].data, "utf8") == 0) {            GeoIP_set_charset (gcf->country, GEOIP_CHARSET_UTF8);        } else {            ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,                               "invalid parameter /"%V/"", &value[2]);            return NGX_CONF_ERROR;        }    }    switch (gcf->country->databaseType) {    case GEOIP_COUNTRY_EDITION:    case GEOIP_PROXY_EDITION:    case GEOIP_NETSPEED_EDITION:        return NGX_CONF_OK;    default:        ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,                           "invalid GeoIP database /"%V/" type:%d",                           &value[1], gcf->country->databaseType);        return NGX_CONF_ERROR;    }}

GeoIP* GeoIP_open_type (int type, int flags) {	GeoIP * gi;	const char * filePath;	if (type < 0 || type >= NUM_DB_TYPES) {		printf("Invalid database type %d/n", type);		return NULL;	}	_GeoIP_setup_dbfilename();	filePath = GeoIPDBFileName[type];	if (filePath == NULL) {		printf("Invalid database type %d/n", type);		return NULL;	}	gi = GeoIP_open (filePath, flags);	return gi;}

/* call-seq: *   Net::GeoIP.new(database) * * Initializes a new GeoIP object.  The argument database is the path to the * database to open and use with this GeoIP instance. */VALUEgeoip_initialize(VALUE self, VALUE database) {	GeoIPContainer *container;	Check_Type(database, T_STRING);	Data_Get_Struct(self, GeoIPContainer, container);	container->geoip = GeoIP_open(RSTRING(database)->ptr, GEOIP_INDEX_CACHE);	if (container->geoip == NULL) {		rb_raise(cGeoIPError,  "Invalid Database");	}	return self;}

int geo_acl_check(struct sockaddr_in *sin, char *allowed_countries, char *peername){	GeoIP * gi;        const char * returnedCountry;        gi = GeoIP_open("/opt/GeoIP/share/GeoIP/GeoIP.dat", GEOIP_STANDARD | GEOIP_CHECK_CACHE);	int retValue = 0;	int j, i=0; // used to iterate through array	char lookup[255];    	char *token[86];        if (gi == NULL) {                ast_log(LOG_WARNING, "Failed to open GeoIP Lookup database - ignoring GeoACL");        } else {		if((allowed_countries == NULL) || (strlen(allowed_countries) == 0) ) {			ast_log(LOG_NOTICE, "GeoACL - Peer %s does not have allowed/denied countries defined, ignoring check/n", peername);		} else {                	ast_log(LOG_DEBUG, "Using %s for allowed geo acl list/n", allowed_countries);			returnedCountry = GeoIP_country_code_by_addr(gi,ast_inet_ntoa(sin->sin_addr));	                if (returnedCountry == NULL) {        	                ast_log(LOG_WARNING, "GeoACL Lookup failed for '%s' - ignoring GeoACL/n", ast_inet_ntoa(sin->sin_addr));             	   	} else {				// Now we default to deny since we know what they want and where the IP is from 				strcpy(lookup, allowed_countries);				retValue = 1;							//ast_log(LOG_NOTICE, "GeoACL - value of allowed_countries is %s", allowed_countries);										token[0] = strtok (lookup,",");  				while(token[i]!= NULL) {   //ensure a pointer was found        				i++;        				token[i] = strtok(NULL, ","); //continue to tokenize the string    				}  				for(j = 0; j <= i-1; j++) {			//		ast_log(LOG_DEBUG, "Checking token %s", token[j]);					if (strncmp(returnedCountry, token[j], 2) == 0) {						retValue = 0;					}				}				if (retValue == 1)  {					ast_log(LOG_NOTICE, "GeoACL - peer '%s' failed ACL check.  Allowed from %s but connected from %s/n", peername, allowed_countries, returnedCountry);				} else {                	       		 ast_log(LOG_NOTICE, "GeoACL passed for peer '%s' - connected from '%s'/n", peername, returnedCountry);                		}			}		}        }        // Free resources        GeoIP_delete(gi);	return retValue;}

static void geoip_child_init(apr_pool_t * p, server_rec * s){    geoip_server_config_rec *cfg;    int i, flags;    cfg = (geoip_server_config_rec *)        ap_get_module_config(s->module_config, &geoip_module);    if (cfg->gips) {        if (cfg->GeoIPFilenames != NULL) {            for (i = 0; i < cfg->numGeoIPFiles; i++) {                flags =                    (cfg->GeoIPFlags2[i] ==                     GEOIP_UNKNOWN) ? cfg->GeoIPFlags : cfg->GeoIPFlags2[i];                if (flags & (GEOIP_MEMORY_CACHE | GEOIP_MMAP_CACHE))                    continue;                if (cfg->gips[i]) {                    GeoIP_delete(cfg->gips[i]);                }                cfg->gips[i] = GeoIP_open(cfg->GeoIPFilenames[i], flags);                if (cfg->gips[i]) {                    if (cfg->GeoIPEnableUTF8) {                        GeoIP_set_charset(cfg->gips[i], GEOIP_CHARSET_UTF8);                    }                } else {                    ap_log_error(APLOG_MARK, APLOG_ERR, 0,                                 s,                                 "[mod_geoip]: Error while opening data file %s",                                 cfg->GeoIPFilenames[i]);                    continue;                }            }        } else {            if (cfg->gips[0])                GeoIP_delete(cfg->gips[0]);            cfg->gips[0] = GeoIP_new(GEOIP_STANDARD);            if (!cfg->gips[0]) {                ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,                             "[mod_geoip]: Error while opening data file");            }            cfg->numGeoIPFiles = 1;        }    }}

void geoip_init(void) {	const char* geoipdat = getenv("xqf_GEOIPDAT");	if (gi) return; // already initialized	if (geoipdat)		gi = GeoIP_open(geoipdat, GEOIP_STANDARD);	if (!gi)		gi = GeoIP_new(GEOIP_STANDARD);	if (gi && geoip_num_countries())		flags = g_malloc0((MaxCountries+1) *sizeof(struct pixmap)); /*+1-> flag for LAN server*/	else {		geoip_done();		xqf_error("GeoIP initialization failed");	}}