chiark - git - mdw - distorted-keys/blob - keyfunc.sh.in

   1 ### -*-sh-*-
   2 ###
   3 ### Common key management functions.
   4 ###
   5 ### (c) 2011 Mark Wooding
   6 ###
   7
   8 ###----- Licensing notice ---------------------------------------------------
   9 ###
  10 ### This file is part of the distorted.org.uk key management suite.
  11 ###
  12 ### distorted-keys is free software; you can redistribute it and/or modify
  13 ### it under the terms of the GNU General Public License as published by
  14 ### the Free Software Foundation; either version 2 of the License, or
  15 ### (at your option) any later version.
  16 ###
  17 ### distorted-keys is distributed in the hope that it will be useful,
  18 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ### GNU General Public License for more details.
  21 ###
  22 ### You should have received a copy of the GNU General Public License
  23 ### along with distorted-keys; if not, write to the Free Software Foundation,
  24 ### Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25
  26 quis=${0##*/}
  27
  28 ###--------------------------------------------------------------------------
  29 ### Configuration variables.
  30
  31 ## Automatically configured pathnames.
  32 PACKAGE="@PACKAGE@" VERSION="@VERSION@"
  33 bindir="@bindir@"
  34
  35 ## Read user configuration.
  36 if [ -f $ETC/keys.conf ]; then . $ETC/keys.conf; fi
  37
  38 ## Maybe turn on debugging.
  39 case "${KEYS_DEBUG+t}" in t) set -x ;; esac
  40
  41 ## Fake up caller credentials if not called via userv.
  42 case "${USERV_USER+t}" in
  43   t) ;;
  44   *) USERV_USER=${LOGNAME-${USER-$(id -un)}} USERV_UID=$(id -u) ;;
  45 esac
  46 case "${USERV_GROUP+t}" in
  47   t) ;;
  48   *) USERV_GROUP=$(id -Gn) USERV_GID=$(id -gn) ;;
  49 esac
  50
  51 ###--------------------------------------------------------------------------
  52 ### Cleanup handling.
  53
  54 cleanups=""
  55 cleanup () { cleanups=${cleanups+$cleanups }$1; }
  56 runcleanups () { for i in $cleanups; do $i; done; }
  57 trap 'rc=$?; runcleanups; exit $rc' EXIT
  58 trap 'trap "" EXIT; runcleanups; exit 127' INT TERM
  59
  60 ###--------------------------------------------------------------------------
  61 ### Utility functions.
  62
  63 reqsafe () {
  64   ## Fail unless a safe directory is set.
  65
  66   err="$quis: (CONFIGURATION ERROR)"
  67   case ${SAFE+t} in
  68     t) ;;
  69     *) echo >&2 "$err: no SAFE directory"; exit 1 ;;
  70   esac
  71   if [ ! -d "$SAFE" ]; then
  72     echo >&2 "$err: SAFE path \`$SAFE' isn't a directory"
  73     exit 1
  74   fi
  75   case "$SAFE" in
  76     [!/]* | *[][[:space:]*?]*)
  77       echo >&2 "$err: SAFE path \`$SAFE' contains bad characters"
  78       exit 1
  79       ;;
  80   esac
  81   ls -ld "$SAFE" | {
  82     me=$(id -un)
  83     read perm _ user stuff
  84     case "$perm:$user" in
  85       d???------:"$me") ;;
  86       *)
  87         echo >&2 "$err: SAFE path \`$SAFE' has bad owner or permissions"
  88         exit 1
  89         ;;
  90     esac
  91   }
  92 }
  93
  94 ## Temporary directory.
  95 unset tmp
  96 rmtmp () { case ${tmp+t} in t) cd /; rm -rf $tmp ;; esac; }
  97 cleanup rmtmp
  98 mktmp () {
  99   ## Make a temporary directory and store its name in `tmp'.
 100
 101   case "${tmp+t}" in t) return ;; esac
 102   reqsafe
 103   tmp="$SAFE/keys.tmp.$$"
 104   rm -rf "$tmp"
 105   mkdir -m700 "$tmp"
 106 }
 107
 108 reqtmp () {
 109   ## Fail unless a temporary directory is set.
 110
 111   case ${tmp+t} in
 112     t) ;;
 113     *) echo >&2 "$quis (INTERNAL): no tmp directory set"; exit 127 ;;
 114   esac
 115 }
 116
 117 parse_keylabel () {
 118   key=$1
 119   ## Parse the key label string KEY.  Set `kdir' to the base path to use for
 120   ## the key's storage, and `kowner' to the key owner's name.
 121
 122   case "$key" in
 123     *:*) kowner=${key%%:*} klabel=${key#*:} ;;
 124     *) kowner=$USERV_USER klabel=$key ;;
 125   esac
 126   checkword "key owner name" "$kowner"
 127   checklabel "key" "$klabel"
 128   kdir=$KEYS/store/$kowner/$klabel
 129   knub=$KEYS/nub/$kowner/$klabel
 130 }
 131
 132 runas () {
 133   user=$1 service=$2; shift 2
 134   ## If the current (effective) user is not USER then reinvoke via `userv',
 135   ## as the specified service, with the remaining arguments.
 136
 137   case $(id -un) in
 138     "$user") ;;
 139     *) exec userv "$user" "$service" "$@" ;;
 140   esac
 141 }
 142
 143 ###--------------------------------------------------------------------------
 144 ### Input validation functions.
 145
 146 nl="
 147 "
 148 check () {
 149   ckwhat=$1 ckpat=$2 thing=$3
 150   ## Verify that THING matches the (anchored, basic) regular expression
 151   ## CKPAT.  Since matching newlines is hard to do portably, also check that
 152   ## THING doesn't contain any.  If the checks fail, report an error and
 153   ## exit.
 154
 155   validp=t
 156   case "$thing" in
 157     *"$nl"*)
 158       validp=nil
 159       ;;
 160     *)
 161       if ! expr >/dev/null "Q$thing" : "\(Q$ckpat\)\$"; then
 162       validp=nil
 163       fi
 164       ;;
 165   esac
 166   case $validp in
 167     nil) echo >&2 "$quis: bad $ckwhat \`$thing'"; exit 1 ;;
 168   esac
 169 }
 170
 171 ## Regular expressions for validating input.
 172 R_IDENTCHARS="A-Za-z0-9_"
 173 R_GOODPUNCT="!%@+="
 174 R_WORDCHARS="-$R_IDENTCHARS$R_GOODPUNCT"
 175 R_IDENT="[$R_IDENTCHARS][$R_IDENTCHARS]*"
 176 R_WORD="[$R_WORDCHARS][$R_WORDCHARS]*"
 177 R_ACLCHARS="][$R_IDENTCHARS$R_GOODPUNCT*?:.#"
 178 R_WORDSEQ="[$R_WORDCHARS[:space:]][$R_WORDCHARS[:space:]]*"
 179 R_ACL="[$R_ACLCHARS[:space:]-][$R_ACLCHARS[:space:]-]*"
 180 R_NUMERIC='\(\([1-9][0-9]*\)\{0,1\}0\{0,1\}\)'
 181 R_LABEL="\($R_WORD\(/$R_WORD\)*\)"
 182 R_LINE=".*"
 183
 184 ## Various validation functions.
 185 checknumber () { check "$1" "$R_NUMERIC" "$2"; }
 186 checkident () { check "$1" "$R_IDENT" "$2"; }
 187 checkword () { check "$1" "$R_WORD" "$2"; }
 188 checklabel () { check "$1 label" "$R_LABEL" "$2"; }
 189
 190 ## Boolean canonification.
 191 boolify () {
 192   var=$1 what=$2
 193
 194   eval v=\$$var
 195   case $v in
 196     1 | y | yes | on | t | true) v=t ;;
 197     0 | n | no | off | f | false | nil) v=nil ;;
 198     *) echo >&2 "$quis: bad boolean $what \`$v'"; exit 1 ;;
 199   esac
 200   eval $var=\$v
 201 }
 202
 203 ###--------------------------------------------------------------------------
 204 ### Key storage and properties.
 205
 206 getsysprofile () {
 207   profile=$1
 208   ## Write the named system PROFILE to standard output.
 209
 210   $bindir/extract-profile "$profile" $ETC/profile.d/
 211 }
 212
 213 setprops () {
 214   what=$1 prefix=$2; shift 2
 215   ## Set variables based on the NAME=VALUE assignments in the arguments.  The
 216   ## value for property NAME is stored in the shell variable PREFIX_NAME.
 217
 218   for assg in "$@"; do
 219     goodp=t
 220     case "$assg" in
 221       *\=*) name=${assg%%=*} value=${assg#*=} ;;
 222       *) goodp=nil ;;
 223     esac
 224     case "$goodp,$name" in t,*[!0-9A-Za-z_]*=*) goodp=nil ;; esac
 225     case "$goodp" in
 226       nil) echo >&2 "$quis: bad $what assignment \`$assg'"; exit 1 ;;
 227     esac
 228     eval "$prefix$name=\$value"
 229   done
 230 }
 231
 232 checkprops () {
 233   whatprop=$1 prefix=$2; shift 2
 234   ## Check that property variables are set in accordance with the remaining
 235   ## TABLE arguments.  Each row of TABLE has the form
 236   ##
 237   ##    NAME OMIT PAT
 238   ##
 239   ## A table row is satisfied if there is a variable PREFIXNAME whose value
 240   ## matces the (basic) regular expression PAT, or if the variable is unset
 241   ## and OMIT is `t'.
 242
 243   for table in "$@"; do
 244     case "$table" in ?*) ;; *) continue ;; esac
 245     while read -r name omit pat; do
 246       eval foundp=\${$prefix$name+t}
 247       case "$foundp,$omit" in
 248         ,t) continue ;;
 249         ,nil)
 250           echo >&2 "$quis: missing $whatprop \`$name' required"
 251           exit 1
 252           ;;
 253       esac
 254       eval value=\$$prefix$name
 255       check "value for $whatprop \`$name'" "$pat" "$value"
 256     done <<EOF
 257 $table
 258 EOF
 259   done
 260 }
 261
 262 dumpprops () {
 263   prefix=$1
 264   ## Write the properties stored in the variables beginning with PREFIX.
 265
 266   set | sed -n "/^$prefix/{s/=.*\$//;p}" | sort | while read name; do
 267     eval value=\$$name
 268     echo "${name#$prefix}=$value"
 269   done
 270 }
 271
 272 defprops () {
 273   name=$1
 274   ## Define a properties table NAME.
 275
 276   table=$(cat)
 277   eval $name=\$table
 278 }
 279
 280 defprops g_props <<EOF
 281 type                    nil     $R_IDENT
 282 recovery                t       $R_WORDSEQ
 283 random                  t       $R_WORD
 284 nub_hash                t       $R_WORD
 285 nubid_hash              t       $R_WORD
 286 nub_random_bytes        t       $R_NUMERIC
 287 acl_encrypt             t       $R_ACL
 288 acl_decrypt             t       $R_ACL
 289 acl_sign                t       $R_ACL
 290 acl_verify              t       $R_ACL
 291 acl_info                t       $R_ACL
 292 EOF
 293
 294 readprops () {
 295   file=$1
 296   ## Read a profile from a file.  This doesn't check the form of the
 297   ## filename, so it's not suitable for unchecked input.  Properties are set
 298   ## using `setprops' with prefix `kprop_'.
 299
 300   ## Parse the settings from the file.
 301   exec 3<"$file"
 302   while read line; do
 303     case "$line" in "" | \#*) continue ;; esac
 304     setprops "property" kprop_ "$line"
 305   done <&3
 306   exec 3>&-
 307   checkprops "property" kprop_ "$g_props"
 308
 309   ## Fetch the key-type handling library.
 310   if [ ! -f $KEYSLIB/ktype.$kprop_type ]; then
 311     echo >&2 "$quis: unknown key type \`$kprop_type'"
 312     exit 1
 313   fi
 314   . $KEYSLIB/ktype.$kprop_type
 315   checkprops "property" kprop_ "$k_props"
 316 }
 317
 318 readmeta () {
 319   kdir=$1
 320   ## Read key metadata from KDIR.
 321
 322   { read profile; } <"$kdir"/meta
 323 }
 324
 325 makenub () {
 326   ## Generate a key nub in the default way, and write it to standard output.
 327   ## The properties `random', `nub_random_bytes' and `nub_hash' are referred
 328   ## to.
 329
 330   dd 2>/dev/null \
 331     if=/dev/${kprop_random-random} bs=1 count=${kprop_nub_random_bytes-64} |
 332   openssl dgst -${kprop_nub_hash-sha256} -binary |
 333   openssl base64
 334 }
 335
 336 nubid () {
 337   ## Compute a hash of the key nub in stdin, and write it to stdout in hex.
 338   ## The property `nubid_hash' is used.
 339
 340   ## Stupid dance because the output incompatibly grew a filename, in order
 341   ## to demonstrate the same idiocy as GNU mumblesum.
 342   set _ $({ echo "distorted-keys nubid"; cat -; } |
 343     openssl dgst -${kprop_nubid_hash-sha256})
 344   if [ $# -gt 2 ]; then shift; fi
 345   echo $2
 346 }
 347
 348 subst () {
 349   what=$1 templ=$2 prefix=$3 pat=$4
 350   ## Substitute option values into the template TEMPL.  Each occurrence of
 351   ## %{VAR} is replaced by the value of the variable PREFIXVAR.  Finally, an
 352   ## error is reported unless the final value matches the regular expression
 353   ## PAT.
 354
 355   out=""
 356   rest=$templ
 357   while :; do
 358
 359     ## If there are no more markers to substitute, then finish.
 360     case "$rest" in *"%{"*"}"*) ;; *) out=$out$rest; break ;; esac
 361
 362     ## Split the template into three parts.
 363     left=${rest%%\%\{*} right=${rest#*\%\{}
 364     var=${right%%\}*} rest=${right#*\}}
 365     case "$var" in
 366       *-*) default=${var#*-} var=${var%%-*} defaultp=t ;;
 367       *) defaultp=nil ;;
 368     esac
 369
 370     ## Find the variable value.
 371     checkident "template variable name" "$var"
 372     eval foundp=\${$prefix$var+t}
 373     case $foundp,$defaultp in
 374       t,*) eval value=\$$prefix$var ;;
 375       ,t) value=$default ;;
 376       *)
 377         echo >&2 "$quis: option \`$var' unset, used in template \`$templ'"
 378         exit 1
 379         ;;
 380     esac
 381
 382     ## Do the substitution.
 383     out=$out$left$value
 384   done
 385
 386   ## Check the final result.
 387   check "$what" "$pat" "$out"
 388
 389   ## Done.
 390   echo "$out"
 391 }
 392
 393 read_profile () {
 394   owner=$1 profile=$2
 395   ## Read property settings from a profile.  The PROFILE name has the form
 396   ## [USER:]LABEL; USER defaults to OWNER.  Properties are set using
 397   ## `setprops' with prefix `kprop_'.
 398
 399   reqtmp
 400   case "$profile" in
 401     :*)
 402       label=${profile#:} uservp=nil
 403       ;;
 404     *)
 405       user=$kowner label=$profile uservp=t
 406       ;;
 407     *:*)
 408       user=${profile%%:*} label=${profile#*:} uservp=t
 409       ;;
 410   esac
 411   checkword "profile label" "$label"
 412
 413   ## Fetch the profile settings from the user.
 414   reqtmp
 415   case $uservp in
 416     t)
 417       checkword "profile user" "$user"
 418       userv "$user" cryptop-profile "$label" >$tmp/profile </dev/null
 419       ;;
 420     nil)
 421       $bindir/extract-profile "$label" $ETC/profile.d/ >$tmp/profile
 422       ;;
 423   esac
 424
 425   ## Read the file.
 426   readprops $tmp/profile
 427 }
 428
 429 ###--------------------------------------------------------------------------
 430 ### General crypto operations.
 431
 432 c_genkey () {
 433   profile=$1 kdir=$2 knub=$3 hook=$4; shift 4
 434   ## Generate a key, and associate it with the named PROFILE (which is
 435   ## assumed already to have been read!); store the main data in KDIR, and
 436   ## the nub separately in the file KNUB; run HOOK after generation, passing
 437   ## it the working key directory and nub file.  Remaining arguments are
 438   ## options to the key type.
 439
 440   ## Set options and check them.
 441   kopt_owner=$kowner kopt_label=$klabel
 442   setprops "option" kopt_ "$@"
 443   checkprops "option" kopt_ "$k_genopts"
 444
 445   ## Create directory structure and start writing metadata.
 446   rm -rf "$kdir.new"
 447   mkdir -m755 -p "$kdir.new"
 448   case "$knub" in */*) mkdir -m755 -p "${knub%/*}" ;; esac
 449   cat >"$kdir.new/meta" <<EOF
 450 $profile
 451 EOF
 452
 453   ## Generate the key.
 454   (umask 077; makenub >"$knub.new")
 455   k_generate "$kdir.new" "$knub.new"
 456   $hook "$kdir.new" "$knub.new"
 457
 458   ## Hash the nub.
 459   nubid <"$knub.new" >"$kdir.new/nubid"
 460
 461   ## Juggle everything into place.  Doing this atomically is very difficult,
 462   ## and requires more machinery than I can really justify here.  If
 463   ## something goes wrong halfway, it should always be possible to fix it,
 464   ## either by backing out (if $kdir.new still exists) or pressing on
 465   ## forwards (if not).
 466   rm -rf "$kdir.old"
 467   if [ -e "$kdir" ]; then mv "$kdir" "$kdir.old"; fi
 468   mv "$kdir.new" "$kdir"
 469   mv "$knub.new" "$knub"
 470   rm -rf "$kdir.old"
 471 }
 472
 473 c_encrypt () { k_encrypt "$@"; }
 474 c_decrypt () {
 475   if k_decrypt "$@" >$tmp/plain; then cat $tmp/plain
 476   else return $?
 477   fi
 478 }
 479 c_sign () { k_sign "$@"; }
 480 c_verify () { k_verify "$@"; }
 481
 482 ## Stub implementations.
 483 notsupp () { op=$1; echo >&2 "$quis: operation \`$op' not supported"; }
 484 k_info () { :; }
 485 k_import () { :; }
 486 k_encrypt () { notsupp encrypt; }
 487 k_decrypt () { notsupp decrypt; }
 488 k_sign () { notsupp sign; }
 489 k_verify () { notsupp verify; }
 490
 491 prepare () {
 492   key=$1 op=$2
 493   ## Prepare for a crypto operation OP, using the KEY.  This validates the
 494   ## key label, reads the profile, and checks the access-control list.  If OP
 495   ## is `-' then allow the operation unconditionally.
 496
 497   ## Find the key properties.
 498   parse_keylabel "$key"
 499   if [ ! -d $kdir ]; then echo >&2 "$quis: unknown key \`$key'"; exit 1; fi
 500   readmeta $kdir
 501   read_profile $kowner "$profile"
 502
 503   ## Check whether we're allowed to do this thing.  This is annoyingly
 504   ## fiddly.
 505   case $op in -) return ;; esac
 506   eval acl=\${kprop_acl_$op-!owner}
 507   verdict=forbid
 508   while :; do
 509
 510     ## Remove leading whitespace.
 511     while :; do
 512       case "$acl" in
 513         [[:space:]]*) acl=${acl#?} ;;
 514         *) break ;;
 515       esac
 516     done
 517
 518     ## If there's nothing left, leave.
 519     case "$acl" in ?*) ;; *) break ;; esac
 520
 521     ## Split off the leading word.
 522     case "$acl" in
 523       *[[:space:]]*) word=${acl%%[[:space:]]*} acl=${acl#*[[:space:]]} ;;
 524       *) word=$acl acl="" ;;
 525     esac
 526
 527     ## See what sense it has if it matches.
 528     case "$word" in
 529       -*) sense=forbid rest=${word#-} ;;
 530       *) sense=allow rest=$word ;;
 531     esac
 532
 533     ## See whether the calling user matches.
 534     case "$rest" in
 535       !owner) pat=$kowner list=$USERV_USER ;;
 536       !*) echo >&2 "$quis: unknown ACL token \`$word'" ;;
 537       %*) pat=${rest#%} list="$USERV_GROUP $USERV_GID" ;;
 538       *) pat=$rest list="$USERV_USER $USERV_UID" ;;
 539     esac
 540     matchp=nil
 541     for i in $list; do case "$i" in $pat) matchp=t; break ;; esac; done
 542     case $matchp in t) verdict=$sense; break ;; esac
 543   done
 544
 545   case $verdict in
 546     forbid) echo >&2 "$quis: $op access to key \`$key' forbidden"; exit 1 ;;
 547   esac
 548 }
 549
 550 ###--------------------------------------------------------------------------
 551 ### Crypto operations for infrastructure purposes.
 552
 553 c_sysprofile () {
 554   profile=$1
 555   ## Select the profile in FILE for future crypto operations.
 556
 557   unset $(set | sed -n '/^kprop_/s/=.*$//p')
 558   reqtmp
 559   getsysprofile "$profile" >$tmp/profile
 560   readprops $tmp/profile
 561 }
 562
 563 c_gensyskey () {
 564   profile=$1 kdir=$2 knub=$3; shift 3
 565   ## Generate a system key using PROFILE; store the data in KDIR and the nub
 566   ## in KNUB.  Remaining arguments are options.
 567
 568   c_sysprofile "$profile"
 569   c_genkey "$profile" "$kdir" "$knub" : "$@"
 570 }
 571
 572 c_sysprepare () {
 573   kdir=$1
 574   readmeta "$kdir"
 575   c_sysprofile "$profile"
 576 }
 577
 578 c_sysop () {
 579   op=$1 kdir=$2; shift 1
 580   c_sysprepare "$kdir"
 581   c_$op "$@"
 582 }
 583
 584 c_sysencrypt () { c_sysop encrypt "$1" /dev/null; }
 585 c_sysdecrypt () { c_sysop decrypt "$1" "$2"; }
 586 c_syssign () { c_sysop sign "$1" "$2"; }
 587 c_sysverify () { c_sysop verify "$1" /dev/null; }
 588
 589 ###--------------------------------------------------------------------------
 590 ### Recovery operations.
 591
 592 sharethresh () {
 593   pf=$1
 594   ## Return the sharing threshold from the parameter file PARAM.
 595
 596   read param <"$pf"
 597   case "$param" in
 598     shamir-params:*) ;;
 599     *)
 600       echo >&2 "$quis: secret sharing parameter file damaged (wrong header)"
 601       exit 1
 602       ;;
 603   esac
 604   t=";${param#*:}"
 605   case "$t" in
 606     *";t="*) ;;
 607     *)
 608       echo >&2 "$quis: secret sharing parameter file damaged (missing t)"
 609       exit 1
 610       ;;
 611   esac
 612   t=${t#*;t=}
 613   t=${t%%;*}
 614   echo "$t"
 615 }
 616
 617 stash () {
 618   recov=$1 label=$2
 619   ## Stash a copy of stdin encrypted under the recovery key RECOV, with a
 620   ## given LABEL.
 621   checkword "recovery key label" "$recov"
 622   checklabel "secret" "$label"
 623
 624   rdir=$KEYS/recov/$recov/current
 625   if [ ! -d $rdir/store ]; then
 626     echo >&2 "$quis: unknown recovery key \`$recov'"
 627     exit 1
 628   fi
 629   case $label in */*) mkdir -m755 -p $rdir/${label%/*} ;; esac
 630   (c_sysencrypt $rdir/store >$rdir/$label.new)
 631   mv $rdir/$label.new $rdir/$label.recov
 632 }
 633
 634 recover () {
 635   recov=$1 inst=$2 label=$3
 636   ## Recover a stashed secret, protected by RECOV and stored as LABEL, and
 637   ## write it to stdout.
 638   checkword "recovery key label" "$recov"
 639   checkword "recovery instance" "$inst"
 640   checklabel "secret" "$label"
 641
 642   rdir=$KEYS/recov/$recov/$inst
 643   if [ ! -f $rdir/$label.recov ]; then
 644     echo >&2 "$quis: recovery key \`$recov/$inst' has no blob for \`$label'"
 645     exit 1
 646   fi
 647   reqsafe
 648   tag=$recov.$inst
 649   nub=$SAFE/keys.reveal/$tag/nub
 650   if [ ! -f $nub ]; then
 651     echo >&2 "$quis: recovery key \`$recov/$inst' not revealed"
 652     exit 1;
 653   fi
 654   mktmp
 655   c_sysdecrypt $rdir/store $nub <$rdir/$label.recov
 656 }
 657
 658 ###--------------------------------------------------------------------------
 659 ### Help text.
 660
 661 defhelp () {
 662   read umsg
 663   usage=$umsg
 664   help=$(cat)
 665   case "$KEYS_HELP" in t) help; exit ;; esac
 666 }
 667
 668 help () { showhelp; }
 669 showhelp () {
 670   cat <<EOF
 671 Usage: $quis${usage:+ $usage}
 672
 673 $help
 674 EOF
 675 }
 676
 677 usage () {
 678   : ${cmdargs=$usage}
 679   echo "usage: $quis${cmdname:+ $cmdname}${cmdargs:+ $cmdargs}"
 680 }
 681 usage_err () { usage >&2; exit 1; }
 682
 683 ###--------------------------------------------------------------------------
 684 ### Subcommand handling.
 685
 686 version () {
 687   echo "$quis, $PACKAGE version $VERSION"
 688 }
 689
 690 unset cmdargs
 691 unset cmdname
 692 cmds=""
 693 defcmd () {
 694   cmd=$1; shift; args=$*
 695   help=$(cat)
 696   eval help_$cmd=\$help
 697   cmds="${cmds:+$cmds
 698 }$cmd $args"
 699 }
 700
 701 defcmd help "[COMMAND ...]" <<EOF
 702 Show help about the COMMANDs, or about $quis if none are named.
 703 EOF
 704 cmd_help () {
 705   rc=0
 706   version
 707   case $# in
 708     0)
 709       cat <<EOF
 710
 711 Usage: $quis${usage:+ $usage}
 712
 713 Options:
 714   -h            Show this help text.
 715   -v            Show the program version number.
 716
 717 Commands provided:
 718 EOF
 719       while read cmd args; do echo "    $cmd${args:+ $args}"; done <<EOF
 720 $cmds
 721 EOF
 722       case ${prefix+t} in
 723         t)
 724           cd $KEYSLIB
 725           for i in $prefix.*; do
 726             if [ ! -x "$i" ]; then continue; fi
 727             sed -n "/<<HELP/{n;s/^/     ${i#$prefix.} /;p;q;}" "$i"
 728           done
 729           ;;
 730       esac
 731       ;;
 732     *)
 733       for cmd in "$@"; do
 734         echo
 735         foundp=nil
 736         while read cmdname cmdargs; do
 737           case $cmdname in "$cmd") foundp=t; break ;; esac
 738         done <<EOF
 739 $cmds
 740 EOF
 741         case $foundp in
 742           t)
 743             usage; echo
 744             eval help=\$help_$cmdname; echo "$help"
 745             ;;
 746           nil)
 747             if [ ! -x "$KEYSLIB/$prefix.$cmd" ]; then
 748               echo >&2 "$quis: unrecognized command \`$cmd'"
 749               rc=1
 750               continue
 751             elif ! KEYS_HELP=t "$KEYSLIB/$prefix.$cmd"; then
 752               rc=1
 753             fi
 754             ;;
 755         esac
 756       done
 757       ;;
 758   esac
 759   return $rc
 760 }
 761
 762 dispatch () {
 763   case $# in 0) usage_err ;; esac
 764   cmd=$1; shift
 765   foundp=nil
 766   while read cmdname cmdargs; do
 767     case $cmdname in "$cmd") foundp=t; break ;; esac
 768   done <<EOF
 769 $cmds
 770 EOF
 771   case $foundp in
 772     t)
 773       OPTIND=1
 774       cmd_$cmdname "$@"
 775       ;;
 776     nil)
 777       if [ ! -x "$KEYSLIB/$prefix.$cmd" ]; then
 778         echo >&2 "$quis: unrecognized command \`$cmd'"
 779         exit 1
 780       fi
 781       unset KEYS_HELP
 782       exec "$KEYSLIB/$prefix.$cmd" "$@"
 783       ;;
 784   esac
 785 }
 786
 787 ###----- That's all, folks --------------------------------------------------