# ssh(1) completion                                        -*- shell-script -*-

_ssh_queries()
{
    COMPREPLY+=( $(compgen -W \
        "cipher cipher-auth mac kex key key-cert key-plain protocol-version sig" \
        -- "$cur") )
}

_ssh_query()
{
    ${1:-ssh} -Q $2 2>/dev/null
}

_ssh_ciphers()
{
    local ciphers='$(_ssh_query "$1" cipher)'
    [[ $ciphers ]] || ciphers="3des-cbc aes128-cbc aes192-cbc aes256-cbc
        aes128-ctr aes192-ctr aes256-ctr arcfour128 arcfour256 arcfour
        blowfish-cbc cast128-cbc"
    COMPREPLY+=( $(compgen -W "$ciphers" -- "$cur") )
}

_ssh_macs()
{
    local macs='$(_ssh_query "$1" mac)'
    [[ $macs ]] || macs="hmac-md5 hmac-sha1 umac-64@openssh.com hmac-ripemd160
        hmac-sha1-96 hmac-md5-96"
    COMPREPLY+=( $(compgen -W "$macs" -- "$cur") )
}

_ssh_options()
{
    local opts=(
        AddKeysToAgent AddressFamily BatchMode BindAddress CanonicalDomains
        CanonicalizeFallbackLocal CanonicalizeHostname CanonicalizeMaxDots
        CanonicalizePermittedCNAMEs CASignatureAlgorithms CertificateFile
        ChallengeResponseAuthentication CheckHostIP Ciphers ClearAllForwardings
        Compression ConnectionAttempts ConnectTimeout ControlMaster ControlPath
        ControlPersist DynamicForward EnableSSHKeysign EscapeChar
        ExitOnForwardFailure FingerprintHash ForwardAgent ForwardX11
        ForwardX11Timeout ForwardX11Trusted GatewayPorts GlobalKnownHostsFile
        GSSAPIAuthentication GSSAPIClientIdentity GSSAPIDelegateCredentials
        GSSAPIKeyExchange GSSAPIRenewalForcesRekey GSSAPIServerIdentity
        GSSAPITrustDns HashKnownHosts Host HostbasedAuthentication
        HostbasedKeyTypes HostKeyAlgorithms HostKeyAlias HostName
        IdentitiesOnly IdentityAgent IdentityFile IgnoreUnknown Include IPQoS
        KbdInteractiveAuthentication KbdInteractiveDevices KexAlgorithms
        LocalCommand LocalForward LogLevel MACs
        NoHostAuthenticationForLocalhost NumberOfPasswordPrompts
        PasswordAuthentication PermitLocalCommand PKCS11Provider Port
        PreferredAuthentications ProxyCommand ProxyJump ProxyUseFdpass
        PubkeyAcceptedKeyTypes PubkeyAuthentication RekeyLimit RemoteCommand
        RemoteForward RequestTTY RevokedHostKeys SendEnv ServerAliveCountMax
        ServerAliveInterval SmartcardDevice StreamLocalBindMask
        StreamLocalBindUnlink StrictHostKeyChecking SyslogFacility TCPKeepAlive
        Tunnel TunnelDevice UpdateHostKeys UsePrivilegedPort User
        UserKnownHostsFile VerifyHostKeyDNS VisualHostKey XAuthLocation )
    local protocols=$(_ssh_query "$1" protocol-version)
    if [[ -z $protocols || $protocols == *1* ]]; then
        opts+=( Cipher CompressionLevel Protocol RhostsRSAAuthentication
                RSAAuthentication )
    fi

    compopt -o nospace
    local IFS=$' \t\n' reset=$(shopt -p nocasematch); shopt -s nocasematch
    local option
    COMPREPLY=( $(for option in "${opts[@]}"; do
                      [[ $option == "$cur"* ]] && printf '%s=\n' "$option"
                  done) )
    $reset
}

# Complete a ssh suboption (like ForwardAgent=y<tab>)
# Two parameters: the string to complete including the equal sign, and
# the ssh executable to invoke (optional).
# Not all suboptions are completed.
# Doesn't handle comma-separated lists.
_ssh_suboption()
{
    # Split into subopt and subval
    local prev=${1%%=*} cur=${1#*=}

    case ${prev,,} in
        batchmode|canonicaldomains|canonicalizefallbacklocal|\
        challengeresponseauthentication|checkhostip|\
        clearallforwardings|controlpersist|compression|enablesshkeysign|\
        exitonforwardfailure|forwardagent|forwardx11|forwardx11trusted|\
        gatewayports|gssapiauthentication|gssapikeyexchange|\
        gssapidelegatecredentials|gssapirenewalforcesrekey|gssapitrustdns|\
        hashknownhosts|hostbasedauthentication|identitiesonly|\
        kbdinteractiveauthentication|kbdinteractivedevices|\
        nohostauthenticationforlocalhost|passwordauthentication|permitlocalcommand|\
        proxyusefdpass|pubkeyauthentication|rhostsrsaauthentication|\
        rsaauthentication|streamlocalbindunlink|\
        tcpkeepalive|useprivilegedport|visualhostkey)
            COMPREPLY=( $(compgen -W 'yes no' -- "$cur") )
            ;;
        addkeystoagent)
            COMPREPLY=( $(compgen -W 'yes ask confirm no' -- "$cur") )
            ;;
        addressfamily)
            COMPREPLY=( $(compgen -W 'any inet inet6' -- "$cur") )
            ;;
        bindaddress)
            _ip_addresses
            ;;
        canonicalizehostname)
            COMPREPLY=( $(compgen -W 'yes no always' -- "$cur") )
            ;;
        identityfile)
            _ssh_identityfile
            ;;
        *file|identityagent|include|controlpath|revokedhostkeys|xauthlocation)
            _filedir
            ;;
        casignaturealgorithms)
            COMPREPLY=( $(compgen -W '$(_ssh_query "$2" sig)' -- "$cur") )
            ;;
        cipher)
            COMPREPLY=( $(compgen -W 'blowfish des 3des' -- "$cur") )
            ;;
        ciphers)
            _ssh_ciphers "$2"
            ;;
        controlmaster)
            COMPREPLY=( $(compgen -W 'yes ask auto autoask no' -- "$cur") )
            ;;
        compressionlevel)
            COMPREPLY=( $(compgen -W '{1..9}' -- "$cur") )
            ;;
        fingerprinthash)
            COMPREPLY=( $(compgen -W 'md5 sha256' -- "$cur") )
            ;;
        ipqos)
            COMPREPLY=( $(compgen -W 'af1{1..4} af2{2..3} af3{1..3} af4{1..3}
                cs{0..7} ef lowdelay throughput reliability' -- "$cur") )
            ;;
        hostbasedkeytypes|hostkeyalgorithms)
            COMPREPLY=( $(compgen -W '$(_ssh_query "$2" key)' -- "$cur") )
            ;;
        kexalgorithms)
            COMPREPLY=( $(compgen -W '$(_ssh_query "$2" kex)' -- "$cur") )
            ;;
        loglevel)
            COMPREPLY=( $(compgen -W 'QUIET FATAL ERROR INFO VERBOSE DEBUG{,1,2,3}' -- "$cur") )
            ;;
        macs)
            _ssh_macs "$2"
            ;;
        pkcs11provider)
            _filedir so
            ;;
        preferredauthentications)
            COMPREPLY=( $(compgen -W 'gssapi-with-mic host-based publickey
                keyboard-interactive password' -- "$cur") )
            ;;
        protocol)
            local protocols=( $(_ssh_query "$2" protocol-version) )
            [[ $protocols ]] || protocols=(1 2)
            if [[ ${#protocols[@]} -gt 1 ]]; then
                COMPREPLY=( $(compgen -W '${protocols[@]}' -- "$cur") )
            fi
            ;;
        proxyjump)
            _known_hosts_real -a -F "$configfile" -- "$cur"
            ;;
        proxycommand|remotecommand|localcommand)
            COMPREPLY=( $(compgen -c -- "$cur") )
            ;;
        pubkeyacceptedkeytypes)
            COMPREPLY=( $(compgen -W '$(_ssh_query "$2" key)' -- "$cur") )
            ;;
        requesttty)
            COMPREPLY=( $(compgen -W 'no yes force auto' -- "$cur") )
            ;;
        stricthostkeychecking)
            COMPREPLY=( $(compgen -W 'accept-new ask no off' -- "$cur") )
            ;;
        syslogfacility)
            COMPREPLY=( $(compgen -W 'DAEMON USER AUTH LOCAL{0..7}' -- "$cur") )
            ;;
        tunnel)
            COMPREPLY=( $(compgen -W 'yes no point-to-point ethernet' \
                                  -- "$cur") )
            ;;
        updatehostkeys|verifyhostkeydns)
            COMPREPLY=( $(compgen -W 'yes no ask' -- "$cur") )
            ;;
    esac
    return 0
}

# Try to complete -o SubOptions=
#
# Returns 0 if the completion was handled or non-zero otherwise.
_ssh_suboption_check()
{
    # Get prev and cur words without splitting on =
    local cureq=`_get_cword :=` preveq=`_get_pword :=`
    if [[ $cureq == *=* && $preveq == -*o ]]; then
        _ssh_suboption $cureq "$1"
        return $?
    fi
    return 1
}

# Search COMP_WORDS for '-F configfile' or '-Fconfigfile' argument
_ssh_configfile()
{
    set -- "${words[@]}"
    while [[ $# -gt 0 ]]; do
        if [[ $1 == -F* ]]; then
            if [[ ${#1} -gt 2 ]]; then
                configfile="$(dequote "${1:2}")"
            else
                shift
                [[ $1 ]] && configfile="$(dequote "$1")"
            fi
            break
        fi
        shift
    done
}

# With $1 set, look for public key files, else private
_ssh_identityfile()
{
    [[ -z $cur && -d ~/.ssh ]] && cur=~/.ssh/id
    _filedir
    if (( ${#COMPREPLY[@]} > 0 )); then
        COMPREPLY=( $(compgen -W '${COMPREPLY[@]}' \
                              -X "${1:+!}*.pub" -- "$cur") )
    fi
}

_ssh()
{
    local cur prev words cword
    _init_completion -n : || return

    local -a config

    local configfile
    _ssh_configfile

    _ssh_suboption_check "$1" && return

    local ipvx

    case $prev in
        -*4*)
            ipvx=-4
            ;;
        -*6*)
            ipvx=-6
            ;;
        -*b)
            _ip_addresses
            return
            ;;
        -*c)
            _ssh_ciphers "$1"
            return
            ;;
        -*[DeLpRW])
            return
            ;;
        -*[EFS])
            _filedir
            return
            ;;
        -*i)
            _ssh_identityfile
            return
            ;;
        -*I)
            _filedir so
            return
            ;;
        -*J)
            _known_hosts_real -a -F "$configfile" -- "$cur"
            return
            ;;
        -*l)
            COMPREPLY=( $(compgen -u -- "$cur") )
            return
            ;;
        -*m)
            _ssh_macs "$1"
            return
            ;;
        -*O)
            COMPREPLY=( $(compgen -W 'check forward cancel exit stop' -- "$cur") )
            return
            ;;
        -*o)
            _ssh_options "$1"
            return
            ;;
        -*Q)
            _ssh_queries "$1"
            return
            ;;
        -*w)
            _available_interfaces
            return
            ;;
    esac

    if [[ "$cur" == -F* ]]; then
        cur=${cur#-F}
        _filedir
        # Prefix completions with '-F'
        COMPREPLY=( "${COMPREPLY[@]/#/-F}" )
        cur=-F$cur  # Restore cur
    elif [[ "$cur" == -* ]]; then
        COMPREPLY=( $(compgen -W '$(_parse_usage "$1")' -- "$cur") )
    else
        _known_hosts_real $ipvx -a -F "$configfile" -- "$cur"

        local args
        _count_args
        if [[ $args -gt 1 ]]; then
            compopt -o filenames
            COMPREPLY+=( $(compgen -c -- "$cur") )
        fi
    fi
} &&
shopt -u hostcomplete && complete -F _ssh ssh slogin autossh sidedoor

# sftp(1) completion
#
_sftp()
{
    local cur prev words cword
    _init_completion || return

    local configfile
    _ssh_configfile

    _ssh_suboption_check && return

    local ipvx

    case $prev in
        -*4*)
            ipvx=-4
            ;;
        -*6*)
            ipvx=-6
            ;;
        -*[BDlPRs])
            return
            ;;
        -*[bF])
            _filedir
            return
            ;;
        -*i)
            _ssh_identityfile
            return
            ;;
        -*c)
            _ssh_ciphers
            return
            ;;
        -*J)
            _known_hosts_real -a -F "$configfile" -- "$cur"
            return
            ;;
        -*o)
            _ssh_options
            return
            ;;
        -*S)
            _command
            return
            ;;
    esac

    if [[ "$cur" == -F* ]]; then
        cur=${cur#-F}
        _filedir
        # Prefix completions with '-F'
        COMPREPLY=( "${COMPREPLY[@]/#/-F}" )
        cur=-F$cur  # Restore cur
    elif [[ "$cur" == -* ]]; then
        COMPREPLY=( $(compgen -W '$(_parse_usage "$1")' -- "$cur") )
    else
        _known_hosts_real $ipvx -a -F "$configfile" -- "$cur"
    fi
} &&
shopt -u hostcomplete && complete -F _sftp sftp

# things we want to backslash escape in scp paths
_scp_path_esc='[][(){}<>",:;^&!$=?`|\\'"'"'[:space:]]'

# Complete remote files with ssh.  If the first arg is -d, complete on dirs
# only.  Returns paths escaped with three backslashes.
_scp_remote_files()
{
    local IFS=$'\n'

    # remove backslash escape from the first colon
    cur=${cur/\\:/:}

    local userhost=${cur%%?(\\):*}
    local path=${cur#*:}

    # unescape (3 backslashes to 1 for chars we escaped)
    path=$(command sed -e 's/\\\\\\\('$_scp_path_esc'\)/\\\1/g' <<<"$path")

    # default to home dir of specified user on remote host
    if [[ -z $path ]]; then
        path=$(ssh -o 'Batchmode yes' $userhost pwd 2>/dev/null)
    fi

    local files
    if [[ $1 == -d ]]; then
        # escape problematic characters; remove non-dirs
        files=$(ssh -o 'Batchmode yes' $userhost \
            command ls -aF1dL "$path*" 2>/dev/null | \
            command sed -e 's/'$_scp_path_esc'/\\\\\\&/g' -e '/[^\/]$/d')
    else
        # escape problematic characters; remove executables, aliases, pipes
        # and sockets; add space at end of file names
        files=$(ssh -o 'Batchmode yes' $userhost \
            command ls -aF1dL "$path*" 2>/dev/null | \
            command sed -e 's/'$_scp_path_esc'/\\\\\\&/g' -e 's/[*@|=]$//g' \
            -e 's/[^\/]$/& /g')
    fi
    COMPREPLY+=( $files )
}

# This approach is used instead of _filedir to get a space appended
# after local file/dir completions, and -o nospace retained for others.
# If first arg is -d, complete on directory names only.  The next arg is
# an optional prefix to add to returned completions.
_scp_local_files()
{
    local IFS=$'\n'

    local dirsonly=false
    if [[ $1 == -d ]]; then
        dirsonly=true
        shift
    fi

    if $dirsonly ; then
        COMPREPLY+=( $(command ls -aF1dL $cur* 2>/dev/null | \
            command sed -e "s/$_scp_path_esc/\\\\&/g" -e '/[^\/]$/d' -e "s/^/$1/") )
    else
        COMPREPLY+=( $(command ls -aF1dL $cur* 2>/dev/null | \
            command sed -e "s/$_scp_path_esc/\\\\&/g" -e 's/[*@|=]$//g' \
            -e 's/[^\/]$/& /g' -e "s/^/$1/") )
    fi
}

# scp(1) completion
#
_scp()
{
    local cur prev words cword
    _init_completion -n : || return

    local configfile
    _ssh_configfile

    _ssh_suboption_check && {
        COMPREPLY=( "${COMPREPLY[@]/%/ }" )
        return
    }

    local ipvx

    case $prev in
        -*4*)
            ipvx=-4
            ;;
        -*6*)
            ipvx=-6
            ;;
        -*c)
            _ssh_ciphers
            COMPREPLY=( "${COMPREPLY[@]/%/ }" )
            return
            ;;
        -*F)
            _filedir
            compopt +o nospace
            return
            ;;
        -*i)
            _ssh_identityfile
            compopt +o nospace
            return
            ;;
        -*J)
            _known_hosts_real -a -F "$configfile" -- "$cur"
            return
            ;;
        -*[lP])
            return
            ;;
        -*o)
            _ssh_options
            return
            ;;
        -*S)
            _command
            compopt +o nospace
            return
            ;;
    esac

    _expand || return

    case $cur in
        !(*:*)/*|[.~]*) ;; # looks like a path
        *:*) _scp_remote_files ; return ;;
    esac

    local prefix

    if [[ "$cur" == -F* ]]; then
        cur=${cur#-F}
        prefix=-F
    else
        case $cur in
            -*)
                COMPREPLY=( $(compgen -W '$(_parse_usage "${words[0]}")' \
                    -- "$cur") )
                COMPREPLY=( "${COMPREPLY[@]/%/ }" )
                return
                ;;
            */*|[.~]*)
                # not a known host, pass through
                ;;
            *)
                _known_hosts_real $ipvx -c -a -F "$configfile" -- "$cur"
                ;;
        esac
    fi

    _scp_local_files "$prefix"
} &&
complete -F _scp -o nospace scp

# ex: filetype=sh