Tomb/src/undertaker

#!/bin/zsh
#
# Undertaker, auxiliary command for Tomb
#
# Tomb is a tool to operate file encryption of private and secret data
#
# Undertaker is a tool to retrieve tomb keys from various sources
#
# {{{ Copyleft (C) 2011 Denis Roio <jaromil@dyne.org>
#
# This source  code is free  software; you can redistribute  it and/or
# modify it under the terms of  the GNU Public License as published by
# the Free  Software Foundation; either  version 3 of the  License, or
# (at your option) any later version.
#
# This source code is distributed in  the hope that it will be useful,
# but  WITHOUT ANY  WARRANTY;  without even  the  implied warranty  of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# Please refer to the GNU Public License for more details.
#
# You should have received a copy of the GNU Public License along with
# this source code; if not, write to:
# Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

# }}}

# first of all source the tomb core functions
which tomb > /dev/null
if [[ $? != 0 ]]; then
    print "$fg[red][!]$fg[white] Tomb command not found, operation aborted."; exit 1
fi

key_found() {
    # $1 is "url"
    if option_is_set --machine-parseable; then
        print -n '[m]'
    fi
    print "$fg[white][found] $1"
}

function undertaker_scheme() {
    zparseopts -D -print-path=print_path

    local scheme
    scheme=$1
    local keypath
    keypath=$2
    case $scheme in
        bluetooth)
            #TODO: support --print-path
            act "access to bluetooth protocol requested"
            which obexftp &> /dev/null
            if [[ $? != 0 ]]; then
                error "obexftp not found, needed for bluetooth: operation aborted."
                return 64
            fi
            keytmp=`safe_dir undertaker`
            cd $keytmp
            # fetch key from bluetooth, url format: bluetooth://55:33:44:55:66/file/path
            obexdevpath=${keypath#*//}
            obexdev=${obexdevpath%%/*}
            obexpath=${obexdevpath#*/}
            act "obex device: $obexdev"
            act "obex path: $obexpath"
	obexftp -b $obexdev -g $obexpath 
	if [[ $? != 0 ]]; then
	    rmdir ${keytmp}
	    die "a problem occurred retreiving the key via bluetooth."
	fi
	# print out the key on stdout
	cat $obexpath >&1
            # wipe out the key
	${WIPE[@]} $obexpath
            cd -
            rmdir ${keytmp}

        #	tombkey="basename $obexpath"
            ;;
        file)
            if ! [[ -f $keypath ]]; then
                error "Invalid path $keypath"
                return 1
            fi
            if [[ -n $print_path ]]; then
                key_found $scheme://$keypath;
            else
                < $keypath
                r=$?
                if [[ $r != 0 ]]; then return 1; fi
                return 0
            fi
            ;;

        mounted)
            for mountpoint in `cut -f2 /etc/mtab -d ' ' | sort -u`; do
                undertaker_scheme ${print_path[@]} file ${mountpoint}/${keypath}
                ret=$?
                if [[ $ret == 0 ]]; then
                    return 0
                fi
            done
            ;;
        *)
            if ! which undertaker-$scheme &> /dev/null; then
                error "url protocol not recognized: $scheme"
                return 64
            fi
            undertaker-$scheme ${print_path[@]} ${scheme}://$keypath
            return $?
            ;;
    esac
}
function main() {
        typeset -A opts
        zparseopts -M -E -D -Aopts -poll -print-path -machine-parseable
        if ! [ $1 ] ; then
            error "an argument is missing, the undertaker is confused"
            act "usage: undertaker [options] url://host:path/to/tomb.key"
            exit 1;
        fi
        local -a tomb_opts
        if [[ -n ${(k)opts[--machine-parseable]} ]]; then
            tomb_opts+='--machine-parseable'
        fi
        local -a under_opts
        if [[ -n ${(k)opts[--print-path]} ]]; then
            under_opts+='--print-path'
        fi
        local -A backupopts
        for a in ${(k)opts}; do
            backupopts[$a]=${opts[$a]}
        done
        source tomb ${tomb_opts[@]} source
        for a in ${(k)backupopts}; do
            opts[$a]=${backupopts[$a]}
        done
        check_bin

        notice "Undertaker will look for $1"

        ARG1=${1}
        scheme=${ARG1%://*}
        keypath=${ARG1#*//}

        if [[ -n ${(k)opts[--poll]} ]]; then
            while true; do
                progress poll 0 search
                undertaker_scheme ${under_opts[@]} $scheme $keypath
                r=$?
                if [[ $r == 64 ]]; then
                    exit 64
                fi
                progress poll 100 done
                sleep 3
            done
        else
            undertaker_scheme ${under_opts[@]} $scheme $keypath
        fi
}
main $*

### Conventions and other comments:
# 
# EXIT CODES FOR SCHEME HANDLERS
# 0 is for everything went fine
# 64 is for "not supported/the problem won't be solved by polling". This is for things like: unmet dependencies, not supported at all, etc
# everything else means just "error". Use 1, please. So other codes can be used if needed
#