Net-LDNS
1 match

 view release on metacpan or  search on metacpan

src/LDNS.xs  view on Meta::CPAN 

#include <LDNS.h>

MODULE = Net::LDNS        PACKAGE = Net::LDNS

PROTOTYPES: ENABLE

SV *
to_idn(...)
    PPCODE:
    {
#ifdef WE_CAN_HAZ_IDN
        int i;
        for( i = 0; i<items; i++ )
        {
            char *out;
            int status;
            SV *obj = ST(i);

            if (SvPOK(ST(i)))
            {
               status = idna_to_ascii_8z(SvPVutf8_nolen(obj), &out, IDNA_ALLOW_UNASSIGNED);
               if (status == IDNA_SUCCESS)
               {
                  SV *new = newSVpv(out,0);
                  SvUTF8_on(new); /* We know the string is plain ASCII, so let Perl know too */
                  mXPUSHs(new);
                  free(out);
               }
               else
               {
                  croak("Error: %s\n", idna_strerror(status));
               }
            }
        }
#else
        croak("libidn not installed");
#endif
    }

bool
has_idn()
    CODE:
#ifdef WE_CAN_HAZ_IDN
        RETVAL = 1;
#else
        RETVAL = 0;
#endif
    OUTPUT:
        RETVAL

bool
has_gost()
	CODE:
#ifdef USE_GOST
		RETVAL = 1;
#else
		RETVAL = 0;
#endif
	OUTPUT:
		RETVAL

const char *
lib_version()
    CODE:
        RETVAL = ldns_version();
    OUTPUT:
        RETVAL

SV *
load_zonefile(filename)
    char *filename;
    PPCODE:
    {
		ldns_zone *zone;
		ldns_status s;
		ldns_rr *soa;
		ldns_rr_list *rrs;
		ldns_rdf *root = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME,".");
        I32 context = GIMME_V;
		size_t i,n;

        if (context == G_VOID)
        {
            return;
        }

        FILE *fp = fopen(filename, "r");
		if(!fp)
		{
	    	croak("%s",strerror(errno));
		}

		s = ldns_zone_new_frm_fp(&zone, fp, root, 3600, LDNS_RR_CLASS_IN);
		if(s != LDNS_STATUS_OK)
		{
			croak("%s",ldns_get_errorstr_by_id(s));
		}

		soa = ldns_zone_soa(zone);
		rrs = ldns_zone_rrs(zone);

        n = ldns_rr_list_rr_count(rrs);

        if (context == G_SCALAR)
        {
            ldns_zone_deep_free(zone);
            ldns_rdf_deep_free(root);
            XSRETURN_IV(n+1); /* Add one for SOA */
        }

        mXPUSHs(rr2sv(ldns_rr_clone(soa)));
        for(i = 0; i < n; ++i)
        {
            mXPUSHs(rr2sv(ldns_rr_clone(ldns_rr_list_rr(rrs,i))));
        }
		ldns_zone_deep_free(zone);
		ldns_rdf_deep_free(root);
    }

SV *
new(class, ...)
    char *class;
    CODE:
    {
        int i;
        ldns_resolver *res;
        RETVAL = newSV(0);

        if (items == 1 ) { /* Called without arguments, use resolv.conf */
            ldns_resolver_new_frm_file(&res,NULL);
        }
        else {

src/LDNS.xs  view on Meta::CPAN 

            ldns_resolver_set_igntc(obj, SvIV(ST(1)));
        }
        RETVAL = ldns_resolver_igntc(obj);
    OUTPUT:
        RETVAL

U8
retry(obj,...)
    Net::LDNS obj;
    CODE:
        if ( items > 1 ) {
            SvGETMAGIC(ST(1));
            ldns_resolver_set_retry(obj, SvIV(ST(1)));
        }
        RETVAL = ldns_resolver_retry(obj);
    OUTPUT:
        RETVAL

U8
retrans(obj,...)
    Net::LDNS obj;
    CODE:
        if ( items > 1 ) {
            SvGETMAGIC(ST(1));
            ldns_resolver_set_retrans(obj, SvIV(ST(1)));
        }
        RETVAL = ldns_resolver_retrans(obj);
    OUTPUT:
        RETVAL

U16
edns_size(obj,...)
    Net::LDNS obj;
    CODE:
        if( items > 1 )
        {
            SvGETMAGIC(ST(1));
            ldns_resolver_set_edns_udp_size(obj, (U16)SvIV(ST(1)));
        }
        RETVAL = ldns_resolver_edns_udp_size(obj);
    OUTPUT:
        RETVAL

U16
port(obj,...)
    Net::LDNS obj;
    CODE:
        if( items > 1 )
        {
            SvGETMAGIC(ST(1));
            ldns_resolver_set_port(obj, (U16)SvIV(ST(1)));
        }
        RETVAL = ldns_resolver_port(obj);
    OUTPUT:
        RETVAL

SV *
name2addr(obj,name)
    Net::LDNS obj;
    const char *name;
    PPCODE:
    {
        ldns_rr_list *addrs;
        ldns_rdf *dname;
        size_t n, i;
        I32 context;

        context = GIMME_V;

        if(context == G_VOID)
        {
            XSRETURN_NO;
        }

        dname = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, name);
        if(dname==NULL)
        {
            croak("Name error for '%s'", name);
        }

        addrs = ldns_get_rr_list_addr_by_name(obj,dname,LDNS_RR_CLASS_IN,0);
        n = ldns_rr_list_rr_count(addrs);
        ldns_rdf_deep_free(dname);

        if (context == G_SCALAR)
        {
          ldns_rr_list_deep_free(addrs);
          XSRETURN_IV(n);
        }
        else
        {
            for(i = 0; i < n; ++i)
            {
                ldns_rr *rr = ldns_rr_list_rr(addrs,i);
                ldns_rdf *addr_rdf = ldns_rr_a_address(rr);
                char *addr_str = ldns_rdf2str(addr_rdf);

                SV* sv = newSVpv(addr_str,0);
                mXPUSHs(sv);
                free(addr_str);
            }
            ldns_rr_list_deep_free(addrs);
        }
    }

SV *
addr2name(obj,addr_in)
    Net::LDNS obj;
    const char *addr_in;
    PPCODE:
    {
        ldns_rr_list *names;
        ldns_rdf *addr_rdf;
        size_t n, i;
        I32 context;

        context = GIMME_V;

        if(context == G_VOID)
        {
            XSRETURN_NO;
        }

        addr_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, addr_in);
        if(addr_rdf==NULL)
        {
            addr_rdf = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, addr_in);
        }
        if(addr_rdf==NULL)
        {
            croak("Failed to parse address: %s", addr_in);
        }

        names = ldns_get_rr_list_name_by_addr(obj,addr_rdf,LDNS_RR_CLASS_IN,0);
        ldns_rdf_deep_free(addr_rdf);
        n = ldns_rr_list_rr_count(names);

        if (context == G_SCALAR)
        {
          ldns_rr_list_deep_free(names);
          XSRETURN_IV(n);
        }
        else
        {
            for(i = 0; i < n; ++i)
            {
                ldns_rr *rr = ldns_rr_list_rr(names,i);
                ldns_rdf *name_rdf = ldns_rr_rdf(rr,0);
                char *name_str = randomize_capitalization(ldns_rdf2str(name_rdf));

                SV* sv = newSVpv(name_str,0);
                mXPUSHs(sv);
                free(name_str);
            }
            ldns_rr_list_deep_free(names);
        }
    }

bool
axfr(obj,dname,callback,class="IN")
    Net::LDNS obj;
    const char *dname;
    SV *callback;
    const char *class;
    CODE:
    {
        ldns_rdf *domain = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, dname);
        ldns_rr_class cl = ldns_get_rr_class_by_name(class);
        ldns_status status;

src/LDNS.xs  view on Meta::CPAN 

    CODE:
		if ( items > 1 ) {
            SvGETMAGIC(ST(1));
			ldns_pkt_set_querytime(obj, (U32)SvIV(ST(1)));
		}
        RETVAL = ldns_pkt_querytime(obj);
    OUTPUT:
        RETVAL

char *
packet_answerfrom(obj,...)
    Net::LDNS::Packet obj;
    CODE:
        if(items >= 2)
        {
           ldns_rdf *address;

           SvGETMAGIC(ST(1));
           address = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, SvPV_nolen(ST(1)));
           if(address == NULL)
           {
              address = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, SvPV_nolen(ST(1)));
           }
           if(address == NULL)
           {
              croak("Failed to parse IP address: %s", SvPV_nolen(ST(1)));
           }

           ldns_pkt_set_answerfrom(obj, address);
        }
        RETVAL = ldns_rdf2str(ldns_pkt_answerfrom(obj));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

double
packet_timestamp(obj,...)
    Net::LDNS::Packet obj;
    CODE:
        if(items >= 2)
        {
            struct timeval tn;
            double dec_part, int_part;

            SvGETMAGIC(ST(1));
            dec_part = modf(SvNV(ST(1)), &int_part);
            tn.tv_sec  = int_part;
            tn.tv_usec = 1000000*dec_part;
            ldns_pkt_set_timestamp(obj,tn);
        }
        struct timeval t = ldns_pkt_timestamp(obj);
        RETVAL = (double)t.tv_sec;
        RETVAL += ((double)t.tv_usec)/1000000;
    OUTPUT:
        RETVAL

SV *
packet_answer(obj)
    Net::LDNS::Packet obj;
    PPCODE:
    {
        size_t i,n;
        ldns_rr_list *rrs;
        I32 context = GIMME_V;

        if (context == G_VOID)
        {
            return;
        }

        rrs = ldns_pkt_answer(obj);
        n = ldns_rr_list_rr_count(rrs);

        if (context == G_SCALAR)
        {
            XSRETURN_IV(n);
        }

        for(i = 0; i < n; ++i)
        {
            mXPUSHs(rr2sv(ldns_rr_clone(ldns_rr_list_rr(rrs,i))));
        }
    }

SV *
packet_authority(obj)
    Net::LDNS::Packet obj;
    PPCODE:
    {
        size_t i,n;
        ldns_rr_list *rrs;
        I32 context = GIMME_V;

        if (context == G_VOID)
        {
            return;
        }

        rrs = ldns_pkt_authority(obj);
        n = ldns_rr_list_rr_count(rrs);

        if (context == G_SCALAR)
        {
            XSRETURN_IV(n);
        }

        for(i = 0; i < n; ++i)
        {
            mXPUSHs(rr2sv(ldns_rr_clone(ldns_rr_list_rr(rrs,i))));
        }
    }

SV *
packet_additional(obj)
    Net::LDNS::Packet obj;
    PPCODE:
    {
        size_t i,n;
        ldns_rr_list *rrs;
        I32 context = GIMME_V;

        if (context == G_VOID)
        {
            return;
        }

        rrs = ldns_pkt_additional(obj);
        n = ldns_rr_list_rr_count(rrs);

        if (context == G_SCALAR)
        {
            XSRETURN_IV(n);
        }

        for(i = 0; i < n; ++i)
        {
            mXPUSHs(rr2sv(ldns_rr_clone(ldns_rr_list_rr(rrs,i))));
        }
    }

SV *
packet_question(obj)
    Net::LDNS::Packet obj;
    PPCODE:
    {
        size_t i,n;
        ldns_rr_list *rrs;
        I32 context = GIMME_V;

        if (context == G_VOID)
        {
            return;
        }

        rrs = ldns_pkt_question(obj);
        n = ldns_rr_list_rr_count(rrs);

        if (context == G_SCALAR)
        {
            XSRETURN_IV(n);
        }

        for(i = 0; i < n; ++i)
        {
            mXPUSHs(rr2sv(ldns_rr_clone(ldns_rr_list_rr(rrs,i))));
        }
    }

bool
packet_unique_push(obj,section,rr)
    Net::LDNS::Packet obj;
    char *section;
    Net::LDNS::RR rr;
    CODE:
    {
        ldns_pkt_section sec;
        char lbuf[21];
        char *p;

        p = lbuf;
        strncpy(lbuf, section, 20);
        for(; *p; p++) *p = tolower(*p);

        if(strncmp(lbuf, "answer", 6)==0)
        {
            sec = LDNS_SECTION_ANSWER;
        }
        else if(strncmp(lbuf, "additional", 10)==0)
        {
            sec = LDNS_SECTION_ADDITIONAL;
        }
        else if(strncmp(lbuf, "authority", 9)==0)
        {
            sec = LDNS_SECTION_AUTHORITY;
        }
        else if(strncmp(lbuf, "question", 8)==0)
        {
            sec = LDNS_SECTION_QUESTION;
        }
        else
        {
            croak("Unknown section: %s", section);
        }

src/LDNS.xs  view on Meta::CPAN 

        RETVAL

SV *
rrlist_pop(obj)
    Net::LDNS::RRList obj;
    CODE:
        ldns_rr *rr = ldns_rr_list_pop_rr(obj);
        if(rr==NULL)
        {
            RETVAL = &PL_sv_no;
        }
        else
        {
            RETVAL = rr2sv(rr);
        }
    OUTPUT:
        RETVAL

bool
rrlist_push(obj,rr)
    Net::LDNS::RRList obj;
    Net::LDNS::RR rr;
    CODE:
        RETVAL = ldns_rr_list_push_rr(obj,ldns_rr_clone(rr));
    OUTPUT:
        RETVAL

bool
rrlist_is_rrset(obj)
    Net::LDNS::RRList obj;
    CODE:
        RETVAL = ldns_is_rrset(obj);
    OUTPUT:
        RETVAL

void
rrlist_DESTROY(obj)
    Net::LDNS::RRList obj;
    CODE:
#ifdef USE_ITHREADS
        net_ldns_forget();
#endif
        ldns_rr_list_deep_free(obj);

#ifdef USE_ITHREADS

void
rrlist_CLONE(class)
    char *class;
	CODE:
		net_ldns_clone_rrlists();

#endif

MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR           PREFIX=rr_

SV *
rr_new_from_string(class,str)
    char *class;
    char *str;
    PPCODE:
        ldns_status s;
        ldns_rr *rr;
        char rrclass[40];
        char *rrtype;
        SV* rr_sv;

        s = ldns_rr_new_frm_str(&rr, str, 0, NULL, NULL);
        if(s != LDNS_STATUS_OK)
        {
            croak("Failed to build RR: %s", ldns_get_errorstr_by_id(s));
        }
        rrtype = ldns_rr_type2str(ldns_rr_get_type(rr));
        snprintf(rrclass, 39, "Net::LDNS::RR::%s", rrtype);
        free(rrtype);
        rr_sv = sv_newmortal();
        sv_setref_pv(rr_sv, rrclass, rr);
#ifdef USE_ITHREADS
        net_ldns_remember_rr(rr_sv);
#endif
        PUSHs(rr_sv);

char *
rr_owner(obj)
    Net::LDNS::RR obj;
    CODE:
        RETVAL = randomize_capitalization(ldns_rdf2str(ldns_rr_owner(obj)));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

U32
rr_ttl(obj)
    Net::LDNS::RR obj;
    CODE:
        RETVAL = ldns_rr_ttl(obj);
    OUTPUT:
        RETVAL

char *
rr_type(obj)
    Net::LDNS::RR obj;
    CODE:
        RETVAL = ldns_rr_type2str(ldns_rr_get_type(obj));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

char *
rr_class(obj)
    Net::LDNS::RR obj;
    CODE:
        RETVAL = ldns_rr_class2str(ldns_rr_get_class(obj));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

char *

src/LDNS.xs  view on Meta::CPAN 

                typestring += pos+1;
                pos = 0;
            }
        }
        RETVAL = newRV_noinc((SV *)res);
        free(copy);
    }
    OUTPUT:
        RETVAL

bool
rr_nsec_covers(obj,name)
    Net::LDNS::RR::NSEC obj;
    const char *name;
    CODE:
        ldns_rdf *dname = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, name);
        ldns_dname2canonical(dname);
        ldns_rr2canonical(obj);
        RETVAL = ldns_nsec_covers_name(obj,dname);
        ldns_rdf_deep_free(dname);
    OUTPUT:
        RETVAL

MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::NSEC3            PREFIX=rr_nsec3_

U8
rr_nsec3_algorithm(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
        RETVAL = ldns_nsec3_algorithm(obj);
    OUTPUT:
        RETVAL

U8
rr_nsec3_flags(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
        RETVAL = ldns_nsec3_flags(obj);
    OUTPUT:
        RETVAL

bool
rr_nsec3_optout(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
        RETVAL = ldns_nsec3_optout(obj);
    OUTPUT:
        RETVAL

U16
rr_nsec3_iterations(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
        RETVAL = ldns_nsec3_iterations(obj);
    OUTPUT:
        RETVAL

SV *
rr_nsec3_salt(obj)
    Net::LDNS::RR::NSEC3 obj;
    PPCODE:
        if(ldns_nsec3_salt_length(obj) > 0)
        {
            ldns_rdf *buf = ldns_nsec3_salt(obj);
            ST(0) = sv_2mortal(newSVpvn((char *)ldns_rdf_data(buf), ldns_rdf_size(buf)));
            ldns_rdf_deep_free(buf);
        }

SV *
rr_nsec3_next_owner(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
        ldns_rdf *buf = ldns_nsec3_next_owner(obj);
        RETVAL = newSVpvn((char *)ldns_rdf_data(buf), ldns_rdf_size(buf));
    OUTPUT:
        RETVAL

char *
rr_nsec3_typelist(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
        RETVAL = ldns_rdf2str(ldns_nsec3_bitmap(obj));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

SV *
rr_nsec3_typehref(obj)
    Net::LDNS::RR::NSEC3 obj;
    CODE:
    {
        char *typestring = ldns_rdf2str(ldns_nsec3_bitmap(obj));
        char *copy = typestring;
        size_t pos;
        HV *res = newHV();

        pos = 0;
        while(typestring[pos] != '\0')
        {
            pos++;
            if(typestring[pos] == ' ')
            {
                typestring[pos] = '\0';
                if(hv_store(res,typestring,pos,newSViv(1),0)==NULL)
                {
                    croak("Failed to store to hash");
                }
                typestring += pos+1;
                pos = 0;
            }
        }
        RETVAL = newRV_noinc((SV *)res);
        free(copy);
    }
    OUTPUT:
        RETVAL

bool
rr_nsec3_covers(obj,name)
    Net::LDNS::RR::NSEC3 obj;
    const char *name;
    CODE:
    {
        ldns_rr *clone;
        ldns_rdf *dname;
        ldns_rdf *hashed;
        ldns_rdf *chopped;

        clone = ldns_rr_clone(obj);
        dname = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, name);
        ldns_dname2canonical(dname);
        ldns_rr2canonical(clone);
        hashed = ldns_nsec3_hash_name_frm_nsec3(clone, dname);
        chopped = ldns_dname_left_chop(dname);
        ldns_rdf_deep_free(dname);
        ldns_dname_cat(hashed,chopped);
        RETVAL = ldns_nsec_covers_name(clone,hashed);
        ldns_rdf_deep_free(hashed);
        ldns_rdf_deep_free(chopped);
        ldns_rr_free(clone);
    }
    OUTPUT:
        RETVAL

MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::NSEC3PARAM       PREFIX=rr_nsec3param_

U8
rr_nsec3param_algorithm(obj)
    Net::LDNS::RR::NSEC3PARAM obj;
    CODE:
        RETVAL = D_U8(obj,0);
    OUTPUT:
        RETVAL

U8
rr_nsec3param_flags(obj)
    Net::LDNS::RR::NSEC3PARAM obj;
    CODE:
        RETVAL = D_U8(obj,1);
    OUTPUT:
        RETVAL


U16
rr_nsec3param_iterations(obj)
    Net::LDNS::RR::NSEC3PARAM obj;
    CODE:
        RETVAL = D_U16(obj,2);
    OUTPUT:
        RETVAL

SV *
rr_nsec3param_salt(obj)
    Net::LDNS::RR::NSEC3PARAM obj;
    PPCODE:
        ldns_rdf *rdf = ldns_rr_rdf(obj,3);
        if(ldns_rdf_size(rdf) > 0)
        {
            mPUSHs(newSVpvn((char *)ldns_rdf_data(rdf), ldns_rdf_size(rdf)));
        }

MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::PTR              PREFIX=rr_ptr_

char *
rr_ptr_ptrdname(obj)
    Net::LDNS::RR::PTR obj;
    CODE:
        RETVAL = randomize_capitalization(D_STRING(obj,0));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);


MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::CNAME            PREFIX=rr_cname_

char *
rr_cname_cname(obj)
    Net::LDNS::RR::CNAME obj;
    CODE:
        RETVAL = randomize_capitalization(D_STRING(obj,0));
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);


MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::TXT              PREFIX=rr_txt_

char *
rr_txt_txtdata(obj)
    Net::LDNS::RR::TXT obj;
    CODE:
        RETVAL = D_STRING(obj,0);
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::SPF              PREFIX=rr_spf_

char *
rr_spf_spfdata(obj)
    Net::LDNS::RR::SPF obj;
    CODE:
        RETVAL = D_STRING(obj,0);
    OUTPUT:
        RETVAL
    CLEANUP:
        free(RETVAL);

MODULE = Net::LDNS        PACKAGE = Net::LDNS::RR::KEY           PREFIX=rr_key_

U16
rr_key_flags(obj)



( run in 0.597 second using v1.01-cache-2.11-cpan-71847e10f99 )