home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 15 / hacker15 / 15_H4CK3R#15.ISO / linux_security / engarde / ENGARDE_COMMUNITY_FEINT.ISO / etc / bash_completion next >
Encoding:
Text File  |  2002-05-30  |  29.5 KB  |  1,138 lines
  1. #   bash_completion - some programmable completion functions for bash 2.04
  2. #
  3. #   <![CDATA[
  4. #
  5. #   $Id: bash_completion,v 1.13 2001/01/11 00:09:48 ianmacd Exp $
  6. #
  7. #   Copyright (C) Ian Macdonald <ian@caliban.org>
  8. #                <ian@linuxcare.com>
  9. #
  10. #   This program is free software; you can redistribute it and/or modify
  11. #   it under the terms of the GNU General Public License as published by
  12. #   the Free Software Foundation; either version 2, or (at your option)
  13. #   any later version.
  14. #
  15. #   This program is distributed in the hope that it will be useful,
  16. #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. #   GNU General Public License for more details.
  19. #
  20. #   You should have received a copy of the GNU General Public License
  21. #   along with this program; if not, write to the Free Software Foundation,
  22. #   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23.  
  24. # Turn on extended globbing and programmable completion
  25. shopt -s extglob progcomp
  26.  
  27. # A lot of the following one-liners were taken directly from the
  28. # completion examples provided with the bash 2.04 source distribution
  29.  
  30. # Make directory commands see only directories
  31. complete -d cd mkdir rmdir pushd
  32.  
  33. # Make file commands see only files
  34. complete -f cat less more ln strip
  35. complete -f -X '*.bz2' bzip2
  36. complete -f -X '!*.bz2' bunzip2
  37. complete -f -X '!*.zip' unzip
  38. complete -f -X '*.gz' gzip
  39. complete -f -X '*.Z' compress
  40. complete -f -X '!*.+(Z|gz|tgz|Gz)' gunzip zcat zmore
  41. complete -f -X '!*.Z' uncompress zmore zcat
  42. complete -f -X '!*.+(gif|jpg|jpeg|GIF|JPG|bmp)' ee xv
  43. complete -f -X '!*.+(ps|PS|ps.gz)' gv
  44. complete -f -X '!*.+(dvi|DVI)' dvips xdvi dviselect dvitype
  45. complete -f -X '!*.+(pdf|PDF)' acroread xpdf
  46. complete -f -X '!*.texi*' makeinfo texi2dvi texi2html
  47. complete -f -X '!*.+(tex|TEX)' tex latex slitex
  48.  
  49. # kill sees only signals
  50. complete -A signal kill -P '%'
  51.  
  52. # user commands see only users
  53. complete -u finger su usermod userdel passwd
  54.  
  55. # bg completes with stopped jobs
  56. complete -A stopped -P '%' bg
  57.  
  58. # other job commands
  59. complete -j -P '%' fg jobs disown
  60.  
  61. # network commands complete with hostname
  62. complete -A hostname ssh rsh telnet rlogin ftp ping fping host traceroute \
  63.         nslookup
  64.  
  65. # export and others complete with shell variables
  66. complete -v export local readonly unset
  67.  
  68. # set completes with set options
  69. complete -A setopt set
  70.  
  71. # shopt completes with shopt options
  72. complete -A shopt shopt
  73.  
  74. # helptopics
  75. complete -A helptopic help
  76.  
  77. # unalias completes with aliases
  78. complete -a unalias
  79.  
  80. # various commands complete with commands
  81. complete -c command type nohup exec nice eval strace gdb sudo
  82.  
  83. # bind completes with readline bindings (make this more intelligent)
  84. complete -A binding bind
  85.  
  86. # Now we get to the meat of the file, the functions themselves. Some
  87. # of these are works in progress. Most assume GNU versions of the
  88. # tools in question and may require modifications for use on vanilla
  89. # UNIX systems.
  90. #
  91. # A couple of functions may have non-portable, Linux specific code in
  92. # them, but this will be noted where applicable
  93.  
  94.  
  95. # GNU chown(1) completion. This should be expanded to allow the use of
  96. # ':' as well as '.' as the user.group separator.
  97. #
  98. _chown()
  99. {
  100.     local cur prev user group
  101.  
  102.         COMPREPLY=()
  103.         cur=${COMP_WORDS[COMP_CWORD]}
  104.         prev=${COMP_WORDS[COMP_CWORD-1]}
  105.  
  106.     # do not attempt completion if we're specifying an option
  107.     if [ "$cur" == -* ]; then return 0; fi
  108.  
  109.     # first parameter on line or first since an option?
  110.     if [ $COMP_CWORD -eq 1 ] || [[ "$prev" == -* ]]; then
  111.         if [[ "$cur" == [a-zA-Z]*.* ]]; then
  112.             user=${cur%.*}
  113.             group=${cur#*.}
  114.             COMPREPLY=( $( awk 'BEGIN {FS=":"} \
  115.                     {if ($1 ~ /^'$group'/) print $1}' \
  116.                     /etc/group ) )
  117.             for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  118.                 COMPREPLY[i]=$user.${COMPREPLY[i]}
  119.             done
  120.         else
  121.             COMPREPLY=( $( compgen -u $cur -S '.' ) )
  122.         fi
  123.     else
  124.         COMPREPLY=( $( compgen -f $cur ) )
  125.     fi
  126.  
  127.     return 0
  128. }
  129. complete -F _chown chown
  130.  
  131. # umount(8) completion. This relies on the mount point being the third
  132. # space-delimited field in the output of mount(8)
  133. #
  134. _umount()
  135. {
  136.     local cur
  137.  
  138.         COMPREPLY=()
  139.         cur=${COMP_WORDS[COMP_CWORD]}
  140.  
  141.     # could rewrite the cut | grep to be a sed command, but this is
  142.     # clearer and doesn't result in much overhead
  143.     COMPREPLY=( $( mount | cut -d' ' -f 3 | grep ^$cur) )
  144.  
  145.     return 0
  146. }
  147. complete -F _umount umount
  148.  
  149. # GID completion. This will get a list of all valid group names from
  150. # /etc/group and should work anywhere.
  151. #
  152. _gid_func()
  153. {
  154.     local cur
  155.  
  156.         COMPREPLY=()
  157.         cur=${COMP_WORDS[COMP_CWORD]}
  158.     COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($1 ~ /^'$cur'/) print $1}' \
  159.                /etc/group ) )
  160.     return 0
  161. }
  162. complete -F _gid_func groupdel groupmod
  163.  
  164. # mount(8) completion. This will pull a list of possible mounts out of
  165. # /etc/fstab, unless the word being completed contains a ':', which
  166. # would indicate the specification of an NFS server. In that case, we
  167. # query the server for a list of all available exports and complete on
  168. # that instead.
  169. #
  170. _mount()
  171.  
  172. {       local cur
  173.  
  174.         COMPREPLY=()
  175.         cur=${COMP_WORDS[COMP_CWORD]}
  176.  
  177.     if [[ "$cur" == *:* ]]; then
  178.         COMPREPLY=( $( /usr/sbin/showmount -e --no-headers ${cur%%:*} |\
  179.                    grep ^${cur#*:} | awk '{print $1}' ) )
  180.     else
  181.         COMPREPLY=( $( awk '{if ($2 ~ /\//) print $2}' /etc/fstab | \
  182.                    grep ^$cur ) )
  183.         # default to filename completion if all else failed
  184.         if [ ${#COMPREPLY[@]} = 0 ]; then
  185.                 COMPREPLY=( $( compgen -f $cur ) )
  186.         fi
  187.     fi
  188.  
  189.     return 0
  190. }
  191. complete -F _mount mount
  192.  
  193. # Linux rmmod(1) completion. This completes on a list of all currently
  194. # installed kernel modules.
  195. #
  196. _rmmod()
  197. {
  198.     local cur
  199.  
  200.         COMPREPLY=()
  201.         cur=${COMP_WORDS[COMP_CWORD]}
  202.  
  203.     COMPREPLY=( $( /sbin/lsmod | \
  204.                awk '{if (NR != 1 && $1 ~ /^'$cur'/) print $1}') )
  205.     return 0
  206. }
  207. complete -F _rmmod rmmod
  208.  
  209. # Linux insmod(1) completion. This completes on a list of all
  210. # available modules for the version of the kernel currently running.
  211. #
  212. _insmod()
  213. {
  214.     local cur prev modpath
  215.  
  216.         COMPREPLY=()
  217.         cur=${COMP_WORDS[COMP_CWORD]}
  218.         prev=${COMP_WORDS[COMP_CWORD-1]}
  219.     modpath=/lib/modules/`uname -r`
  220.  
  221.     if [ $COMP_CWORD -gt 1 ]; then
  222.         COMPREPLY=( $( /sbin/modinfo -p $prev | cut -f 1 -d ' ' ) )
  223.     else
  224.         COMPREPLY=($( ls -R $modpath | sed -ne 's/^\('$cur'.*\)\.o$/\1/p'))
  225.     fi
  226.  
  227.     return 0
  228. }
  229. complete -F _insmod insmod modprobe modinfo
  230.  
  231. # man(1) completion. This relies on the security enhanced version of
  232. # GNU locate(1). UNIX variants having non-numeric man page sections
  233. # other than l, m and n should add the appropriate sections to the
  234. # first clause of the case statement.
  235. #
  236. # This is Linux specific, in that 'man <section> <page>' is the
  237. # expected syntax. This allows one to do something like
  238. # 'man 3 str<tab>' to obtain a list of all string handling syscalls on
  239. # the system.
  240. #
  241. _man()
  242. {
  243.     [ -f /etc/man.config ] || return 0
  244.         local cur prev cmd
  245.  
  246.         COMPREPLY=()
  247.         cur=${COMP_WORDS[COMP_CWORD]}
  248.         prev=${COMP_WORDS[COMP_CWORD-1]}
  249.  
  250.         # filename completion if parameter contains /
  251.         if [[ "$cur" == /* ]]; then
  252.                 COMPREPLY=( $( compgen -f $cur ) )
  253.                 return 0
  254.         fi
  255.  
  256.         if [[ "$prev" == [0-9n] ]]; then
  257.                 # churn out a string of paths to search, with * appended to $cur
  258.                 cmd=`awk '{if ($1 ~ /^MANPATH/) \
  259.                      print $(NF)"/man'$prev'/'$cur'*"}' /etc/man.config | \
  260.                      sort -u`
  261.                 # strip off * from paths ending in /*
  262.                 cmd=${cmd//\/\\*/\/}
  263.                 # redirect stderr for when path doesn't exist
  264.                 cmd="ls $cmd 2>/dev/null"
  265.                 COMPREPLY=( $( eval $cmd ) )
  266.                 # get basename of man pages
  267.                 COMPREPLY=( ${COMPREPLY[@]##*/} )
  268.                 # strip suffix from man pages
  269.                 COMPREPLY=( ${COMPREPLY[@]%.gz} )
  270.                 COMPREPLY=( ${COMPREPLY[@]%.*} )
  271.     else
  272.                 cmd=`awk '{if ($1 ~ /^MANPATH/) \
  273.                      print $(NF)"/man?/'$cur'*"}' /etc/man.config | sort -u`
  274.                 cmd=${cmd//\/\\*/\/}
  275.                 cmd="ls $cmd 2>/dev/null"
  276.                 COMPREPLY=( $( eval $cmd ) )
  277.                 COMPREPLY=( ${COMPREPLY[@]##*/} )
  278.                 COMPREPLY=( ${COMPREPLY[@]%.gz} )
  279.                 COMPREPLY=( ${COMPREPLY[@]%.*} $( compgen -G $cur\*.[0-9n] ) )
  280.         fi
  281.  
  282.     return 0
  283. }
  284. complete -F _man man
  285.  
  286. # Linux killall(1) completion. This wouldn't be much use on, say,
  287. # Solaris, where killall does exactly that: kills ALL processes.
  288. #
  289. # This could be improved. For example, it currently doesn't take
  290. # command line options into account
  291. #
  292. _killall()
  293. {
  294.     local cur prev
  295.  
  296.         COMPREPLY=()
  297.         cur=${COMP_WORDS[COMP_CWORD]}
  298.         prev=${COMP_WORDS[COMP_CWORD-1]}
  299.  
  300.     if [[ "$prev" == -[A-Z0-9]* ]]; then
  301.         # get a list of processes (the gensub() in the awk takes care
  302.         # of getting the basename of the process, the first sed
  303.         # evaluation takes care of swapped out processes, and the
  304.         # second takes care of getting the basename of the process)
  305.             COMPREPLY=( $( ps ahx | sed -e 's#[]\[()]##g' | \
  306.            awk '{if (gensub("^.*/","",1,$5) ~ /^'$cur'/) print $5}' | \
  307.            sed  -e 's#^.*/##' ) )
  308.         return 0
  309.     fi
  310.  
  311.     # first parameter can be either a signal or a process
  312.     if [ $COMP_CWORD -eq 1 ]; then
  313.         # standard signal completion is rather braindead, so we need
  314.         # to hack around to get what we want here, which is to
  315.         # complete on a dash, followed by the signal name minus
  316.         # the SIG prefix
  317.         COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
  318.         for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  319.             COMPREPLY[i]=-${COMPREPLY[i]#SIG}
  320.         done
  321.     fi
  322.  
  323.     # get processes, adding to signals if applicable
  324.     COMPREPLY=( ${COMPREPLY[*]} $( ps ahx | sed -e 's#[]\[()]##g' | \
  325.            awk '{if (gensub("^.*/","",1,$5) ~ /^'$cur'/) print $5}' | \
  326.            sed -e 's#^.*/##' ))
  327.     return 0
  328. }
  329. complete -F _killall killall
  330.  
  331. # GNU find(1) completion. This makes heavy use of ksh style extended
  332. # globs and contains Linux specific code for completing the parameter
  333. # to the -fstype option.
  334. #
  335. _find()
  336. {
  337.     local cur prev
  338.  
  339.         COMPREPLY=()
  340.         cur=${COMP_WORDS[COMP_CWORD]#-}
  341.         prev=${COMP_WORDS[COMP_CWORD-1]}
  342.  
  343.     case "$prev" in
  344.     -@(max|min)depth)
  345.         COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' ) )
  346.         return 0
  347.         ;;
  348.     -?(a)newer|-fls|-fprint?(0|f))
  349.         COMPREPLY=( $( compgen -f $cur ) )
  350.         return 0
  351.         ;;
  352.     -fstype)
  353.         # this is highly non-portable (the option to -d is a tab)
  354.         COMPREPLY=( $( cut -d'    ' -f 2 /proc/filesystems | grep ^$cur ) )
  355.         return 0
  356.         ;;
  357.     -gid)
  358.         COMPREPLY=( $( awk 'BEGIN {FS=":"} \
  359.                 {if ($3 ~ /^'$cur'/) print $3}' /etc/group ) )
  360.         return 0
  361.         ;;
  362.     -group)
  363.         COMPREPLY=( $( awk 'BEGIN {FS=":"} \
  364.                 {if ($1 ~ /^'$cur'/) print $1}' /etc/group ) )
  365.         return 0
  366.         ;;
  367.     -?(x)type)
  368.         COMPREPLY=( $( compgen -W 'b c d p f l s' $cur ) )
  369.         return 0
  370.         ;;
  371.     -uid)
  372.         COMPREPLY=( $( awk 'BEGIN {FS=":"} \
  373.                 {if ($3 ~ /^'$cur'/) print $3}' /etc/passwd ) )
  374.         return 0
  375.         ;;
  376.     -user)
  377.         COMPREPLY=( $( compgen -u $cur ) )
  378.         return 0
  379.         ;;
  380.     -[acm]min|-[acm]time|-?(i)?(l)name|-inum|-?(i)path|-?(i)regex| \
  381.     -links|-perm|-size|-used|-exec|-ok|-printf)
  382.         # do nothing, just wait for a parameter to be given
  383.         return 0
  384.         ;;
  385.     esac
  386.  
  387.     # complete using basic options ($cur has had its dash removed here,
  388.     # as otherwise compgen will bomb out with an error, since it thinks
  389.     # the dash is an option to itself)
  390.     COMPREPLY=( $( compgen -W 'daystart depth follow help maxdepth \
  391.             mindepth mount noleaf version xdev amin anewer atime \
  392.             cmin cnewer ctime empty false fstype gid group ilname \
  393.             iname inum ipath iregex links lname mmin mtime name \
  394.             newer nouser nogroup perm regex size true type uid \
  395.             used user xtype exec fls fprint fprint0 fprintf ok \
  396.             print print0 printf prune ls' $cur ) )
  397.  
  398.     # this removes any options from the list of completions that have
  399.     # already been specified somewhere on the command line.
  400.     COMPREPLY=( $( echo "${COMP_WORDS[@]}-" | \
  401.                (while read -d '-' i; do
  402.                 [ "$i" == "" ] && continue
  403.                 # flatten array with spaces on either side,
  404.                 # otherwise we cannot grep on word boundaries of
  405.                 # first and last word
  406.                 COMPREPLY=" ${COMPREPLY[@]} "
  407.                 # remove word from list of completions
  408.                 COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
  409.                 done
  410.                 echo ${COMPREPLY[@]})
  411.           ) )
  412.     
  413.     # put dashes back
  414.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  415.         COMPREPLY[i]=-${COMPREPLY[i]}
  416.     done
  417.  
  418.     # default to filename completion if all else failed
  419.     if [ ${#COMPREPLY[@]} = 0 ]; then
  420.         COMPREPLY=( $( compgen -f $cur ) )
  421.     fi
  422.  
  423.     return 0
  424. }
  425. complete -F _find find
  426.  
  427. # Linux ifconfig(8) completion
  428. #
  429. _ifconfig()
  430. {
  431.     local cur
  432.  
  433.         COMPREPLY=()
  434.         cur=${COMP_WORDS[COMP_CWORD]}
  435.  
  436.     case "${COMP_WORDS[1]}" in
  437.     -|*[0-9]*)
  438.         COMPREPLY=( $( compgen -W '-a up down arp promisc allmulti \
  439.                        metric mtu dstaddr netmask add del \
  440.                        tunnel irq io_addr mem_start media \
  441.                        broadcast pointopoint hw multicast \
  442.                        address txqueuelen' $cur ))
  443.         COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
  444.                    (while read -d ' ' i; do
  445.                    [ "$i" == "" ] && continue
  446.                    # flatten array with spaces on either side,
  447.                    # otherwise we cannot grep on word
  448.                    # boundaries of first and last word
  449.                    COMPREPLY=" ${COMPREPLY[@]} "
  450.                    # remove word from list of completions
  451.                    COMPREPLY=( ${COMPREPLY/ $i / } )
  452.                 done
  453.                     echo ${COMPREPLY[@]})
  454.               ) )
  455.         return 0
  456.         ;;
  457.     esac
  458.  
  459.     COMPREPLY=( $( ifconfig -a | sed -ne 's/^\('$cur'[^ ]*\).*$/\1/p' ))
  460. }
  461. complete -F _ifconfig ifconfig
  462.  
  463. # Linux ipsec(8) completion (for FreeS/WAN). Basic.
  464. #
  465. _ipsec()
  466. {
  467.     local cur
  468.  
  469.         COMPREPLY=()
  470.         cur=${COMP_WORDS[COMP_CWORD]}
  471.  
  472.     
  473.     if [ $COMP_CWORD = 1 ]; then
  474.         COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look manual \
  475.                    pluto ranbits rsasigkey setup showdefaults \
  476.                    showhostkey spi spigrp tncfg whack' $cur ))
  477.         return 0
  478.     fi
  479.  
  480.     case ${COMP_WORDS[1]} in
  481.     auto)
  482.         COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
  483.                        --replace --down --route --unroute \
  484.                        --ready --status --rereadsecrets' $cur ) )
  485.         return 0
  486.         ;;
  487.     manual)
  488.         COMPREPLY=( $( compgen -W '--up --down --route --unroute \
  489.                        --union' $cur ) )
  490.         return 0
  491.         ;;
  492.     ranbits)
  493.         COMPREPLY=( $( compgen -W '--quick --continuous --bytes' $cur ) )
  494.         return 0
  495.         ;;
  496.     setup)
  497.         COMPREPLY=( $( compgen -W '--start --stop --restart' $cur ) )
  498.         return 0
  499.         ;;
  500.  
  501.     *)
  502.         return 0
  503.         ;;
  504.     esac
  505.  
  506.     return 0
  507. }
  508. complete -F _ipsec ipsec
  509.  
  510. # cvs(1) completion
  511. #
  512. _cvs()
  513. {
  514.     local cur prev
  515.  
  516.         COMPREPLY=()
  517.         cur=${COMP_WORDS[COMP_CWORD]}
  518.         prev=${COMP_WORDS[COMP_CWORD-1]}
  519.  
  520.     if [ $COMP_CWORD -eq 1 ] || [[ "$prev" == -* ]]; then
  521.         COMPREPLY=( $( compgen -W 'add admin checkout commit diff \
  522.         export history import log rdiff release remove rtag status \
  523.         tag update' $cur ))
  524.     else
  525.         COMPREPLY=( $( compgen -f $cur ))
  526.     fi
  527.  
  528.     return 0
  529. }
  530. complete -F _cvs cvs
  531.  
  532. # rpm(8) completion. This is quite comprehensive now and covers rpm 4.x
  533. # 
  534. _rpm()
  535. {
  536.     dashify()
  537.     {
  538.         local i
  539.  
  540.         for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  541.             if [ ${#COMPREPLY[i]} -le 2 ]; then
  542.                 COMPREPLY[i]=-${COMPREPLY[i]}
  543.             else
  544.                 COMPREPLY[i]=--${COMPREPLY[i]}
  545.             fi
  546.         done
  547.     }
  548.  
  549.     add_package_list()
  550.     {
  551.         COMPREPLY=( ${COMPREPLY[@]} $( rpm -qa | \
  552.            sed -ne 's/^\('$cur'.*\)-[0-9a-zA-Z._]\+-[0-9a-z.]\+$/\1/p' ) )
  553.     }
  554.  
  555.     file_glob()
  556.     {
  557.         local suffix
  558.  
  559.         # get extension of current word, if relevant
  560.         suffix=${cur##*.}
  561.         # nullify it if it's not a substring of the extension we're
  562.         # completing on
  563.         [ "$suffix" != "${1:0:${#suffix}}" ] && suffix=""
  564.         COMPREPLY=( ${COMPREPLY[@]} $( compgen -G $cur\*${1:${#suffix}} ) )
  565.         # directory completion if all else fails and current word
  566.         # contains a slash
  567.         if [ ${#COMPREPLY[@]} = 0 ] && [[ $cur == */* ]]; then
  568.                 COMPREPLY=( $( compgen -d $cur ) )
  569.         fi
  570.     }
  571.  
  572.     local cur cur_nodash prev
  573.  
  574.         COMPREPLY=()
  575.         cur=${COMP_WORDS[COMP_CWORD]}
  576.     cur_nodash=${cur#-}
  577.         prev=${COMP_WORDS[COMP_CWORD-1]}
  578.  
  579.     if [ $COMP_CWORD = 1 ]; then
  580.         # first parameter on line
  581.         case "$cur" in
  582.         -b*)
  583.             COMPREPLY=( $( compgen -W 'ba bb bc bi bl bp bs' \
  584.                        $cur_nodash ) )
  585.             dashify
  586.             return 0
  587.             ;;
  588.         -t*)
  589.             COMPREPLY=( $( compgen -W 'ta tb tc ti tl tp ts' \
  590.                        $cur_nodash ) )
  591.             dashify
  592.             return 0
  593.             ;;
  594.         --*)
  595.             COMPREPLY=( $( compgen -W 'help version initdb \
  596.             checksig recompile rebuild resign addsign rebuilddb \
  597.             showrc setperms setgids tarbuild eval install \
  598.             upgrade query freshen erase verify querytags rmsource' \
  599.             ${cur_nodash#-} ) )
  600.             dashify
  601.             return 0
  602.             ;;
  603.         *)
  604.             COMPREPLY=( $( compgen -W 'b e F i q t U V' \
  605.                        $cur_nodash ) )
  606.             dashify
  607.             return 0
  608.             ;;
  609.         esac
  610.     fi
  611.  
  612.     case "$prev" in
  613.     --@(db|exclude)path|prefix|relocate|root)
  614.         COMPREPLY=( $( compgen -d $cur ) )
  615.         return 0
  616.         ;;
  617.     --eval)
  618.         # get a list of macros (char class contains a space and tab)
  619.         COMPREPLY=( $( sed -ne 's/^\(%'${cur#\%}'[^     ]*\).*$/\1/p' \
  620.                    /usr/lib/rpm/macros ) )
  621.         return 0
  622.         ;;
  623.     --pipe)
  624.         COMPREPLY=( $( compgen -c $cur ) )
  625.         return 0
  626.         ;;
  627.     --rcfile)
  628.         COMPREPLY=( $( compgen -f $cur ) )
  629.         return 0
  630.         ;;
  631.     esac
  632.  
  633.     case "${COMP_WORDS[1]}" in
  634.     -@([iFU]*|-install|-freshen|-upgrade))
  635.         # complete on list of relevant options
  636.         COMPREPLY=( $( compgen -W 'percent force test replacepkgs \
  637.         replacefiles root excludedocs includedocs noscripts rcfile \
  638.         ignorearch dbpath prefix ignoreos nodeps allfiles ftpproxy \
  639.         ftpport justdb httpproxy httpport noorder relocate badreloc \
  640.         notriggers excludepath ignoresize oldpackage define eval \
  641.         pipe queryformat' ${cur_nodash#-} ))
  642.         dashify
  643.         # return if $cur is an option
  644.         [[ "$cur" == -* ]] && return 0
  645.         # add a list of RPMS to possible completions
  646.         file_glob rpm
  647.         return 0
  648.         ;;
  649.     -qp*)
  650.         # complete on list of relevant options
  651.         COMPREPLY=( $( compgen -W 'scripts root rcfile whatprovides \
  652.         whatrequires requires triggeredby ftpport ftpproxy httpproxy \
  653.         httpport provides triggers dump changelog dbpath filesbypkg \
  654.         define eval pipe showrc info list state docfiles \
  655.         configfiles queryformat' ${cur_nodash#-} ) )
  656.         dashify
  657.         # return if $cur is an option
  658.         [[ "$cur" == -* ]] && return 0
  659.         # add a list of RPMS to possible completions
  660.         file_glob rpm
  661.         return 0
  662.         ;;
  663.     -*f)
  664.         # standard filename completion
  665.         COMPREPLY=( $( compgen -f $cur ) )
  666.         return 0
  667.         ;;
  668.     -*g)
  669.         # package group completion
  670.         local IFS=$(echo -e "\t")
  671.         # remove trailing backslash, or grep will complain
  672.         cur=${cur%'\'}
  673.         COMPREPLY=( $( rpm -qa --queryformat '%{group}\n' | \
  674.                    grep ^$cur ) )
  675.         # backslash escape spaces and translate newlines to tabs
  676.         COMPREPLY=( $( echo ${COMPREPLY[@]} | sed 's/ /\\ /g' | \
  677.                    tr '\n' '\t' ) )
  678.         return 0
  679.         ;;
  680.     -@(e|-erase))
  681.         # complete on list of relevant options
  682.         COMPREPLY=( $( compgen -W 'allmatches noscripts notriggers \
  683.         nodeps test' ${cur_nodash#-} ) )
  684.         dashify
  685.         # return if $cur is an option
  686.         [[ "$cur" == -* ]] && return 0
  687.         add_package_list
  688.         return 0
  689.         ;;
  690.     -q*)
  691.         # complete on list of relevant options
  692.         COMPREPLY=( $( compgen -W 'scripts root rcfile whatprovides \
  693.         whatrequires requires triggeredby ftpport ftpproxy httpproxy \
  694.         httpport provides triggers dump changelog dbpath specfile \
  695.         querybynumber last filesbypkg define eval pipe showrc info \
  696.         list state docfiles configfiles queryformat' \
  697.         ${cur_nodash#-} ) )
  698.         dashify
  699.         # return if $cur is an option
  700.         [[ "$cur" == -* ]] && return 0
  701.         # don't complete on packages if we are querying all packages
  702.         [[ ${COMP_WORDS[1]} == -qa* ]] && return 0
  703.         add_package_list
  704.         return 0
  705.         ;;
  706.     -@(K|-checksig))
  707.         # complete on list of relevant options
  708.         COMPREPLY=( $( compgen -W 'nopgp nogpg nomd5' \
  709.         ${cur_nodash#-} ) )
  710.         dashify
  711.         # return if $cur is an option
  712.         [[ "$cur" == -* ]] && return 0
  713.         # add a list of RPMS to possible completions
  714.         file_glob rpm
  715.         return 0
  716.         ;;
  717.     -@([Vy]*|-verify))
  718.         # complete on list of relevant options
  719.         COMPREPLY=( $( compgen -W 'root rcfile dbpath nodeps nofiles \
  720.         noscripts nomd5' ${cur_nodash#-} ) )
  721.         dashify
  722.         # return if $cur is an option
  723.         [[ "$cur" == -* ]] && return 0
  724.         add_package_list
  725.         return 0
  726.         ;;
  727.     -[bt]*)
  728.         # complete on list of relevant options
  729.         COMPREPLY=( $( compgen -W 'short-circuit timecheck clean \
  730.         rmsource test sign buildroot target buildarch buildos \
  731.         nobuild' ${cur_nodash#-} ) )
  732.         dashify
  733.         # return if $cur is an option
  734.         [[ "$cur" == -* ]] && return 0
  735.         if [[ ${COMP_WORDS[1]} == -b* ]]; then
  736.             # complete on .spec files
  737.             file_glob spec
  738.         else
  739.             # complete on .tar files
  740.             COMPREPLY=( $( compgen -G $cur\*.+(tgz|tar.+(gz|bz2)) ) )
  741.         fi
  742.         return 0
  743.         ;;
  744.     --re@(build|compile))
  745.         # complete on source RPMs
  746.         COMPREPLY=( $( compgen -G $cur\*.src.rpm ) )
  747.         return 0
  748.         ;;
  749.     --tarbuild)
  750.         # complete on tarred sources
  751.         COMPREPLY=( $( compgen -G $cur\*.+(tgz|tar.+(gz|bz2)) ) )
  752.         return 0
  753.         ;;
  754.     --@(re|add)sign)
  755.         # complete on RPMs
  756.         file_glob rpm
  757.         return 0
  758.         ;;
  759.     --set@(perms|gids))
  760.         add_package_list
  761.         return 0
  762.         ;;
  763.     --rmsource)
  764.         file_glob spec
  765.         return 0
  766.         ;;
  767.     esac
  768.  
  769.     return 0
  770. }
  771. complete -F _rpm rpm
  772.  
  773. # Debian Linux apt-get(8) completion.
  774. #
  775. _apt-get()
  776. {
  777.     local cur prev special
  778.  
  779.         COMPREPLY=()
  780.         cur=${COMP_WORDS[COMP_CWORD]}
  781.         prev=${COMP_WORDS[COMP_CWORD-1]}
  782.  
  783.     for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
  784.         if [[ ${COMP_WORDS[i]} == @(install|remove|source) ]]; then
  785.             special=${COMP_WORDS[i]}
  786.         fi
  787.     done
  788.     if [ -n "$special" ]; then
  789.         case $special in
  790.         @(install|remove|source))
  791.             COMPREPLY=( $( apt-cache pkgnames $cur ) )
  792.             return 0
  793.             ;;
  794.         esac
  795.     fi
  796.  
  797.     if [[ "$prev" == -*c ]] || [ "$prev" = --config-file ]; then
  798.         COMPREPLY=( $( compgen -f $cur ) )
  799.     else
  800.         COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
  801.                   dist-upgrade install remove source check \
  802.                   clean autoclean -d -f -h -v -m -q -s -y -u \
  803.                   -b -c -o --download-only --fix-broken --help \
  804.                   --version --ignore-missing --fix-missing \
  805.                   --no-download --quiet --simulate \
  806.                   --just-print --dry-run --recon --no-act \
  807.                   --yes --assume-yes --show-upgraded \
  808.                   --compile --build --ignore-hold \
  809.                   --no-upgrade --force-yes --print-uris \
  810.                   --purge --reinstall --list-cleanup \
  811.                   --trivial-only --no-remove --diff-only \
  812.                   --tar-only --config-file --option ' | \
  813.                   grep ^$cur ) )
  814.     fi
  815.  
  816.     return 0
  817. }
  818. complete -F _apt-get apt-get
  819.  
  820. # Debian Linux apt-cache(8) completion.
  821. #
  822. _apt-cache()
  823. {
  824.     local cur prev special
  825.  
  826.         COMPREPLY=()
  827.         cur=${COMP_WORDS[COMP_CWORD]}
  828.         prev=${COMP_WORDS[COMP_CWORD-1]}
  829.  
  830.     
  831.     for (( i=0; i < ${#COMP_WORDS}-1; i++ )); do
  832.         if [[ ${COMP_WORDS[i]} == @(add|showpkg) ]]; then
  833.             special=${COMP_WORDS[i]}
  834.         fi
  835.     done
  836.     if [ -n "$special" ]; then
  837.         case $special in
  838.         add)
  839.             COMPREPLY=( $( compgen -f $cur ) )
  840.             return 0
  841.             ;;
  842.         showpkg)
  843.             COMPREPLY=( $( apt-cache pkgnames $cur ) )
  844.             return 0
  845.             ;;
  846.         esac
  847.     fi
  848.  
  849.  
  850.     if [[ "$prev" == -*c ]] || [ "$prev" = --config-file ]; then
  851.         COMPREPLY=( $( compgen -f $cur ) )
  852.     else
  853.         COMPREPLY=( $( compgen -W 'add gencaches showpkg stats dump \
  854.                 dumpavail unmet check search show showpkg \
  855.                 depends pkgnames -h -v -p -s -q -i -f -a -g -c \
  856.                 -o --help --version --pkg-cache --src-cache \
  857.                 --quiet --important --full --all-versions \
  858.                 --no-generate --names-only --all-names \
  859.                 --config-file --option' | grep ^$cur ) )
  860.     fi
  861.  
  862.     return 0
  863. }
  864. complete -F _apt-cache apt-cache
  865.  
  866. # chsh(1) completion
  867. #
  868. _chsh()
  869. {
  870.     local cur prev
  871.  
  872.         COMPREPLY=()
  873.         cur=${COMP_WORDS[COMP_CWORD]}
  874.         prev=${COMP_WORDS[COMP_CWORD-1]}
  875.  
  876.     if [ "$prev" = "-s" ]; then
  877.         COMPREPLY=( $( chsh -l | grep ^$cur ) )
  878.     else
  879.         COMPREPLY=( $( compgen -u $cur ) )
  880.     fi
  881.  
  882.     return 0
  883. }
  884. complete -F _chsh chsh
  885.  
  886. # chkconfig(8) completion
  887. #
  888. _chkconfig()
  889. {
  890.     local cur prev
  891.  
  892.         COMPREPLY=()
  893.         cur=${COMP_WORDS[COMP_CWORD]}
  894.     cur_nodash=${cur#--}
  895.         prev=${COMP_WORDS[COMP_CWORD-1]}
  896.  
  897.     if [ $COMP_CWORD -eq 1 ]; then
  898.         COMPREPLY=( $( compgen -W 'list add del level' $cur_nodash ) )
  899.         for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  900.             COMPREPLY[i]=--${COMPREPLY[i]}
  901.         done
  902.         return 0
  903.     fi
  904.  
  905.     if [ $COMP_CWORD -eq 4 ]; then
  906.         COMPREPLY=( $( compgen -W 'on off reset' $cur ) )
  907.         return 0
  908.     fi
  909.  
  910.     case "$prev" in
  911.     @([1-6]|--@(list|add|del)))
  912.         COMPREPLY=( $( compgen -W "`(cd /etc/rc.d/init.d; echo *)`" \
  913.                    $cur) )
  914.         return 0
  915.         ;;
  916.     --level)
  917.         COMPREPLY=( $( compgen -W '1 2 3 4 5 6' $cur ) )
  918.         return 0
  919.         ;;
  920.     esac
  921.  
  922.     return 0
  923. }
  924. complete -F _chkconfig chkconfig
  925.  
  926. # This function performs host completion based on ssh's known_hosts files, defaulting
  927. # to standard host completion if they don't exist.
  928. #
  929. _known_hosts()
  930. {
  931.     local cur kh
  932.  
  933.     kh=()
  934.         COMPREPLY=()
  935.         cur=${COMP_WORDS[COMP_CWORD]}
  936.  
  937.     [ -r /etc/known_hosts ]   && kh[0]=/etc/known_hosts
  938.     [ -r ~/.ssh/known_hosts ] && kh[1]=~/.ssh/known_hosts
  939.  
  940.     # If we have known_hosts files to use
  941.     if [ ${#kh[@]} -gt 0 ]; then
  942.         if [[ $cur == [0-9]*.* ]]; then
  943.         # Digits followed by a dot - just search for that
  944.         cur="^$cur.*"
  945.         elif [[ $cur == [0-9]* ]]; then
  946.         # Digits followed by no dot - search for digits followed
  947.         # by a dot
  948.         cur="^$cur.*\."
  949.         elif [ -z $cur ]; then
  950.         # A blank - search for a dot or an alpha character
  951.         cur="[a-z.]"
  952.         else
  953.         cur="^$cur"
  954.         fi
  955.         # FS needs to look for a comma separated list
  956.         COMPREPLY=( $( awk 'BEGIN {FS="[ ,]"}
  957.                 {for (i=1; i<=NR; ++i) { \
  958.                        if ($i ~ /'$cur'/) {print $i} \
  959.                 }}' ${kh[@]} ) )
  960.     else
  961.         # Just do normal hostname completion
  962.         COMPREPLY=( $( compgen -A hostname $cur ) )
  963.     fi
  964.  
  965.     return 0
  966. }
  967. complete -F _known_hosts traceroute ping fping telnet host nslookup
  968.  
  969. # ssh(1) completion. Should be able to improve this with user@host notation,
  970. # but the '@' seems to trigger some kind of bug in bash's completion.
  971. #
  972. _ssh()
  973. {
  974.     local cur prev
  975.  
  976.         COMPREPLY=()
  977.         cur=${COMP_WORDS[COMP_CWORD]}
  978.         prev=${COMP_WORDS[COMP_CWORD-1]}
  979.  
  980.     case "$prev" in
  981.     -*c)
  982.         COMPREPLY=( $( compgen -W 'blowfish 3des 3des-cbc blowfish-cbc \
  983.                arcfour cast128-cbc' $cur ) )
  984.         return 0
  985.         ;;
  986.     -*l)
  987.         COMPREPLY=( $( compgen -u $cur ) )
  988.         return 0
  989.         ;;
  990.     esac
  991.  
  992.     # Host has been specified, so now do simple command completion
  993.     if [ $COMP_CWORD -gt 1 ]; then
  994.         COMPREPLY=( $( compgen -c $cur ) )
  995.         return 0
  996.     fi
  997.  
  998.     # Otherwise, check for known hosts
  999.     _known_hosts
  1000.  
  1001.     return 0
  1002. }
  1003. complete -F _ssh ssh slogin
  1004.  
  1005. # Linux route(8) completion. This could be improved by adding address family
  1006. # completion for -A, etc.
  1007. #
  1008. _route()
  1009. {
  1010.     local cur prev
  1011.  
  1012.         COMPREPLY=()
  1013.         cur=${COMP_WORDS[COMP_CWORD]}
  1014.         prev=${COMP_WORDS[COMP_CWORD-1]}
  1015.  
  1016.     if [ "$prev" = dev ]; then
  1017.         COMPREPLY=( $( ifconfig -a | sed -ne 's/^\('$cur'[^ ]*\).*$/\1/p' ))
  1018.         return 0
  1019.     fi
  1020.  
  1021.     # Must use grep here, otherwise $cur will cause compgen to barf, if
  1022.     # it begins with a hyphen
  1023.     COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
  1024.                   window irtt reject mod dyn reinstate dev' | \
  1025.                grep ^$cur ) )
  1026.  
  1027.     COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
  1028.                (while read -d ' ' i; do
  1029.                [ "$i" == "" ] && continue
  1030.                # flatten array with spaces on either side,
  1031.                # otherwise we cannot grep on word
  1032.                # boundaries of first and last word
  1033.                COMPREPLY=" ${COMPREPLY[@]} "
  1034.                # remove word from list of completions
  1035.                COMPREPLY=( ${COMPREPLY/ $i / } )
  1036.             done
  1037.                echo ${COMPREPLY[@]})
  1038.           ) )
  1039.     return 0
  1040. }
  1041. complete -F _route route
  1042.  
  1043. # GNU make(1) completion (adapted from the example supplied with the bash 2.04
  1044. # source code)
  1045. #
  1046. _make()
  1047. {
  1048.         local mdef makef gcmd cur prev i
  1049.  
  1050.         COMPREPLY=()
  1051.         cur=${COMP_WORDS[COMP_CWORD]}
  1052.         prev=${COMP_WORDS[COMP_CWORD-1]}
  1053.  
  1054.         # if prev argument is -f, return possible filename completions.
  1055.         # we could be a little smarter here and return matches against
  1056.         # `makefile Makefile *.mk', whatever exists
  1057.         if [[ "$prev" == -*f ]]; then
  1058.         COMPREPLY=( $( compgen -f $cur ) )
  1059.         return 0
  1060.     fi
  1061.  
  1062.         # if we want an option, return the possible posix options
  1063.         if [[ "$cur" == - ]]; then
  1064.             COMPREPLY=( $( compgen -W '-e -f -i -k -n -p -q -r -S -s -t' | grep ^$cur ) )
  1065.         return 0
  1066.         fi
  1067.  
  1068.         # make reads `makefile' before `Makefile'
  1069.         if [ -f makefile ]; then
  1070.                 mdef=makefile
  1071.         elif [ -f Makefile ]; then
  1072.                 mdef=Makefile
  1073.         else
  1074.                 mdef=*.mk               # local convention
  1075.         fi
  1076.  
  1077.         # before we scan for targets, see if a makefile name was specified
  1078.         # with -f
  1079.         for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  1080.                 if [[ ${COMP_WORDS[i]} == -*f ]]; then
  1081.                         eval makef=${COMP_WORDS[i+1]}   # eval for tilde expansion
  1082.                         break
  1083.                 fi
  1084.         done
  1085.  
  1086.         [ -z "$makef" ] && makef=$mdef
  1087.  
  1088.         # if we have a partial word to complete, restrict completions to
  1089.         # matches of that word
  1090.         if [ -n "$2" ]; then
  1091.         gcmd='grep "^$2"'
  1092.     else
  1093.         gcmd=cat
  1094.     fi
  1095.  
  1096.         # if we don't want to use *.mk, we can take out the cat and use
  1097.         # test -f $makef and input redirection  
  1098.         COMPREPLY=( $( cat $makef 2>/dev/null | \
  1099.                awk 'BEGIN {FS=":"} /^[^.#    ][^=]*:/ {print $1}' | \
  1100.                eval $gcmd ) )
  1101.  
  1102.     # default to filename completion if all else failed
  1103.     if [ ${#COMPREPLY[@]} = 0 ]; then
  1104.         COMPREPLY=( $( compgen -f $cur ) )
  1105.     fi
  1106.  
  1107.     return 0
  1108. }
  1109. complete -F _make -X '+($*|*.[cho])' make gmake pmake
  1110.  
  1111. # Red Hat Linux service completion. This completes on a list of all available
  1112. # service scripts in the SysV init.d directory, followed by that script's
  1113. # available commands
  1114. #
  1115. _service()
  1116. {
  1117.     local cur sysvdir
  1118.  
  1119.         COMPREPLY=()
  1120.         cur=${COMP_WORDS[COMP_CWORD]}
  1121.  
  1122.     [ -d /etc/rc.d/initi.d ] && sysvdir=/etc/rc.d/init.d \
  1123.                  || sysvdir=/etc/init.d
  1124.  
  1125.     #[[ "$cur" == -* ]] && return 0
  1126.     if [ $COMP_CWORD = 1 ]; then
  1127.         COMPREPLY=( $( compgen -W '`echo $sysvdir/!(*.rpmsave|*.rpmorig)`' ) )
  1128.         COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$sysvdir/}' $cur ) )
  1129.     else
  1130.         COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  1131.                         s/^.*Usage.*{\(.*\)}.*$/\1/p" \
  1132.                         $sysvdir/${COMP_WORDS[1]}' $cur ) )
  1133.     fi
  1134.  
  1135.     return 0
  1136. }
  1137. complete -F _service service
  1138.