functions

#!/bin/sh
# vim: set ft=sh et sw=4 sts=4 ts=4:

# https://github.com/roytenberg/brilliant-bash/blob/master/.bashrc

#You can also sign it for 1 week using this format:


# s3cmd signurl s3://my_bucket/my_file.png $(echo "`date +%s` + 3600 * 24 * 7" | bc)

download_chrome_extension() {
    # from https://gist.github.com/paulirish/78d6c1406c901be02c2d
    extension_id=$1 # change this ID
    curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc" 
    unzip -d "$extension_id-source" "$extension_id.zip"
}


function save_tabs()
{
    chrome-cli list tabs | cut -f1 -d ' ' | tr -d '[' | tr -d ']' | cut -f2 -d: | while read line; do
        chrome-cli info -t $line;
    done | grep -E 'Title:|Url:' | tac | xargs -d'\n' -n2 echo | sed 's/: /\t/g' | sed 's/ Title/\tTitle/' > urls.tsv
}

dns_check() {
    domain=$1
    curl -s "https://crt.sh/?q=%.${domain}&output=json" | jq -r '.name_value' | sed 's/\*\.//g' | sort -u
    echo
    curl -s "https://certspotter.com/api/v0/certs?domain=${domain}" | jq '.[].dns_names[]' | sed 's/\"//g' | sed 's/\*\.//g' | sort -u | grep $domain
}

macstuff() {
    mdfind "kMDItemCFBundleIdentifier == 'org*'"
}

macaddress() {
    ifconfig en0 | awk '/ether/{print $2}'
}

virustotal() {
    APIKEY=01b00a91ca133340a6ea1c2adaa4c70a897b8389960209b99f7123d9cd4ed4da;
    curl -v -F "file=@$1" -F apikey=${APIKEY} https://www.virustotal.com/vtapi/v2/file/scan
}

function ports() {
    alias ports="sudo netstat -tulpn"
}

function incognito() {
  case $1 in
    start)
    set +o history;;
    stop)
    set -o history;;
    *)
    echo -e "USAGE: incognito start - disable command history.
       incognito stop  - enable command history.";;
  esac
}


function server() {
    local port="${1:-8000}"
    sleep 1 && open "http://localhost:${port}/" &
    # Set the default Content-Type to `text/plain` instead of `application/octet-stream`
    # And serve everything as UTF-8 (although not technically correct, this doesn’t break anything for binary files)
    python -c $'import SimpleHTTPServer;\nmap = SimpleHTTPServer.SimpleHTTPRequestHandler.extensions_map;\nmap[""] = "text/plain";\nfor key, value in map.items():\n\tmap[key] = value + ";charset=UTF-8";\nSimpleHTTPServer.test();' "$port"
}


function mancolor () {
    #env \
        LESS_TERMCAP_mb=$(printf "\e[1;31m") \
        LESS_TERMCAP_md=$(printf "\e[1;31m") \
        LESS_TERMCAP_me=$(printf "\e[0m") \
        LESS_TERMCAP_se=$(printf "\e[0m") \
        LESS_TERMCAP_so=$(printf "\e[1;44;33m") \
        LESS_TERMCAP_ue=$(printf "\e[0m") \
        LESS_TERMCAP_us=$(printf "\e[1;32m") \
        man "$@"
}


function git-add-orphan-branch() {
    BRANCH=$1 
    REMOTEPATH=$2
    echo git checkout --orphan $BRANCH
    echo git remote add rem ${REMOTEPATH}
    echo git pull rem master
    echo git commit -am $BRANCH
    echo git remote remove rem

}



git-add-repo () 
{ 
    # https://stackoverflow.com/a/43340503/217652
    repo="$1";
    dir="$(echo "$2" | sed 's/\/$//')";
    path="$(pwd)";
    tmp="$(mktemp -d)";
    remote="$(echo "$tmp" | sed 's/\///g'| sed 's/\./_/g')";
    git clone "$repo" "$tmp";
    cd "$tmp";
    git filter-branch --index-filter '
        git ls-files -s |
        sed "s,\t,&'"$dir"'/," |
        GIT_INDEX_FILE="$GIT_INDEX_FILE.new" git update-index --index-info &&
        mv "$GIT_INDEX_FILE.new" "$GIT_INDEX_FILE"
    ' HEAD;
    cd "$path";
    git remote add -f "$remote" "file://$tmp/.git";
    git pull "$remote/master";
    git merge --allow-unrelated-histories -m "Merge repo $repo into master" --edit "$remote/master";
    git remote remove "$remote";
    rm -rf "$tmp"
}


function gitwtf()
{
    git filter-branch --tree-filter 'git diff-tree --name-only --diff-filter=AM -r --no-commit-id $GIT_COMMIT | find -iname "*.py" -exec perl -pi -e "s/\t/    /g" {} \;' HEAD
}

function chrome-private() 
{ 
    tdir=$(mktemp -d);
    echo $tdir;
    open -W -na "Google Chrome" --args "--user-data-dir=${tdir}";
    if [[ -d ${$tdir} ]] ; then 
        rm -rf ${tdir}
    fi
}

function chrome-booxby() 
{ 
    tdir=${HOME}/chrome/booxby
    test -d $tdir || return 1
    echo $tdir;
    open -W -na "Google Chrome" --args "--user-data-dir=${tdir}";
    if [[ -d ${$tdir} ]] ; then 
        rm -rf ${tdir}
    fi
}




wtfipython() {
    echo  "get_ipython().init_readline()"
    echo  "IPython.InteractiveShell.init_readline(get_ipython())"
    echo "pip install rlipython"
    echo "import rlipython; rlipython.install()"
}

# networksetup -listnetworkserviceorder
# networksetup  -getnetworkserviceenabled Wi-Fi-Proxy
# networksetup  -getnetworkserviceenabled Wi-Fi
# networksetup  -getnetworkserviceenabled Wi-Fi-Proxy on
# networksetup -setnetworkserviceenabled Wi-Fi-Proxy on
# networksetup -setnetworkserviceenabled Wi-Fi off

nmaptown ()
{
    sudo nmap -sS -sU -T4 -A -v -PE -PP -PS80,443 -PA3389 -PU40125 -PY -g 53 "$1" --webxml -oX - | sed "s|https://svn.nmap.org/nmap/docs/nmap.xsl|http://bucket-stuff.s3.amazonaws.com/nmap.xsl|" | xsltproc --output "$1.html" -
}

alias scan='sudo arp-scan --interface=en0 192.168.1.0/24 -D'
alias nmap.walk='nmap -sCV --osscan-guess'
alias nmap.enum='nmap --script=http-enum -p80 -n'






function ho ()
{
    command heroku $* -a ${HEROKU_APP}
}

function sniff ()
{
    sudo ngrep -d 'en0' -W byline -t '^(GET|POST) ' 'tcp'
}
function digga ()
{
    dig +nocmd "$1" any +multiline +noall +answer
}

function echof ()
{
  # echo the finder's window
  echo $(osascript -e 'tell app "Finder" to POSIX path of (insertion location as alias)')
}

encrypt_with_openssl ()
{
    openssl aes-256-cbc -in "$1" -out "$2"
}

decrypt_with_openssl ()
{
    openssl aes-256-cbc -d -in "$1" -out "$2"
}

mixdecode ()
{
    python -c "import urllib,json,base64,sys; arg = sys.argv[1]; print json.dumps(json.loads(base64.decodestring(urllib.unquote(arg))),indent=4)" "$1"
}

function vim-diff-dir ()
{
    first=$1;
    second=$2;
    res1=$(find $first -maxdepth 4 -type d | sed "s|$first||");
    res2=$(find $second -maxdepth 4 -type d | sed "s|$second||");

    echo "vim -d <(find $first -maxdepth 4  | sed \"s|$first||\")  <(find $second -maxdepth 4  | sed \"s|$second||\");"
    {
        cat "$res2" && cat "$res2"
    }
}

vim-diff-dir-2 ()
{
    first=$1;
    second=$2;
    f1=$(mktemp --suffix .1.a)
    f2=$(mktemp --suffix .2.a)

    echo "find $first -maxdepth 5 | LC_ALL=C sort | sed \"s|$first||\" > $f1"
    echo
    echo "find $second -maxdepth 5 | LC_ALL=C sort | sed \"s|$second||\" > $f2"
    echo
    echo "vim -d $f1 $f2"
}




function curlstats ()
{
    ( echo "url_effective\t%{url_effective}\n";
    echo "http_code\t%{http_code}\n";
    echo "content_type\t%{content_type}\n";
    echo "http_connect\t%{http_connect}\n";
    echo "time_total\t%{time_total}\n";
    echo "time_namelookup\t%{time_namelookup}\n";
    echo "time_connect\t%{time_connect}\n";
    echo "time_pretransfer\t%{time_pretransfer}\n";
    echo "time_redirect\t%{time_redirect}\n";
    echo "time_starttransfer\t%{time_starttransfer}\n";
    echo "size_download\t%{size_download}\n";
    echo "size_upload\t%{size_upload}\n";
    echo "size_header\t%{size_header}\n";
    echo "size_request\t%{size_request}\n";
    echo "speed_download\t%{speed_download}\n";
    echo "speed_upload\t%{speed_upload}\n";
    echo "redirect_url\t%{redirect_url}\n";
    echo "num_connects\t%{num_connects}\n";
    echo "num_redirects\t%{num_redirects}\n";
    echo -ne "" ) | command curl "$@" -w '@-'
}



function make_table ()
{
    echo "<style>td{border:1px solid black;}</style>";
    echo "<table>";
    {
    while read line; 
        do echo -ne "$line";
    done
    } | perl -p -e 's/^/<tr><td>/' | perl -p -e 's/\t/<\/td><td>/g' | perl -p -e 's|$|</td></tr>|';
    echo "</table>";
}


# this function replaces all the text between 'START.*END' with the contents of the passed fileparam
# http://paste.pocoo.org/show/576070/
function replace_stdin_with_contents_of_file ()
{
    REGEX="$1";
    REPLFILE=$2;
    python -c "import sys,re; print '$REPLFILE'; print re.sub(re.compile('$REGEX',re.DOTALL), open('$REPLFILE').read(), sys.stdin.read())"
}

function python3_find_module ()
{
    module=$1
    python3 -c "import ${module};print (${module}.__file__[:-1])"
}


function python_find_module ()
{
    module=$1
    python -c "import ${module};print ${module}.__file__[:-1]"
}


function sqltable ()
{ 
    echo "<style>td{border:1px solid black;}</style>"; echo "<table>"; sqlite3 -html "$@"; echo "</table>";
}


function sprunge ()
{
    curl -sF 'sprunge=<-' 'http://sprunge.us' <"${1:-/dev/stdin}"
}

function resolvedns ()
{
    python -c "import socket; s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM); s.connect(("\"$1\"", 80)); print s.getpeername()[0]"
}


function vdiff ()
{
    vd=vd.html;
    vim -c":windo :set nofoldenable" -c"TOhtml" -c"w! $vd" -c'qall!' -d "$@";
    echo $vd
}


function prettyprint_csv ()
{
    python -c 'import sys,csv; [sys.stdout.write("^M".join(map(str,r))+"\n") for r in csv.reader(sys.stdin)];' < $1 | column -s '^M' -t
}

function urldecode ()
{
    echo -e "$(sed 'y/+/ /; s/%/\x/g')";
}

function pvim ()
{
    read -r somefile; exec < /dev/fd/1; vi "$somefile"
}



function vim_html_diff ()
{
    vim -c ":windo :set nofoldenable" -c "TOhtml" -c "wqall" -d $*
}


show_tcp_ports ()
{
    server=${1:-localhost};
    nmap -p1-65535 "$server" 2> /dev/null | awk -v SERVER="$server" -F/ '/^[0-9]+\/tcp/{print "http://"SERVER":"$1 }'
}


function dfp ()
{
    # reports the percentage of used diskspace
    # stu@vervet:~$ dfp
    # 11%
    # stu@sente ~ $ dfp
    # 97%
    mydf=($(df -P /));
    echo "${mydf[11]}"
}


function cdp ()
{
    # usage: cdp <python> <module>
    # cdp python json --> cd's you into the json module's directory
    # can be used to determine the module for a given python version

    if [ -n $2 ]; then
        python=$1;
        module=$2;
    else
        python=python;
        module=$1;
    fi;
    cd "$($python -c "import os.path as _, ${module}; print _.dirname(_.realpath(${module}.__file__[:-1]))")"
}

function RED    () { tput setaf 1; echo "$@"; tput setaf 9; }
function GREEN	() { tput setaf 2; echo "$@"; tput setaf 9; }
function YELLOW	() { tput setaf 3; echo "$@"; tput setaf 9; }
function BLUE	() { tput setaf 4; echo "$@"; tput setaf 9; }
function PURPLE	() { tput setaf 5; echo "$@"; tput setaf 9; }
function CYAN	() { tput setaf 6; echo "$@"; tput setaf 9; }
function WHITE	() { tput setaf 7; echo "$@"; tput setaf 9; }

function COLORFUNC ()
{
    n=$1
    shift;

    if ! [[ -n $n ]]; then
        echo "pass parm" >&2;
        return 1;
    fi

    [[ $n -eq 1 ]] && BLUE "$@" && return 0
    [[ $n -eq 2 ]] && RED "$@" && return 0
    [[ $n -eq 3 ]] && GREEN "$@" && return 0
    [[ $n -eq 4 ]] && YELLOW "$@" && return 0
    [[ $n -eq 5 ]] && PURPLE "$@" && return 0
    [[ $n -eq 6 ]] && CYAN "$@" && return 0
    [[ $n -eq 7 ]] && WHITE "$@" && return 0
    echo "bad parm" >&2; return 1;

}




function confirm ()
{
    local reply;
    # make sure stdin is a terminal
    [[ -t 0 ]] || exec < /dev/tty;

    read -p "$bold$1$reset [Y/n] " reply;

    # if reply is empty
    [[ -z $reply ]] && return 0

    # if reply is Yes
    [[ $reply = [Yy] || $reply = [Yy][Ee][Ss] ]] && return 0
    
    # they typed something but it wasn't Y,Yes,YES,yES...
    return 1
}

function die ()
{
    if ((color)) && [[ -t 2 ]]; then
        printf "$red%s:$reset" "error";
    else
        printf "$bold%s:$reset" "error";
    fi;
    printf "\t %s\n" "$@";
    exit 1
} 1>&2





function webshare ()
{
    #usage: 'webshare <PORT>' - creates an HTTP Server on <PORT>
    python -c "import SimpleHTTPServer;SimpleHTTPServer.test()" $*
}




function reverse_array ()
{
    # A=(a b c d e f)
    # reverse_array B "${A[@]}"
    # echo "A = ${A[@]}"
    # echo "B = ${B[@]}"

    # A = a b c d e f
    # B = f e d c b a

    local _array="$1"
    shift

    unset $_array
    while test $# != 0
    do
        IFS= read -rd '' "$_array[$#-1]" < <(printf %s "$1")
        #printf -v "$_array[$(( $#-1 ))]" "%s" "$1"
        #printf -v $_array[$#-1] "%s" "$1"
        shift
    done
}




#baseN(int(time.time()),36)

function baseN()
{
    NUM=$1;
    base=$2;
    base=${base:=36}
    python -c \
"def baseN(num,base,numerals='0123456789abcdefghijklmnopqrstuvwxyz'):
    return ((num == 0) and  '0' ) or ( baseN(num // base, base).lstrip('0') + numerals[num % base])
print baseN($NUM,$base)"

}

postit ()
{
    POSTIT_URL="http://sente.cc/scripts/index_curlit.cgi";
    URL=${URL:-$POSTIT_URL}
    if [[ -t 0 ]]; then
        curl -sF "$(basename "$1")=<-" $URL < "$1";
    else
        if [[ -n $1 ]]; then
            curl -sF "$1=<-" $URL;
        else
            curl -sF "index=<-" $URL;
        fi;
    fi
}
export -f postit

#creates an image of the repo
function git-graph ()
{
    file=$1;
    {
        echo 'digraph git {';
        git log --pretty='format:  %h -> { %p }' "$@" | sed 's/[0-9a-f][0-9a-f]*/\"&\"/g';
        echo '}'
    } | dot -o "$file.dot";
    dot -Tpng -o "$file.png" "$file.dot"
}



function CD()
{
    [ -d "$1" ] && cd "$1" || cd "$(dirname "$1")";
}

# change terminal title
function tname()
{
    echo -ne "\033]0;${1:-$TERM}\007";
}


function pstable ()
{
    ps -eo user,rss,vsize,pid,ppid,pcpu,pmem,cmd -ww --sort=user | tr '\t' ' ' | sed 's/ \+/ /g' | while read a b c d e f g h; do
        echo -e "$a\t$b\t$c\t$d\t$e\t$f\t$g\t$h\t$i";
    done | columnate.awk -F'\t' | less -SR
}



function snapshot-list ()
{
    #function lists the snapshot paths for $ARG

    local path=$1;

    if [[ -x $(which readlink) ]]; then
        path=$($(which readlink) -m "$path")
        if [[ $path =~ ^/ ]]; then
            #remove leading '/' from $path if $path starts with /
            path="${path:1}"
        fi
    fi

    #if we're not currently in /snapshots...
    local snapdir="";
    if [[ ! $PWD =~ ^/snapshots/* ]]; then
        snapdir=/snapshots/;
    fi;

    local prefix=sente;
    local types=(daily weekly monthly);
    local numbers=(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16);


    for t in ${types[@]};
    do
        for n in ${numbers[@]};
        do
            ddd=${snapdir}${t}.${n}
            if [[ -d $ddd ]]; then
                str=$ddd/${prefix}/$path
                if [[ -e $str ]]; then echo "$str"; fi
            fi
        done
    done
}



#stat's terse format:
#stat -t ==  "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %o"
stat_delim="\t"
SFMT=$(echo "%n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %o\n" | sed "s/ /${stat_delim-\t}/g")


#inarray() { local q=$1 e; shift; for e; do [[ $q = "$e" ]] && return; done; } # Usage: inarray "$value" "${array[@]}"
function inarray ()
{
    local q=$1 e;
    shift;
    for e in "$@";
    do
        [[ $q = "$e" ]] && return;
    done
}


repeat()
{
    local i n; n=$1; shift; for ((i=1; i<=n; i++)); do "$@"; done
}
export -f repeat



function python_module_dir ()
{
    python -c """
import os.path as _, $1 
print _.dirname(_.realpath($1.__file__[:-1]))
"""
}

function python3_module_dir ()
{
    python -c """
import os.path as _, $1
print ( _.dirname(_.realpath($1.__file__[:-1])))
"""
}



function canonpath ()
{
    # show's the absolute path of a given file/directory
    # uses pwd'd -P option which resolves all symlinks

    # echo $(cd $(dirname "$1"); pwd -P)/$(basename "$1")
    readlink -m "$1"
}


function colordirdiff ()
{
    serverA=$1;
    serverB=$2;
    thedir=$3;
    if [[ -x $(which colordiff ) ]]; then
        colordiff -y --side-by-side <(ssh $1 "cd $thedir; find . -maxdepth 1 -type f -exec md5sum {} \;| sort -k 2") <(ssh $2 "cd $thedir; find . -maxdepth 1 -type f -exec md5sum {} \;| sort -k 2")
    else 
        diff -y --side-by-side <(ssh $1 "cd $thedir; find . -maxdepth 1 -type f -exec md5sum {} \;| sort -k 2") <(ssh $2 "cd $thedir; find . -maxdepth 1 -type f -exec md5sum {} \;| sort -k 2")
    fi  
}

function cmddiff ()
{
    CMD1="$1"
    CMD2="$2"
    if [[ -x $(which colordiff ) ]]; then
        colordiff -W 200 -y --side-by-side <( eval "${CMD1}" ) <( eval "${CMD2}" )
    else
        diff -W 200 -y --side-by-side <( eval "${CMD1}" ) <( eval "${CMD2}" )
    fi
}


# inspired by tpope :)
function FINDDIR ()
{ 
    find "$@" -mindepth 1 -type d 2> /dev/null
}
function FIND ()
{ 
    find "$@" ! -type d 2> /dev/null
}

function decolor ()
{
    sed -r "s/\x1B\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]//g"

    # or perhaps: 
    # sed -r "s/\x1B\[([0-9]{1,3}((;[0-9]{1,3})*)?)?[m|K]//g"
    # who can really say these days?
}

function list_latest ()
{
    local file files=("${1:-.}/"*) latest=$files;
    for file in "${files[@]}"; do
        [[ $file -nt $latest ]] && latest=$file;
    done;
    echo "$latest"
}

function list_files ()
{
    local file files=("${1:-.}/"*)
    for file in "${files[@]}"; do
        [[ -f "$file" ]] && echo $file
    done;
}

function _list_dotfiles ()
{
    local file files=("${1:-.}/".*)
    for file in "${files[@]}"; do
        [[ "$file" = "./." ]] && continue
        [[ "$file" = "./.." ]] && continue
        [[ -f "$file" ]] && echo $file
    done
}

function _list_dotdirs ()
{
    local file files=("${1:-.}/".*)
    for file in "${files[@]}"; do
        [[ "$file" = "./." ]] && continue
        [[ "$file" = "./.." ]] && continue
        [[ -d "$file" ]] && echo $file
    done
}

function _list_paths ()
{
	echo -e "${PATH//:/\n}";
}

# http://bash-hackers.org/wiki/doku.php/snipplets/prargs
function print_arglist()
{
   printf '"%b"\n' "$0" "$@" | nl -v0 -s": "
}

function inspect ()
{
    echo "\$$1 = ${!1}";
}

function p ()
{
    prog=$1
    found=`pgrep $prog`
    # command name width
    if [ ! -z "$2" ]
        then cmdwide='cmd -ww'
        else cmdwide='comm'
    fi
    if [ ! -z "$prog" ] && [ ! -z "$found" ]; then
        ps -o user,pid,ppid,%cpu,%mem,stat,$cmdwide -p `pgrep $prog`
    fi
}

function pw ()
{
    p "$1" show_wide_command_line
}


function mkcd ()
{
    mkdir "$@" && cd "${!#}"
}

function cdl ()
{
    if [ "$1" ]
        then builtin cd "$1" && ll
        else builtin cd && ll
    fi
}

function mkt ()
{
    BASEDIR=${HOME}/scratch;
    YEAR=$(date "+%Y");
    DIR=${BASEDIR}/daily/${YEAR};
    TEMPLATE=$(date "+%m/%d");

    #BASEDIR=${HOME}/scratch
    #DIR=${BASEDIR}/daily
    #TEMPLATE=$(date "+%m/%d")

    arg=$1
    if [[ -n $arg ]]; then
        if [[ $arg =~ ^([[:alnum:]]|[[:punct:]])+$ ]]; then
            TEMPLATE=$TEMPLATE/${arg}
            echo "arg=$arg"
        else
            echo "error: arg: '$arg'" >&2
            sleep 1
        fi
    fi

    if [ -d $DIR/$TEMPLATE/ ]; then
         cd $DIR/$TEMPLATE && ls -l
    else
        mkdir -p $DIR/$TEMPLATE && cd $DIR/$TEMPLATE
    fi
    echo $TEMPLATE >> $DIR/list.txt
    echo -e "$(date +%s)\t$TEMPLATE" >> $DIR/log.txt
}


function mkt_old ()
{

    DIR=${HOME}/tmp
    TEMPLATE=tmp.$(date "+%m-%d")

    if [ -d $DIR/$TEMPLATE/ ]; then
         cd $DIR/$TEMPLATE && ls -l *
    else
        mkdir $DIR/$TEMPLATE && cd $DIR/$TEMPLATE
    fi
}


#we don't want these functions defined on any IR servers

function tmpfile ()
{
    basedir=${HOME}/public_html/tmpfiles
    extension=html

    while test $# -gt 0; do
        case $1 in 
            -e | --e )
                shift; extension="$1"
                ;;
            -d | --dir )
                shift; baseidr="$1"
                ;;
            *)
                break
                ;;
        esac
    done
    file="${basedir}/$(date +%F.%s).${extension}";
    echo $file
    while IFS='' read -r line; do
        echo "$line" >> $file;
    done;

    echo "${file/$basedir/http://www.sente.cc/stu/tmpfiles}"
}



function snapshot-show ()
{
    arg=$(readlink -m "$1")
    echo "arg=$arg" >&2
    snapdirs=(/snapshots/{daily,weekly,monthly}.*/sente)
    for f in "${snapdirs[@]}"; do
        if [[ -f ${f}${arg} ]] ; then
            echo ${f}${arg}
        else
            echo ${f}${arg} "[missing]">&2
        fi
    done
}

function snapdiff ()
{
    snapshot-show $1 2> /dev/null | xargs md5sum | awk '{if(!foo[$1]++){print $2}}' | while read line; do
        if  [[ $(which colordiff) ]]; then
            CCC="diff --side-by-side --suppress-common-lines  $LAST $line | colordiff";
        else
            CCC="diff --side-by-side --suppress-common-lines  $LAST $line";
        fi
        echo $CCC;
        eval $CCC;
        echo -e "\n\n\n\n\n";
        LAST=$line;
    done 
    #| ansi2html.sh --bg=dark > public_html/bahtown.html
}

function snapdiff2 ()
{
    echo 'ls -1t /snapshots/daily.*/some/file | snapdiff2' >&2
    echo '-e to run the commands ' >&2
    

    while read meta; do
        md5sum $meta;
    done | awk '{if(!foo[$1]++){print $2}}' | while read line; do
        if [[ -n $(which colordiff) ]]; then
            CCC="diff --side-by-side --suppress-common-lines  $LAST $line | colordiff";
        else
            CCC="diff --side-by-side --suppress-common-lines  $LAST $line";
        fi;
        echo $CCC;
        LAST=$line;
    done
}



function epochtime ()
{
    dddd="$1"
    shift
    ffff="$2"
    shift
#    rest="$3"
    date --date "1970-01-01 UTC $dddd seconds" $ffff #$rest" 
}

#taken from !du-h in #bash
function dusk ()
{
   du -sk "$@" | 
   sort -n  |
   awk -F'\t' '{
      if ($1 > 1000000)   printf("%.2fG\t%s\n",$1/1000000,$2);
      else if ($1 > 1000) printf("%.2fM\t%s\n",$1/1000,$2);
      else                printf("%sk\t%s\n",  $1,$2)
   }';
}

function dumdl ()
{
    for mdl in "$@"; do
        if [[ -f "$mdl" && "$mdl" == *.mdl ]]; then
            mdlbase=${mdl%%.mdl};
            mdlsize=$(du -sck "${mdlbase}"*|grep total|cut -f1);
            #mdlhumansize=$(awk -v m=${mdlsize} 'BEGIN{printf "%.02f",(m/(1024)/1024)}' 1);
            echo -e "${mdlsize}\t${mdlbase}.mdl";
            #echo -e "${mdlhumansize}\t${mdlsize}\t${mdlbase}*";
        fi
    done | sort -n |
        awk '{
            if ($1 > 1000000)   printf("%.2fG\t%s\n",$1/1000000,$2);
            else if ($1 > 1000) printf("%.2fM\t%s\n",$1/1000,$2);
            else                printf("%sk\t%s\n",  $1,$2)
        }';
}


function webget ()
{

    if [ -x "`which curl`" ]; then
       get="curl -s"
    else
       get="wget -qO -"
    fi
}
function pip2h ()
{
    NAME=$1;
    python -c "import socket;  print socket.gethostbyaddr(\"$NAME\");"
}
function ph2ip ()
{
    NAME=$1;
    python -c "import socket;  print socket.gethostbyname(\"$NAME\");"
}

function pname ()
{
    NAME=$1;
    python -c "import socket; print socket.gethostbyname(\"$NAME\"); print socket.gethostbyaddr(\"$NAME\");"
}


function pyget ()
{

   python -c "import urllib2; print urllib2.urlopen(\"$1\").read()"
}

function webheaders ()
{

   python -c "import urllib2; print urllib2.urlopen(\"$1\").info()"
}

function assert_file ()
{
   ONE=$1
   [[ -z "$ONE" ]] && { echo "MISSING PARAMETER"; return 1; };
   [[ -f "$ONE" ]] || { echo "$ONE: IS NOT A FILE"; return 1; };
}


function emailpipe ()
{

   curl -F "note=<-" http://sente.cc/cgi-bin/email.pl
}

function curlnote ()
{
   if [ ! -f "$1" ]; then echo "$1 is not a file"; return 1; fi
   #curl -F "note=<$1" http://sente.cc/cgi-bin/note.pl 2>/dev/null | grep -m1 -o -E '"http://[^"]+"'
   curl --data-urlencode "note@$1" http://sente.cc/cgi-bin/note.pl 2>/dev/null | grep -m1 -o -E '"http://[^"]+"'
   echo "http://sente.cc/notes/recent/"
}

function webdiff ()
{
    if [[ ! -f $1 || ! -f $2 ]]; then
        echo "usage: $0 file1 file2"
        return 1
    fi

    if [[ ! -s $1 || ! -s $2 ]]; then
        echo "$1 or $2 is empty"
        return 1
    fi

    read md5 _ < <(md5sum < $1)
    read md6 _ < <(md5sum < $2)

    if [[ $md5 = $md6 ]]; then
        echo "$1 and $2 are equal"
        return 0
    fi

    F1=$(basename "$1");
    F2=$(basename "$2");

    if [[ $F1 = $F2 ]]; then
        F1=${F1}.1;
        F2=${F2}.2;
    fi;

    curl -F "file.1=@$1;filename=${F1}" \
         -F "file.2=@$2;filename=${F2}" \
         http://sente.cc/stu/cgi-bin/compare-bin.py 2>/dev/null | \
         grep --color=auto -E "^http"
}




#function bucket ()
#{
#
#   FILE=$1
#   test -f "$FILE" && 
#   cp -a "$FILE" /home/stu/code/github/bucket/ &&
#   FILE=$(basename $FILE)
#   cd /home/stu/code/github/bucket/ &&
#   git add "$FILE" &&
#   git commit -m "$FILE" &&
#   git push gitweb master && 
#   cd -;
#}

function dotadd ()
{

   FILE=$1
   arr=("$@")
   [ ${#arr[@]} -lt 2 ] && { echo "must pass params"; return 1; }

   test -f "$FILE" && 
   echo cp "${HOME}/${FILE}" "/home/stu/code/github/dotfiles/${FILE}" &&
   echo cd /home/stu/code/github/dotfiles/ &&
   echo git status &&
   echo git add "${FILE}" &&
   echo git commit -m ${arr[1]} &&
   echo git status &&
   echo git-archive --format=tar HEAD > /home/stu/dotfiles.tar &&
   echo cd - 


   cp "${HOME}/${FILE}" "/home/stu/code/github/dotfiles/${FILE}" &&
   cd /home/stu/code/github/dotfiles/ &&
   git status &&
   git add "${FILE}" &&
   git commit -m ${arr[1]} &&
   git status &&
   git-archive --format=tar HEAD > /home/stu/dotfiles.tar &&
   cd - 


#   git add "$FILE" &&
#   git commit -m "$FILE" &&
#   git push gitweb master && 
}

function git-tar ()
{
    cd /home/stu/code/github/dotfiles &&
    git-status &&
    git-archive --format=tar HEAD > /home/stu/dotfiles.tar
}

function curl_note ()
{
   curl -F "note=<-" http://sente.cc/cgi-bin/email.pl
}


#stolen from tpope:  http://www.tpope.net/node/108  http://c.tpope.net/
function get_tgzfile()
{

   REMOTEFILE=http://sente.cc/stu/dotfiles.tgz
   DESTDIR=DOTFILES
   mkdir $DESTDIR || return 1

   if [ -x "`which curl`" ];
      then get="curl -s"
      else get="wget -qO -"
   fi
   $get $REMOTEFILE | gzip -dc | tar xf - -C $DESTDIR
   find $REMOTEFILE
}

function locates()    { find $HOME/tmp/ -name '*locate*'; }

function dlocate()    { locate -d "$HOME/tmp/locatedb" "$@"; }
function hlocate()    { locate -d "$HOME/tmp/.mlocate.db" "$@"; }
function tlocate()    { locate -d "$HOME/tmp/.tlocate.db" "$@"; }
function wlocate()    { locate -d "$HOME/tmp/.wlocate.db" "$@"; }
function slocate()    { locate -d "$HOME/tmp/locate/stu.locatedb" "$@"; }
function alocate()    { locate -d "$HOME/tmp/.alocate.db" "$@"; }
function olocate()    { locate -d "$HOME/tmp/.olocate.db" "$@"; }
function mlocate()    { locate -d "$HOME/tmp/.mlocate.db" "$@"; }

function locates()    { _locates=(hlocate tlocate wlocate slocate alocate olocate mlocate); for l in ${_locates[@]}; do echo $l $@; done; }

export -f hlocate
export -f tlocate
export -f wlocate
export -f slocate
export -f alocate
export -f olocate
export -f mlocate
export -f locates

function irdaily()    { locate -d '/var/lib/mlocate/mlocate.ir-daily.db'   "$@"; }

function locate_migration() { locate -d '/var/lib/mlocate/mlocate.migration.db' "$@"; }
function locate_scratch()   { locate -d '/var/lib/mlocate/mlocate.scratch.db'   "$@"; }
function locate_irdaily()   { locate -d '/var/lib/mlocate/mlocate.ir-daily.db'  "$@"; }
function locate_all()       { locate -d '/var/lib/mlocate/mlocate.all.db'       "$@"; }
function locate_snapshot() { ls -1 /snapshots/locate/*.db; locate -d '/snapshots/locate/daily.0.db' "$@";  }

function ff()        { find . -name "*$@*" -print 2>/dev/null; }

function psa()       { ps aux $@; }
function psu()       { ps  ux $@; }

function lpsa()      { ps aux $@ | p; }
function lpsu()      { ps  ux $@ | p; }

function psgrep()    { ps ax | grep $1 | fgrep -v "grep $1"; }


# Rename *.foo to *.bar
function rename_ext ()
{
    fr=$1
    to=$2
    shift; shift; 
    for f in "${@}"; do
        #make sure the file extension matches
        [[ ${f##*.} == "$fr" ]] && echo "mv $f ${f%$fr}$to"
    done
}

function wget_mirror ()
{
    
    if [ -x $HOME/bin/wget ]; then
        WGET=$HOME/bin/wget
    else
        WGET=$(which wget)
    fi

    URL="$1"
    NEW="${URL//\//^}"
    mkdir "$NEW"
    (
        cd "$NEW" &&
        $WGET -nd -pHEKk "$URL";
    )        
}



function tailwithfile ()
{
    if [[ $1 == -n ]]; then
        n=$2; shift; shift;
    fi;
    for foo in "${@}"; do
        while read line; do
            echo -e "$foo:\t$line";
        done < <(tail -n$n $foo);
    done
}

function catwithfile ()
{
    if [[ $1 == -n ]]; then
        n=$2; shift; shift;
    fi;
    for foo in "${@}"; do
        while read line; do
            echo -e "$foo:\t$line";
        done < <(tail -n$n $foo);
    done
}