[adns] / src / general.c

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