Provided by: chase_0.5.2-4build2_amd64 bug


       chase - chase symbolic links


       chase  [  --verbose  |  --from-file  | -f | --null | -0 | --loop-warn-threshold COUNT | -w
       COUNT | --loop-fail-threshold COUNT | -l COUNT | --disable-loop-detection | -D ] [file...]

       chase -v | --version

       chase -h | --help


       Chase is a small utility that tracks down the name  of  the  actual  file  that  is  truly
       accessed, when one hits a symbolic link.  It chases the link, so to speak.

       In  normal  operation,  you  give chase a name of an existing file.  The program will then
       show you (or, more accurately, print to the standard output stream) the name of  the  real
       file  that  the original file referred to.  It does not matter if you give the program the
       name of a regular file; chase will just give you the same name back.   You  can  give  the
       utility  the  option --verbose, in order to have it be more verbose in its operation.  You
       can also give the program a list of files from which it will read the  file  names  to  be
       chased (see the option --from-file).

       I'll  give  you  a  good  example  of a case where chase is useful.  In a Debian GNU/Linux
       system, software installation is handled by the program dpkg(8).  There is a way to  query
       dpkg(8),  which  package  a  file  belongs  to.  Unfortunately, this does not not grok all
       symlinks.  This is a problem, since the Debian system uses symbolic links extensively  for
       handling  several flavours of a program (say, XEmacs and GNU Emacs and the versions 19 and
       20 of both).  Now with chase, one can determine the real file easily and then  using  this
       result as an argument to dpkg(8).  Observe:

       ajk@ugh:~$ dpkg -S `which xemacs20`
       dpkg: /usr/bin/xemacs20 not found.
       ajk@ugh:~$ dpkg -S `which xemacs20 | xargs chase`
       xemacs20-nomule: /usr/bin/xemacs-20.4-nomule

       When given multiple file names as arguments, chase will chase every one of them in order.


       The following options are recognized by chase:

              Chat about what is being done.

       -f, --from-file
              Treat  the  file  names  on the command line as sources for names to be chased.  If
              this option is present, chase will read in each of the files given on  the  command
              line  (both  a sole dash "-" and the absence of file names will be taken as meaning
              the standard input stream).  Each line in the files is taken  as  a  verbatim  file
              name  that  will  be  chased  like  it  had been given on the command line of a run
              without this option.   There  is  no  means  for  quoting  the  newline  character;
              therefore  only  file  names  that do not contain newlines can be specified via the
              files.  This restriction is lifted by the  -0  option,  though.   However,  literal
              spaces are preserved and are not interpreted as special.

       -0, --null
              This  option  implies  the  option  -f, which reads file names from a file.  The -0
              option modifies the behavior -f so that instead of treating lines in  the  file  as
              file  names,  the file names are expected to be separated by null characters.  This
              allows for specifying file names with newlines in them with -f.

       -w WCOUNT, --loop-warn-threshold=WCOUNT

       -l LCOUNT, --loop-fail-threshold=LCOUNT
              Set the threshold for warning about  a  possible  symlink  loop  (WCOUNT)  and  for
              failing  because of one (LCOUNT).  There are default values, which you can find out
              by invoking chase with the  argument  --help.   Using  zero  as  WCOUNT  or  LCOUNT
              disables the check.

       -D, --disable-loop-detection
              Normally  chase  keeps  a  record  of  all symlinks it has visited when chasing the
              current file.  It uses this record to  reliably  detect  symlink  loops.   However,
              checking  the  record slows the process a little (more for long chains of symlinks)
              and the record requires  a  small  amount  of  memory  (more  for  long  chains  of
              symlinks), so it may be desirable in some cases to inhibit this check.  This option
              disables this loop detection and the  associated  recording  of  visited  symlinks.
              When  this option is in effect (assuming no bugs in the related code) chase runs in
              constant space and linear time  relative  to  the  length  of  the  symlink  chains

       -h, --help
              Output a usage summary and exit successfully.

       -v, --version
              Show version information and exit successfully.


       The exit status is 0 if and only if all files given in the command lines exist and none of
       them are dangling symlinks.

       The following messages are emitted by chase when it suspects or detects a symlink loop:

       quite many symlink hops, hope we're not looping...
              This means that the chain of symlinks is longer than a given threshold.   This  may
              mean  that  the  chain  is  infinite  (and  thus  contains  a loop somewhere).  The
              threshold can be specified by using the --loop-warn-threshold command line option.

       too many symlink hops, giving up...
              This means that the chain of symlinks is  longer  than  a  given  threshold.   This
              usually means that the chain is infinite (and thus contains a loop somewhere).  The
              threshold can be specified by using the --loop-fail-threshold command line  option.
              If you see this message, it means that chase has given up on that file.

       symlink loop detected, giving up...
              The symlink chain is looping and therefore there is no result for the chase.  Chase
              has given up on that file.

       Additionally, Chase emits several error messages under problematic conditions.   They  all
       come  from  the system libraries, so the program has no control over the actual wording of
       the messages.  They all follow the format "program name: file name: error message",  where
       file name is the name of the offending file or directory.


       Chase  may  have  bugs.  If  you  find  them,  please report them to <> or
       preferably via the Debian bugtracking system.


       Chase has been written by Antti-Juhani Kaijanaho <> and is currently maintained
       by Andreas Rottmann <>.


       find(1), ln(1), namei(1), readlink(1), readlink(2), symlinks(1)