Special Geoip 1.0.0.1

#include "amxxmodule.h"
#include "GeoIP.h"
#include "GeoIP_internal.h"
#include "GeoIPCity.h"

#if defined __linux__
#include <dirent.h>
#else
#include "pread.h"
#include <io.h>
#endif

#include "Header.h"

GeoIP * g_Handle = NULL;
GeoIPRecord * g_Record = NULL;

char g_Database[256U];
char g_String[256U];

char g_FileFound = FALSE;
char g_CustomCharset = 8U;

const char * g_LocalInfo = NULL;
const char * g_Address = NULL;
const char * g_ModName = NULL;

static cell AMX_NATIVE_CALL GeoipInfo(AMX * Handle, cell * Parameter)
{
    if (!ReadLocation(MF_GetAmxString(Handle, Parameter[1U], 0U, 0U)))
    {
        MF_SetAmxString(Handle, Parameter[3U], "N/A", Parameter[4U]);

        return 0U;
    }

    switch ((GeoInfo)Parameter[2U])
    {
    case GI_Country:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->country_name ? g_Record->country_name : "N/A", Parameter[4U]);

        break;

    case GI_CountryCode:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->country_code && strcmp(g_Record->country_code, "--") \
            ? g_Record->country_code : "N/A", Parameter[4U]);

        break;

    case GI_CountryCode3:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->country_code3 && strcmp(g_Record->country_code3, "--") \
            ? g_Record->country_code3 : "N/A", Parameter[4U]);

        break;

    case GI_Region:
        if (!g_Record->country_code || !g_Record->region)
        {
            MF_SetAmxString(Handle, Parameter[3U], "N/A", Parameter[4U]);
        }

        else
        {
            MF_SetAmxString(Handle, Parameter[3U], GeoIP_region_name_by_code(g_Record->country_code, g_Record->region) \
                ? GeoIP_region_name_by_code(g_Record->country_code, g_Record->region) : "N/A", Parameter[4U]);
        }

        break;

    case GI_TimeZone:
        if (!g_Record->country_code || !g_Record->region)
        {
            MF_SetAmxString(Handle, Parameter[3U], "N/A", Parameter[4U]);
        }

        else
        {
            MF_SetAmxString(Handle, Parameter[3U], GeoIP_time_zone_by_country_and_region(g_Record->country_code, g_Record->region) \
                ? GeoIP_time_zone_by_country_and_region(g_Record->country_code, g_Record->region) : "N/A", Parameter[4U]);
        }

        break;

    case GI_City:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->city ? g_Record->city : "N/A", Parameter[4U]);

        break;

    case GI_ContinentCode:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->continent_code ? g_Record->continent_code : "N/A", Parameter[4U]);

        break;

    case GI_RegionCode:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->region ? g_Record->region : "N/A", Parameter[4U]);

        break;

    case GI_Latitude:
        _snprintf(g_String, sizeof(g_String), "%f", g_Record->latitude);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;

    case GI_Longitude:
        _snprintf(g_String, sizeof(g_String), "%f", g_Record->longitude);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;

    case GI_AreaCode:
        _snprintf(g_String, sizeof(g_String), "%i", g_Record->area_code);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;

    case GI_PostalCode:
        MF_SetAmxString(Handle, Parameter[3U], g_Record->postal_code ? g_Record->postal_code : "N/A", Parameter[4U]);

        break;

    case GI_MetroCode:
        _snprintf(g_String, sizeof(g_String), "%i", g_Record->metro_code);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;

    case GI_DmaCode:
        _snprintf(g_String, sizeof(g_String), "%i", g_Record->dma_code);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;

    case GI_NetMask:
        _snprintf(g_String, sizeof(g_String), "%i", g_Record->netmask);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;

    case GI_Continent:
        MF_SetAmxString(Handle, Parameter[3U], GeoipContinentName(g_Record->continent_code), Parameter[4U]);

        break;

    case GI_Charset:
        _snprintf(g_String, sizeof(g_String), "%i", g_Record->charset);

        MF_SetAmxString(Handle, Parameter[3U], g_String, Parameter[4U]);

        break;
    }

    GeoIPRecord_delete(g_Record);

    g_Record = NULL;

    return 1U;
}

static cell AMX_NATIVE_CALL GeoipCharset(AMX * Handle, cell * Parameter)
{
    switch (GeoIPCharset(Parameter[1U]))
    {
    case GEOIP_CHARSET_ISO_8859_1:
        g_CustomCharset = GEOIP_CHARSET_ISO_8859_1;

        printf("[%s] Changing Geoip's charset to ISO-8859.\n", MODULE_LOGTAG);

        break;

    case GEOIP_CHARSET_UTF8:
        g_CustomCharset = GEOIP_CHARSET_UTF8;

        printf("[%s] Changing Geoip's charset to UTF-8.\n", MODULE_LOGTAG);

        break;
    }

    if (g_Handle)
    {
        g_Handle->charset = g_CustomCharset;
    }

    if (g_Record)
    {
        g_Record->charset = g_CustomCharset;
    }

    return 1U;
}

const AMX_NATIVE_INFO g_Functions[] =
{
    { "GeoipInfo", GeoipInfo },
    { "GeoipCharset", GeoipCharset },

    { NULL, NULL}
};

const char * GeoipContinentName(const char * ContinentCode)
{
    if (!ContinentCode)
    {
        return "N/A";
    }

    if (!strcmp(ContinentCode, "AF"))
    {
        return "Africa";
    }

    else if (!strcmp(ContinentCode, "EU"))
    {
        return "Europe";
    }

    else if (!strcmp(ContinentCode, "SA"))
    {
        return "South America";
    }

    else if (!strcmp(ContinentCode, "NA"))
    {
        return "North America";
    }

    else if (!strcmp(ContinentCode, "OC"))
    {
        return "Oceania";
    }

    else if (!strcmp(ContinentCode, "AS"))
    {
        return "Asia";
    }

    else if (!strcmp(ContinentCode, "AN"))
    {
        return "Antarctica";
    }

    return "N/A";
}

char LoadGeoip(char * Location)
{
    if (!g_Handle)
    {
        g_Handle = GeoIP_open(Location, GEOIP_INDEX_CACHE);

        if (g_Handle)
        {
            if (g_CustomCharset != 8U)
            {
                g_Handle->charset = GEOIP_CHARSET_UTF8;
            }

            else
            {
                g_Handle->charset = g_CustomCharset;
            }

            return TRUE;
        }

        return FALSE;
    }

    return FALSE;
}

char CloseGeoip(void)
{
    if (g_Record)
    {
        GeoIPRecord_delete(g_Record);

        g_Record = NULL;
    }

    if (g_Handle)
    {
        GeoIP_delete(g_Handle);

        g_Handle = NULL;

        return TRUE;
    }

    return FALSE;
}

char ReadLocation(char * Address)
{
    if (g_Handle && Address)
    {
        g_Record = GeoIP_record_by_addr(g_Handle, Address);

        if (g_Record)
        {
            if (g_CustomCharset != 8U)
            {
                g_Record->charset = g_CustomCharset;
            }

            else
            {
                g_Record->charset = GEOIP_CHARSET_UTF8;
            }

            return TRUE;
        }

        return FALSE;
    }

    return FALSE;
}

void OnAmxxAttach(void)
{
    g_FileFound = FALSE;

    MF_AddNatives(g_Functions);

    if (!g_ModName)
    {
        g_ModName = MF_GetModname();
    }

    g_LocalInfo = MF_GetLocalInfo("amxx_datadir", "addons/amxmodx/data");

#if defined __linux__
    DIR * Handle = NULL;

    dirent * Data = NULL;

    _snprintf(g_Database, sizeof(g_Database), "%s/%s/", g_ModName, g_LocalInfo);

    if ((Handle = opendir(g_Database)))
    {
        while ((Data = readdir(Handle)))
        {
            if (strstr(Data->d_name, "Geo") && strstr(Data->d_name, "City"))
            {
                _snprintf(g_Database, sizeof(g_Database), "%s/%s/%s", g_ModName, g_LocalInfo, \
                    Data->d_name);

                printf("[%s] Taking %s file as database.\n", MODULE_LOGTAG, Data->d_name);

                g_FileFound = TRUE;
            }
        }

        closedir(Handle);
    }
#else
    _finddata_t Data;

    intptr_t File = NULL;

    _snprintf(g_Database, sizeof(g_Database), "%s/%s/*", g_ModName, g_LocalInfo);

    if ((File = _findfirst(g_Database, &Data)) != -1L)
    {
        do
        {
            if (strstr(Data.name, "Geo") && strstr(Data.name, "City"))
            {
                _snprintf(g_Database, sizeof(g_Database), "%s/%s/%s", g_ModName, g_LocalInfo, \
                    Data.name);

                printf("[%s] Taking %s file as database.\n", MODULE_LOGTAG, Data.name);

                g_FileFound = TRUE;
            }
        }

        while (!_findnext(File, &Data));

        _findclose(File);
    }
#endif

    if (!g_FileFound)
    {
        printf("[%s] Unable to find any database.\n", MODULE_LOGTAG);
    }

    else
    {
        if (LoadGeoip(g_Database))
        {
            printf("[%s] %s\n", MODULE_LOGTAG, GeoIP_database_info(g_Handle));
        }

        else
        {
            printf("[%s] Unable to load database.\n", MODULE_LOGTAG);
        }
    }
}

void OnAmxxDetach(void)
{
    if (CloseGeoip())
    {
        printf("[%s] Geoip's database has been closed.\n", MODULE_LOGTAG);
    }
}