view release on metacpan or  search on metacpan

lib/MaxMind/DB/Reader/XS.xs  view on Meta::CPAN

            croak("You must provide an IP address to look up");
        }

        result = MMDB_lookup_string(mmdb, ip_address, &gai_status, &mmdb_status);
        if (0 != gai_status) {
            croak(
                "The IP address you provided (%s) is not a valid IPv4 or IPv6 address",
                ip_address);
        }

        if (MMDB_SUCCESS != mmdb_status) {
            const char *mmdb_error = MMDB_strerror(mmdb_status);
            croak(
                "MaxMind::DB::Reader::XS - Error looking up IP address \"%s\": %s",
                ip_address, mmdb_error
                );
        }

        if (result.found_entry) {
            get_status = MMDB_get_entry_data_list(&result.entry, &entry_data_list);
            if (MMDB_SUCCESS != get_status) {
                const char *get_error = MMDB_strerror(get_status);
                MMDB_free_entry_data_list(entry_data_list);
                croak(
                    "MaxMind::DB::Reader::XS - Entry data error looking up \"%s\": %s",
                    ip_address, get_error
                    );
            }
            RETVAL = decode_and_free_entry_data_list(entry_data_list);
        } else {
            RETVAL = &PL_sv_undef;
        }
    OUTPUT:
        RETVAL

void
_iterate_search_tree(self, mmdb, data_callback, node_callback)
        MMDB_s *mmdb
        SV *data_callback;
        SV *node_callback;
    PREINIT:
        uint32_t node_num;
        int depth;
        int max_depth;
    CODE:
        node_num = 0;
        depth = 1;
        max_depth = mmdb->metadata.ip_version == 6 ? 128 : 32;
        mmdb_uint128_t ipnum = 0;

        iterate_search_nodes(mmdb, data_callback, node_callback, node_num,
            ipnum, depth, max_depth);

void
__read_node(self, mmdb, node_number)
        MMDB_s *mmdb
        U32 node_number
    PREINIT:
        MMDB_search_node_s node;
        int status;
    PPCODE:
        status = MMDB_read_node(mmdb, node_number, &node);
        if (MMDB_SUCCESS != status) {
            const char *error = MMDB_strerror(status);
            croak(
                "MaxMind::DB::Reader::XS - Error trying to read node %i: %s",
                node_number, error
                );
        }
        EXTEND(SP, 2);
        mPUSHu(node.left_record);
        mPUSHu(node.right_record);

SV *
libmaxminddb_version()
    CODE:
        const char *v = MMDB_lib_version();
        RETVAL = newSVpv(v, strlen(v));
    OUTPUT:
        RETVAL