static PyObject *Reader_metadata(PyObject *self, PyObject *UNUSED(args))
{
Reader_obj *mmdb_obj = (Reader_obj *)self;
if (NULL == mmdb_obj->mmdb) {
PyErr_SetString(PyExc_IOError,
"Attempt to read from a closed MaxMind DB.");
return NULL;
}
MMDB_entry_data_list_s *entry_data_list;
MMDB_get_metadata_as_entry_data_list(mmdb_obj->mmdb, &entry_data_list);
MMDB_entry_data_list_s *original_entry_data_list = entry_data_list;
PyObject *metadata_dict = from_entry_data_list(&entry_data_list);
MMDB_free_entry_data_list(original_entry_data_list);
if (NULL == metadata_dict || !PyDict_Check(metadata_dict)) {
PyErr_SetString(MaxMindDB_error,
"Error decoding metadata.");
return NULL;
}
PyObject *args = PyTuple_New(0);
if (NULL == args) {
Py_DECREF(metadata_dict);
return NULL;
}
PyObject *metadata = PyObject_Call((PyObject *)&Metadata_Type, args,
metadata_dict);
Py_DECREF(metadata_dict);
return metadata;
}
static gboolean
maxminddb_parser_process(LogParser *s, LogMessage **pmsg,
const LogPathOptions *path_options,
const gchar *input, gsize input_len)
{
GeoIPParser *self = (GeoIPParser *) s;
LogMessage *msg = log_msg_make_writable(pmsg, path_options);
msg_trace("geoip2-parser message processing started",
evt_tag_str ("input", input),
evt_tag_str ("prefix", self->prefix),
evt_tag_printf("msg", "%p", *pmsg));
MMDB_entry_data_list_s *entry_data_list;
if (!_mmdb_load_entry_data_list(self, input, &entry_data_list))
return TRUE;
GArray *path = g_array_new(TRUE, FALSE, sizeof(gchar *));
g_array_append_val(path, self->prefix);
gint status;
dump_geodata_into_msg(msg, entry_data_list, path, &status);
MMDB_free_entry_data_list(entry_data_list);
g_array_free(path, TRUE);
return TRUE;
}
void test_metadata_as_data_entry_list(MMDB_s * mmdb,
const char *mode_desc)
{
MMDB_entry_data_list_s *entry_data_list, *first;
int status =
MMDB_get_metadata_as_entry_data_list(mmdb, &entry_data_list);
first = entry_data_list;
cmp_ok(status, "==", MMDB_SUCCESS, "get metadata as data_entry_list - %s",
mode_desc);
cmp_ok(first->entry_data.data_size, "==", 9,
"metadata map has 9 key/value pairs");
while (1) {
MMDB_entry_data_list_s *key = entry_data_list =
entry_data_list->next;
if (!key) {
break;
}
cmp_ok(key->entry_data.type, "==", MMDB_DATA_TYPE_UTF8_STRING,
"found a map key");
const char *key_name = dup_entry_string_or_bail(key->entry_data);
if (strcmp(key_name, "node_count") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
cmp_ok(value->entry_data.uint32, "==", 37, "node_count == 37");
} else if (strcmp(key_name, "record_size") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
cmp_ok(value->entry_data.uint16, "==", 24, "record_size == 24");
} else if (strcmp(key_name, "ip_version") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
cmp_ok(value->entry_data.uint16, "==", 4, "ip_version == 4");
} else if (strcmp(key_name, "binary_format_major_version") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
cmp_ok(value->entry_data.uint16, "==", 2,
"binary_format_major_version == 2");
} else if (strcmp(key_name, "binary_format_minor_version") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
cmp_ok(value->entry_data.uint16, "==", 0,
"binary_format_minor_version == 0");
} else if (strcmp(key_name, "build_epoch") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
ok(value->entry_data.uint64 > 1373571901,
"build_epoch > 1373571901");
} else if (strcmp(key_name, "database_type") == 0) {
MMDB_entry_data_list_s *value
= entry_data_list = entry_data_list->next;
const char *type = dup_entry_string_or_bail(value->entry_data);
is(type, "Test", "type == Test");
free((void *)type);
} else if (strcmp(key_name, "languages") == 0) {
entry_data_list = test_languages_value(entry_data_list);
} else if (strcmp(key_name, "description") == 0) {
entry_data_list = test_description_value(entry_data_list);
} else {
ok(0, "unknown key found in metadata map - %s",
key_name);
}
free((void *)key_name);
}
MMDB_free_entry_data_list(first);
}
void OnGeoipCommand()
{
const auto cmd = CMD_ARGV(1);
if (!strcmp(cmd, "version"))
{
if (!HandleDB.filename)
{
MF_PrintSrvConsole("\n Database is not loaded.\n");
return;
}
const auto meta_dump = "\n"
" Database metadata\n"
" Node count: %i\n"
" Record size: %i bits\n"
" IP version: IPv%i\n"
" Binary format: %i.%i\n"
" Build epoch: %llu (%s)\n"
" Type: %s\n"
" Languages: ";
char date[40];
strftime(date, sizeof date, "%Y-%m-%d %H:%M:%S UTC", gmtime(reinterpret_cast<const time_t *>(&HandleDB.metadata.build_epoch)));
fprintf(stdout, meta_dump,
HandleDB.metadata.node_count,
HandleDB.metadata.record_size,
HandleDB.metadata.ip_version,
HandleDB.metadata.binary_format_major_version,
HandleDB.metadata.binary_format_minor_version,
HandleDB.metadata.build_epoch,
date,
HandleDB.metadata.database_type);
for (size_t i = 0; i < HandleDB.metadata.languages.count; ++i)
{
fprintf(stdout, "%s", HandleDB.metadata.languages.names[i]);
if (i < HandleDB.metadata.languages.count - 1)
{
fprintf(stdout, " ");
}
}
fprintf(stdout, "\n");
fprintf(stdout, " Description:\n");
for (size_t i = 0; i < HandleDB.metadata.description.count; ++i)
{
fprintf(stdout, " %s: %s\n",
HandleDB.metadata.description.descriptions[i]->language,
HandleDB.metadata.description.descriptions[i]->description);
}
fprintf(stdout, "\n");
}
else if (!strcmp(cmd, "dump"))
{
if (!HandleDB.filename)
{
MF_PrintSrvConsole("\n Database is not loaded.\n\n");
return;
}
const auto num_args = CMD_ARGC();
if (num_args < 3)
{
MF_PrintSrvConsole("\n An IP address must be provided.\n\n");
return;
}
const auto ip = stripPort(const_cast<char *>(CMD_ARGV(2)));
auto gai_error = 0;
auto mmdb_error = 0;
auto result = MMDB_lookup_string(&HandleDB, ip, &gai_error, &mmdb_error);
if (gai_error != 0 || mmdb_error != MMDB_SUCCESS || !result.found_entry)
{
MF_PrintSrvConsole("\n Either look up failed or no found result.\n\n");
return;
}
MMDB_entry_data_list_s *entry_data_list = nullptr;
int status;
if ((status = MMDB_get_entry_data_list(&result.entry, &entry_data_list)) != MMDB_SUCCESS || entry_data_list == nullptr)
{
MF_PrintSrvConsole("\n Could not retrieve data list - %s.\n\n", MMDB_strerror(status));
return;
}
const char *file = nullptr;
FILE *fp = nullptr;
if (num_args > 3)
{
file = CMD_ARGV(3);
fp = fopen(MF_BuildPathname("%s", file), "w");
}
if (!fp)
{
file = nullptr;
fp = stdout;
}
fprintf(fp, "\n");
MMDB_dump_entry_data_list(fp, entry_data_list, 2);
fprintf(fp, "\n");
if (file)
{
fclose(fp);
}
MMDB_free_entry_data_list(entry_data_list);
}
else if (!strcmp(cmd, "reload"))
{
const auto isDatabaseLoaded = HandleDB.filename != nullptr;
if (isDatabaseLoaded)
{
MMDB_close(&HandleDB);
}
if (loadDatabase() && !NativesRegistered)
{
MF_AddNatives(GeoipNatives);
NativesRegistered = true;
}
}
else
{
MF_PrintSrvConsole("\n");
MF_PrintSrvConsole(" Usage: geoip <command> [argument]\n");
MF_PrintSrvConsole(" Commands:\n");
MF_PrintSrvConsole(" version - display geoip database metadata\n");
MF_PrintSrvConsole(" reload - reload geoip database\n");
MF_PrintSrvConsole(" dump <ip> [output file] - dump all data from an IP address formatted in a JSON-ish fashion.\n");
MF_PrintSrvConsole(" An output file is mod-based and if not provided, it will print in the console.\n");
MF_PrintSrvConsole("\n");
}
}
static PyObject *Reader_get(PyObject *self, PyObject *args)
{
char *ip_address = NULL;
Reader_obj *mmdb_obj = (Reader_obj *)self;
if (!PyArg_ParseTuple(args, "s", &ip_address)) {
return NULL;
}
MMDB_s *mmdb = mmdb_obj->mmdb;
if (NULL == mmdb) {
PyErr_SetString(PyExc_ValueError,
"Attempt to read from a closed MaxMind DB.");
return NULL;
}
int gai_error = 0;
int mmdb_error = MMDB_SUCCESS;
MMDB_lookup_result_s result =
MMDB_lookup_string(mmdb, ip_address, &gai_error,
&mmdb_error);
if (0 != gai_error) {
PyErr_Format(PyExc_ValueError,
"'%s' does not appear to be an IPv4 or IPv6 address.",
ip_address);
return NULL;
}
if (MMDB_SUCCESS != mmdb_error) {
PyObject *exception;
if (MMDB_IPV6_LOOKUP_IN_IPV4_DATABASE_ERROR == mmdb_error) {
exception = PyExc_ValueError;
} else {
exception = MaxMindDB_error;
}
PyErr_Format(exception, "Error looking up %s. %s",
ip_address, MMDB_strerror(mmdb_error));
return NULL;
}
if (!result.found_entry) {
Py_RETURN_NONE;
}
MMDB_entry_data_list_s *entry_data_list = NULL;
int status = MMDB_get_entry_data_list(&result.entry, &entry_data_list);
if (MMDB_SUCCESS != status) {
PyErr_Format(MaxMindDB_error,
"Error while looking up data for %s. %s",
ip_address, MMDB_strerror(status));
MMDB_free_entry_data_list(entry_data_list);
return NULL;
}
MMDB_entry_data_list_s *original_entry_data_list = entry_data_list;
PyObject *py_obj = from_entry_data_list(&entry_data_list);
MMDB_free_entry_data_list(original_entry_data_list);
return py_obj;
}
