client/adh-opts.c

   1 /*
   2  * adh-opts.c
   3  * - useful general-purpose resolver client program
   4  *   option handling tables etc.
   5  */
   6 /*
   7  *  This file is part of adns, which is
   8  *    Copyright (C) 1997-2000,2003,2006  Ian Jackson
   9  *    Copyright (C) 1999-2000,2003,2006  Tony Finch
  10  *    Copyright (C) 1991 Massachusetts Institute of Technology
  11  *  (See the file INSTALL for full details.)
  12  *
  13  *  This program is free software; you can redistribute it and/or modify
  14  *  it under the terms of the GNU General Public License as published by
  15  *  the Free Software Foundation; either version 2, or (at your option)
  16  *  any later version.
  17  *
  18  *  This program is distributed in the hope that it will be useful,
  19  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  *  GNU General Public License for more details.
  22  *
  23  *  You should have received a copy of the GNU General Public License
  24  *  along with this program; if not, write to the Free Software Foundation,
  25  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  26  */
  27
  28 #include "adnshost.h"
  29
  30 int ov_env=1, ov_pipe=0, ov_asynch=0;
  31 int ov_verbose= 0;
  32 adns_rrtype ov_type= adns_r_none;
  33 int ov_search=0, ov_qc_query=0, ov_qc_anshost=0, ov_qc_cname=1;
  34 int ov_tcp=0, ov_cname=0, ov_afflags=0, ov_v6map=0, ov_format=fmt_default;
  35 char *ov_id= 0;
  36 struct perqueryflags_remember ov_pqfr = { 1,1,1, tm_none };
  37
  38 static const struct optioninfo global_options[]= {
  39   { ot_desconly, "global binary options:" },
  40   { ot_flag,             "Do not look at environment variables at all",
  41     "e", "env",            &ov_env, 0 },
  42   { ot_flag,             "Read queries on stdin instead of using args",
  43     "f", "pipe",           &ov_pipe, 1 },
  44   { ot_flag,             "Allow answers to be reordered",
  45     "a", "asynch",         &ov_asynch, 1 },
  46
  47   { ot_desconly, "answer/error output format and destination (see below):" },
  48   { ot_value,            "Answers to stdout, errors as messages to stderr (default)",
  49     "Fs", "fmt-simple",    &ov_format, fmt_simple },
  50   { ot_value,            "Answers and errors both to stdout in parseable format",
  51     "Fi", "fmt-inline",    &ov_format, fmt_inline },
  52   { ot_value,            "Fully-parseable output format (default for --asynch)",
  53     "Fa", "fmt-asynch",    &ov_format, fmt_asynch },
  54
  55   { ot_desconly, "global verbosity level:" },
  56   { ot_value,            "Do not print anything to stderr",
  57     "Vq", "quiet",         &ov_verbose, adns_if_noerrprint },
  58   { ot_value,            "Report unexpected kinds of problem only  (default)",
  59     "Vn", "no-quiet",      &ov_verbose, 0 },
  60   { ot_value,            "Debugging mode",
  61     "Vd", "debug",         &ov_verbose, adns_if_debug },
  62
  63   { ot_desconly, "other global options:" },
  64   { ot_funcarg,          "Configuration to use instead of /etc/resolv.conf",
  65     0, "config",           0,0, of_config, "<config-text>" },
  66   { ot_func,             "Print version number",
  67     0, "version",          0,0, of_version },
  68   { ot_func,             "Print usage information",
  69     0, "help",             0,0, of_help },
  70
  71   { ot_end }
  72 };
  73
  74 static const struct optioninfo perquery_options[]= {
  75   { ot_desconly, "per-query options:" },
  76   { ot_funcarg,          "Query type (see below)",
  77     "t", "type",           0,0, &of_type, "type" },
  78   { ot_funcarg,          "Do reverse query (address -> name lookup)",
  79     "i", "ptr",            0,0, &of_ptr, "addr" },
  80   { ot_funcarg2,         "Lookup in in-addr-like `zone' (eg MAPS RBL)",
  81     0, "reverse",          0,0, &of_reverse, "addr","zone" },
  82
  83   { ot_desconly, "per-query binary options:" },
  84   { ot_flag,             "Use the search list",
  85     "s", "search",         &ov_search, 1 },
  86   { ot_flag,             "Let query domains contain quote-requiring chars",
  87     "Qq", "qc-query",      &ov_qc_query, 1 },
  88   { ot_flag,             "Let hostnames in answers contain ...",
  89     "Qa", "qc-anshost",    &ov_qc_anshost, 1 },
  90   { ot_flag,             "Prevent CNAME target domains from containing ...",
  91     "Qc", "qc-cname",      &ov_qc_cname, 0 },
  92   { ot_flag,             "Force use of a virtual circuit",
  93     "u", "tcp",            &ov_tcp, 1 },
  94   { ot_flag,             "Do not display owner name in output",
  95     "Do", "show-owner",   &ov_pqfr.show_owner, 0 },
  96   { ot_flag,             "Do not display RR type in output",
  97     "Dt", "show-type",    &ov_pqfr.show_type, 0 },
  98   { ot_flag,             "Do not display CNAME target in output",
  99     "Dc", "show-cname",    &ov_pqfr.show_cname, 0 },
 100
 101   { ot_desconly, "per-query TTL mode (NB TTL is minimum across all info in reply):" },
 102   { ot_value,            "Show the TTL as a TTL",
 103     "Tt", "ttl-ttl",       &ov_pqfr.ttl, tm_rel },
 104   { ot_value,            "Show the TTL as a time_t when the data might expire",
 105     "Ta", "ttl-abs",       &ov_pqfr.ttl, tm_abs },
 106   { ot_value,            "Do not show the TTL (default)",
 107     "Tn", "no-ttl",        &ov_pqfr.ttl, tm_none },
 108
 109   { ot_desconly, "per-query address family options (for `addr' etc.):" },
 110   { ot_value,            "Only return IPv4 addresses",
 111     "A4", "--addr-ipv4-only", &ov_afflags, adns_qf_want_ipv4 },
 112   { ot_value,            "Only return IPv6 addresses",
 113     "A6", "--addr-ipv6-only", &ov_afflags, adns_qf_want_ipv6 },
 114   { ot_value,            "Return all available addresses (default)",
 115     "Aa", "--addr-all",    &ov_afflags, 0 },
 116   { ot_flag,             "Return IPv4 addresses as IPv6-mapped",
 117     "Am", "--addr-ipv6-mapped", &ov_v6map, 1 },
 118
 119   { ot_desconly, "per-query CNAME handling mode:" },
 120   { ot_value,            "Call it an error if a CNAME is found",
 121     "Cf", "cname-reject",  &ov_cname, adns_qf_cname_forbid },
 122   { ot_value,            "Allow references to CNAMEs in other RRs",
 123     "Cl", "cname-loose",   &ov_cname, adns_qf_cname_loose },
 124   { ot_value,            "CNAME ok for query domain, but not in RRs (default)",
 125     "Cs", "cname-ok",      &ov_cname, 0 },
 126
 127   { ot_desconly, "asynchronous/pipe mode options:" },
 128   { ot_funcarg,          "Set <id>, default is decimal sequence starting 0",
 129     0, "asynch-id",        0,0, &of_asynch_id, "id" },
 130   { ot_funcarg,          "Cancel the query with id <id> (no error if not found)",
 131     0, "cancel-id",        0,0, &of_cancel_id, "id" },
 132
 133   { ot_end }
 134 };
 135
 136 static void printusage(void) {
 137   static const struct optioninfo *const all_optiontables[]= {
 138     global_options, perquery_options, 0
 139   };
 140
 141   const struct optioninfo *const *oiap, *oip=0;
 142   int maxsopt, maxlopt, l;
 143
 144   maxsopt= maxlopt= 0;
 145
 146   for (oiap=all_optiontables; *oiap; oiap++) {
 147     for (oip=*oiap; oip->type != ot_end; oip++) {
 148       if (oip->type == ot_funcarg) continue;
 149       if (oip->sopt) { l= strlen(oip->sopt); if (l>maxsopt) maxsopt= l; }
 150       if (oip->lopt) {
 151         l= strlen(oip->lopt);
 152         if (oip->type == ot_flag && !oip->value) l+= 3;
 153         if (l>maxlopt) maxlopt= l;
 154       }
 155     }
 156   }
 157
 158   fputs("usage: adnshost [global-opts] [query-opts] query-domain\n"
 159         "                             [[query-opts] query-domain ...]\n"
 160         "       adnshost [global-opts] [query-opts] -f|--pipe\n",
 161         stdout);
 162
 163   for (oiap=all_optiontables; *oiap; oiap++) {
 164     putchar('\n');
 165     for (oip=*oiap; oip->type != ot_end; oip++) {
 166       switch (oip->type) {
 167       case ot_flag:
 168         if (!oip->value) {
 169           if (oip->sopt) {
 170             printf(" +%-*s --no-%-*s %s\n",
 171                    maxsopt, oip->sopt,
 172                    maxlopt-2, oip->lopt,
 173                    oip->desc);
 174           } else {
 175             printf(" --no-%-*s %s\n",
 176                    maxlopt+maxsopt+1, oip->lopt,
 177                    oip->desc);
 178           }
 179           break;
 180         }
 181       case ot_value: case ot_func: /* fall through */
 182         if (oip->sopt) {
 183           printf(" -%-*s --%-*s %s\n",
 184                  maxsopt, oip->sopt,
 185                  maxlopt+1, oip->lopt,
 186                  oip->desc);
 187         } else {
 188           printf(" --%-*s %s\n",
 189                  maxlopt+maxsopt+3, oip->lopt,
 190                  oip->desc);
 191         }
 192         break;
 193       case ot_funcarg:
 194         if (oip->sopt) {
 195           l= (maxlopt + maxsopt - 9 -
 196               (strlen(oip->sopt) + strlen(oip->lopt) + 2*strlen(oip->argdesc)));
 197           printf(" -%s<%s> / --%s <%s>%*s%s\n",
 198                  oip->sopt, oip->argdesc, oip->lopt, oip->argdesc,
 199                  l>2 ? l : 2, "",
 200                  oip->desc);
 201         } else {
 202           l= (maxlopt + maxsopt + 1 -
 203               (strlen(oip->lopt) + strlen(oip->argdesc)));
 204           printf(" --%s <%s>%*s%s\n",
 205                  oip->lopt, oip->argdesc,
 206                  l>2 ? l : 2, "",
 207                  oip->desc);
 208         }
 209         break;
 210       case ot_funcarg2:
 211         assert(!oip->sopt);
 212         l= (maxlopt + maxsopt - 2 -
 213             (strlen(oip->lopt) + strlen(oip->argdesc) + strlen(oip->argdesc2)));
 214           printf(" --%s <%s> <%s>%*s%s\n",
 215                  oip->lopt, oip->argdesc, oip->argdesc2,
 216                  l>2 ? l : 2, "",
 217                  oip->desc);
 218         break;
 219       case ot_desconly:
 220         printf("%s\n", oip->desc);
 221         break;
 222       default:
 223         abort();
 224       }
 225     }
 226   }
 227
 228   printf("\nEscaping domains which might start with `-':\n"
 229          " - %-*s Next argument is a domain, but more options may follow\n",
 230          maxlopt+maxsopt+3, "<domain>");
 231
 232   fputs("\n"
 233         "Query domains should always be quoted according to master file format.\n"
 234         "\n"
 235         "For binary options, --FOO and --no-FOO are opposites, as are\n"
 236         "-X and +X.  In each case the default is the one not listed.\n"
 237         "Per query options stay set a particular way until they are reset,\n"
 238         "whether they appear on the command line or on stdin.\n"
 239         "All global options must preceed the first query domain.\n"
 240         "\n"
 241         "With -f, the input should be lines with either an option, possibly\n"
 242         "with a value argument (separated from the option by a space if it's a long\n"
 243         "option), or a domain (possibly preceded by a hyphen and a space to\n"
 244         "distinguish it from an option).\n"
 245         "\n"
 246         "Output format is master file format without class or TTL by default:\n"
 247         "   [<owner>] [<ttl>] [<type>] <data>\n"
 248         "or if the <owner> domain refers to a CNAME and --show-cname is on\n"
 249         "   [<owner>] [<ttl>] CNAME <cname>\n"
 250         "   [<cname>] [<ttl>] <type> <data>\n"
 251         "When a query fails you get an error message to stderr (with --fmt-simple).\n"
 252         "Specify --fmt-inline for lines like this (broken here for readability):\n"
 253         "   ; failed <statustype> <statusnum> <statusabbrev> \\\n"
 254         "       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
 255         "If you use --fmt-asynch, which is the default for --asynch,\n"
 256         "each answer (success or failure) is preceded by a line\n"
 257         "   <id> <nrrs> <statustype> <statusnum> <statusabbrev> \\\n"
 258         "       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
 259         "where <nrrs> is the number of RRs that follow and <cname> will be `$' or\n"
 260         "the CNAME target; the CNAME indirection and error formats above are not used.\n"
 261         "\n"
 262         "Exit status:\n"
 263         " 0    all went well\n"
 264         " 1-6  at least one query failed with statustype:\n"
 265         "   1    localfail   )\n"
 266         "   2    remotefail  ) temporary errors\n"
 267         "   3    tempfail  __)_________________\n"
 268         "   4    misconfig   )\n"
 269         "   5    misquery    ) permanent errors\n"
 270         "   6    permfail    )\n"
 271         " 10   system trouble\n"
 272         " 11   usage problems\n"
 273         "\n"
 274         "Query types (see adns.h; default is addr):\n"
 275         "  ns  soa  ptr  mx  rp  srv  addr           - enhanced versions\n"
 276         "  cname  hinfo  txt                         - types with only one version\n"
 277         "  a  aaaa  ns-  soa-  ptr-  mx-  rp-  srv-  - _raw versions\n"
 278         "  type<number>                              - `unknown' type, RFC3597\n"
 279         "Default is addr, or ptr for -i/--ptr queries\n",
 280         stdout);
 281   if (ferror(stdout)) sysfail("write usage message",errno);
 282 }
 283
 284 void of_version(const struct optioninfo *oi, const char *arg, const char *arg2) {
 285   VERSION_PRINT_QUIT("adnshost");
 286 }
 287
 288 void of_help(const struct optioninfo *oi, const char *arg, const char *arg2) {
 289   printusage();
 290   if (fclose(stdout)) sysfail("finish writing output",errno);
 291   quitnow(0);
 292 }
 293
 294 typedef int comparer_type(const char **optp, const struct optioninfo *entry);
 295
 296 static int oc_long(const char **optp, const struct optioninfo *entry) {
 297   return entry->lopt && !strcmp(*optp,entry->lopt);
 298 }
 299
 300 static int oc_short(const char **optp, const struct optioninfo *entry) {
 301   const char *sopt;
 302   int l;
 303
 304   sopt= entry->sopt;
 305   if (!sopt) return 0;
 306   l= strlen(sopt);
 307   if (memcmp(*optp,sopt,l)) return 0;
 308   (*optp) += l;
 309   return 1;
 310 }
 311
 312 static const struct optioninfo *find1(const char **optp,
 313                                       const struct optioninfo *table,
 314                                       comparer_type *comparer) {
 315   for (;;) {
 316     if (table->type == ot_end) return 0;
 317     if (comparer(optp,table)) return table;
 318     table++;
 319   }
 320 }
 321
 322 static const struct optioninfo *find(const char **optp,
 323                                      const char *prefix,
 324                                      comparer_type *comparer) {
 325   const struct optioninfo *oip;
 326   const char *opt;
 327
 328   opt= *optp;
 329   oip= find1(optp,perquery_options,comparer);
 330   if (oip) return oip;
 331   oip= find1(optp,global_options,comparer);
 332   if (!oip) usageerr("unknown option %s%s",prefix,opt);
 333   if (ads) usageerr("global option %s%s specified after query domain(s)",prefix,opt);
 334   return oip;
 335 }
 336
 337 const struct optioninfo *opt_findl(const char *opt) { return find(&opt,"--",oc_long); }
 338 const struct optioninfo *opt_finds(const char **optp) { return find(optp,"-",oc_short); }
 339
 340 static void noninvert(const struct optioninfo *oip) NONRETURNING;
 341 static void noninvert(const struct optioninfo *oip) {
 342   usageerr("option %s%s%s%s%s may not be inverted",
 343            oip->sopt ? "-" : "", oip->sopt ? oip->sopt : "",
 344            oip->lopt && oip->sopt ? " / " : "",
 345            oip->lopt ? "--" : "", oip->lopt ? oip->lopt : "");
 346 }
 347
 348 void opt_do(const struct optioninfo *oip, int invert,
 349             const char *arg, const char *arg2) {
 350   switch (oip->type) {
 351   case ot_flag:
 352     assert(!arg);
 353     *oip->storep= !invert;
 354     return;
 355   case ot_value:
 356     assert(!arg);
 357     if (invert) noninvert(oip);
 358     *oip->storep= oip->value;
 359     return;
 360   case ot_func: case ot_funcarg: case ot_funcarg2:
 361     if (invert) noninvert(oip);
 362     oip->func(oip,arg,arg2);
 363     return;
 364   default:
 365     abort();
 366   }
 367 }