+/*
+ * _srv* (ckl,(pap),pa*2,mf*2,di,(csp),cs*2,postsort)
+ */
+
+static adns_status ckl_srv(adns_state ads, adns_queryflags flags,
+ union checklabel_state *cls, qcontext *ctx,
+ int labnum, const char *label, int lablen) {
+ if (labnum < 2 && !(flags & adns_qf_quoteok_query)) {
+ if (!lablen || label[0] != '_') return adns_s_querydomaininvalid;
+ return adns_s_ok;
+ }
+ return adns__ckl_hostname(ads, flags, cls, ctx, labnum, label, lablen);
+}
+
+static adns_status pap_srv_begin(const parseinfo *pai, int *cbyte_io, int max,
+ adns_rr_srvha *rrp
+ /* might be adns_rr_srvraw* */) {
+ const byte *dgram= pai->dgram;
+ int ti, cbyte;
+
+ cbyte= *cbyte_io;
+ if ((*cbyte_io += 6) > max) return adns_s_invaliddata;
+
+ rrp->priority= GET_W(cbyte, ti);
+ rrp->weight= GET_W(cbyte, ti);
+ rrp->port= GET_W(cbyte, ti);
+ return adns_s_ok;
+}
+
+static adns_status pa_srvraw(const parseinfo *pai, int cbyte,
+ int max, void *datap) {
+ adns_rr_srvraw *rrp= datap;
+ adns_status st;
+
+ st= pap_srv_begin(pai,&cbyte,max,datap);
+ if (st) return st;
+
+ st= pap_domain(pai, &cbyte, max, &rrp->host,
+ pai->qu->flags & adns_qf_quoteok_anshost ? pdf_quoteok : 0);
+ if (st) return st;
+
+ if (cbyte != max) return adns_s_invaliddata;
+ return adns_s_ok;
+}
+
+static adns_status pa_srvha(const parseinfo *pai, int cbyte,
+ int max, void *datap) {
+ adns_rr_srvha *rrp= datap;
+ adns_status st;
+
+ st= pap_srv_begin(pai,&cbyte,max,datap); if (st) return st;
+ st= pap_hostaddr(pai, &cbyte, max, &rrp->ha); if (st) return st;
+ if (cbyte != max) return adns_s_invaliddata;
+ return adns_s_ok;
+}
+
+static void mf_srvraw(adns_query qu, void *datap) {
+ adns_rr_srvraw *rrp= datap;
+ adns__makefinal_str(qu, &rrp->host);
+}
+
+static void mf_srvha(adns_query qu, void *datap) {
+ adns_rr_srvha *rrp= datap;
+ mfp_hostaddr(qu,&rrp->ha);
+}
+
+static int di_srv(adns_state ads, const void *datap_a, const void *datap_b) {
+ const adns_rr_srvraw *ap= datap_a, *bp= datap_b;
+ /* might be const adns_rr_svhostaddr* */
+
+ if (ap->priority < bp->priority) return 0;
+ if (ap->priority > bp->priority) return 1;
+ return 0;
+}
+
+static adns_status csp_srv_begin(vbuf *vb, const adns_rr_srvha *rrp
+ /* might be adns_rr_srvraw* */) {
+ char buf[30];
+ sprintf(buf,"%u %u %u ", rrp->priority, rrp->weight, rrp->port);
+ CSP_ADDSTR(buf);
+ return adns_s_ok;
+}
+
+static adns_status cs_srvraw(vbuf *vb, const void *datap) {
+ const adns_rr_srvraw *rrp= datap;
+ adns_status st;
+
+ st= csp_srv_begin(vb,(const void*)rrp); if (st) return st;
+ return csp_domain(vb,rrp->host);
+}
+
+static adns_status cs_srvha(vbuf *vb, const void *datap) {
+ const adns_rr_srvha *rrp= datap;
+ adns_status st;
+
+ st= csp_srv_begin(vb,(const void*)datap); if (st) return st;
+ return csp_hostaddr(vb,&rrp->ha);
+}
+
+static void postsort_srv(adns_state ads, void *array, int nrrs,int rrsz,
+ const struct typeinfo *typei) {
+ /* we treat everything in the array as if it were an adns_rr_srvha
+ * even though the array might be of adns_rr_srvraw. That's OK
+ * because they have the same prefix, which is all we access.
+ * We use rrsz, too, rather than naive array indexing, of course.
+ */
+ char *workbegin, *workend, *search, *arrayend;
+ const adns_rr_srvha *rr;
+ union { adns_rr_srvha ha; adns_rr_srvraw raw; } rrtmp;
+ int cpriority, totalweight, runtotal;
+ long randval;
+
+ assert(rrsz <= sizeof(rrtmp));
+ for (workbegin= array, arrayend= workbegin + rrsz * nrrs;
+ workbegin < arrayend;
+ workbegin= workend) {
+ cpriority= (rr=(void*)workbegin)->priority;
+
+ for (workend= workbegin, totalweight= 0;
+ workend < arrayend && (rr=(void*)workend)->priority == cpriority;
+ workend += rrsz) {
+ totalweight += rr->weight;
+ }
+
+ /* Now workbegin..(workend-1) incl. are exactly all of the RRs of
+ * cpriority. From now on, workbegin points to the `remaining'
+ * records: we select one record at a time (RFC2782 `Usage rules'
+ * and `Format of the SRV RR' subsection `Weight') to place at
+ * workbegin (swapping with the one that was there, and then
+ * advance workbegin. */
+ for (;
+ workbegin + rrsz < workend; /* don't bother if just one */
+ workbegin += rrsz) {
+
+ randval= nrand48(ads->rand48xsubi);
+ randval %= (totalweight + 1);
+ /* makes it into 0..totalweight inclusive; with 2^10 RRs,
+ * totalweight must be <= 2^26 so probability nonuniformity is
+ * no worse than 1 in 2^(31-26) ie 1 in 2^5, ie
+ * abs(log(P_intended(RR_i) / P_actual(RR_i)) <= log(2^-5).
+ */
+
+ for (search=workbegin, runtotal=0;
+ (runtotal += (rr=(void*)search)->weight) < randval;
+ search += rrsz);
+ assert(search < arrayend);
+ totalweight -= rr->weight;
+ if (search != workbegin) {
+ memcpy(&rrtmp, workbegin, rrsz);
+ memcpy(workbegin, search, rrsz);
+ memcpy(search, &rrtmp, rrsz);
+ }
+ }
+ }
+ /* tests:
+ * dig -t srv _srv._tcp.test.iwj.relativity.greenend.org.uk.
+ * ./adnshost_s -t srv- _sip._udp.voip.net.cam.ac.uk.
+ * ./adnshost_s -t srv- _jabber._tcp.jabber.org
+ */
+}
+
+/*
+ * _byteblock (mf)
+ */
+
+static void mf_byteblock(adns_query qu, void *datap) {
+ adns_rr_byteblock *rrp= datap;
+ void *bytes= rrp->data;
+ adns__makefinal_block(qu,&bytes,rrp->len);
+ rrp->data= bytes;
+}
+
+/*
+ * _opaque (pa,cs)
+ */
+
+static adns_status pa_opaque(const parseinfo *pai, int cbyte,
+ int max, void *datap) {
+ adns_rr_byteblock *rrp= datap;
+
+ rrp->len= max - cbyte;
+ rrp->data= adns__alloc_interim(pai->qu, rrp->len);
+ if (!rrp->data) R_NOMEM;
+ memcpy(rrp->data, pai->dgram + cbyte, rrp->len);
+ return adns_s_ok;
+}
+
+static adns_status cs_opaque(vbuf *vb, const void *datap) {
+ const adns_rr_byteblock *rrp= datap;
+ char buf[10];
+ int l;
+ unsigned char *p;
+
+ sprintf(buf,"\\# %d",rrp->len);
+ CSP_ADDSTR(buf);
+
+ for (l= rrp->len, p= rrp->data;
+ l>=4;
+ l -= 4, p += 4) {
+ sprintf(buf," %02x%02x%02x%02x",p[0],p[1],p[2],p[3]);
+ CSP_ADDSTR(buf);
+ }
+ for (;
+ l>0;
+ l--, p++) {
+ sprintf(buf," %02x",*p);
+ CSP_ADDSTR(buf);
+ }
+ return adns_s_ok;
+}
+