LOCAL int lookup_and_print(MMDB_s *mmdb, const char *ip_address, const char **lookup_path, int lookup_path_length) { MMDB_lookup_result_s result = lookup_or_die(mmdb, ip_address); MMDB_entry_data_list_s *entry_data_list = NULL; int exit_code = 0; if (result.found_entry) { int status; if (lookup_path_length) { MMDB_entry_data_s entry_data; status = MMDB_aget_value(&result.entry, &entry_data, lookup_path); if (MMDB_SUCCESS == status) { if (entry_data.offset) { MMDB_entry_s entry = { .mmdb = mmdb, .offset = entry_data.offset }; status = MMDB_get_entry_data_list(&entry, &entry_data_list); } else { fprintf( stdout, "\n No data was found at the lookup path you provided\n\n"); } } } else {
CAMLprim value mmdb_ml_dump_per_ip(value ip, value mmdb) { CAMLparam2(ip, mmdb); CAMLlocal1(pulled_string); unsigned int len = caml_string_length(ip); char *as_string = caml_strdup(String_val(ip)); if (strlen(as_string) != (size_t)len) { caml_failwith("Could not copy IP address properly"); } MMDB_s *as_mmdb = (MMDB_s*)Data_custom_val(mmdb); int gai_error = 0, mmdb_error = 0; MMDB_lookup_result_s *result = caml_stat_alloc(sizeof(*result)); *result = MMDB_lookup_string(as_mmdb, as_string, &gai_error, &mmdb_error); MMDB_entry_data_list_s *entry_data_list = NULL; int status = MMDB_get_entry_data_list(&result->entry, &entry_data_list); check_status(status); char *pulled_from_db = data_from_dump(entry_data_list); pulled_string = caml_copy_string(pulled_from_db); caml_stat_free(result); caml_stat_free(as_string); caml_stat_free(pulled_from_db); free(entry_data_list); as_mmdb = NULL; CAMLreturn(pulled_string); }
// ------------------------------------------------------------------------------------------------ Object LookupResult::GetEntryDataList() { // See if there's an entry if (!m_Result.found_entry) { STHROWF("Result does not have an entry"); } MMDB_entry_data_list_s * entry_data_list = nullptr; // Attempt to retrieve the entire entry data list at once const int status = MMDB_get_entry_data_list(&m_Result.entry, &entry_data_list); // Validate the status code if (status != MMDB_SUCCESS) { STHROWF("Unable to get entry data list [%s]", MMDB_strerror(status)); } // Return the resulted list return Object(new EntryDataList(m_Handle, entry_data_list)); }
static gboolean _mmdb_load_entry_data_list(GeoIPParser *self, const gchar *input, MMDB_entry_data_list_s **entry_data_list) { int _gai_error, mmdb_error; MMDB_lookup_result_s result = MMDB_lookup_string(self->database, input, &_gai_error, &mmdb_error); if (!result.found_entry) { mmdb_problem_to_error(_gai_error, mmdb_error, "lookup"); return FALSE; } mmdb_error = MMDB_get_entry_data_list(&result.entry, entry_data_list); if (MMDB_SUCCESS != mmdb_error) { msg_debug("GeoIP2: MMDB_get_entry_data_list", evt_tag_str("error", MMDB_strerror(mmdb_error))); return FALSE; } return TRUE; }
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; }