3 # Copyright (c) 2010 Gordon Tetlow
6 # Redistribution and use in source and binary forms, with or without
7 # modification, are permitted provided that the following conditions
9 # 1. Redistributions of source code must retain the above copyright
10 # notice, this list of conditions and the following disclaimer.
11 # 2. Redistributions in binary form must reproduce the above copyright
12 # notice, this list of conditions and the following disclaimer in the
13 # documentation and/or other materials provided with the distribution.
15 # THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 # IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 # ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 # OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 # OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 # Usage: add_to_manpath path
30 # Adds a variable to manpath while ensuring we don't have duplicates.
31 # Returns true if we were able to add something. False otherwise.
34 *:$1) decho " Skipping duplicate manpath entry $1" 2 ;;
35 $1:*) decho " Skipping duplicate manpath entry $1" 2 ;;
36 *:$1:*) decho " Skipping duplicate manpath entry $1" 2 ;;
37 *) if [ -d "$1" ]; then
38 decho " Adding $1 to manpath"
48 # Usage: build_manlocales
49 # Builds a correct MANLOCALES variable.
51 # If the user has set manlocales, who are we to argue.
52 if [ -n "$MANLOCALES" ]; then
59 MANLOCALES=${manlocales#:}
61 decho "Available manual locales: $MANLOCALES"
64 # Usage: build_manpath
65 # Builds a correct MANPATH variable.
69 # If the user has set a manpath, who are we to argue.
70 if [ -n "$MANPATH" ]; then
76 decho "Adding default manpath entries"
78 for path in $man_default_path; do
79 add_to_manpath "$path"
88 decho "Using manual path: $MANPATH"
91 # Usage: check_cat catglob
92 # Checks to see if a cat glob is available.
97 setup_cattool $catpage
98 decho " Found catpage $catpage"
105 # Usage: check_man manglob catglob
106 # Given 2 globs, figures out if the manglob is available, if so, check to
107 # see if the catglob is also available and up to date.
110 # We have a match, check for a cat page
112 setup_cattool $manpage
113 decho " Found manpage $manpage"
115 if [ -n "${use_width}" ]; then
118 decho " Skipping catpage: non-standard page width"
119 elif exists "$2" && is_newer $found $manpage; then
120 # cat page found and is newer, use that
123 setup_cattool $catpage
124 decho " Using catpage $catpage"
126 # no cat page or is older
128 decho " Skipping catpage: not found or old"
136 # Usage: decho "string" [debuglevel]
137 # Echoes to stderr string prefaced with -- if high enough debuglevel.
139 if [ $debug -ge ${2:-1} ]; then
145 # Returns true if glob resolves to a real file.
149 # Don't accidentally inherit callers IFS (breaks perl manpages)
152 # Use some globbing tricks in the shell to determine if a file
158 if [ "$1" != "$2" -a -r "$2" ]; then
166 # Usage: find_file path section subdir pagename
167 # Returns: true if something is matched and found.
168 # Search the given path/section combo for a given page.
170 local manroot catroot mann man0 catn cat0
175 manroot="$manroot/$3"
176 catroot="$catroot/$3"
179 if [ ! -d "$manroot" ]; then
182 decho " Searching directory $manroot" 2
184 mann="$manroot/$4.$2*"
185 man0="$manroot/$4.0*"
186 catn="$catroot/$4.$2*"
187 cat0="$catroot/$4.0*"
189 # This is the behavior as seen by the original man utility.
190 # Let's not change that which doesn't seem broken.
191 if check_man "$mann" "$catn"; then
193 elif check_man "$man0" "$cat0"; then
195 elif check_cat "$catn"; then
197 elif check_cat "$cat0"; then
204 # Usage: is_newer file1 file2
205 # Returns true if file1 is newer than file2 as calculated by mtime.
207 if ! [ "$1" -ot "$2" ]; then
208 decho " mtime: $1 not older than $2" 3
211 decho " mtime: $1 older than $2" 3
216 # Usage: manpath_parse_args "$@"
217 # Parses commandline options for manpath.
218 manpath_parse_args() {
221 while getopts 'Ldq' cmd_arg; do
224 d) debug=$(( $debug + 1 )) ;;
231 # Usage: manpath_usage
232 # Display usage for the manpath(1) utility.
234 echo 'usage: manpath [-Ldq]' >&2
238 # Usage: manpath_warnings
239 # Display some warnings to stderr.
241 if [ -z "$Lflag" -a -n "$MANPATH" ]; then
242 echo "(Warning: MANPATH environment variable set)" >&2
245 if [ -n "$Lflag" -a -n "$MANLOCALES" ]; then
246 echo "(Warning: MANLOCALES environment variable set)" >&2
250 # Usage: man_check_for_so page path
251 # Returns: True if able to resolve the file, false if it ended in tears.
252 # Detects the presence of the .so directive and causes the file to be
253 # redirected to another source file.
259 # We need to loop to accommodate multiple .so directives.
262 line=$($cattool $manpage | head -1)
264 .so*) trim "${line#.so}"
265 decho "$manpage includes $tstr"
266 # Glob and check for the file.
267 if ! check_man "$path/$tstr*" ""; then
268 decho " Unable to find $tstr"
280 local IFS pipeline preconv_enc testline
282 # We are called with IFS set to colon. This causes really weird
283 # things to happen for the variables that have spaces in them.
286 # If we are supposed to use a catpage and we aren't using troff(1)
287 # just zcat the catpage and we are done.
288 if [ -z "$tflag" -a -n "$use_cat" ]; then
289 if [ -n "$wflag" ]; then
290 echo "$catpage (source: $manpage)"
293 if [ $debug -gt 0 ]; then
294 decho "Command: $cattool $catpage | $MANPAGER"
297 eval "$cattool $catpage | $MANPAGER"
304 # Okay, we are using the manpage, do we just need to output the
305 # name of the manpage?
306 if [ -n "$wflag" ]; then
314 case "$man_charset" in
315 ISO8859-1) preconv_enc="latin-1" ;;
316 ISO8859-15) preconv_enc="latin-1" ;;
317 UTF-8) preconv_enc="utf-8" ;;
322 if [ -n "$preconv_enc" ]; then
323 pipeline="preconv -e $preconv_enc |"
325 testline="$pipeline mandoc -Tlint -Werror 2>/dev/null"
326 pipeline="$pipeline mandoc -Tlocale | $MANPAGER"
328 if ! eval "$cattool $manpage | $testline" ;then
329 if which -s groff2; then
330 man_display_page_groff
332 echo "This manpage needs groff(1) to be rendered" >&2
333 echo "First install groff(1): " >&2
334 echo "pkg install groff " >&2
340 if [ $debug -gt 0 ]; then
341 decho "Command: $cattool $manpage | $pipeline"
344 eval "$cattool $manpage | $pipeline"
349 # Usage: man_display_page
350 # Display either the manpage or catpage depending on the use_cat variable
351 man_display_page_groff() {
352 local EQN NROFF PIC TBL TROFF REFER VGRIND
353 local IFS l nroff_dev pipeline preproc_arg tool
355 # So, we really do need to parse the manpage. First, figure out the
356 # device flag (-T) we have to pass to eqn(1) and groff(1). Then,
357 # setup the pipeline of commands based on the user's request.
359 # If the manpage is from a particular charset, we need to setup nroff
360 # to properly output for the correct device.
363 # I don't pretend to know this; I'm just copying from the
364 # previous version of man(1).
365 case "$man_charset" in
366 KOI8-R) nroff_dev="koi8-r" ;;
367 ISO8859-1) nroff_dev="latin1" ;;
368 ISO8859-15) nroff_dev="latin1" ;;
369 UTF-8) nroff_dev="utf8" ;;
370 *) nroff_dev="ascii" ;;
373 NROFF="$NROFF -T$nroff_dev"
374 EQN="$EQN -T$nroff_dev"
376 # Iff the manpage is from the locale and not just the charset,
377 # then we need to define the locale string.
379 */${man_lang}_${man_country}.${man_charset}/*)
380 NROFF="$NROFF -dlocale=$man_lang.$man_charset"
382 */${man_lang}.${man_charset}/*)
383 NROFF="$NROFF -dlocale=$man_lang.$man_charset"
387 # Allow language specific calls to override the default
389 l=$(echo $man_lang | tr [:lower:] [:upper:])
390 for tool in EQN NROFF PIC TBL TROFF REFER VGRIND; do
391 eval "$tool=\${${tool}_$l:-\$$tool}"
394 *) NROFF="$NROFF -Tascii"
399 if [ -z "$MANCOLOR" ]; then
403 if [ -n "${use_width}" ]; then
404 NROFF="$NROFF -rLL=${use_width}n -rLT=${use_width}n"
407 if [ -n "$MANROFFSEQ" ]; then
409 while getopts 'egprtv' preproc_arg; do
410 case "${preproc_arg}" in
411 e) pipeline="$pipeline | $EQN" ;;
412 g) ;; # Ignore for compatibility.
413 p) pipeline="$pipeline | $PIC" ;;
414 r) pipeline="$pipeline | $REFER" ;;
415 t) pipeline="$pipeline | $TBL" ;;
416 v) pipeline="$pipeline | $VGRIND" ;;
420 # Strip the leading " | " from the resulting pipeline.
421 pipeline="${pipeline#" | "}"
426 if [ -n "$tflag" ]; then
427 pipeline="$pipeline | $TROFF"
429 pipeline="$pipeline | $NROFF | $MANPAGER"
432 if [ $debug -gt 0 ]; then
433 decho "Command: $cattool $manpage | $pipeline"
436 eval "$cattool $manpage | $pipeline"
441 # Usage: man_find_and_display page
442 # Search through the manpaths looking for the given page.
443 man_find_and_display() {
444 local found_page locpath p path sect
446 # Check to see if it's a file. But only if it has a '/' in
449 */*) if [ -f "$1" -a -r "$1" ]; then
450 decho "Found a usable page, displaying that"
453 setup_cattool $manpage
454 if man_check_for_so $manpage $(dirname $manpage); then
464 for sect in $MANSECT; do
465 decho "Searching section $sect" 2
466 for path in $MANPATH; do
467 for locpath in $locpaths; do
469 p=${p%/.} # Rid ourselves of the trailing /.
471 # Check if there is a MACHINE specific manpath.
472 if find_file $p $sect $MACHINE "$1"; then
473 if man_check_for_so $manpage $p; then
476 if [ -n "$aflag" ]; then
484 # Check if there is a MACHINE_ARCH
486 if find_file $p $sect $MACHINE_ARCH "$1"; then
487 if man_check_for_so $manpage $p; then
490 if [ -n "$aflag" ]; then
498 # Check plain old manpath.
499 if find_file $p $sect '' "$1"; then
500 if man_check_for_so $manpage $p; then
503 if [ -n "$aflag" ]; then
515 # Nothing? Well, we are done then.
516 if [ -z "$found_page" ]; then
517 echo "No manual entry for $1" >&2
523 # Usage: man_parse_args "$@"
524 # Parses commandline options for man.
528 while getopts 'M:P:S:adfhkm:op:tw' cmd_arg; do
530 M) MANPATH=$OPTARG ;;
531 P) MANPAGER=$OPTARG ;;
532 S) MANSECT=$OPTARG ;;
534 d) debug=$(( $debug + 1 )) ;;
540 p) MANROFFSEQ=$OPTARG ;;
547 shift $(( $OPTIND - 1 ))
549 # Check the args for incompatible options.
550 case "${fflag}${kflag}${tflag}${wflag}" in
551 fflagkflag*) echo "Incompatible options: -f and -k"; man_usage ;;
552 fflag*tflag*) echo "Incompatible options: -f and -t"; man_usage ;;
553 fflag*wflag) echo "Incompatible options: -f and -w"; man_usage ;;
554 *kflagtflag*) echo "Incompatible options: -k and -t"; man_usage ;;
555 *kflag*wflag) echo "Incompatible options: -k and -w"; man_usage ;;
556 *tflagwflag) echo "Incompatible options: -t and -w"; man_usage ;;
559 # Short circuit for whatis(1) and apropos(1)
560 if [ -n "$fflag" ]; then
565 if [ -n "$kflag" ]; then
571 for sect in $man_default_sections; do
572 if [ "$sect" = "$1" ]; then
573 decho "Detected manual section as first arg: $1"
585 # Setup various trivial but essential variables.
587 # Setup machine and architecture variables.
588 if [ -n "$mflag" ]; then
589 MACHINE_ARCH=${mflag%%:*}
592 if [ -z "$MACHINE_ARCH" ]; then
593 MACHINE_ARCH=$($SYSCTL -n hw.machine_arch)
595 if [ -z "$MACHINE" ]; then
596 MACHINE=$($SYSCTL -n hw.machine)
598 decho "Using architecture: $MACHINE_ARCH:$MACHINE"
602 # Setup manual sections to search.
603 if [ -z "$MANSECT" ]; then
604 MANSECT=$man_default_sections
606 decho "Using manual sections: $MANSECT"
613 # Usage: man_setup_width
621 if [ "$MANWIDTH" -gt 0 2>/dev/null ]; then
626 if { sizes=$($STTY size 0>&3 2>/dev/null); } 3>&1; then
628 if [ $2 -gt 80 ]; then
634 if [ -n "$use_width" ]; then
635 decho "Using non-standard page width: ${use_width}"
637 decho 'Using standard page width'
641 # Usage: man_setup_locale
642 # Setup necessary locale variables.
647 man_charset='US-ASCII'
649 # Setup locale information.
650 if [ -n "$oflag" ]; then
651 decho 'Using non-localized manpages'
653 # Use the locale tool to give us the proper LC_CTYPE
659 [a-z][a-z]_[A-Z][A-Z]\.*)
660 lang_cc="${LC_CTYPE%.*}"
661 man_lang="${LC_CTYPE%_*}"
662 man_country="${lang_cc#*_}"
663 man_charset="${LC_CTYPE#*.}"
665 locpaths="$locpaths:$man_lang.$man_charset"
666 if [ "$man_lang" != "en" ]; then
667 locpaths="$locpaths:en.$man_charset"
669 locpaths="$locpaths:."
671 *) echo 'Unknown locale, assuming C' >&2
676 decho "Using locale paths: $locpaths"
679 # Usage: man_usage [exitcode]
680 # Display usage for the man utility.
683 echo ' man [-adho] [-t | -w] [-M manpath] [-P pager] [-S mansect]'
684 echo ' [-m arch[:machine]] [-p [eprtv]] [mansect] page [...]'
685 echo ' man -f page [...] -- Emulates whatis(1)'
686 echo ' man -k page [...] -- Emulates apropos(1)'
688 # When exit'ing with -h, it's not an error.
692 # Usage: parse_configs
693 # Reads the end-user adjustable config files.
697 if [ -n "$parsed_configs" ]; then
703 # Read the global config first in case the user wants
704 # to override config_local.
705 if [ -r "$config_global" ]; then
706 parse_file "$config_global"
709 # Glob the list of files to parse.
711 files=$(echo $config_local)
714 for file in $files; do
715 if [ -r "$file" ]; then
723 # Usage: parse_file file
724 # Reads the specified config files.
726 local file line tstr var
729 decho "Parsing config file: $file"
733 \#*) decho " Comment" 3
735 MANPATH*) decho " MANPATH" 3
736 trim "${line#MANPATH}"
737 add_to_manpath "$tstr"
739 MANLOCALE*) decho " MANLOCALE" 3
740 trim "${line#MANLOCALE}"
741 manlocales="$manlocales:$tstr"
743 MANCONFIG*) decho " MANCONFIG" 3
744 trim "${line#MANCONFIG}"
747 # Set variables in the form of FOO_BAR
748 *_*[\ \ ]*) var="${line%%[\ \ ]*}"
750 eval "$var=\"$tstr\""
751 decho " Parsed $var" 3
758 # Traverse $PATH looking for manpaths.
762 decho "Searching PATH for man directories"
765 for path in $PATH; do
766 # Do a little special casing since the base manpages
767 # are in /usr/share/man instead of /usr/man or /man.
769 /bin|/usr/bin) add_to_manpath "/usr/share/man" ;;
770 *) if add_to_manpath "$path/man"; then
772 elif add_to_manpath "$path/MAN"; then
776 */bin) p="${path%/bin}/man"
787 if [ -z "$manpath" ]; then
788 decho ' Unable to find any manpaths, using default'
789 manpath=$man_default_path
793 # Usage: search_whatis cmd [arglist]
794 # Do the heavy lifting for apropos/whatis
796 local IFS bad cmd f good key keywords loc opt out path rval wlist
801 whatis_parse_args "$@"
807 if [ "$cmd" = "whatis" ]; then
814 for path in $MANPATH; do
815 if [ \! -d "$path" ]; then
816 decho "Skipping non-existent path: $path" 2
820 if [ -f "$path/$f" -a -r "$path/$f" ]; then
821 decho "Found whatis: $path/$f"
822 wlist="$wlist $path/$f"
825 for loc in $MANLOCALES; do
826 if [ -f "$path/$loc/$f" -a -r "$path/$loc/$f" ]; then
827 decho "Found whatis: $path/$loc/$f"
828 wlist="$wlist $path/$loc/$f"
834 if [ -z "$wlist" ]; then
835 echo "$cmd: no whatis databases in $MANPATH" >&2
840 for key in $keywords; do
841 out=$(grep -Ehi $opt -- "$key" $wlist)
842 if [ -n "$out" ]; then
845 bad="$bad\\n$key: nothing appropriate"
850 # Strip leading carriage return.
854 if [ -n "$good" ]; then
855 echo -e "$good" | $MANPAGER
858 if [ -n "$bad" ]; then
865 # Usage: setup_cattool page
866 # Finds an appropriate decompressor based on extension
869 *.bz) cattool='/usr/bin/bzcat' ;;
870 *.bz2) cattool='/usr/bin/bzcat' ;;
871 *.gz) cattool='/usr/bin/zcat' ;;
872 *.lzma) cattool='/usr/bin/lzcat' ;;
873 *.xz) cattool='/usr/bin/xzcat' ;;
874 *) cattool='/usr/bin/zcat -f' ;;
879 # Correctly sets $MANPAGER
882 if [ -z "$MANPAGER" ]; then
883 if [ -n "$MANCOLOR" ]; then
886 if [ -n "$PAGER" ]; then
893 decho "Using pager: $MANPAGER"
897 # Trims whitespace from beginning and end of a variable
902 [\ \ ]*) tstr="${tstr##[\ \ ]}" ;;
903 *[\ \ ]) tstr="${tstr%%[\ \ ]}" ;;
909 # Usage: whatis_parse_args "$@"
910 # Parse commandline args for whatis and apropos.
911 whatis_parse_args() {
913 while getopts 'd' cmd_arg; do
915 d) debug=$(( $debug + 1 )) ;;
920 shift $(( $OPTIND - 1 ))
925 # Usage: whatis_usage
926 # Display usage for the whatis/apropos utility.
928 echo "usage: $cmd [-d] keyword [...]"
936 search_whatis apropos "$@"
941 if [ -z "$pages" ]; then
942 echo 'What manual page do you want?' >&2
947 for page in $pages; do
948 decho "Searching for $page"
949 man_find_and_display "$page"
956 manpath_parse_args "$@"
957 if [ -z "$qflag" ]; then
960 if [ -n "$Lflag" ]; then
971 search_whatis whatis "$@"
974 # User's PATH setting decides on the groff-suite to pick up.
976 NROFF='groff -S -P-h -Wall -mtty-char -man'
980 TROFF='groff -S -man'
983 LOCALE=/usr/bin/locale
988 man_default_sections='1:8:2:3:n:4:5:6:7:9:l'
989 man_default_path='/usr/share/man:/usr/share/openssl/man:/usr/local/man'
990 cattool='/usr/bin/zcat -f'
992 config_global='/etc/man.conf'
994 # This can be overridden via a setting in /etc/man.conf.
995 config_local='/usr/local/etc/man.d/*.conf'
997 # Set noglobbing for now. I don't want spurious globbing.
1001 *apropos) do_apropos "$@" ;;
1002 *manpath) do_manpath "$@" ;;
1003 *whatis) do_whatis "$@" ;;