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_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_flag,             "Return IPv4 addresses as IPv6-mapped",
 110     "Am", "--addr-ipv6-mapped", &ov_v6map, 1 },
 111
 112   { ot_desconly, "per-query CNAME handling mode:" },
 113   { ot_value,            "Call it an error if a CNAME is found",
 114     "Cf", "cname-reject",  &ov_cname, adns_qf_cname_forbid },
 115   { ot_value,            "Allow references to CNAMEs in other RRs",
 116     "Cl", "cname-loose",   &ov_cname, adns_qf_cname_loose },
 117   { ot_value,            "CNAME ok for query domain, but not in RRs (default)",
 118     "Cs", "cname-ok",      &ov_cname, 0 },
 119
 120   { ot_desconly, "asynchronous/pipe mode options:" },
 121   { ot_funcarg,          "Set <id>, default is decimal sequence starting 0",
 122     0, "asynch-id",        0,0, &of_asynch_id, "id" },
 123   { ot_funcarg,          "Cancel the query with id <id> (no error if not found)",
 124     0, "cancel-id",        0,0, &of_cancel_id, "id" },
 125
 126   { ot_end }
 127 };
 128
 129 static void printusage(void) {
 130   static const struct optioninfo *const all_optiontables[]= {
 131     global_options, perquery_options, 0
 132   };
 133
 134   const struct optioninfo *const *oiap, *oip=0;
 135   int maxsopt, maxlopt, l;
 136
 137   maxsopt= maxlopt= 0;
 138
 139   for (oiap=all_optiontables; *oiap; oiap++) {
 140     for (oip=*oiap; oip->type != ot_end; oip++) {
 141       if (oip->type == ot_funcarg) continue;
 142       if (oip->sopt) { l= strlen(oip->sopt); if (l>maxsopt) maxsopt= l; }
 143       if (oip->lopt) {
 144         l= strlen(oip->lopt);
 145         if (oip->type == ot_flag && !oip->value) l+= 3;
 146         if (l>maxlopt) maxlopt= l;
 147       }
 148     }
 149   }
 150
 151   fputs("usage: adnshost [global-opts] [query-opts] query-domain\n"
 152         "                             [[query-opts] query-domain ...]\n"
 153         "       adnshost [global-opts] [query-opts] -f|--pipe\n",
 154         stdout);
 155
 156   for (oiap=all_optiontables; *oiap; oiap++) {
 157     putchar('\n');
 158     for (oip=*oiap; oip->type != ot_end; oip++) {
 159       switch (oip->type) {
 160       case ot_flag:
 161         if (!oip->value) {
 162           if (oip->sopt) {
 163             printf(" +%-*s --no-%-*s %s\n",
 164                    maxsopt, oip->sopt,
 165                    maxlopt-2, oip->lopt,
 166                    oip->desc);
 167           } else {
 168             printf(" --no-%-*s %s\n",
 169                    maxlopt+maxsopt+1, oip->lopt,
 170                    oip->desc);
 171           }
 172           break;
 173         }
 174       case ot_value: case ot_func: /* fall through */
 175         if (oip->sopt) {
 176           printf(" -%-*s --%-*s %s\n",
 177                  maxsopt, oip->sopt,
 178                  maxlopt+1, oip->lopt,
 179                  oip->desc);
 180         } else {
 181           printf(" --%-*s %s\n",
 182                  maxlopt+maxsopt+3, oip->lopt,
 183                  oip->desc);
 184         }
 185         break;
 186       case ot_funcarg:
 187         if (oip->sopt) {
 188           l= (maxlopt + maxsopt - 9 -
 189               (strlen(oip->sopt) + strlen(oip->lopt) + 2*strlen(oip->argdesc)));
 190           printf(" -%s<%s> / --%s <%s>%*s%s\n",
 191                  oip->sopt, oip->argdesc, oip->lopt, oip->argdesc,
 192                  l>2 ? l : 2, "",
 193                  oip->desc);
 194         } else {
 195           l= (maxlopt + maxsopt + 1 -
 196               (strlen(oip->lopt) + strlen(oip->argdesc)));
 197           printf(" --%s <%s>%*s%s\n",
 198                  oip->lopt, oip->argdesc,
 199                  l>2 ? l : 2, "",
 200                  oip->desc);
 201         }
 202         break;
 203       case ot_funcarg2:
 204         assert(!oip->sopt);
 205         l= (maxlopt + maxsopt - 2 -
 206             (strlen(oip->lopt) + strlen(oip->argdesc) + strlen(oip->argdesc2)));
 207           printf(" --%s <%s> <%s>%*s%s\n",
 208                  oip->lopt, oip->argdesc, oip->argdesc2,
 209                  l>2 ? l : 2, "",
 210                  oip->desc);
 211         break;
 212       case ot_desconly:
 213         printf("%s\n", oip->desc);
 214         break;
 215       default:
 216         abort();
 217       }
 218     }
 219   }
 220
 221   printf("\nEscaping domains which might start with `-':\n"
 222          " - %-*s Next argument is a domain, but more options may follow\n",
 223          maxlopt+maxsopt+3, "<domain>");
 224
 225   fputs("\n"
 226         "Query domains should always be quoted according to master file format.\n"
 227         "\n"
 228         "For binary options, --FOO and --no-FOO are opposites, as are\n"
 229         "-X and +X.  In each case the default is the one not listed.\n"
 230         "Per query options stay set a particular way until they are reset,\n"
 231         "whether they appear on the command line or on stdin.\n"
 232         "All global options must preceed the first query domain.\n"
 233         "\n"
 234         "With -f, the input should be lines with either an option, possibly\n"
 235         "with a value argument (separated from the option by a space if it's a long\n"
 236         "option), or a domain (possibly preceded by a hyphen and a space to\n"
 237         "distinguish it from an option).\n"
 238         "\n"
 239         "Output format is master file format without class or TTL by default:\n"
 240         "   [<owner>] [<ttl>] [<type>] <data>\n"
 241         "or if the <owner> domain refers to a CNAME and --show-cname is on\n"
 242         "   [<owner>] [<ttl>] CNAME <cname>\n"
 243         "   [<cname>] [<ttl>] <type> <data>\n"
 244         "When a query fails you get an error message to stderr (with --fmt-simple).\n"
 245         "Specify --fmt-inline for lines like this (broken here for readability):\n"
 246         "   ; failed <statustype> <statusnum> <statusabbrev> \\\n"
 247         "       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
 248         "If you use --fmt-asynch, which is the default for --asynch,\n"
 249         "each answer (success or failure) is preceded by a line\n"
 250         "   <id> <nrrs> <statustype> <statusnum> <statusabbrev> \\\n"
 251         "       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
 252         "where <nrrs> is the number of RRs that follow and <cname> will be `$' or\n"
 253         "the CNAME target; the CNAME indirection and error formats above are not used.\n"
 254         "\n"
 255         "Exit status:\n"
 256         " 0    all went well\n"
 257         " 1-6  at least one query failed with statustype:\n"
 258         "   1    localfail   )\n"
 259         "   2    remotefail  ) temporary errors\n"
 260         "   3    tempfail  __)_________________\n"
 261         "   4    misconfig   )\n"
 262         "   5    misquery    ) permanent errors\n"
 263         "   6    permfail    )\n"
 264         " 10   system trouble\n"
 265         " 11   usage problems\n"
 266         "\n"
 267         "Query types (see adns.h; default is addr):\n"
 268         "  ns  soa  ptr  mx  rp  srv  addr           - enhanced versions\n"
 269         "  cname  hinfo  txt                         - types with only one version\n"
 270         "  a  aaaa  ns-  soa-  ptr-  mx-  rp-  srv-  - _raw versions\n"
 271         "  type<number>                              - `unknown' type, RFC3597\n"
 272         "Default is addr, or ptr for -i/--ptr queries\n",
 273         stdout);
 274   if (ferror(stdout)) sysfail("write usage message",errno);
 275 }
 276
 277 void of_version(const struct optioninfo *oi, const char *arg, const char *arg2) {
 278   VERSION_PRINT_QUIT("adnshost");
 279 }
 280
 281 void of_help(const struct optioninfo *oi, const char *arg, const char *arg2) {
 282   printusage();
 283   if (fclose(stdout)) sysfail("finish writing output",errno);
 284   quitnow(0);
 285 }
 286
 287 typedef int comparer_type(const char **optp, const struct optioninfo *entry);
 288
 289 static int oc_long(const char **optp, const struct optioninfo *entry) {
 290   return entry->lopt && !strcmp(*optp,entry->lopt);
 291 }
 292
 293 static int oc_short(const char **optp, const struct optioninfo *entry) {
 294   const char *sopt;
 295   int l;
 296
 297   sopt= entry->sopt;
 298   if (!sopt) return 0;
 299   l= strlen(sopt);
 300   if (memcmp(*optp,sopt,l)) return 0;
 301   (*optp) += l;
 302   return 1;
 303 }
 304
 305 static const struct optioninfo *find1(const char **optp,
 306                                       const struct optioninfo *table,
 307                                       comparer_type *comparer) {
 308   for (;;) {
 309     if (table->type == ot_end) return 0;
 310     if (comparer(optp,table)) return table;
 311     table++;
 312   }
 313 }
 314
 315 static const struct optioninfo *find(const char **optp,
 316                                      const char *prefix,
 317                                      comparer_type *comparer) {
 318   const struct optioninfo *oip;
 319   const char *opt;
 320
 321   opt= *optp;
 322   oip= find1(optp,perquery_options,comparer);
 323   if (oip) return oip;
 324   oip= find1(optp,global_options,comparer);
 325   if (!oip) usageerr("unknown option %s%s",prefix,opt);
 326   if (ads) usageerr("global option %s%s specified after query domain(s)",prefix,opt);
 327   return oip;
 328 }
 329
 330 const struct optioninfo *opt_findl(const char *opt) { return find(&opt,"--",oc_long); }
 331 const struct optioninfo *opt_finds(const char **optp) { return find(optp,"-",oc_short); }
 332
 333 static void noninvert(const struct optioninfo *oip) NONRETURNING;
 334 static void noninvert(const struct optioninfo *oip) {
 335   usageerr("option %s%s%s%s%s may not be inverted",
 336            oip->sopt ? "-" : "", oip->sopt ? oip->sopt : "",
 337            oip->lopt && oip->sopt ? " / " : "",
 338            oip->lopt ? "--" : "", oip->lopt ? oip->lopt : "");
 339 }
 340
 341 void opt_do(const struct optioninfo *oip, int invert,
 342             const char *arg, const char *arg2) {
 343   switch (oip->type) {
 344   case ot_flag:
 345     assert(!arg);
 346     *oip->storep= !invert;
 347     return;
 348   case ot_value:
 349     assert(!arg);
 350     if (invert) noninvert(oip);
 351     *oip->storep= oip->value;
 352     return;
 353   case ot_func: case ot_funcarg: case ot_funcarg2:
 354     if (invert) noninvert(oip);
 355     oip->func(oip,arg,arg2);
 356     return;
 357   default:
 358     abort();
 359   }
 360 }