[adns] / client / adh-opts.c

/*
 * adh-opts.c
 * - useful general-purpose resolver client program
 *   option handling tables etc.
 */
/*
 *  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 "adnshost.h"

int ov_env=1, ov_pipe=0, ov_asynch=0;
int ov_verbose= 0;
adns_rrtype ov_type= adns_r_none;
int ov_search=0, ov_qc_query=0, ov_qc_anshost=0, ov_qc_cname=1;
int ov_tcp=0, ov_cname=0;
char *ov_id= 0;
struct perqueryflags_remember ov_pqfr = { 1,1,1, tm_none };

static const struct optioninfo global_options[]= {
  { ot_desconly, "global binary options:" },
  { ot_flag,             "Do not look at environment variables at all",
    "e", "env",            &ov_env, 0 },
  { ot_flag,             "Read queries on stdin instead of using args",
    "f", "pipe",           &ov_pipe, 1 },
  { ot_flag,             "Allow answers to be reordered",
    "a", "asynch",         &ov_asynch, 1 },
  		         
  { ot_desconly, "global verbosity level:" },
  { ot_value,            "Do not print anything to stderr",
    "Vq", "quiet",         &ov_verbose, adns_if_noerrprint },
  { ot_value,            "Report unexpected kinds of problem only  (default)",
    "Vn", "no-quiet",      &ov_verbose, 0 },
  { ot_value,            "Debugging mode",
    "Vd", "debug",         &ov_verbose, adns_if_debug },
  		         
  { ot_desconly, "other global options:" },
  { ot_func,             "Print usage information",
    0, "help",             0,0, of_help },

  { ot_end }
};

static const struct optioninfo perquery_options[]= {
  { ot_desconly, "per-query options:" },
  { ot_funcarg,          "Query type (see below)",
    "t", "type",           0,0, &of_type, "type" },
  { ot_funcarg,          "Do reverse query (address -> name lookup)",
    "i", "ptr",            0,0, &of_ptr, "addr" },

  { ot_desconly, "per-query binary options:" },
  { ot_flag,             "Use the search list",
    "s", "search",         &ov_search, 1 },
  { ot_flag,             "Let query domains contain quote-requiring chars",
    "Qq", "qc-query",      &ov_qc_query, 1 },
  { ot_flag,             "Let hostnames in answers contain ...",
    "Qa", "qc-anshost",    &ov_qc_anshost, 1 },
  { ot_flag,             "Prevent CNAME target domains from containing ...",
    "Qc", "qc-cname",      &ov_qc_cname, 0 },
  { ot_flag,             "Force use of a virtual circuit",
    "u", "tcp",            &ov_tcp, 1 },
  { ot_flag,             "Do not display owner name in output",
    "Do", "show-owner",   &ov_pqfr.show_owner, 0 },
  { ot_flag,             "Do not display RR type in output",
    "Dt", "show-type",    &ov_pqfr.show_type, 0 },
  { ot_flag,             "Do not display CNAME target in output",
    "Dc", "show-cname",    &ov_pqfr.show_cname, 0 },
  
  { ot_desconly, "per-query TTL mode (NB TTL is minimum across all info in reply):" },
  { ot_value,            "Show the TTL as a TTL",
    "Tt", "ttl-ttl",       &ov_pqfr.ttl, tm_rel },
  { ot_value,            "Show the TTL as a time_t when the data might expire",
    "Ta", "ttl-abs",       &ov_pqfr.ttl, tm_abs },
  { ot_value,            "Do not show the TTL (default)",
    "Tn", "no-ttl",        &ov_pqfr.ttl, tm_none },
  
  { ot_desconly, "per-query CNAME handling mode:" },
  { ot_value,            "Call it an error if a CNAME is found",
    "Cf", "cname-reject",  &ov_cname, adns_qf_cname_forbid },
  { ot_value,            "Allow references to CNAMEs in other RRs",
    "Cl", "cname-loose",   &ov_cname, adns_qf_cname_loose },
  { ot_value,            "CNAME ok for query domain, but not in RRs (default)",
    "Cs", "cname-ok",      &ov_cname, 0 },
  
  { ot_desconly, "asynchronous/pipe mode options:" },
  { ot_funcarg,          "Set <id>, default is decimal sequence starting 0",
    0, "asynch-id",        0,0, &of_asynch_id, "id" },
  { ot_funcarg,          "Cancel the query with id <id> (no error if not found)",
    0, "cancel-id",        0,0, &of_cancel_id, "id" },

  { ot_end }
};

static void printusage(void) {
  static const struct optioninfo *const all_optiontables[]= {
    global_options, perquery_options, 0
  };

  const struct optioninfo *const *oiap, *oip=0;
  int maxsopt, maxlopt, l;

  maxsopt= maxlopt= 0;
  
  for (oiap=all_optiontables; *oiap; oiap++) {
    for (oip=*oiap; oip->type != ot_end; oip++) {
      if (oip->type == ot_funcarg) continue;
      if (oip->sopt) { l= strlen(oip->sopt); if (l>maxsopt) maxsopt= l; }
      if (oip->lopt) {
	l= strlen(oip->lopt);
	if (oip->type == ot_flag && !oip->value) l+= 3;
	if (l>maxlopt) maxlopt= l;
      }
    }
  }
	
  fputs("usage: adnshost [global-opts] [query-opts] query-domain\n"
	"                             [[query-opts] query-domain ...]\n"
	"       adnshost [global-opts] [query-opts] -f|--pipe\n",
	stdout);

  for (oiap=all_optiontables; *oiap; oiap++) {
    putchar('\n');
    for (oip=*oiap; oip->type != ot_end; oip++) {
      switch (oip->type) {
      case ot_flag:
	if (!oip->value) {
	  if (oip->sopt) {
	    printf(" +%-*s --no-%-*s %s\n",
		   maxsopt, oip->sopt,
		   maxlopt-2, oip->lopt,
		   oip->desc);
	  } else {
	    printf(" --no-%-*s %s\n",
		   maxlopt+maxsopt+1, oip->lopt,
		   oip->desc);
	  }
	  break;
	}
      case ot_value: case ot_func: /* fall through */
	if (oip->sopt) {
	  printf(" -%-*s --%-*s %s\n",
		 maxsopt, oip->sopt,
		 maxlopt+1, oip->lopt,
		 oip->desc);
	} else {
	  printf(" --%-*s %s\n",
		 maxlopt+maxsopt+3, oip->lopt,
		 oip->desc);
	}
	break;
      case ot_funcarg:
	if (oip->sopt) {
	  l= (maxlopt + maxsopt - 9 -
	      (strlen(oip->sopt) + strlen(oip->lopt) + 2*strlen(oip->argdesc)));
	  printf(" -%s<%s> / --%s <%s>%*s%s\n",
		 oip->sopt, oip->argdesc, oip->lopt, oip->argdesc,
		 l>2 ? l : 2, "",
		 oip->desc);
	} else {
	  l= (maxlopt + maxsopt + 1 -
	      (strlen(oip->lopt) + strlen(oip->argdesc)));
	  printf(" --%s <%s>%*s%s\n",
		 oip->lopt, oip->argdesc,
		 l>2 ? l : 2, "",
		 oip->desc);
	}
	break;
      case ot_desconly:
	printf("%s\n", oip->desc);
	break;
      default:
	abort();
      }
    }
  }

  printf("\nEscaping domains which might start with `-':\n"
	 " - %-*s Next argument is a domain, but more options may follow\n",
	 maxlopt+maxsopt+3, "<domain>");
  
  fputs("\n"
	"Query domains should always be quoted according to master file format.\n"
	"\n"
	"For binary options, --FOO and --no-FOO are opposites, as are\n"
	"-X and +X.  In each case the default is the one not listed.\n"
	"Per query options stay set a particular way until they are reset,\n"
	"whether they appear on the command line or on stdin.\n"
	"All global options must preceed the first query domain.\n"
	"\n"
	"With -f, the input should be lines with either an option, possibly\n"
	"with a value argument (separated from the option by a space if it's a long\n"
	"option), or a domain (possibly preceded by a hyphen and a space to\n"
	"distinguish it from an option).\n"
	"\n"
	"Output format is master file format without class or TTL by default:\n"
	"   [<owner>] [<ttl>] [<type>] <data>\n"
	"or if the <owner> domain refers to a CNAME and --show-cname is on\n"
	"   [<owner>] [<ttl>] CNAME <cname>\n"
	"   [<cname>] [<ttl>] <type> <data>\n"
	"When a query fails you get a line like this (broken here for readability):\n"
	"   ; failed <statustype> <statusnum> <statusabbrev> \\\n"
	"       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
	"\n"
	"If you use --asynch each answer (success or failure) is preceded by a line\n"
	"   <id> <nrrs> <statustype> <statusnum> <statusabbrev> \\\n"
	"       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
	"where <nrrs> is the number of RRs that follow and <cname> will be `$' or\n"
	"the CNAME target; the CNAME indirection and error formats above are not used.\n"
	"\n"
	"Exit status:\n"
	" 0    all went well\n"
	" 1-6  at least one query failed with statustype:\n"
	"   1    localfail   )\n"
	"   2    remotefail  ) temporary errors\n"
	"   3    tempfail  __)_________________\n"
	"   4    misconfig   )\n"
	"   5    misquery    ) permanent errors\n"
	"   6    permfail    )\n"
	" 10   system trouble\n"
	" 11   usage problems\n"
	"\n"
	"Query types (see adns.h; default is addr):\n"
	"  ns  soa  ptr  mx  rp  addr       - enhanced versions\n"
	"  cname  hinfo  txt                - types with only one version\n"
	"  a  ns-  soa-  ptr-  mx-  rp-     - _raw versions\n"
	"Default is addr, or ptr for -i/--ptr queries\n",
	stdout);
  if (ferror(stdout)) sysfail("write usage message",errno);
}

void of_help(const struct optioninfo *oi, const char *arg) {
  printusage();
  if (fclose(stdout)) sysfail("finish writing output",errno);
  exit(0);
}

typedef int comparer_type(const char **optp, const struct optioninfo *entry);

static int oc_long(const char **optp, const struct optioninfo *entry) {
  return entry->lopt && !strcmp(*optp,entry->lopt);
}

static int oc_short(const char **optp, const struct optioninfo *entry) {
  const char *sopt;
  int l;

  sopt= entry->sopt;
  if (!sopt) return 0;
  l= strlen(sopt);
  if (memcmp(*optp,sopt,l)) return 0;
  (*optp) += l;
  return 1;
}

static const struct optioninfo *find1(const char **optp,
				      const struct optioninfo *table,
				      comparer_type *comparer) {
  for (;;) {
    if (table->type == ot_end) return 0;
    if (comparer(optp,table)) return table;
    table++;
  }
}

static const struct optioninfo *find(const char **optp,
				     const char *prefix,
				     comparer_type *comparer) {
  const struct optioninfo *oip;
  const char *opt;

  opt= *optp;
  oip= find1(optp,perquery_options,comparer);
  if (oip) return oip;
  oip= find1(optp,global_options,comparer);
  if (!oip) usageerr("unknown option %s%s",prefix,opt);
  if (ads) usageerr("global option %s%s specified after query domain(s)",prefix,opt);
  return oip;
}

const struct optioninfo *opt_findl(const char *opt) { return find(&opt,"--",oc_long); }
const struct optioninfo *opt_finds(const char **optp) { return find(optp,"-",oc_short); }

static void noninvert(const struct optioninfo *oip) NONRETURNING;
static void noninvert(const struct optioninfo *oip) {
  usageerr("option %s%s%s%s%s may not be inverted",
	   oip->sopt ? "-" : "", oip->sopt ? oip->sopt : "",
	   oip->lopt && oip->sopt ? " / " : "",
	   oip->lopt ? "--" : "", oip->lopt ? oip->lopt : "");
}

void opt_do(const struct optioninfo *oip, const char *arg, int invert) {
  switch (oip->type) {
  case ot_flag:
    assert(!arg);
    *oip->storep= !invert;
    return;
  case ot_value:
    assert(!arg);
    if (invert) noninvert(oip);
    *oip->storep= oip->value;
    return;
  case ot_func: case ot_funcarg:
    if (invert) noninvert(oip);
    oip->func(oip,arg);
    return;
  default:
    abort();
  }
}
Commit	Line	Data
39d64e6e	1	/*
b3543b6b	2	* adh-opts.c
39d64e6e	3	* - useful general-purpose resolver client program
b3543b6b	4	* option handling tables etc.
39d64e6e	5	*/
39d64e6e	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>
39d64e6e	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
aa1d7195	29	#include "adnshost.h"
aa1d7195	30
b3543b6b	31	int ov_env=1, ov_pipe=0, ov_asynch=0;
b3543b6b	32	int ov_verbose= 0;
aa1d7195	33	adns_rrtype ov_type= adns_r_none;
b3543b6b	34	int ov_search=0, ov_qc_query=0, ov_qc_anshost=0, ov_qc_cname=1;
b3543b6b	35	int ov_tcp=0, ov_cname=0;
aa1d7195	36	char *ov_id= 0;
aa1d7195	37	struct perqueryflags_remember ov_pqfr = { 1,1,1, tm_none };
91ae575b	38
aa1d7195	39	static const struct optioninfo global_options[]= {
91ae575b	40	{ ot_desconly, "global binary options:" },
	41	{ ot_flag, "Do not look at environment variables at all",
	42	"e", "env", &ov_env, 0 },
	43	{ ot_flag, "Read queries on stdin instead of using args",
	44	"f", "pipe", &ov_pipe, 1 },
	45	{ ot_flag, "Allow answers to be reordered",
	46	"a", "asynch", &ov_asynch, 1 },
	47
	48	{ ot_desconly, "global verbosity level:" },
	49	{ ot_value, "Do not print anything to stderr",
	50	"Vq", "quiet", &ov_verbose, adns_if_noerrprint },
	51	{ ot_value, "Report unexpected kinds of problem only (default)",
	52	"Vn", "no-quiet", &ov_verbose, 0 },
	53	{ ot_value, "Debugging mode",
	54	"Vd", "debug", &ov_verbose, adns_if_debug },
	55
	56	{ ot_desconly, "other global options:" },
	57	{ ot_func, "Print usage information",
	58	0, "help", 0,0, of_help },
	59
	60	{ ot_end }
	61	};
	62
aa1d7195	63	static const struct optioninfo perquery_options[]= {
91ae575b	64	{ ot_desconly, "per-query options:" },
	65	{ ot_funcarg, "Query type (see below)",
	66	"t", "type", 0,0, &of_type, "type" },
0b535035	67	{ ot_funcarg, "Do reverse query (address -> name lookup)",
5e6342f0	68	"i", "ptr", 0,0, &of_ptr, "addr" },
91ae575b	69
	70	{ ot_desconly, "per-query binary options:" },
	71	{ ot_flag, "Use the search list",
	72	"s", "search", &ov_search, 1 },
	73	{ ot_flag, "Let query domains contain quote-requiring chars",
	74	"Qq", "qc-query", &ov_qc_query, 1 },
	75	{ ot_flag, "Let hostnames in answers contain ...",
	76	"Qa", "qc-anshost", &ov_qc_anshost, 1 },
	77	{ ot_flag, "Prevent CNAME target domains from containing ...",
	78	"Qc", "qc-cname", &ov_qc_cname, 0 },
	79	{ ot_flag, "Force use of a virtual circuit",
	80	"u", "tcp", &ov_tcp, 1 },
	81	{ ot_flag, "Do not display owner name in output",
b3543b6b	82	"Do", "show-owner", &ov_pqfr.show_owner, 0 },
91ae575b	83	{ ot_flag, "Do not display RR type in output",
b3543b6b	84	"Dt", "show-type", &ov_pqfr.show_type, 0 },
91ae575b	85	{ ot_flag, "Do not display CNAME target in output",
b3543b6b	86	"Dc", "show-cname", &ov_pqfr.show_cname, 0 },
91ae575b	87
	88	{ ot_desconly, "per-query TTL mode (NB TTL is minimum across all info in reply):" },
	89	{ ot_value, "Show the TTL as a TTL",
b3543b6b	90	"Tt", "ttl-ttl", &ov_pqfr.ttl, tm_rel },
91ae575b	91	{ ot_value, "Show the TTL as a time_t when the data might expire",
b3543b6b	92	"Ta", "ttl-abs", &ov_pqfr.ttl, tm_abs },
91ae575b	93	{ ot_value, "Do not show the TTL (default)",
b3543b6b	94	"Tn", "no-ttl", &ov_pqfr.ttl, tm_none },
91ae575b	95
	96	{ ot_desconly, "per-query CNAME handling mode:" },
	97	{ ot_value, "Call it an error if a CNAME is found",
	98	"Cf", "cname-reject", &ov_cname, adns_qf_cname_forbid },
	99	{ ot_value, "Allow references to CNAMEs in other RRs",
	100	"Cl", "cname-loose", &ov_cname, adns_qf_cname_loose },
	101	{ ot_value, "CNAME ok for query domain, but not in RRs (default)",
	102	"Cs", "cname-ok", &ov_cname, 0 },
	103
b3543b6b	104	{ ot_desconly, "asynchronous/pipe mode options:" },
91ae575b	105	{ ot_funcarg, "Set <id>, default is decimal sequence starting 0",
0b535035	106	0, "asynch-id", 0,0, &of_asynch_id, "id" },
5692efb1	107	{ ot_funcarg, "Cancel the query with id <id> (no error if not found)",
91ae575b	108	0, "cancel-id", 0,0, &of_cancel_id, "id" },
	109
	110	{ ot_end }
	111	};
39d64e6e	112
39d64e6e	113	static void printusage(void) {
aa1d7195	114	static const struct optioninfo *const all_optiontables[]= {
b3543b6b	115	global_options, perquery_options, 0
91ae575b	116	};
91ae575b	117
aa1d7195	118	const struct optioninfo const oiap, *oip=0;
91ae575b	119	int maxsopt, maxlopt, l;
	120
	121	maxsopt= maxlopt= 0;
	122
aa1d7195	123	for (oiap=all_optiontables; *oiap; oiap++) {
91ae575b	124	for (oip=*oiap; oip->type != ot_end; oip++) {
	125	if (oip->type == ot_funcarg) continue;
	126	if (oip->sopt) { l= strlen(oip->sopt); if (l>maxsopt) maxsopt= l; }
	127	if (oip->lopt) {
	128	l= strlen(oip->lopt);
	129	if (oip->type == ot_flag && !oip->value) l+= 3;
	130	if (l>maxlopt) maxlopt= l;
	131	}
	132	}
	133	}
	134
	135	fputs("usage: adnshost [global-opts] [query-opts] query-domain\n"
	136	" [[query-opts] query-domain ...]\n"
	137	" adnshost [global-opts] [query-opts] -f\|--pipe\n",
	138	stdout);
	139
aa1d7195	140	for (oiap=all_optiontables; *oiap; oiap++) {
91ae575b	141	putchar('\n');
	142	for (oip=*oiap; oip->type != ot_end; oip++) {
	143	switch (oip->type) {
	144	case ot_flag:
	145	if (!oip->value) {
	146	if (oip->sopt) {
	147	printf(" +%-s --no-%-s %s\n",
	148	maxsopt, oip->sopt,
	149	maxlopt-2, oip->lopt,
	150	oip->desc);
	151	} else {
	152	printf(" --no-%-*s %s\n",
	153	maxlopt+maxsopt+1, oip->lopt,
	154	oip->desc);
	155	}
	156	break;
	157	}
	158	case ot_value: case ot_func: /* fall through */
	159	if (oip->sopt) {
	160	printf(" -%-s --%-s %s\n",
	161	maxsopt, oip->sopt,
	162	maxlopt+1, oip->lopt,
	163	oip->desc);
	164	} else {
	165	printf(" --%-*s %s\n",
	166	maxlopt+maxsopt+3, oip->lopt,
	167	oip->desc);
	168	}
	169	break;
	170	case ot_funcarg:
	171	if (oip->sopt) {
	172	l= (maxlopt + maxsopt - 9 -
	173	(strlen(oip->sopt) + strlen(oip->lopt) + 2*strlen(oip->argdesc)));
	174	printf(" -%s<%s> / --%s <%s>%*s%s\n",
	175	oip->sopt, oip->argdesc, oip->lopt, oip->argdesc,
	176	l>2 ? l : 2, "",
	177	oip->desc);
	178	} else {
	179	l= (maxlopt + maxsopt + 1 -
	180	(strlen(oip->lopt) + strlen(oip->argdesc)));
	181	printf(" --%s <%s>%*s%s\n",
	182	oip->lopt, oip->argdesc,
	183	l>2 ? l : 2, "",
	184	oip->desc);
	185	}
	186	break;
	187	case ot_desconly:
	188	printf("%s\n", oip->desc);
	189	break;
	190	default:
	191	abort();
	192	}
	193	}
	194	}
	195
	196	printf("\nEscaping domains which might start with `-':\n"
	197	" - %-*s Next argument is a domain, but more options may follow\n",
	198	maxlopt+maxsopt+3, "<domain>");
	199
	200	fputs("\n"
	201	"Query domains should always be quoted according to master file format.\n"
	202	"\n"
	203	"For binary options, --FOO and --no-FOO are opposites, as are\n"
	204	"-X and +X. In each case the default is the one not listed.\n"
205	"Per query options stay set a particular way until they are reset,\n"
206	"whether they appear on the command line or on stdin.\n"
207	"All global options must preceed the first query domain.\n"
208	"\n"
209	"With -f, the input should be lines with either an option, possibly\n"
210	"with a value argument (separated from the option by a space if it's a long\n"
211	"option), or a domain (possibly preceded by a hyphen and a space to\n"
212	"distinguish it from an option).\n"
213	"\n"
214	"Output format is master file format without class or TTL by default:\n"
215	" [<owner>] [<ttl>] [<type>] <data>\n"
216	"or if the <owner> domain refers to a CNAME and --show-cname is on\n"
217	" [<owner>] [<ttl>] CNAME <cname>\n"
218	" [<cname>] [<ttl>] <type> <data>\n"
2798305f	219	"When a query fails you get a line like this (broken here for readability):\n"
	220	" ; failed <statustype> <statusnum> <statusabbrev> \\\n"
	221	" [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
91ae575b	222	"\n"
91ae575b	223	"If you use --asynch each answer (success or failure) is preceded by a line\n"
2798305f	224	" <id> <nrrs> <statustype> <statusnum> <statusabbrev> \\\n"
2798305f	225	" [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
91ae575b	226	"where <nrrs> is the number of RRs that follow and <cname> will be `$' or\n"
	227	"the CNAME target; the CNAME indirection and error formats above are not used.\n"
	228	"\n"
	229	"Exit status:\n"
	230	" 0 all went well\n"
	231	" 1-6 at least one query failed with statustype:\n"
	232	" 1 localfail )\n"
	233	" 2 remotefail ) temporary errors\n"
	234	" 3 tempfail __)_________________\n"
	235	" 4 misconfig )\n"
	236	" 5 misquery ) permanent errors\n"
	237	" 6 permfail )\n"
	238	" 10 system trouble\n"
	239	" 11 usage problems\n"
	240	"\n"
	241	"Query types (see adns.h; default is addr):\n"
	242	" ns soa ptr mx rp addr - enhanced versions\n"
	243	" cname hinfo txt - types with only one version\n"
0b535035	244	" a ns- soa- ptr- mx- rp- - _raw versions\n"
0b535035	245	"Default is addr, or ptr for -i/--ptr queries\n",
91ae575b	246	stdout);
91ae575b	247	if (ferror(stdout)) sysfail("write usage message",errno);
39d64e6e	248	}
39d64e6e	249
aa1d7195	250	void of_help(const struct optioninfo oi, const char arg) {
39d64e6e	251	printusage();
	252	if (fclose(stdout)) sysfail("finish writing output",errno);
	253	exit(0);
	254	}
91ae575b	255
aa1d7195	256	typedef int comparer_type(const char *optp, const struct optioninfo entry);
	257
	258	static int oc_long(const char *optp, const struct optioninfo entry) {
	259	return entry->lopt && !strcmp(*optp,entry->lopt);
	260	}
	261
	262	static int oc_short(const char *optp, const struct optioninfo entry) {
	263	const char *sopt;
	264	int l;
	265
	266	sopt= entry->sopt;
	267	if (!sopt) return 0;
	268	l= strlen(sopt);
	269	if (memcmp(*optp,sopt,l)) return 0;
	270	(*optp) += l;
	271	return 1;
	272	}
	273
	274	static const struct optioninfo find1(const char *optp,
	275	const struct optioninfo *table,
	276	comparer_type *comparer) {
	277	for (;;) {
	278	if (table->type == ot_end) return 0;
	279	if (comparer(optp,table)) return table;
	280	table++;
	281	}
	282	}
	283
	284	static const struct optioninfo find(const char *optp,
	285	const char *prefix,
	286	comparer_type *comparer) {
	287	const struct optioninfo *oip;
44fb8e6f	288	const char *opt;
aa1d7195	289
44fb8e6f	290	opt= *optp;
aa1d7195	291	oip= find1(optp,perquery_options,comparer);
	292	if (oip) return oip;
	293	oip= find1(optp,global_options,comparer);
44fb8e6f	294	if (!oip) usageerr("unknown option %s%s",prefix,opt);
44fb8e6f	295	if (ads) usageerr("global option %s%s specified after query domain(s)",prefix,opt);
aa1d7195	296	return oip;
	297	}
	298
	299	const struct optioninfo opt_findl(const char opt) { return find(&opt,"--",oc_long); }
	300	const struct optioninfo opt_finds(const char *optp) { return find(optp,"-",oc_short); }
	301
196e9104	302	static void noninvert(const struct optioninfo *oip) NONRETURNING;
	303	static void noninvert(const struct optioninfo *oip) {
	304	usageerr("option %s%s%s%s%s may not be inverted",
	305	oip->sopt ? "-" : "", oip->sopt ? oip->sopt : "",
	306	oip->lopt && oip->sopt ? " / " : "",
	307	oip->lopt ? "--" : "", oip->lopt ? oip->lopt : "");
	308	}
	309
	310	void opt_do(const struct optioninfo oip, const char arg, int invert) {
aa1d7195	311	switch (oip->type) {
196e9104	312	case ot_flag:
196e9104	313	assert(!arg);
caa16c6a	314	*oip->storep= !invert;
196e9104	315	return;
196e9104	316	case ot_value:
aa1d7195	317	assert(!arg);
196e9104	318	if (invert) noninvert(oip);
aa1d7195	319	*oip->storep= oip->value;
	320	return;
	321	case ot_func: case ot_funcarg:
196e9104	322	if (invert) noninvert(oip);
196e9104	323	oip->func(oip,arg);
aa1d7195	324	return;
	325	default:
	326	abort();
	327	}
	328	}