/* Converted to D from GeoIP.h by htod */
module GeoIPlib;
/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 2; tab-width: 2 -*- */
/* GeoIP.h
 *
 * Copyright (C) 2006 MaxMind LLC
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

//C     #ifndef GEOIP_H
//C     #define GEOIP_H

//C     #ifdef __cplusplus
//C     extern "C" {
//C     #endif

//C     #include<stdio.h>
import std.c.stdio;
//C     #include<stdlib.h>
import std.c.stdlib;
//C     #include<string.h>
import std.c.string;
import std.c.time;
//C     #include <sys/types.h> /* for fstat */
//import std.c.types;
//C     #include <sys/stat.h>	/* for fstat */
//import std.c.stat;

//C     #define SEGMENT_RECORD_LENGTH 3
//C     #define STANDARD_RECORD_LENGTH 3
const SEGMENT_RECORD_LENGTH = 3;
//C     #define ORG_RECORD_LENGTH 4
const STANDARD_RECORD_LENGTH = 3;
//C     #define MAX_RECORD_LENGTH 4
const ORG_RECORD_LENGTH = 4;
//C     #define NUM_DB_TYPES 20
const MAX_RECORD_LENGTH = 4;

const NUM_DB_TYPES = 20;
//C     typedef struct GeoIPTag {
//C       FILE *GeoIPDatabase;
//C       char *file_path;
//C     	unsigned char *cache;
//C     	unsigned char *index_cache;
//C     	unsigned int *databaseSegments;
//C     	char databaseType;
//C     	time_t mtime;
//C     	int flags;
//C     	char record_length;
//C     	int charset; /* 0 iso-8859-1 1 utf8 */
//C     	int record_iter; /* used in GeoIP_next_record */
//C     	int netmask; /* netmask of last lookup - set using depth in _GeoIP_seek_record */
//C     } GeoIP;
struct GeoIPTag
{
    FILE *GeoIPDatabase;
    char *file_path;
    ubyte *cache;
    ubyte *index_cache;
    uint *databaseSegments;
    char databaseType;
    time_t mtime;
    int flags;
    char record_length;
    int charset;
    int record_iter;
    int netmask;
}
extern (C):
alias GeoIPTag GeoIP;


//C     typedef enum {
//C     	GEOIP_CHARSET_ISO_8859_1 = 0,
//C     	GEOIP_CHARSET_UTF8       = 1
//C     } GeoIPCharset;
enum
{
    GEOIP_CHARSET_ISO_8859_1,
    GEOIP_CHARSET_UTF8,
}
alias int GeoIPCharset;

//C     typedef struct GeoIPRegionTag {
//C     	char country_code[3];
//C     	char region[3];
//C     } GeoIPRegion;
struct GeoIPRegionTag
{
    char [3]country_code;
    char [3]region;
}
alias GeoIPRegionTag GeoIPRegion;

//C     typedef enum {
//C     	GEOIP_STANDARD = 0,
//C     	GEOIP_MEMORY_CACHE = 1,
//C     	GEOIP_CHECK_CACHE = 2,
//C     	GEOIP_INDEX_CACHE = 4,
//C     } GeoIPOptions;
enum
{
    GEOIP_STANDARD,
    GEOIP_MEMORY_CACHE,
    GEOIP_CHECK_CACHE,
    GEOIP_INDEX_CACHE = 4,
}
alias int GeoIPOptions;

//C     typedef enum {
//C     	GEOIP_COUNTRY_EDITION     = 1,
//C     	GEOIP_REGION_EDITION_REV0 = 7,
//C     	GEOIP_CITY_EDITION_REV0   = 6,
//C     	GEOIP_ORG_EDITION         = 5,
//C     	GEOIP_ISP_EDITION         = 4,
//C     	GEOIP_CITY_EDITION_REV1   = 2,
//C     	GEOIP_REGION_EDITION_REV1 = 3,
//C     	GEOIP_PROXY_EDITION       = 8,
//C     	GEOIP_ASNUM_EDITION       = 9,
//C     	GEOIP_NETSPEED_EDITION    = 10,
//C     	GEOIP_DOMAIN_EDITION      = 11
//C     } GeoIPDBTypes;
enum
{
    GEOIP_COUNTRY_EDITION = 1,
    GEOIP_REGION_EDITION_REV0 = 7,
    GEOIP_CITY_EDITION_REV0 = 6,
    GEOIP_ORG_EDITION = 5,
    GEOIP_ISP_EDITION = 4,
    GEOIP_CITY_EDITION_REV1 = 2,
    GEOIP_REGION_EDITION_REV1,
    GEOIP_PROXY_EDITION = 8,
    GEOIP_ASNUM_EDITION,
    GEOIP_NETSPEED_EDITION,
    GEOIP_DOMAIN_EDITION,
}
alias int GeoIPDBTypes;

//C     typedef enum {
//C     	GEOIP_ANON_PROXY = 1,
//C     	GEOIP_HTTP_X_FORWARDED_FOR_PROXY = 2,
//C     	GEOIP_HTTP_CLIENT_IP_PROXY = 3,
//C     } GeoIPProxyTypes;
enum
{
    GEOIP_ANON_PROXY = 1,
    GEOIP_HTTP_X_FORWARDED_FOR_PROXY,
    GEOIP_HTTP_CLIENT_IP_PROXY,
}
alias int GeoIPProxyTypes;

//C     typedef enum {
//C     	GEOIP_UNKNOWN_SPEED = 0,
//C     	GEOIP_DIALUP_SPEED = 1,
//C     	GEOIP_CABLEDSL_SPEED = 2,
//C     	GEOIP_CORPORATE_SPEED = 3,
//C     } GeoIPNetspeedValues;
enum
{
    GEOIP_UNKNOWN_SPEED,
    GEOIP_DIALUP_SPEED,
    GEOIP_CABLEDSL_SPEED,
    GEOIP_CORPORATE_SPEED,
}
alias int GeoIPNetspeedValues;

//C     extern char **GeoIPDBFileName;
extern char **GeoIPDBFileName;
//C     extern const char * GeoIPDBDescription[NUM_DB_TYPES];
extern char *[20]GeoIPDBDescription;
//C     extern const char *GeoIPCountryDBFileName;
extern char *GeoIPCountryDBFileName;
//C     extern const char *GeoIPRegionDBFileName;
extern char *GeoIPRegionDBFileName;
//C     extern const char *GeoIPCityDBFileName;
extern char *GeoIPCityDBFileName;
//C     extern const char *GeoIPOrgDBFileName;
extern char *GeoIPOrgDBFileName;
//C     extern const char *GeoIPISPDBFileName;
extern char *GeoIPISPDBFileName;

//C     extern const char GeoIP_country_code[251][3];
extern const char [3][251]GeoIP_country_code;
//C     extern const char GeoIP_country_code3[251][4];
extern const char [4][251]GeoIP_country_code3;
//C     extern const char * GeoIP_country_name[251];
extern char *[251]GeoIP_country_name;
//C     extern const char GeoIP_country_continent[251][3];
extern const char [3][251]GeoIP_country_continent;

//C     #ifdef DLL
//C     #define GEOIP_API __declspec(dllexport)
//C     #else
//C     #define GEOIP_API
//C     #endif  /* DLL */

//C     GEOIP_API void GeoIP_setup_custom_directory(char *dir);
void  GeoIP_setup_custom_directory(char *dir);
//C     GEOIP_API GeoIP* GeoIP_open_type (int type, int flags);
GeoIP * GeoIP_open_type(int type, int flags);
//C     GEOIP_API GeoIP* GeoIP_new(int flags);
GeoIP * GeoIP_new(int flags);
//C     GEOIP_API GeoIP* GeoIP_open(const char * filename, int flags);
GeoIP * GeoIP_open(char *filename, int flags);
//C     GEOIP_API int GeoIP_db_avail(int type);
int  GeoIP_db_avail(int type);
//C     GEOIP_API void GeoIP_delete(GeoIP* gi);
void  GeoIP_delete(GeoIP *gi);
//C     GEOIP_API const char *GeoIP_country_code_by_addr (GeoIP* gi, const char *addr);
char * GeoIP_country_code_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API const char *GeoIP_country_code_by_name (GeoIP* gi, const char *host);
char * GeoIP_country_code_by_name(GeoIP *gi, char *host);
//C     GEOIP_API const char *GeoIP_country_code3_by_addr (GeoIP* gi, const char *addr);
char * GeoIP_country_code3_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API const char *GeoIP_country_code3_by_name (GeoIP* gi, const char *host);
char * GeoIP_country_code3_by_name(GeoIP *gi, char *host);
//C     GEOIP_API const char *GeoIP_country_name_by_addr (GeoIP* gi, const char *addr);
char * GeoIP_country_name_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API const char *GeoIP_country_name_by_name (GeoIP* gi, const char *host);
char * GeoIP_country_name_by_name(GeoIP *gi, char *host);
//C     GEOIP_API const char *GeoIP_country_name_by_ipnum (GeoIP* gi, unsigned long ipnum);
char * GeoIP_country_name_by_ipnum(GeoIP *gi, uint ipnum);
//C     GEOIP_API const char *GeoIP_country_code_by_ipnum (GeoIP* gi, unsigned long ipnum);
char * GeoIP_country_code_by_ipnum(GeoIP *gi, uint ipnum);
//C     GEOIP_API const char *GeoIP_country_code3_by_ipnum (GeoIP* gi, unsigned long ipnum);
char * GeoIP_country_code3_by_ipnum(GeoIP *gi, uint ipnum);

/* Deprecated - for backwards compatibility only */
//C     GEOIP_API int GeoIP_country_id_by_addr (GeoIP* gi, const char *addr);
int  GeoIP_country_id_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API int GeoIP_country_id_by_name (GeoIP* gi, const char *host);
int  GeoIP_country_id_by_name(GeoIP *gi, char *host);
//C     GEOIP_API char *GeoIP_org_by_addr (GeoIP* gi, const char *addr);
char * GeoIP_org_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API char *GeoIP_org_by_name (GeoIP* gi, const char *host);
char * GeoIP_org_by_name(GeoIP *gi, char *host);
/* End deprecated */

//C     GEOIP_API int GeoIP_id_by_addr (GeoIP* gi, const char *addr);
int  GeoIP_id_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API int GeoIP_id_by_name (GeoIP* gi, const char *host);
int  GeoIP_id_by_name(GeoIP *gi, char *host);
//C     GEOIP_API int GeoIP_id_by_ipnum (GeoIP* gi, unsigned long ipnum);
int  GeoIP_id_by_ipnum(GeoIP *gi, uint ipnum);

//C     GEOIP_API GeoIPRegion * GeoIP_region_by_addr (GeoIP* gi, const char *addr);
GeoIPRegion * GeoIP_region_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API GeoIPRegion * GeoIP_region_by_name (GeoIP* gi, const char *host);
GeoIPRegion * GeoIP_region_by_name(GeoIP *gi, char *host);
//C     GEOIP_API GeoIPRegion * GeoIP_region_by_ipnum (GeoIP *gi, unsigned long ipnum);
GeoIPRegion * GeoIP_region_by_ipnum(GeoIP *gi, uint ipnum);

/* Warning - don't call this after GeoIP_assign_region_by_inetaddr calls */
//C     GEOIP_API void GeoIPRegion_delete (GeoIPRegion *gir);
void  GeoIPRegion_delete(GeoIPRegion *gir);

//C     GEOIP_API void GeoIP_assign_region_by_inetaddr(GeoIP* gi, unsigned long inetaddr, GeoIPRegion *gir);
void  GeoIP_assign_region_by_inetaddr(GeoIP *gi, uint inetaddr, GeoIPRegion *gir);

/* Used to query GeoIP Organization, ISP and AS Number databases */
//C     GEOIP_API char *GeoIP_name_by_ipnum (GeoIP* gi, unsigned long ipnum);
char * GeoIP_name_by_ipnum(GeoIP *gi, uint ipnum);
//C     GEOIP_API char *GeoIP_name_by_addr (GeoIP* gi, const char *addr);
char * GeoIP_name_by_addr(GeoIP *gi, char *addr);
//C     GEOIP_API char *GeoIP_name_by_name (GeoIP* gi, const char *host);
char * GeoIP_name_by_name(GeoIP *gi, char *host);

//C     GEOIP_API char *GeoIP_database_info (GeoIP* gi);
char * GeoIP_database_info(GeoIP *gi);
//C     GEOIP_API unsigned char GeoIP_database_edition (GeoIP* gi);
ubyte  GeoIP_database_edition(GeoIP *gi);

//C     GEOIP_API int GeoIP_charset (GeoIP* gi);
int  GeoIP_charset(GeoIP *gi);
//C     GEOIP_API int GeoIP_set_charset (GeoIP* gi, int charset);
int  GeoIP_set_charset(GeoIP *gi, int charset);

//C     GEOIP_API int GeoIP_last_netmask (GeoIP* gi);
int  GeoIP_last_netmask(GeoIP *gi);

/* Convert region code to region name */
//C     GEOIP_API const char * GeoIP_region_name_by_code(const char *country_code, const char *region_code);
char * GeoIP_region_name_by_code(char *country_code, char *region_code);

/* Get timezone from country and region code */
//C     GEOIP_API const char * GeoIP_time_zone_by_country_and_region(const char *country_code, const char *region_code);
char * GeoIP_time_zone_by_country_and_region(char *country_code, char *region_code);

//C     #ifdef BSD
//C     #define memcpy(dest, src, n) bcopy(src, dest, n)
//C     #endif

//C     #ifdef __cplusplus
//C     }
//C     #endif

//C     #endif /* GEOIP_H */