[adns] / src / general.c

/*
 * general.c
 * - diagnostic functions
 * - vbuf handling
 */
/*
 *  This file is
 *    Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
 *
 *  It is part of adns, which is
 *    Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
 *    Copyright (C) 1999 Tony Finch <dot@dotat.at>
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2, or (at your option)
 *  any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software Foundation,
 *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
 */

#include <stdlib.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include "internal.h"

/* Core diagnostic functions */

void adns__vdiag(adns_state ads, const char *pfx, adns_initflags prevent,
		 int serv, adns_query qu, const char *fmt, va_list al) {
  const char *bef, *aft;
  vbuf vb;
  
  if (!ads->diagfile ||
      (!(ads->iflags & adns_if_debug) && (!prevent || (ads->iflags & prevent))))
    return;

  fprintf(ads->diagfile,"adns%s: ",pfx);

  vfprintf(ads->diagfile,fmt,al);

  bef= " (";
  aft= "\n";

  if (qu && qu->query_dgram) {
    adns__vbuf_init(&vb);
    fprintf(ads->diagfile,"%sQNAME=%s, QTYPE=%s",
	    bef,
	    adns__diag_domain(qu->ads,-1,0, &vb,
			      qu->query_dgram,qu->query_dglen,DNS_HDRSIZE),
	    qu->typei ? qu->typei->rrtname : "<unknown>");
    if (qu->typei && qu->typei->fmtname)
      fprintf(ads->diagfile,"(%s)",qu->typei->fmtname);
    bef=", "; aft=")\n";
  }
  
  if (serv>=0) {
    fprintf(ads->diagfile,"%sNS=%s",bef,inet_ntoa(ads->servers[serv].addr));
    bef=", "; aft=")\n";
  }

  fputs(aft,ads->diagfile);
}

void adns__debug(adns_state ads, int serv, adns_query qu, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  adns__vdiag(ads," debug",0,serv,qu,fmt,al);
  va_end(al);
}

void adns__warn(adns_state ads, int serv, adns_query qu, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  adns__vdiag(ads," warning",adns_if_noerrprint|adns_if_noserverwarn,serv,qu,fmt,al);
  va_end(al);
}

void adns__diag(adns_state ads, int serv, adns_query qu, const char *fmt, ...) {
  va_list al;

  va_start(al,fmt);
  adns__vdiag(ads,"",adns_if_noerrprint,serv,qu,fmt,al);
  va_end(al);
}

/* vbuf functions */

void adns__vbuf_init(vbuf *vb) {
  vb->used= vb->avail= 0; vb->buf= 0;
}

int adns__vbuf_ensure(vbuf *vb, int want) {
  void *nb;
  
  if (vb->avail >= want) return 1;
  nb= realloc(vb->buf,want); if (!nb) return 0;
  vb->buf= nb;
  vb->avail= want;
  return 1;
}
  
void adns__vbuf_appendq(vbuf *vb, const byte *data, int len) {
  memcpy(vb->buf+vb->used,data,len);
  vb->used+= len;
}

int adns__vbuf_append(vbuf *vb, const byte *data, int len) {
  int newlen;
  void *nb;

  newlen= vb->used+len;
  if (vb->avail < newlen) {
    if (newlen<20) newlen= 20;
    newlen <<= 1;
    nb= realloc(vb->buf,newlen);
    if (!nb) { newlen= vb->used+len; nb= realloc(vb->buf,newlen); }
    if (!nb) return 0;
    vb->buf= nb;
    vb->avail= newlen;
  }
  adns__vbuf_appendq(vb,data,len);
  return 1;
}

int adns__vbuf_appendstr(vbuf *vb, const char *data) {
  int l;
  l= strlen(data);
  return adns__vbuf_append(vb,data,l);
}

void adns__vbuf_free(vbuf *vb) {
  free(vb->buf);
  adns__vbuf_init(vb);
}

/* Additional diagnostic functions */

const char *adns__diag_domain(adns_state ads, int serv, adns_query qu,
			      vbuf *vb, const byte *dgram, int dglen, int cbyte) {
  adns_status st;

  st= adns__parse_domain(ads,serv,qu,vb, pdf_quoteok, dgram,dglen,&cbyte,dglen);
  if (st == adns_s_nomemory) {
    return "<cannot report domain... out of memory>";
  }
  if (st) {
    vb->used= 0;
    if (!(adns__vbuf_appendstr(vb,"<bad format... ") &&
	  adns__vbuf_appendstr(vb,adns_strerror(st)) &&
	  adns__vbuf_appendstr(vb,">") &&
	  adns__vbuf_append(vb,"",1))) {
      return "<cannot report bad format... out of memory>";
    }
  }
  if (!vb->used) {
    adns__vbuf_appendstr(vb,"<truncated ...>");
    adns__vbuf_append(vb,"",1);
  }
  return vb->buf;
}

adns_status adns_rr_info(adns_rrtype type,
			 const char **rrtname_r, const char **fmtname_r,
			 int *len_r,
			 const void *datap, char **data_r) {
  const typeinfo *typei;
  vbuf vb;
  adns_status st;

  typei= adns__findtype(type);
  if (!typei) return adns_s_unknownrrtype;

  if (rrtname_r) *rrtname_r= typei->rrtname;
  if (fmtname_r) *fmtname_r= typei->fmtname;
  if (len_r) *len_r= typei->rrsz;

  if (!datap) return adns_s_ok;
  
  adns__vbuf_init(&vb);
  st= typei->convstring(&vb,datap);
  if (st) goto x_freevb;
  if (!adns__vbuf_append(&vb,"",1)) { st= adns_s_nomemory; goto x_freevb; }
  assert(strlen(vb.buf) == vb.used-1);
  *data_r= realloc(vb.buf,vb.used);
  if (!*data_r) *data_r= vb.buf;
  return adns_s_ok;

 x_freevb:
  adns__vbuf_free(&vb);
  return st;
}

#define SINFO(n,s) { adns_s_##n, #n, s }

static const struct sinfo {
  adns_status st;
  const char *abbrev;
  const char *string;
} sinfos[]= {
  SINFO(  ok,                  "OK"                                            ),

  SINFO(  nomemory,            "Out of memory"                                 ),
  SINFO(  unknownrrtype,       "Query not implemented in DNS library"          ),
  SINFO(  systemfail,          "General resolver or system failure"            ),

  SINFO(  timeout,             "DNS query timed out"                           ),
  SINFO(  allservfail,         "All nameservers failed"                        ),
  SINFO(  norecurse,           "Recursion denied by nameserver"                ),
  SINFO(  invalidresponse,     "Nameserver sent bad response"                  ),
  SINFO(  unknownformat,       "Nameserver used unknown format"                ),

  SINFO(  rcodeservfail,       "Nameserver reports failure"                    ),
  SINFO(  rcodeformaterror,    "Query not understood by nameserver"            ),
  SINFO(  rcodenotimplemented, "Query not implemented by nameserver"           ),
  SINFO(  rcoderefused,        "Query refused by nameserver"                   ),
  SINFO(  rcodeunknown,        "Nameserver sent unknown response code"         ),
  
  SINFO(  inconsistent,        "Inconsistent resource records in DNS"          ),
  SINFO(  prohibitedcname,     "DNS alias found where canonical name wanted"   ),
  SINFO(  answerdomaininvalid, "Found syntactically invalid domain name"       ),
  SINFO(  answerdomaintoolong, "Found overly-long domain name"                 ),
  SINFO(  invaliddata,         "Found invalid DNS data"                        ),

  SINFO(  querydomainwrong,    "Domain invalid for particular DNS query type"  ),
  SINFO(  querydomaininvalid,  "Domain name is syntactically invalid"          ),
  SINFO(  querydomaintoolong,  "Domain name is too long"                       ),

  SINFO(  nxdomain,            "No such domain"                                ),
  SINFO(  nodata,              "No such data"                                  ),
};

static int si_compar(const void *key, const void *elem) {
  const adns_status *st= key;
  const struct sinfo *si= elem;

  return *st < si->st ? -1 : *st > si->st ? 1 : 0;
}

static const struct sinfo *findsinfo(adns_status st) {
  return bsearch(&st,sinfos,sizeof(sinfos)/sizeof(*sinfos),sizeof(*sinfos),si_compar);
}

const char *adns_strerror(adns_status st) {
  const struct sinfo *si;

  si= findsinfo(st);
  return si->string;
}

const char *adns_errabbrev(adns_status st) {
  const struct sinfo *si;

  si= findsinfo(st);
  return si->abbrev;
}

void adns__isort(void *array, int nobjs, int sz, void *tempbuf,
		 int (*needswap)(void *context, const void *a, const void *b),
		 void *context) {
  byte *data= array;
  int i, place;

  for (i=0; i<nobjs; i++) {
    for (place= i;
	 place>0 && needswap(context, data + (place-1)*sz, data + i*sz);
	 place--);
    if (place != i) {
      memcpy(tempbuf, data + i*sz, sz);
      memmove(data + (place+1)*sz, data + place*sz, (i-place)*sz);
      memcpy(data + place*sz, tempbuf, sz);
    }
  }
}

/* SIGPIPE protection. */

void adns__sigpipe_protect(adns_state ads) {
  sigset_t toblock;
  struct sigaction sa;
  int r;

  if (ads->iflags & adns_if_nosigpipe) return;

  sigfillset(&toblock);
  sigdelset(&toblock,SIGPIPE);

  sa.sa_handler= SIG_IGN;
  sigfillset(&sa.sa_mask);
  sa.sa_flags= 0;
  
  r= sigprocmask(SIG_SETMASK,&toblock,&ads->stdsigmask); assert(!r);
  r= sigaction(SIGPIPE,&sa,&ads->stdsigpipe); assert(!r);
}

void adns__sigpipe_unprotect(adns_state ads) {
  int r;

  if (ads->iflags & adns_if_nosigpipe) return;

  r= sigaction(SIGPIPE,&ads->stdsigpipe,0); assert(!r);
  r= sigprocmask(SIG_SETMASK,&ads->stdsigmask,0); assert(!r);
}
Commit	Line	Data
98db6da3	1	/*
	2	* general.c
	3	* - diagnostic functions
	4	* - vbuf handling
	5	*/
	6	/*
a79ac5ba	7	* This file is
	8	* Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
	9	*
	10	* It is part of adns, which is
	11	* Copyright (C) 1997-1999 Ian Jackson <ian@davenant.greenend.org.uk>
	12	* Copyright (C) 1999 Tony Finch <dot@dotat.at>
98db6da3	13	*
	14	* This program is free software; you can redistribute it and/or modify
	15	* it under the terms of the GNU General Public License as published by
	16	* the Free Software Foundation; either version 2, or (at your option)
	17	* any later version.
	18	*
	19	* This program is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with this program; if not, write to the Free Software Foundation,
	26	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	27	*/
	28
11c8bf9b	29	#include <stdlib.h>
11c8bf9b	30
b6b3ac61	31	#include <sys/types.h>
29cf9c44	32	#include <sys/socket.h>
29cf9c44	33	#include <netinet/in.h>
11c8bf9b	34	#include <arpa/inet.h>
11c8bf9b	35
98db6da3	36	#include "internal.h"
	37
	38	/* Core diagnostic functions */
	39
	40	void adns__vdiag(adns_state ads, const char *pfx, adns_initflags prevent,
11c8bf9b	41	int serv, adns_query qu, const char *fmt, va_list al) {
98db6da3	42	const char bef, aft;
98db6da3	43	vbuf vb;
d6b271ae	44
	45	if (!ads->diagfile \|\|
	46	(!(ads->iflags & adns_if_debug) && (!prevent \|\| (ads->iflags & prevent))))
	47	return;
98db6da3	48
d6b271ae	49	fprintf(ads->diagfile,"adns%s: ",pfx);
98db6da3	50
d6b271ae	51	vfprintf(ads->diagfile,fmt,al);
98db6da3	52
	53	bef= " (";
	54	aft= "\n";
	55
	56	if (qu && qu->query_dgram) {
	57	adns__vbuf_init(&vb);
d6b271ae	58	fprintf(ads->diagfile,"%sQNAME=%s, QTYPE=%s",
98db6da3	59	bef,
cd363ffd	60	adns__diag_domain(qu->ads,-1,0, &vb,
11c8bf9b	61	qu->query_dgram,qu->query_dglen,DNS_HDRSIZE),
1e9efa71	62	qu->typei ? qu->typei->rrtname : "<unknown>");
1e9efa71	63	if (qu->typei && qu->typei->fmtname)
d6b271ae	64	fprintf(ads->diagfile,"(%s)",qu->typei->fmtname);
98db6da3	65	bef=", "; aft=")\n";
	66	}
	67
	68	if (serv>=0) {
d6b271ae	69	fprintf(ads->diagfile,"%sNS=%s",bef,inet_ntoa(ads->servers[serv].addr));
98db6da3	70	bef=", "; aft=")\n";
	71	}
	72
d6b271ae	73	fputs(aft,ads->diagfile);
98db6da3	74	}
	75
	76	void adns__debug(adns_state ads, int serv, adns_query qu, const char *fmt, ...) {
	77	va_list al;
	78
	79	va_start(al,fmt);
	80	adns__vdiag(ads," debug",0,serv,qu,fmt,al);
	81	va_end(al);
	82	}
	83
	84	void adns__warn(adns_state ads, int serv, adns_query qu, const char *fmt, ...) {
	85	va_list al;
	86
	87	va_start(al,fmt);
	88	adns__vdiag(ads," warning",adns_if_noerrprint\|adns_if_noserverwarn,serv,qu,fmt,al);
	89	va_end(al);
	90	}
	91
	92	void adns__diag(adns_state ads, int serv, adns_query qu, const char *fmt, ...) {
	93	va_list al;
	94
	95	va_start(al,fmt);
	96	adns__vdiag(ads,"",adns_if_noerrprint,serv,qu,fmt,al);
	97	va_end(al);
	98	}
	99
	100	/* vbuf functions */
	101
	102	void adns__vbuf_init(vbuf *vb) {
	103	vb->used= vb->avail= 0; vb->buf= 0;
	104	}
	105
	106	int adns__vbuf_ensure(vbuf *vb, int want) {
	107	void *nb;
	108
	109	if (vb->avail >= want) return 1;
	110	nb= realloc(vb->buf,want); if (!nb) return 0;
	111	vb->buf= nb;
	112	vb->avail= want;
	113	return 1;
	114	}
	115
	116	void adns__vbuf_appendq(vbuf vb, const byte data, int len) {
	117	memcpy(vb->buf+vb->used,data,len);
	118	vb->used+= len;
	119	}
	120
	121	int adns__vbuf_append(vbuf vb, const byte data, int len) {
	122	int newlen;
	123	void *nb;
	124
	125	newlen= vb->used+len;
	126	if (vb->avail < newlen) {
f47cdeec	127	if (newlen<20) newlen= 20;
98db6da3	128	newlen <<= 1;
98db6da3	129	nb= realloc(vb->buf,newlen);
f47cdeec	130	if (!nb) { newlen= vb->used+len; nb= realloc(vb->buf,newlen); }
98db6da3	131	if (!nb) return 0;
	132	vb->buf= nb;
	133	vb->avail= newlen;
	134	}
	135	adns__vbuf_appendq(vb,data,len);
	136	return 1;
	137	}
	138
c9afe7bb	139	int adns__vbuf_appendstr(vbuf vb, const char data) {
c9afe7bb	140	int l;
9a2b67d4	141	l= strlen(data);
c9afe7bb	142	return adns__vbuf_append(vb,data,l);
	143	}
	144
f47cdeec	145	void adns__vbuf_free(vbuf *vb) {
	146	free(vb->buf);
	147	adns__vbuf_init(vb);
	148	}
	149
98db6da3	150	/* Additional diagnostic functions */
98db6da3	151
cd363ffd	152	const char *adns__diag_domain(adns_state ads, int serv, adns_query qu,
cd363ffd	153	vbuf vb, const byte dgram, int dglen, int cbyte) {
98db6da3	154	adns_status st;
98db6da3	155
cd363ffd	156	st= adns__parse_domain(ads,serv,qu,vb, pdf_quoteok, dgram,dglen,&cbyte,dglen);
9b86645c	157	if (st == adns_s_nomemory) {
98db6da3	158	return "<cannot report domain... out of memory>";
	159	}
	160	if (st) {
	161	vb->used= 0;
	162	if (!(adns__vbuf_appendstr(vb,"<bad format... ") &&
	163	adns__vbuf_appendstr(vb,adns_strerror(st)) &&
	164	adns__vbuf_appendstr(vb,">") &&
	165	adns__vbuf_append(vb,"",1))) {
	166	return "<cannot report bad format... out of memory>";
	167	}
	168	}
11c8bf9b	169	if (!vb->used) {
98db6da3	170	adns__vbuf_appendstr(vb,"<truncated ...>");
	171	adns__vbuf_append(vb,"",1);
	172	}
	173	return vb->buf;
	174	}
1e9efa71	175
	176	adns_status adns_rr_info(adns_rrtype type,
	177	const char rrtname_r, const char fmtname_r,
	178	int *len_r,
	179	const void datap, char *data_r) {
	180	const typeinfo *typei;
	181	vbuf vb;
	182	adns_status st;
	183
	184	typei= adns__findtype(type);
9b86645c	185	if (!typei) return adns_s_unknownrrtype;
1e9efa71	186
	187	if (rrtname_r) *rrtname_r= typei->rrtname;
	188	if (fmtname_r) *fmtname_r= typei->fmtname;
	189	if (len_r) *len_r= typei->rrsz;
	190
	191	if (!datap) return adns_s_ok;
	192
	193	adns__vbuf_init(&vb);
	194	st= typei->convstring(&vb,datap);
	195	if (st) goto x_freevb;
9b86645c	196	if (!adns__vbuf_append(&vb,"",1)) { st= adns_s_nomemory; goto x_freevb; }
1e9efa71	197	assert(strlen(vb.buf) == vb.used-1);
	198	*data_r= realloc(vb.buf,vb.used);
	199	if (!data_r) data_r= vb.buf;
	200	return adns_s_ok;
	201
	202	x_freevb:
	203	adns__vbuf_free(&vb);
	204	return st;
	205	}
	206
c2875680	207	#define SINFO(n,s) { adns_s_##n, #n, s }
1e9efa71	208
	209	static const struct sinfo {
	210	adns_status st;
c2875680	211	const char *abbrev;
1e9efa71	212	const char *string;
1e9efa71	213	} sinfos[]= {
9b86645c	214	SINFO( ok, "OK" ),
	215
	216	SINFO( nomemory, "Out of memory" ),
	217	SINFO( unknownrrtype, "Query not implemented in DNS library" ),
e7e89cca	218	SINFO( systemfail, "General resolver or system failure" ),
9b86645c	219
	220	SINFO( timeout, "DNS query timed out" ),
	221	SINFO( allservfail, "All nameservers failed" ),
	222	SINFO( norecurse, "Recursion denied by nameserver" ),
	223	SINFO( invalidresponse, "Nameserver sent bad response" ),
	224	SINFO( unknownformat, "Nameserver used unknown format" ),
	225
	226	SINFO( rcodeservfail, "Nameserver reports failure" ),
	227	SINFO( rcodeformaterror, "Query not understood by nameserver" ),
	228	SINFO( rcodenotimplemented, "Query not implemented by nameserver" ),
	229	SINFO( rcoderefused, "Query refused by nameserver" ),
	230	SINFO( rcodeunknown, "Nameserver sent unknown response code" ),
	231
	232	SINFO( inconsistent, "Inconsistent resource records in DNS" ),
c1716cb3	233	SINFO( prohibitedcname, "DNS alias found where canonical name wanted" ),
9b86645c	234	SINFO( answerdomaininvalid, "Found syntactically invalid domain name" ),
	235	SINFO( answerdomaintoolong, "Found overly-long domain name" ),
	236	SINFO( invaliddata, "Found invalid DNS data" ),
	237
	238	SINFO( querydomainwrong, "Domain invalid for particular DNS query type" ),
	239	SINFO( querydomaininvalid, "Domain name is syntactically invalid" ),
	240	SINFO( querydomaintoolong, "Domain name is too long" ),
	241
	242	SINFO( nxdomain, "No such domain" ),
	243	SINFO( nodata, "No such data" ),
1e9efa71	244	};
	245
	246	static int si_compar(const void key, const void elem) {
	247	const adns_status *st= key;
	248	const struct sinfo *si= elem;
	249
	250	return st < si->st ? -1 : st > si->st ? 1 : 0;
	251	}
	252
c2875680	253	static const struct sinfo *findsinfo(adns_status st) {
	254	return bsearch(&st,sinfos,sizeof(sinfos)/sizeof(sinfos),sizeof(sinfos),si_compar);
	255	}
	256
98db6da3	257	const char *adns_strerror(adns_status st) {
c2875680	258	const struct sinfo *si;
1e9efa71	259
c2875680	260	si= findsinfo(st);
	261	return si->string;
	262	}
	263
	264	const char *adns_errabbrev(adns_status st) {
1e9efa71	265	const struct sinfo *si;
1e9efa71	266
c2875680	267	si= findsinfo(st);
c2875680	268	return si->abbrev;
98db6da3	269	}
f318f883	270
f318f883	271	void adns__isort(void array, int nobjs, int sz, void tempbuf,
8c3aa944	272	int (needswap)(void context, const void a, const void b),
8c3aa944	273	void *context) {
f318f883	274	byte *data= array;
	275	int i, place;
	276
	277	for (i=0; i<nobjs; i++) {
8c3aa944	278	for (place= i;
	279	place>0 && needswap(context, data + (place-1)sz, data + isz);
	280	place--);
f318f883	281	if (place != i) {
	282	memcpy(tempbuf, data + i*sz, sz);
	283	memmove(data + (place+1)sz, data + placesz, (i-place)*sz);
	284	memcpy(data + place*sz, tempbuf, sz);
	285	}
	286	}
	287	}
87e46054	288
	289	/* SIGPIPE protection. */
	290
	291	void adns__sigpipe_protect(adns_state ads) {
	292	sigset_t toblock;
	293	struct sigaction sa;
	294	int r;
	295
	296	if (ads->iflags & adns_if_nosigpipe) return;
	297
	298	sigfillset(&toblock);
	299	sigdelset(&toblock,SIGPIPE);
	300
	301	sa.sa_handler= SIG_IGN;
	302	sigfillset(&sa.sa_mask);
	303	sa.sa_flags= 0;
	304
	305	r= sigprocmask(SIG_SETMASK,&toblock,&ads->stdsigmask); assert(!r);
	306	r= sigaction(SIGPIPE,&sa,&ads->stdsigpipe); assert(!r);
	307	}
	308
	309	void adns__sigpipe_unprotect(adns_state ads) {
	310	int r;
	311
	312	if (ads->iflags & adns_if_nosigpipe) return;
	313
	314	r= sigaction(SIGPIPE,&ads->stdsigpipe,0); assert(!r);
	315	r= sigprocmask(SIG_SETMASK,&ads->stdsigmask,0); assert(!r);
	316	}