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
   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>
  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
  29 #include "adnshost.h"
  30
  31 int ov_env=1, ov_pipe=0, ov_asynch=0;
  32 int ov_verbose= 0;
  33 adns_rrtype ov_type= adns_r_none;
  34 int ov_search=0, ov_qc_query=0, ov_qc_anshost=0, ov_qc_cname=1;
  35 int ov_tcp=0, ov_cname=0;
  36 char *ov_id= 0;
  37 struct perqueryflags_remember ov_pqfr = { 1,1,1, tm_none };
  38
  39 static const struct optioninfo global_options[]= {
  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
  63 static const struct optioninfo perquery_options[]= {
  64   { ot_desconly, "per-query options:" },
  65   { ot_funcarg,          "Query type (see below)",
  66     "t", "type",           0,0, &of_type, "type" },
  67   { ot_funcarg,          "Do reverse query (address -> name lookup)",
  68     "i", "ptr",            0,0, &of_type, "addr" },
  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",
  82     "Do", "show-owner",   &ov_pqfr.show_owner, 0 },
  83   { ot_flag,             "Do not display RR type in output",
  84     "Dt", "show-type",    &ov_pqfr.show_type, 0 },
  85   { ot_flag,             "Do not display CNAME target in output",
  86     "Dc", "show-cname",    &ov_pqfr.show_cname, 0 },
  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",
  90     "Tt", "ttl-ttl",       &ov_pqfr.ttl, tm_rel },
  91   { ot_value,            "Show the TTL as a time_t when the data might expire",
  92     "Ta", "ttl-abs",       &ov_pqfr.ttl, tm_abs },
  93   { ot_value,            "Do not show the TTL (default)",
  94     "Tn", "no-ttl",        &ov_pqfr.ttl, tm_none },
  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
 104   { ot_desconly, "asynchronous/pipe mode options:" },
 105   { ot_funcarg,          "Set <id>, default is decimal sequence starting 0",
 106     0, "asynch-id",        0,0, &of_asynch_id, "id" },
 107   { ot_funcarg,          "Cancel the query with id <id> (no error if not found)",
 108     0, "cancel-id",        0,0, &of_cancel_id, "id" },
 109
 110   { ot_end }
 111 };
 112
 113 static void printusage(void) {
 114   static const struct optioninfo *const all_optiontables[]= {
 115     global_options, perquery_options, 0
 116   };
 117
 118   const struct optioninfo *const *oiap, *oip=0;
 119   int maxsopt, maxlopt, l;
 120
 121   maxsopt= maxlopt= 0;
 122
 123   for (oiap=all_optiontables; *oiap; oiap++) {
 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
 140   for (oiap=all_optiontables; *oiap; oiap++) {
 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"
 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"
 222         "\n"
 223         "If you use --asynch each answer (success or failure) is preceded by a line\n"
 224         "   <id> <nrrs> <statustype> <statusnum> <statusabbrev> \\\n"
 225         "       [<owner>] [<ttl>] [<cname>] \"<status string>\"\n"
 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"
 244         "  a  ns-  soa-  ptr-  mx-  rp-     - _raw versions\n"
 245         "Default is addr, or ptr for -i/--ptr queries\n",
 246         stdout);
 247   if (ferror(stdout)) sysfail("write usage message",errno);
 248 }
 249
 250 void of_help(const struct optioninfo *oi, const char *arg) {
 251   printusage();
 252   if (fclose(stdout)) sysfail("finish writing output",errno);
 253   exit(0);
 254 }
 255
 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;
 288
 289   oip= find1(optp,perquery_options,comparer);
 290   if (oip) return oip;
 291   oip= find1(optp,global_options,comparer);
 292   if (!oip) usageerr("unknown option %s%s",prefix,*optp);
 293   if (ads) usageerr("global option %s%s specified after query domain(s)",prefix,*optp);
 294   return oip;
 295 }
 296
 297 const struct optioninfo *opt_findl(const char *opt) { return find(&opt,"--",oc_long); }
 298 const struct optioninfo *opt_finds(const char **optp) { return find(optp,"-",oc_short); }
 299
 300 static void noninvert(const struct optioninfo *oip) NONRETURNING;
 301 static void noninvert(const struct optioninfo *oip) {
 302   usageerr("option %s%s%s%s%s may not be inverted",
 303            oip->sopt ? "-" : "", oip->sopt ? oip->sopt : "",
 304            oip->lopt && oip->sopt ? " / " : "",
 305            oip->lopt ? "--" : "", oip->lopt ? oip->lopt : "");
 306 }
 307
 308 void opt_do(const struct optioninfo *oip, const char *arg, int invert) {
 309   switch (oip->type) {
 310   case ot_flag:
 311     assert(!arg);
 312     *oip->storep= !invert;
 313     return;
 314   case ot_value:
 315     assert(!arg);
 316     if (invert) noninvert(oip);
 317     *oip->storep= oip->value;
 318     return;
 319   case ot_func: case ot_funcarg:
 320     if (invert) noninvert(oip);
 321     oip->func(oip,arg);
 322     return;
 323   default:
 324     abort();
 325   }
 326 }