C++ (Cpp) adns__findlabel_start Examples

Example #1

File: transmit.c Project: Cloudxtreme/eggdrop-1.9

adns_status adns__mkquery_frdgram(adns_state ads, vbuf *vb, int *id_r,
				  const byte *qd_dgram, int qd_dglen, int qd_begin,
				  adns_rrtype type, adns_queryflags flags) {
  byte *rqp;
  findlabel_state fls;
  int lablen, labstart;
  adns_status st;

  st= mkquery_header(ads,vb,id_r,qd_dglen); if (st) return st;

  MKQUERY_START(vb);

  adns__findlabel_start(&fls,ads,-1,0,qd_dgram,qd_dglen,qd_dglen,qd_begin,0);
  for (;;) {
    st= adns__findlabel_next(&fls,&lablen,&labstart); assert(!st);
    if (!lablen) break;
    assert(lablen<255);
    MKQUERY_ADDB(lablen);
    memcpy(rqp,qd_dgram+labstart,lablen);
    rqp+= lablen;
  }
  MKQUERY_ADDB(0);

  MKQUERY_STOP(vb);
  
  st= mkquery_footer(vb,type);
  
  return adns_s_ok;
}

Example #2

File: parse.c Project: BackupTheBerlios/phoenixfn-svn

adns_status adns__parse_domain(adns_state ads, int serv, adns_query qu,
			       vbuf *vb, parsedomain_flags flags,
			       const byte *dgram, int dglen, int *cbyte_io, int max) {
  findlabel_state flstate;
  
  adns__findlabel_start(&flstate,ads, serv,qu, dgram,dglen,max, *cbyte_io,cbyte_io);
  vb->used= 0;
  return adns__parse_domain_more(&flstate,ads,qu, vb,flags,dgram);
}

Example #3

File: parse.c Project: as2120/ZAchieve

adns_status adns__findrr_anychk(adns_query qu, int serv,
                                const byte *dgram, int dglen, int *cbyte_io,
                                int *type_r, int *class_r, unsigned long *ttl_r,
                                int *rdlen_r, int *rdstart_r,
                                const byte *eo_dgram, int eo_dglen, int eo_cbyte,
                                int *eo_matched_r)
{
    findlabel_state fls, eo_fls;
    int cbyte;

    int tmp, rdlen, mismatch;
    unsigned long ttl;
    int lablen, labstart, ch;
    int eo_lablen, eo_labstart, eo_ch;
    adns_status st;

    cbyte= *cbyte_io;

    adns__findlabel_start(&fls,qu->ads, serv,qu, dgram,dglen,dglen,cbyte,&cbyte);
    if (eo_dgram)
    {
        adns__findlabel_start(&eo_fls,qu->ads, -1,0, eo_dgram,eo_dglen,eo_dglen,eo_cbyte,0);
        mismatch= 0;
    }
    else
    {
        mismatch= 1;
    }

    for (;;)
    {
        st= adns__findlabel_next(&fls,&lablen,&labstart);
        if (st) return st;
        if (lablen<0) goto x_truncated;

        if (!mismatch)
        {
            st= adns__findlabel_next(&eo_fls,&eo_lablen,&eo_labstart);
            assert(!st);
            assert(eo_lablen>=0);
            if (lablen != eo_lablen) mismatch= 1;
            while (!mismatch && eo_lablen-- > 0)
            {
                ch= dgram[labstart++];
                if (ctype_alpha(ch)) ch &= ~32;
                eo_ch= eo_dgram[eo_labstart++];
                if (ctype_alpha(eo_ch)) eo_ch &= ~32;
                if (ch != eo_ch) mismatch= 1;
            }
        }
        if (!lablen) break;
    }
    if (eo_matched_r) *eo_matched_r= !mismatch;

    if (cbyte+10>dglen) goto x_truncated;
    GET_W(cbyte,tmp);
    *type_r= tmp;
    GET_W(cbyte,tmp);
    *class_r= tmp;

    GET_L(cbyte,ttl);
    if (ttl > MAXTTLBELIEVE) ttl= MAXTTLBELIEVE;
    *ttl_r= ttl;

    GET_W(cbyte,rdlen);
    if (rdlen_r) *rdlen_r= rdlen;
    if (rdstart_r) *rdstart_r= cbyte;
    cbyte+= rdlen;
    if (cbyte>dglen) goto x_truncated;
    *cbyte_io= cbyte;
    return adns_s_ok;

x_truncated:
    *type_r= -1;
    return 0;
}