view release on metacpan or  search on metacpan

ADNS.xs  view on Meta::CPAN

CODE:
    RETVAL = 0;
    if (config) {
        adns_init_strcfg(&RETVAL, flags, 0, config);
    }
    else {
        adns_init(&RETVAL, flags, 0);
    }
OUTPUT:
    RETVAL

SV *
adns_synchronous(self, owner, type, flags=0)
    adns_state self
    const char *owner
    adns_rrtype type
    adns_queryflags flags
PREINIT:
    adns_answer *answer;
CODE:
    RETVAL = &PL_sv_undef;
    if (!(errno = adns_synchronous(self, owner, type, flags, &answer))) {
        SV *sv = make_sv_query(aTHX);
        if (init_sv_query(aTHX_ sv, 0, owner, type) ||
            answer_sv_query(aTHX_ sv, answer)) {
            SvREFCNT_dec(sv);
        }
        else
            RETVAL = sv;
    }
OUTPUT:
    RETVAL

SV *
adns_submit(self, owner, type, flags=0)
    adns_state self
    char *owner
    adns_rrtype type
    adns_queryflags flags
PREINIT:
    adns_query query;
    SV *rv = make_sv_query(aTHX);
CODE:
    RETVAL = &PL_sv_undef;
    if(errno = adns_submit(self, owner, type, flags, rv, &query)) {
        SvREFCNT_dec(rv);
    }
    else {
        if (!init_sv_query(aTHX_ rv, query, owner, type))
            RETVAL = newSVsv(rv);
    }
OUTPUT:
    RETVAL

void
open_queries(self)
    adns_state self
PREINIT:
    int n;
    SV *wrapper;
PPCODE:
    adns_forallqueries_begin(self);
    for ( n = 0;
          adns_forallqueries_next(self, (void**)(&wrapper));
          n++)
        XPUSHs(sv_2mortal(newSVsv(wrapper)));
    XSRETURN(n);

SV *
adns_wait(self, query=0)
    adns_state self
    adns_query query
PREINIT:
    adns_answer *answer = 0;
    SV *query_sv = 0;
    int r;
CODE:
    RETVAL = &PL_sv_undef;
    if (!(errno = adns_wait(self, &query, &answer, (void**)(&query_sv)))) {
        assert(query_sv);
        assert(answer);
        answer_sv_query(aTHX_ query_sv, answer);
        free(answer);
        RETVAL = query_sv;
    }
OUTPUT:
    RETVAL

SV *
adns_check(self, query=0)
    adns_state self
    adns_query query
PREINIT:
    adns_answer *answer = 0;
    SV *query_sv = 0;
    int r;
CODE:
    RETVAL = &PL_sv_undef;
    if (!(errno = adns_check(self, &query, &answer, (void**)(&query_sv)))) {
        assert(query_sv);
        assert(answer);
        answer_sv_query(aTHX_ query_sv, answer);
        free(answer);
        RETVAL = query_sv;
    }
OUTPUT:
    RETVAL

void
adns_cancel(self, query)
    adns_state self
    adns_query query
PREINIT:
    adns_query q;
    SV *wrapper;
CODE:
    adns_forallqueries_begin(self);
    while(q = adns_forallqueries_next(self, (void**)(&wrapper))) {
        if (q == query) {
            sv_2mortal(wrapper);
            break;
        }
    }

void
adns_DESTROY(self)
    adns_state self
PREINIT:
    adns_query q;
    SV *wrapper;
CODE:
    adns_forallqueries_begin(self);
    while(adns_forallqueries_next(self, (void**)(&wrapper))) {
        HV *hv;
        assert(wrapper);
        assert(SvRV(wrapper));
        hv = (HV*)SvRV(wrapper);
        sv_unmagic((SV*)hv, '~');
        sv_2mortal(wrapper);
    }
    adns_finish(self);
    sv_unmagic(SvRV(ST(0)), '~');

SV *
adns_process(self)
    adns_state self
CODE:
    if (!(errno = adns_processany(self)))
        RETVAL = &PL_sv_yes;
    else
        RETVAL = &PL_sv_undef;
OUTPUT:
    RETVAL

SV *
adns_first_timeout(self)
    adns_state self
PREINIT:
    struct timeval *tv_mod = 0;
    struct timeval tv_buf;
    struct timeval now;
CODE:
    gettimeofday(&now, NULL);
    adns_firsttimeout(self, &tv_mod, &tv_buf, now);
    RETVAL = (tv_mod
              ? newSVnv(tv_buf.tv_sec + 1e-6 * tv_buf.tv_usec)
              : &PL_sv_undef);
OUTPUT:
    RETVAL

void
adns_before_select(self)
    adns_state self;
PREINIT:
    fd_set rfds, wfds, efds;
    int maxfd = 0;
    struct timeval *tv_mod = 0;
    struct timeval tv_buf, now;
PPCODE:
    FD_ZERO(&rfds); FD_ZERO(&wfds); FD_ZERO(&efds);
    gettimeofday(&now, NULL);
    adns_beforeselect(self,
                      &maxfd, &rfds, &wfds, &efds,
                      &tv_mod, &tv_buf, &now);
    /* fprintf(stderr, "maxfd: %d\n", maxfd); fflush(stderr); */
    XPUSHs(sv_2mortal(_fd_set2sv(aTHX_ &rfds, maxfd)));
    XPUSHs(sv_2mortal(_fd_set2sv(aTHX_ &wfds, maxfd)));
    XPUSHs(sv_2mortal(_fd_set2sv(aTHX_ &efds, maxfd)));
    if (tv_mod) {
        XPUSHs(sv_2mortal(newSVnv(tv_buf.tv_sec + 1e-6 * tv_buf.tv_usec)));
        XSRETURN(4);
    }
    else
        XSRETURN(3);
 
void
adns_after_select(self, rfds, wfds, efds)
    adns_state self
    SV *rfds
    SV *wfds
    SV *efds
PREINIT:
    int maxfd = 0;
    fd_set r, w, e;
    int i, len;
    char *pv;
    struct timeval now;
CODE:
    gettimeofday(&now, 0);
    _sv2fd_set(aTHX_ rfds, &r, &maxfd);
    _sv2fd_set(aTHX_ wfds, &w, &maxfd);
    _sv2fd_set(aTHX_ efds, &e, &maxfd);
    adns_afterselect(self, maxfd, &r, &w, &e, &now);