From d732b038289bb467091ab462778192d668f422b5 Mon Sep 17 00:00:00 2001 From: Maarten Billemont Date: Sat, 7 Jun 2014 15:51:11 -0400 Subject: [PATCH] Finished the C implementation & CLI tool. Providing an OS X binary. --- .gitignore | 1 + External/LoveLyndir | 2 +- MasterPassword/C/bashlib | 1920 ++++++++++++++++++++++++++ MasterPassword/C/build | 8 +- MasterPassword/C/ciphers | 78 -- MasterPassword/C/install | 64 +- MasterPassword/C/lib/proplib/.source | 1 - MasterPassword/C/mpw.bashrc | 24 + MasterPassword/C/mpw.c | 123 +- MasterPassword/C/types.c | 19 + MasterPassword/C/types.h | 3 + 11 files changed, 2112 insertions(+), 131 deletions(-) create mode 100755 MasterPassword/C/bashlib delete mode 100644 MasterPassword/C/ciphers delete mode 100644 MasterPassword/C/lib/proplib/.source create mode 100644 MasterPassword/C/mpw.bashrc diff --git a/.gitignore b/.gitignore index 14785cf2..ab3f334d 100644 --- a/.gitignore +++ b/.gitignore @@ -29,6 +29,7 @@ Press/MasterPassword_PressKit/MasterPassword_pressrelease_*.pdf MasterPassword/Java/**/target # C +MasterPassword/C/*.o MasterPassword/C/mpw MasterPassword/C/lib/*/* !MasterPassword/C/lib/*/.source diff --git a/External/LoveLyndir b/External/LoveLyndir index ceed9e20..77e8fa37 160000 --- a/External/LoveLyndir +++ b/External/LoveLyndir @@ -1 +1 @@ -Subproject commit ceed9e20009f2cf3679445e2c60b0f206aaef383 +Subproject commit 77e8fa376e3b28224ca26e08146242b71269567c diff --git a/MasterPassword/C/bashlib b/MasterPassword/C/bashlib new file mode 100755 index 00000000..d02d9cdf --- /dev/null +++ b/MasterPassword/C/bashlib @@ -0,0 +1,1920 @@ +#! /usr/bin/env bash +# ___________________________________________________________________________ # +# # +# BashLIB -- A library for Bash scripting convenience. # +# # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +# ___________________________________________________________________________ # +# # +# # +# Copyright 2007-2013, lhunath # +# * http://www.lhunath.com # +# * Maarten Billemont # +# # + + + +# ______________________________________________________________________ +# | | +# | .:: TABLE OF CONTENTS ::. | +# |______________________________________________________________________| +# +# chr decimal +# Outputs the character that has the given decimal ASCII value. +# +# ord character +# Outputs the decimal ASCII value of the given character. +# +# hex character +# Outputs the hexadecimal ASCII value of the given character. +# +# unhex character +# Outputs the character that has the given decimal ASCII value. +# +# max numbers... +# Outputs the highest of the given numbers. +# +# min numbers... +# Outputs the lowest of the given numbers. +# +# totime "YYYY-MM-DD HH:MM:SS.mmm"... +# Outputs the number of milliseconds in the given date string(s). +# +# exists application +# Succeeds if the application is in PATH and is executable. +# +# eol message +# Return termination punctuation for a message, if necessary. +# +# hr pattern [length] +# Outputs a horizontal ruler of the given length in characters or the terminal column length otherwise. +# +# cloc +# Outputs the current cursor location as two space-separated numbers: row column. +# +# readwhile command [args] +# Outputs the characters typed by the user into the terminal's input buffer while running the given command. +# +# pushqueue element ... +# Pushes the given arguments as elements onto the queue. +# +# popqueue +# Pops one element off the queue. +# +# log [format] [arguments...] +# Log an event at a certain importance level. The event is expressed as a printf(1) format argument. +# +# emit [options] message... [-- [command args...]] +# Display a message with contextual coloring. +# +# spinner [-code|message... [-- style color textstyle textcolor]] +# Displays a spinner on the screen that waits until a certain time. +# +# report [-code] [-e] failure-message [success-message] +# This is a convenience function for replacement of spinner -code. +# +# ask [-c optionchars|-d default] [-s|-S maskchar] message... +# Ask a question and read the user's reply to it. Then output the result on stdout. +# +# trim lines ... +# Trim the whitespace off of the beginning and end of the given lines. +# +# reverse [-0|-d delimitor] [elements ...] [<<< elements] +# Reverse the order of the given elements. +# +# order [-0|-d char] [-[cC] isAscending|-n] [-t number] [elements ...] [<<< elements] +# Orders the elements in ascending order. +# +# mutex file +# Open a mutual exclusion lock on the file, unless another process already owns one. +# +# pushjob [poolsize] command +# Start an asynchronous command within a pool, waiting for space in the pool if it is full. +# +# fsleep time +# Wait for the given (fractional) amount of seconds. +# +# getArgs [options] optstring [args...] +# Retrieve all options present in the given arguments. +# +# showHelp name description author [option description]... +# Generate a prettily formatted usage description of the application. +# +# shquote [-e] [argument...] +# Shell-quote the arguments to make them safe for injection into bash code. +# +# requote [string] +# Escape the argument string to make it safe for injection into a regex. +# +# shorten [-p pwd] path [suffix]... +# Shorten an absolute path for pretty printing. +# +# up .../path|num +# Walk the current working directory up towards root num times or until path is found. +# +# buildarray name terms... -- elements... +# Create an array by adding all the terms to it for each element, replacing {} terms by the element. +# +# inArray element array +# Checks whether a certain element is in the given array. +# +# xpathNodes query [files...] +# Outputs every xpath node that matches the query on a separate line. +# +# hideDebug [on|off] +# Toggle Bash's debugging mode off temporarily. +# +# stackTrace +# Output the current script's function execution stack. +# +_tocHash=71e13f42e1ea82c1c7019b27a3bc71f3 + + +# ______________________________________________________________________ +# | | +# | .:: GLOBAL CONFIGURATION ::. | +# |______________________________________________________________________| + +# Unset all exported functions. Exported functions are evil. +while read _ _ func; do + command unset -f "$func" +done < <(command declare -Fx) + +{ +shopt -s extglob +shopt -s globstar +} 2>/dev/null ||: + +# Generate Table Of Contents +genToc() { + local line= comments=() usage= whatis= lineno=0 out= outhash= outline= + while read -r line; do + (( ++lineno )) + + [[ $line = '#'* ]] && comments+=("$line") && continue + [[ $line = +([[:alnum:]])'() {' ]] && IFS='()' read func _ <<< "$line" && [[ $func != $FUNCNAME ]] && { + usage=${comments[3]##'#'+( )} + whatis=${comments[5]##'#'+( )} + [[ $usage = $func* && $whatis = *. ]] || err "Malformed docs for %s (line %d)." "$func" "$lineno" + + printf -v outline '# %s\n# %s\n#\n' "$usage" "$whatis" + out+=$outline + } + comments=() + done < ~/.bin/bashlib + + outhash=$(openssl md5 <<< "$out") + if [[ $_tocHash = $outhash ]]; then + inf 'Table of contents up-to-date.' + else + printf '%s' "$out" + printf '_tocHash=%q' "$outhash" + wrn 'Table of contents outdated.' + fi +} + + + +# ______________________________________________________________________ +# | | +# | .:: GLOBAL DECLARATIONS ::. | +# |______________________________________________________________________| + +# Variables for global internal operation. +bobber=( '.' 'o' 'O' 'o' ) +spinner=( '-' \\ '|' '/' ) +crosser=( '+' 'x' '+' 'x' ) +runner=( '> >' \ + '>> ' \ + ' >>' ) + +# Variables for terminal requests. +[[ -t 2 ]] && { + alt=$( tput smcup || tput ti ) # Start alt display + ealt=$( tput rmcup || tput te ) # End alt display + hide=$( tput civis || tput vi ) # Hide cursor + show=$( tput cnorm || tput ve ) # Show cursor + save=$( tput sc ) # Save cursor + load=$( tput rc ) # Load cursor + dim=$( tput dim || tput mh ) # Start dim + bold=$( tput bold || tput md ) # Start bold + stout=$( tput smso || tput so ) # Start stand-out + estout=$( tput rmso || tput se ) # End stand-out + under=$( tput smul || tput us ) # Start underline + eunder=$( tput rmul || tput ue ) # End underline + reset=$( tput sgr0 || tput me ) # Reset cursor + blink=$( tput blink || tput mb ) # Start blinking + italic=$( tput sitm || tput ZH ) # Start italic + eitalic=$( tput ritm || tput ZR ) # End italic +[[ $TERM != *-m ]] && { + red=$( tput setaf 1|| tput AF 1 ) + green=$( tput setaf 2|| tput AF 2 ) + yellow=$( tput setaf 3|| tput AF 3 ) + blue=$( tput setaf 4|| tput AF 4 ) + magenta=$( tput setaf 5|| tput AF 5 ) + cyan=$( tput setaf 6|| tput AF 6 ) +} + black=$( tput setaf 0|| tput AF 0 ) + white=$( tput setaf 7|| tput AF 7 ) + default=$( tput op ) + eed=$( tput ed || tput cd ) # Erase to end of display + eel=$( tput el || tput ce ) # Erase to end of line + ebl=$( tput el1 || tput cb ) # Erase to beginning of line + ewl=$eel$ebl # Erase whole line + draw=$( tput -S <<< ' enacs + smacs + acsc + rmacs' || { \ + tput eA; tput as; + tput ac; tput ae; } ) # Drawing characters + back=$'\b' +} 2>/dev/null ||: + + + + + +# ______________________________________________________________________ +# | | +# | .:: FUNCTION DECLARATIONS ::. | +# |______________________________________________________________________| + + + +# ______________________________________________________________________ +# |__ Chr _______________________________________________________________| +# +# chr decimal +# +# Outputs the character that has the given decimal ASCII value. +# +chr() { + printf \\"$(printf '%03o' "$1")" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Ord _______________________________________________________________| +# +# ord character +# +# Outputs the decimal ASCII value of the given character. +# +ord() { + printf %d "'$1" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Hex _______________________________________________________________| +# +# hex character +# +# Outputs the hexadecimal ASCII value of the given character. +# +hex() { + printf '%x' "'$1" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Unhex _______________________________________________________________| +# +# unhex character +# +# Outputs the character that has the given decimal ASCII value. +# +unhex() { + printf \\x"$1" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ max _______________________________________________________________| +# +# max numbers... +# +# Outputs the highest of the given numbers. +# +max() { + local max=$1 n + for n + do (( n > max )) && max=$n; done + printf %d "$max" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ min _______________________________________________________________| +# +# min numbers... +# +# Outputs the lowest of the given numbers. +# +min() { + local min=$1 n + for n + do (( n < min )) && min=$n; done + printf %d "$min" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ totime ____________________________________________________________| +# +# totime "YYYY-MM-DD HH:MM:SS.mmm"... +# +# Outputs the number of milliseconds in the given date string(s). +# +# When multiple date string arguments are given, multiple time strings are output, one per line. +# +# The fields should be in the above defined order. The delimitor between the fields may be any one of [ -:.]. +# If a date string does not follow the defined format, the result is undefined. +# +# Note that this function uses a very simplistic conversion formula which does not take any special calendar +# convenions into account. It assumes there are 12 months in evert year, 31 days in every month, 24 hours +# in every day, 60 minutes in every hour, 60 seconds in every minute and 1000 milliseconds in every second. +# +totime() { + local arg time year month day hour minute second milli + for arg; do + IFS=' -:.' read year month day hour minute second milli <<< "$arg" && + (( time = (((((((((((10#$year * 12) + 10#$month) * 31) + 10#$day) * 24) + 10#$hour) * 60) + 10#$minute) * 60) + 10#$second) * 1000) + 10#$milli )) && + printf '%d\n' "$time" + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Exists ____________________________________________________________| +# +# exists application +# +# Succeeds if the application is in PATH and is executable. +# +exists() { + [[ -x $(type -P "$1" 2>/dev/null) ]] +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Eol _______________________________________________________________| +# +# eol message +# +# Return termination punctuation for a message, if necessary. +# +eol() { + : #[[ $1 && $1 != *[\!\?.,:\;\|] ]] && printf .. ||: +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Hr _______________________________________________________________| +# +# hr pattern [length] +# +# Outputs a horizontal ruler of the given length in characters or the terminal column length otherwise. +# The ruler is a repetition of the given pattern string. +# +hr() { + local pattern=${1:--} length=${2:-$COLUMNS} ruler= + (( length )) || length=$(tput cols) + + while (( ${#ruler} < length )); do + ruler+=${pattern:0:length-${#ruler}} + done + + printf %s "$ruler" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ CLoc ______________________________________________________________| +# +# cloc +# +# Outputs the current cursor location as two space-separated numbers: row column. +# +cloc() { + local old=$(stty -g) + trap 'stty "$old"' RETURN + stty raw + + # If the tty has input waiting then we can't read back its response. We'd only break and pollute the tty input buffer. + read -t 0 < /dev/tty 2>/dev/null && return 1 + + printf '\e[6n' > /dev/tty + IFS='[;' read -dR _ row col < /dev/tty + printf '%d %d' "$row" "$col" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ readwhile ______________________________________________________________| +# +# readwhile command [args] +# +# Outputs the characters typed by the user into the terminal's input buffer while running the given command. +# +readwhile() { + local old=$(stty -g) in result REPLY + trap 'stty "$old"' RETURN + stty raw + + "$@" + result=$? + + while read -t 0; do + IFS= read -rd '' -n1 && in+=$REPLY + done + printf %s "$in" + + return $result +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Latest ____________________________________________________________| +# +# latest [file...] +# +# Output the argument that represents the file with the latest modification time. +# +latest() ( + shopt -s nullglob + local file latest=$1 + for file; do + [[ $file -nt $latest ]] && latest=$file + done + printf '%s\n' "$latest" +) # _____________________________________________________________________ + + + +# _______________________________________________________________________ +# |__ Iterate ____________________________________________________________| +# +# iterate [command] +# +# All arguments to iterate make up a single command that will be executed. +# +# Any of the arguments may be of the format {x..y[..z]} which causes the command +# to be executed in a loop, each iteration substituting the argument for the +# current step the loop has reached from x to y. We step from x to y by +# walking from x's position in the ASCII character table to y's with a step of z +# or 1 if z is not specified. +# +iterate() ( + set -x + local command=( "$@" ) iterationCommand=() loop= a= arg= current=() step=() target=() + for a in "${!command[@]}"; do + arg=${command[a]} + if [[ $arg = '{'*'}' ]]; then + loop=${arg#'{'} loop=${loop%'}'} + step[a]=${loop#*..*..} current[a]=${loop%%..*} target[a]=${loop#*..} target[a]=${target[a]%.."${step[a]}"} + [[ ! ${step[a]} || ${step[a]} = $loop ]] && step[a]=1 + fi + done + if (( ${#current[@]} )); then + for loop in "${!current[@]}"; do + while true; do + iterationCommand=() + + for a in "${!command[@]}"; do + (( a == loop )) \ + && iterationCommand+=( "${current[a]}" ) \ + || iterationCommand+=( "${command[a]}" ) + done + + iterate "${iterationCommand[@]}" + + [[ ${current[loop]} = ${target[loop]} ]] && break + current[loop]="$(chr "$(( $(ord "${current[loop]}") + ${step[loop]} ))")" + done + done + else + "${command[@]}" + fi +) # _____________________________________________________________________ + +# ______________________________________________________________________ +# |__ Logging ___________________________________________________________| +# +# log [format] [arguments...] +# +# Log an event at a certain importance level. The event is expressed as a printf(1) format argument. +# The current exit code remains unaffected by the execution of this function. +# +# Instead of 'log', you can use a level as command name, to log at that level. Using log, messages are +# logged at level inf. The supported levels are: trc, dbg, inf, wrn, err, ftl. +# +# If you prefix the command name with a p, the log message is shown as a spinner and waits for the next +# closing statement. Eg. +# +# pinf 'Converting image' +# convert image.png image.jpg +# fnip +# +# The closing statement (here fnip) is the reverse of the opening statement and exits with the exit code +# of the last command. If the last command failed, it shows the exit code in the spinner before it is stopped. +# The closing statement also takes a format and arguments, which are displayed in the spinner. +# +log() { + local exitcode=$? level=${level:-inf} supported=0 end=$'\n' type=msg conMsg= logMsg= format= colorFormat= date= info= arg= args=() colorArgs=() ruler= + + # Handle options. + local OPTIND=1 + while getopts :puPr arg; do + case $arg in + p) + end='.. ' + type=startProgress ;; + u) + end='.. ' + type=updateProgress ;; + P) + type=stopProgress ;; + r) + ruler='____' ;; + esac + done + shift "$((OPTIND-1))" + format=$1 args=( "${@:2}" ) + (( ! ${#args[@]} )) && [[ $format ]] && { args=("$format") format=%s; local bold=; } + + # Level-specific settings. + case $level in + TRC) (( supported = _logVerbosity >= 4 )) + logLevelColor=$_logTrcColor ;; + DBG) (( supported = _logVerbosity >= 3 )) + logLevelColor=$_logDbgColor ;; + INF) (( supported = _logVerbosity >= 2 )) + logLevelColor=$_logInfColor ;; + WRN) (( supported = _logVerbosity >= 1 )) + logLevelColor=$_logWrnColor ;; + ERR) (( supported = _logVerbosity >= 0 )) + logLevelColor=$_logErrColor ;; + FTL) (( supported = 1 )) + logLevelColor=$_logFtlColor ;; + *) + log FTL "Log level %s does not exist" "$level" + exit 1 ;; + esac + (( ! supported )) && return "$exitcode" + local logColor=${logColor:-$logLevelColor} + + # Generate the log message. + date=$(date +"${_logDate:-%H:%M}") + case $type in + msg|startProgress) + printf -v logMsg "[%s %-3s] $format$end" "$date" "$level" "${args[@]}" + if (( _logColor )); then + colorFormat=$(sed -e "s/$(requote "$reset")/$reset$logColor/g" -e "s/%[^a-z]*[a-z]/$reset$bold$logColor&$reset$logColor/g" <<< "$format") + colorArgs=("${args[@]//$reset/$reset$bold$logColor}") + printf -v conMsg "$reset[%s $logLevelColor%-3s$reset] $logColor$colorFormat$reset$black\$$reset$end$save" "$date" "$level" "${colorArgs[@]}" + else + conMsg=$logMsg + fi + ;; + + updateProgress) + printf -v logMsg printf " [$format]" "${args[@]}" + if (( _logColor )); then + colorFormat=$(sed -e "s/$(requote "$reset")/$reset$logColor/g" -e "s/%[^a-z]*[a-z]/$reset$bold$logColor&$reset$logColor/g" <<< "$format") + colorArgs=("${args[@]//$reset/$reset$bold$logColor}") + printf -v conMsg "$load$eel$blue$bold[$reset$logColor$colorFormat$reset$blue$bold]$reset$end" "${colorArgs[@]}" + else + conMsg=$logMsg + fi + ;; + + stopProgress) + case $exitcode in + 0) printf -v logMsg "done${format:+ ($format)}.\n" "${args[@]}" + if (( _logColor )); then + colorFormat=$(sed -e "s/$(requote "$reset")/$reset$logColor/g" -e "s/%[^a-z]*[a-z]/$reset$bold$logColor&$reset$logColor/g" <<< "$format") + colorArgs=("${args[@]//$reset/$reset$bold$logColor}") + printf -v conMsg "$load$eel$green${bold}done${colorFormat:+ ($reset$logColor$colorFormat$reset$green$bold)}$reset.\n" "${colorArgs[@]}" + else + conMsg=$logMsg + fi + ;; + + *) info=${format:+$(printf ": $format" "${args[@]}")} + printf -v logMsg "error(%d%s).\n" "$exitcode" "$info" + if (( _logColor )); then + printf -v conMsg "${eel}${red}error${reset}(${bold}${red}%d${reset}%s).\n" "$exitcode" "$info" + else + conMsg=$logMsg + fi + ;; + esac + ;; + esac + + # Create the log file. + if [[ $_logFile && ! -e $_logFile ]]; then + [[ $_logFile = */* ]] || $_logFile=./$logFile + mkdir -p "${_logFile%/*}" && touch "$_logFile" + fi + + # Stop the spinner. + if [[ $type = stopProgress && $_logSpinner ]]; then + kill "$_logSpinner" + wait "$_logSpinner" 2>/dev/null + unset _logSpinner + fi + + # Output the ruler. + if [[ $ruler ]]; then + printf >&2 '%s\n' "$(hr "$ruler")" + [[ -w $_logFile ]] \ + && printf >> "$_logFile" '%s' "$ruler" + fi + + # Output the log message. + printf >&2 '%s' "$conMsg" + [[ -w $_logFile ]] \ + && printf >> "$_logFile" '%s' "$logMsg" + + # Start the spinner. + if [[ $type = startProgress && ! $_logSpinner ]]; then + { + set +m + trap 'touch exit; printf %s "$show"' EXIT + echo "$BASHPID" > start + printf %s "$hide" + while printf "$eel$blue$bold[$reset%s$reset$blue$bold]$reset\b\b\b" "${spinner[s++ % ${#spinner[@]}]}" && sleep .1 + do :; done + } & _logSpinner=$! + fi 2>/dev/null + + return $exitcode +} +trc() { level=TRC log "$@"; } +dbg() { level=DBG log "$@"; } +inf() { level=INF log "$@"; } +wrn() { level=WRN log "$@"; } +err() { level=ERR log "$@"; } +ftl() { level=FTL log "$@"; } +plog() { log -p "$@"; } +ulog() { log -u "$@"; } +golp() { log -P "$@"; } +ptrc() { level=TRC plog "$@"; } +pdbg() { level=DBG plog "$@"; } +pinf() { level=INF plog "$@"; } +pwrn() { level=WRN plog "$@"; } +perr() { level=ERR plog "$@"; } +pftl() { level=FTL plog "$@"; } +utrc() { level=TRC ulog "$@"; } +udbg() { level=DBG ulog "$@"; } +uinf() { level=INF ulog "$@"; } +uwrn() { level=WRN ulog "$@"; } +uerr() { level=ERR ulog "$@"; } +uftl() { level=FTL ulog "$@"; } +gtrc() { level=trc golp "$@"; } +gbdp() { level=DBG golp "$@"; } +fnip() { level=INF golp "$@"; } +nrwp() { level=WRN golp "$@"; } +rrep() { level=ERR golp "$@"; } +ltfp() { level=FTL golp "$@"; } +_logColor=${_logColor:-$([[ -t 2 ]] && echo 1)} _logVerbosity=2 +_logTrcColor=$grey _logDbgColor=$blue _logInfColor=$white _logWrnColor=$yellow _logErrColor=$red _logFtlColor=$bold$red +# _______________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Emit ______________________________________________________________| +# +# emit [options] message... [-- [command args...]] +# +# Display a message with contextual coloring. +# +# DEPRECATED: Use inf and variants instead. +# +# When a command is provided, a spinner will be activated in front of the +# message for as long as the command runs. When the command ends, its +# exit status will result in a message 'done' or 'failed' to be displayed. +# +# It is possible to only specify -- as final argument. This will prepare +# a spinner for you with the given message but leave it up to you to +# notify the spinner that it needs to stop. See the documentation for +# 'spinner' to learn how to do this. +# +# -n Do not end the line with a newline. +# -b Activate bright (bold) mode. +# -d Activate half-bright (dim) mode. +# -g Display in green. +# -y Display in yellow. +# -r Display in red. +# -w Display in the default color. +# +# -[code] A proxy-call to 'spinner -[code]'. +# +# Non-captialized versions of these options affect the * or the spinner +# in front of the message. Capitalized options affect the message text +# displayed. +# +emit() { + + # Proxy call to spinner. + [[ $# -eq 1 && $1 = -+([0-9]) ]] \ + && { spinner $1; return; } + + # Initialize the vars. + local arg + local style= + local color= + local textstyle= + local textcolor= + local noeol=0 + local cmd=0 + + # Parse the options. + spinArgs=() + for arg in $(getArgs odbwgyrDBWGYRn "$@"); do + case ${arg%% } in + d) style=$dim ;; + b) style=$bold ;; + w) color=$white ;; + g) color=$green ;; + y) color=$yellow ;; + r) color=$red ;; + D) textstyle=$dim ;; + B) textstyle=$bold ;; + W) textcolor=$white ;; + G) textcolor=$green ;; + Y) textcolor=$yellow ;; + R) textcolor=$red ;; + n) noeol=1 + spinArgs+=(-n) ;; + o) spinArgs+=("-$arg") ;; + esac + done + shift $(getArgs -c odbwgyrDBWGYRn "$@") + while [[ $1 = +* ]]; do + spinArgs+=("-${1#+}") + shift + done + + # Defaults. + color=${color:-$textcolor} + color=${color:-$green} + [[ $color = $textcolor && -z $style ]] && style=$bold + + # Get the text message. + local text= origtext= + for arg; do [[ $arg = -- ]] && break; origtext+="$arg "; done + origtext=${origtext%% } + (( noeol )) && text=$origtext || text=$origtext$reset$(eol "$origtext")$'\n' + + + # Trim off everything up to -- + while [[ $# -gt 1 && $1 != -- ]]; do shift; done + [[ $1 = -- ]] && { shift; cmd=1; } + + # Figure out what FD to use for our messages. + [[ -t 1 ]]; local fd=$(( $? + 1 )) + + # Display the message or spinner. + if (( cmd )); then + # Don't let this Bash handle SIGINT. + #trap : INT + + # Create the spinner in the background. + spinPipe=${TMPDIR:-/tmp}/bashlib.$$ + { touch "$spinPipe" && rm -f "$spinPipe" && mkfifo "$spinPipe"; } 2>/dev/null \ + || unset spinPipe + { spinner "${spinArgs[@]}" "$origtext" -- "$style" "$color" "$textstyle" "$textcolor" < "${spinPipe:-/dev/null}" & } 2>/dev/null + [[ $spinPipe ]] && echo > "$spinPipe" + spinPid=$! + + # Execute the command for the spinner if one is given. + #fsleep 1 # Let the spinner initialize itself properly first. # Can probably remove this now that we echo > spinPipe? + if (( $# == 1 )); then command=$1 + elif (( $# > 1 )); then command=$(printf '%q ' "$@") + else return 0; fi + + eval "$command" >/dev/null \ + && spinner -0 \ + || spinner -1 + else + # Make reset codes restore the initial font. + local font=$reset$textstyle$textcolor + text=$font${text//$reset/$font} + + printf "\r$reset $style$color* %s$reset" "$text" >&$fd + fi +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Spinner ___________________________________________________________| +# +# spinner [-code|message... [-- style color textstyle textcolor]] +# +# DEPRECATED: Use pinf and variants instead. +# +# Displays a spinner on the screen that waits until a certain time. +# Best used through its interface provided by 'emit'. +# +# style A terminal control string that defines the style of the spinner. +# color A terminal control string that defines the color of the spinner. +# textstyle A terminal control string that defines the style of the message. +# textcolor A terminal control string that defines the color of the message. +# +# -[code] Shut down a previously activated spinner with the given exit +# code. If the exit code is 0, a green message 'done' will be +# displayed. Otherwise a red message 'failed' will appear. +# The function will return with this exit code as result. +# +# You can manually specify a previously started spinner by putting its PID in +# the 'spinPid' variable. If this variable is not defined, the PID of the most +# recently backgrounded process is used. The 'spinPid' variable is unset upon +# each call to 'spinner' and reset to the PID of the spinner if one is created. +# +spinner() { + + # Check usage. + (( ! $# )) || getArgs -q :h "$@" && { + emit -y 'Please specify a message as argument or a status option.' + return 1 + } + + # Initialize spinner vars. + # Make sure monitor mode is off or we won't be able to trap INT properly. + local monitor=0; [[ $- = *m* ]] && monitor=1 + local done= + + # Place the trap for interrupt signals. + trap 'done="${red}failed"' USR2 + trap 'done="${green}done"' USR1 + + # Initialize the vars. + local pid=${spinPid:-$!} + local graphics=( "${bobber[@]}" ) + local style=$bold + local color=$green + local textstyle= + local textcolor= + local output= + local noeol= + unset spinPid + + # Any remaining options are the exit status of an existing spinner or spinner type. + while [[ $1 = -* ]]; do + arg=${1#-} + shift + + # Stop parsing when arg is -- + [[ $arg = - ]] && break + + # Process arg: Either a spinner type or result code. + if [[ $arg = *[^0-9]* ]]; then + case $arg in + b) graphics=( "${bobber[@]}" ) ;; + c) graphics=( "${crosser[@]}" ) ;; + r) graphics=( "${runner[@]}" ) ;; + s) graphics=( "${spinner[@]}" ) ;; + o) output=1 ;; + n) noeol=1 ;; + esac + elif [[ $pid ]]; then + [[ $arg = 0 ]] \ + && kill -USR1 $pid 2>/dev/null \ + || kill -USR2 $pid 2>/dev/null + + trap - INT + wait $pid 2>/dev/null + + return $arg + fi + done + + # Read arguments. + local text= origtext= + for arg; do [[ $arg = -- ]] && break; origtext+="$arg "; done + origtext=${origtext% } + local styles=$*; [[ $styles = *' -- '* ]] || styles= + read -a styles <<< "${styles##* -- }" + [[ ${styles[0]} ]] && style=${styles[0]} + [[ ${styles[1]} ]] && color=${styles[1]} + [[ ${styles[2]} ]] && textstyle=${styles[2]} + [[ ${styles[3]} ]] && textcolor=${styles[3]} + + # Figure out what FD to use for our messages. + [[ -t 1 ]]; local fd=$(( $? + 1 )) + + # Make reset codes restore the initial font. + local font=$reset$textstyle$textcolor + origtext=$font${origtext//$reset/$font} + (( noeol )) && text=$origtext || text=$origtext$reset$(eol "$origtext") + + # Spinner initial status. + printf "\r$save$eel$reset $style$color* %s$reset" "$text" >&$fd + (( output )) && printf "\n" >&$fd + + # Render the spinner. + set +m + local i=0 + while [[ ! $done ]]; do + IFS= read -r -d '' newtext || true + newtext=${newtext%%$'\n'}; newtext=${newtext##*$'\n'} + if [[ $newtext = +* ]]; then + newtext="$origtext [${newtext#+}]" + fi + if [[ $newtext ]]; then + newtext="$font${newtext//$reset/$font}" + (( noeol )) && text=$newtext || text=$newtext$reset$(eol "$newtext") + fi + + if (( output )) + then printf "\r" >&$fd + else printf "$load$eel" >&$fd + fi + + if (( output )) + then printf "$reset $style$color$blue%s %s$reset" \ + "${graphics[i++ % 4]}" "$text" >&$fd + else printf "$reset $style$color%s %s$reset" \ + "${graphics[i++ % 4]}" "$text" >&$fd + fi + + fsleep .25 # Four iterations make one second. + + # Cancel when calling script disappears. + kill -0 $$ >/dev/null || done="${red}aborted" + done + + # Get rid of the spinner traps. + trap - USR1 USR2; (( monitor )) && set -m + + # Spinner final status. + if (( output )) + then text=; printf "\r" >&$fd + else printf "$load" >&$fd + fi + + printf "$eel$reset $style$color* %s${text:+ }$bold%s$font.$reset\n" \ + "$text" "$done" >&$fd +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ report ___________________________________________________________| +# +# report [-code] [-e] failure-message [success-message] +# +# This is a convenience function for replacement of spinner -code. +# +# DEPRECATED: Use fnip and variants instead. +# +# It checks either the exit code of the previously completed command or +# the code provided as option to determine whether to display the success +# or failure message. It calls spinner -code to complete an actively +# emitted message if there is one. The success message is optional. +# +# -[code] The exit code to use. +# -e Exit the script on failure. +# +report() { + + # Exit Status of previous command. + local code=$? + + # Parse the options. + while [[ $1 = -* && $2 ]]; do + arg=${1#-} + shift + + # Stop parsing when arg is -- + [[ $arg = - ]] && break + + # Process arg: Either a spinner type or result code. + if [[ $arg = *[^0-9]* ]]; then + case $arg in + esac + else code=$arg + fi + done + + # Initialize the vars. + local failure=$1 + local success=$2 + + # Check usage. + (( ! $# )) || getArgs -q :h "$@" && { + emit -y 'Please specify at least a failure message as argument.' + return 1 + } + + # Proxy call to spinner. + (( spinPid )) \ + && { spinner -$code; } + + # Success or failure message. + if (( ! code )) + then [[ $success ]] && emit " $success" + else [[ $failure ]] && emit -R " $failure" + fi + + # Pass on exit code. + return $code +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Ask _______________________________________________________________| +# +# ask [-c optionchars|-d default] [-s|-S maskchar] message... +# +# Ask a question and read the user's reply to it. Then output the result on stdout. +# +# When in normal mode, a single line is read. If the line is empty and +# -d was specified, the default argument is output instead of an empty line. +# The exit code is always 0. +# +# When in option mode (-c), the user is shown the option characters with +# which he can reply and a single character is read. +# If the reply is empty (user hits enter) and any of the optionchars are +# upper-case, the upper-case option (= the default option) character will +# be output instead of an empty line. +# If the reply character is not amoungst the provided options the default +# option is again output instead if present. If no default was given, an +# exit code of 2 is returned. +# You may mark an optionchar as 'valid' by appending a '!' to it. As a +# result, an exit code of 0 will only be returned if this valid option +# is replied. If not, an exit code of 1 will be returned. +# +ask() { + + # Check usage. + (( ! $# )) || getArgs -q :h "$@" && { + emit -y 'Please specify a question as argument.' + return 1 + } + + # Initialize the vars. + local opt arg + local option= + local options= + local default= + local silent= + local valid= + local muteChar= + local message= + + # Parse the options. + local OPTIND=1 + while getopts :sS:c:d: opt; do + case $opt in + s) silent=1 ;; + S) silent=1 muteChar=$OPTARG ;; + c) while read -n1 arg; do + case $arg in + [[:upper:]]) default=$arg ;; + !) valid=${options: -1}; continue ;; + esac + + options+=$arg + done <<< "$OPTARG" ;; + d) default=$OPTARG option=$default ;; + esac + done + + # Trim off the options. + shift $((OPTIND-1)) + + # Figure out what FD to use for our messages. + [[ -t 1 ]] && local fd=1 || local fd=2 + + # Ask the question. + message=$1; shift; printf -v message "$message" "$@" + emit -yn "$message${option:+ [$option]}${options:+ [$options]} " + + # Read the reply. + exec 8<&0; [[ -t 8 ]] || exec 8&$fd + done + REPLY=$reply + else + read -u8 -e ${options:+-n1} ${silent:+-s} + fi + [[ $options && $REPLY ]] || (( silent )) && printf '\n' >&$fd + + # Evaluate the reply. + while true; do + if [[ $REPLY && ( ! $options || $options = *$REPLY* ) ]]; then + if [[ $valid ]] + then [[ $REPLY = $valid ]] + else printf "%s" "$REPLY" + fi + + return + fi + + [[ -z $default || $REPLY = $default ]] \ + && return 2 + + REPLY=$default + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Trim ______________________________________________________________| +# +# trim lines ... +# +# Trim the whitespace off of the beginning and end of the given lines. +# Each argument is considdered one line; is treated and printed out. +# +# When no arguments are given, lines will be read from standard input. +# +trim() { + + # Initialize the vars. + local lines + local line + local oIFS + + # Get the lines. + lines=( "$@" ) + if (( ! ${#lines[@]} )); then + oIFS=$IFS; IFS=$'\n' + lines=( $(cat) ) + IFS=$oIFS + fi + + # Trim the lines + for line in "${lines[@]}"; do + line=${line##*([[:space:]])}; line=${line%%*([[:space:]])} + printf "%s" "$line" + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Reverse ___________________________________________________________| +# +# reverse [-0|-d delimitor] [elements ...] [<<< elements] +# +# Reverse the order of the given elements. +# Elements are read from command arguments or standard input if no element +# arguments are given. +# They are reversed and output on standard output. +# +# If the -0 option is given, input and output are delimited by NUL bytes. +# If the -d option is given, input and output are delimited by the +# character argument. +# Otherwise, they are delimited by newlines. +# +reverse() { + + # Initialize the vars. + local elements=() delimitor=$'\n' i + + # Parse the options. + local OPTIND=1 + while getopts :0d: opt; do + case $opt in + 0) delimitor=$'\0' ;; + d) delimitor=$OPTARG ;; + esac + done + shift "$((OPTIND-1))" + + # Get the elements. + if (( $# )); then + elements=( "$@" ) + else + while IFS= read -r -d "$delimitor"; do + elements+=("$REPLY") + done + fi + + # Iterate in reverse order. + for (( i=${#elements[@]} - 1; i >=0; --i )); do + printf "%s${delimitor:-'\0'}" "${elements[i]}" + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Order _____________________________________________________________| +# +# order [-0|-d char] [-[cC] isAscending|-n] [-t number] [-a array|elements ...] [<<< elements] +# +# Orders the elements in ascending order. +# Elements are read from command arguments or standard input if no element +# arguments are given. +# The result is output on standard output. +# +# By default, the elements will be ordered using lexicographic comparison. +# If the -n option is given, the elements will be considered integer numbers. +# If the -c option is given, the command name following it will be used +# as a comparator. +# If the -C option is given, the bash code following it will be used +# as a comparator. +# If the -t option is given, only the first number results are returned. +# If the -a option is given, the elements in array are ordered instead and +# array is mutated to contain the result. +# If number is 0, all results are returned. +# +# If given, isAscending comparator command will be executed for each element +# comparison and will be passed two element arguments. The command should +# succeed if the first argument is less than the second argument for the +# purpose of this sort. +# +# If the -0 option is given, input and output are delimited by NUL bytes. +# If the -d option is given, input and output are delimited by the +# character argument. +# Otherwise, they are delimited by newlines. +# +# The ordering is implemented by an insertion sort algorithm. +# +order() { + + # Initialize the vars. + local elements=() element delimitor=$'\n' i isAscending=_order_string_ascends top=0 array= arrayElements= + + # Parse the options. + local OPTIND=1 + while getopts :0nd:c:C:t:a: opt; do + case $opt in + 0) delimitor=$'\0' ;; + d) delimitor=$OPTARG ;; + n) comparator=_order_number_ascends ;; + c) isAscending=$OPTARG ;; + C) isAscending=_order_cmd_ascends _order_cmd=$OPTARG ;; + t) top=$OPTARG ;; + a) array=$OPTARG arrayElements=$array[@] ;; + esac + done + shift "$((OPTIND-1))" + + # Get the elements. + if [[ $array ]]; then + elements=( "${!arrayElements}" ) + elif (( $# )); then + elements=( "$@" ) + else + while IFS= read -r -d "$delimitor"; do + elements+=("$REPLY") + done + fi + + # Iterate in reverse order. + for (( i = 2; i < ${#elements[@]}; ++i )); do + for (( j = i; j > 1; --j )); do + element=${elements[j]} + if "$isAscending" "$element" "${elements[j-1]}"; then + elements[j]=${elements[j-1]} + elements[j-1]=$element + fi + done + done + + (( top )) || top=${#elements[@]} + if [[ $array ]]; then + declare -ga "$array=($(printf '%q ' "${elements[@]:0:top}"))" + else + printf "%s${delimitor:-\0}" "${elements[@]:0:top}" + fi +} # _____________________________________________________________________ +_order_string_ascends() { [[ $1 < $2 ]]; } +_order_number_ascends() { (( $1 < $2 )); } +_order_mtime_ascends() { [[ $1 -ot $2 ]]; } +_order_cmd_ascends() { bash -c "$_order_cmd" -- "$@"; } + + +# ______________________________________________________________________ +# |__ Mutex _____________________________________________________________| +# +# mutex file +# +# Open a mutual exclusion lock on the file, unless another process already owns one. +# +# If the file is already locked by another process, the operation fails. +# This function defines a lock on a file as having a file descriptor open to the file. +# This function uses FD 9 to open a lock on the file. To release the lock, close FD 9: +# exec 9>&- +# +mutex() { + local lockfile=${1:-${BASH_SOURCE[-1]}} pid pids + [[ -e $lockfile ]] || err "No such file: $lockfile" || return + + exec 9>> "$lockfile" && [[ $({ fuser -f "$lockfile"; } 2>&- 9>&-) == $$ ]] +} + + +# ______________________________________________________________________ +# |__ PushJob ___________________________________________________________| +# +# pushjob [poolsize] command +# +# Start an asynchronous command within a pool, waiting for space in the pool if it is full. +# +# The pool is pruned automatically as running jobs complete. This function +# allows you to easily run asynchronous commands within a pool of N, +# automatically starting the next command as soon as there's space. +# +pushjob() { + local size=$1; shift 1 + + # Wait for space in the pool. + until (( ${#jobpool[@]} < size )); do + sleep 1 & pushjobsleep=$! + wait "$pushjobsleep" + done 2>/dev/null + + # Register prunejobs and start the pushed job. + trap _prunejobs SIGCHLD + set -m + "$@" & jobpool[$!]= +} +_prunejobs() { + # Prune all pool jobs that are no longer running. + for pid in "${!jobpool[@]}"; do + kill -0 "$pid" 2>/dev/null || unset "jobpool[$pid]" + done + + # Unregister SIGCHLD if our pool is empty. + (( ${#jobpool[@]} )) || trap - SIGCHLD + + # Wake up pushjob. + kill "$pushjobsleep" 2>/dev/null +} + + + + +# ______________________________________________________________________ +# |__ FSleep _____________________________________________________________| +# +# fsleep time +# +# Wait for the given (fractional) amount of seconds. +# +# This implementation solves the problem portably, assuming that either +# bash 4.x or a fractional sleep(1) is available. +# +fsleep() { + + local fifo=${TMPDIR:-/tmp}/.fsleep.$$ + trap 'rm -f "$fifo"' RETURN + mkfifo "$fifo" && { read -t "$1" <> "$fifo" 2>/dev/null || sleep "$1"; } +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ GetArgs ___________________________________________________________| +# +# getArgs [options] optstring [args...] +# +# Retrieve all options present in the given arguments. +# +# This is a wrapper for getopts(P) which will safely work inside functions. +# It manages OPTIND for you and returns a list of options found in the +# provided arguments. +# +# optstring This is a string of characters in which each character +# represents an option to look for in the arguments. +# See getopts(P) for a description of the optstring syntax. +# +# args This is a list of arguments in which to look for options. +# Most commonly, you will use "$@" to supply these arguments. +# +# -c Instead of output the arguments, output OPTARGS. +# -q Be quiet. No arguments are displayed. Only the exit code is set. +# -n Use newlines as a separator between the options that were found. +# -0 Use NULL-bytes as a separator between the options that were found. +# +# If any given arguments are found, an exit code of 0 is returned. If none +# are found, an exit code of 1 is returned. +# +# After the operation, OPTARGS is set the the index of the last argument +# that has been parsed by getArgs. Ready for you to use shift $OPTARGS. +# +getArgs() { + + # Check usage. + (( ! $# )) && { + emit -y 'Please provide the arguments to search for in' \ + 'getopts(P) format followed by the positional parameters.' + return 1 + } + + # Initialize the defaults. + local arg + local found=0 + local quiet=0 + local count=0 + local delimitor=' ' + + # Parse the options. + while [[ $1 = -* ]]; do + case $1 in + -q) quiet=1 ;; + -c) count=1 ;; + -n) delimitor=$'\n' ;; + -0) delimitor=$'\0' ;; + esac + shift + done + + # Get the optstring. + local optstring=$1; shift + + # Enumerate the arguments. + local OPTIND=1 + while getopts "$optstring" arg; do + [[ $arg != '?' ]] && found=1 + + (( quiet + count )) || \ + printf "%s${OPTARG:+ }%s%s" "$arg" "$OPTARG" "$delimitor" + done + OPTARGS=$(( OPTIND - 1 )) + + # Any arguments found? + (( count )) && printf "%s" "$OPTARGS" + return $(( ! found )) +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ ShowHelp __________________________________________________________| +# +# showHelp name description author [option description]... +# +# Generate a prettily formatted usage description of the application. +# +# name Provide the name of the application. +# +# description Provide a detailed description of the application's +# purpose and usage. +# +# option An option the application can take as argument. +# +# description A description of the effect of the preceding option. +# +showHelp() { + + # Check usage. + (( $# < 3 )) || getArgs -q :h "$@" && { + emit -y 'Please provide the name, description, author and options' \ + 'of the application.' + return 1 + } + + # Parse the options. + local appName=$1; shift + local appDesc=${1//+([[:space:]])/ }; shift + local appAuthor=$1; shift + local cols=$(tput cols) + (( cols = ${cols:-80} - 10 )) + + # Figure out what FD to use for our messages. + [[ -t 1 ]]; local fd=$(( $? + 1 )) + + # Print out the help header. + printf "$reset$bold\n" >&$fd + printf "\t\t%s\n" "$appName" >&$fd + printf "$reset\n" >&$fd + printf "%s\n" "$appDesc" | fmt -w "$cols" | sed $'s/^/\t/' >&$fd + printf "\t $reset$bold~ $reset$bold%s\n" "$appAuthor" >&$fd + printf "$reset\n" >&$fd + + # Print out the application options and columnize them. + while (( $# )); do + local optName=$1; shift + local optDesc=$1; shift + printf " %s\t" "$optName" + printf "%s\n" "${optDesc//+( )/ }" | fmt -w "$cols" | sed $'1!s/^/ \t/' + printf "\n" + done | column -t -s $'\t' \ + | sed "s/^\( [^ ]*\)/$bold$green\1$reset/" >&$fd + printf "\n" >&$fd +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Quote _____________________________________________________________| +# +# shquote [-e] [argument...] +# +# Shell-quote the arguments to make them safe for injection into bash code. +# +# The result is bash code that represents a series of words, where each +# word is a literal string argument. By default, quoting happens using +# single-quotes. +# +# -e Use backslashes rather than single quotes. +# -d Use double-quotes rather than single quotes (does NOT disable expansions!). +# +shquote() { + + # Initialize the defaults. + local arg escape=0 sq="'\\''" dq='\"' quotedArgs=() type=single + + # Parse the options. + while [[ $1 = -* ]]; do + case $1 in + -e) type=escape ;; + -d) type=double ;; + --) shift; break ;; + esac + shift + done + + # Print out each argument, quoting it properly. + for arg; do + case "$type" in + escape) + quotedArgs+=("$(printf "%q" "$arg")") ;; + single) + arg=${arg//"'"/$sq} + quotedArgs+=("$(printf "'%s'" "$arg")") ;; + double) + arg=${arg//'"'/$dq} + quotedArgs+=("$(printf '"%s"' "$arg")") ;; + esac + done + + printf '%s\n' "$(IFS=' '; echo "${quotedArgs[*]}")" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ ReQuote __________________________________________________________| +# +# requote [string] +# +# Escape the argument string to make it safe for injection into a regex. +# +# The result is a regular expression that matches the literal argument +# string. +# +requote() { + + # Initialize the defaults. + local char + + printf '%s' "$1" | while IFS= read -r -d '' -n1 char; do + printf '[%s]' "$char" + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Shorten ___________________________________________________________| +# +# shorten [-p pwd] path [suffix]... +# +# Shorten an absolute path for pretty printing. +# Paths are shortened by replacing the homedir by ~, making it relative and +# cutting off given suffixes from the end. +# +# -p Use the given pathname as the base for relative filenames instead of PWD. +# path The path string to shorten. +# suffix Suffix strings that must be cut off from the end. +# Only the first suffix string matched will be cut off. +# +shorten() { + + # Check usage. + (( $# < 1 )) || getArgs -q :h "$@" && { + emit -y 'Please provide the path to shorten.' + return 1 + } + + # Parse the options. + local suffix path pwd=$PWD + [[ $1 = -p ]] && { pwd=$2; shift 2; } + path=$1; shift + + # Make path absolute. + [[ $path = /* ]] || path=$PWD/$path + + # If the path denotes something that exists; it's easy. + if [[ -d $path ]] + then path=$(cd "$path"; printf "%s" "$PWD") + elif [[ -d ${path%/*} ]] + then path=$(cd "${path%/*}"; printf "%s" "$PWD/${path##*/}") + + # If not, we'll try readlink -m. + elif readlink -m / >/dev/null 2>&1; then + path=$(readlink -m "$path") + + # If we don't have that - unleash the sed(1) madness. + else + local oldpath=/ + while [[ $oldpath != $path ]]; do + oldpath=$path + path=$(sed -e 's,///*,/,g' -e 's,\(^\|/\)\./,\1,g' -e 's,\(^\|/\)[^/]*/\.\.\($\|/\),\1,g' <<< "$path") + done + fi + + # Replace special paths. + path=${path/#$HOME/'~'} + path=${path#$pwd/} + + # Cut off suffix. + for suffix; do + [[ $path = *$suffix ]] && { + path=${path%$suffix} + break + } + done + + printf "%s" "$path" +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ Up ________________________________________________________________| +# +# up .../path|num +# +# Walk the current working directory up towards root num times or until path is found. +# +# Returns 0 if the destination was reached or 1 if we hit root. +# +# Prints PWD on stdout on success. +# +up() { + local up=0 + until [[ $PWD = / ]]; do + cd ../ + + if [[ $1 = .../* ]]; then + [[ -e ${1#.../} ]] && pwd && return + elif (( ++up == $1 )); then + pwd && return + fi + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ BuildArray ________________________________________________________| +# +# buildarray name terms... -- elements... +# +# Create an array by adding all the terms to it for each element, replacing {} terms by the element. +# +# name The name of the array to put the result into. +# terms The values to add to the array for each of the elements. A {} term is replaced by the current element. +# elements The elements to iterate the terms for. +# +buildarray() { + local target=$1 term terms=() element value + shift + + while [[ $1 != -- ]]; do + terms+=("$1") + shift + done + shift + + for element; do + for term in "${terms[@]}"; do + [[ $term = {} ]] && value="$element" || value="$term" + declare -ag "$target+=($(printf '%q' "$value"))" + done + done +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ InArray ___________________________________________________________| +# +# inArray element array +# +# Checks whether a certain element is in the given array. +# +# element The element to search the array for. +# array This is a list of elements to search through. +# +inArray() { + + # Check usage. + (( $# < 1 )) || getArgs -q :h "$@" && { + emit -y 'Please provide the element to search for and the array' \ + 'to search through.' + return 1 + } + + # Parse the options. + local element + local search=$1; shift + + # Perform the search. + for element + do [[ $element = $search ]] && return 0; done + return 1 +} # _____________________________________________________________________ + + + +# ______________________________________________________________________ +# |__ HideDebug _________________________________________________________| +# +# hideDebug [on|off] +# +# Toggle Bash's debugging mode off temporarily. +# To hide Bash's debugging output for a function, you should have +# hideDebug on +# as its first line, and +# hideDebug off +# as its last. +# +hideDebug() { + + if [[ $1 = on ]]; then + : -- HIDING DEBUG OUTPUT .. + [[ $- != *x* ]]; bashlib_debugWasOn=$? + set +x + elif [[ $1 = off ]]; then + : -- SHOWING DEBUG OUTPUT .. + (( bashlib_debugWasOn )) && \ + set -x + fi +} + + + +# ______________________________________________________________________ +# |__ anfunc ____________________________________________________________| +# +# anfunc [on|off] +# +# Turn on or off support for annonymous functions. +# +# WARNING: This is a hack. It turns on extdebug and causes any argument +# that matches (){code} to be replaced by a function name that if invoked +# runs code. +# +# eg. +# confirm '(){ rm "$1" }' *.txt +# # In this example, confirm() could be a function that asks confirmation +# # for each argument past the first and runs the anfunc in the first +# # argument on each confirmed argument. +# +# Don't use this. It is an academic experiment and has bugs. +# +# Bugs: +# - commands lose their exit code. +# To inhibit the real command from running, we use extdebug and +# a DEBUG trap that returns non-0. As a result, the actual return +# code is lost. +# +anfunc() { + case "$1" in + on) + shopt -s extdebug + trap _anfunc_trap DEBUG + ;; + off) + trap - DEBUG + shopt -u extdebug + ;; + esac +} +_anfunc_trap() { + local f w + + # Perform the command parsing and handling up to its word splitting. + # This includes command substitution, quote handling, pathname expansion, etc. + declare -a words="($BASH_COMMAND)" + + # Iterate the words to run in the final stage, and handle anfunc matches. + for ((w=0; w<${#words[@]}; ++w)); do + [[ ${words[w]} = '(){'*'}' ]] && + # Declare a new function for this anfunc. + eval "_f$((++f))${words[w]}" && + # Replace the word by the new function's name. + words[w]="_f$f" + done + + # Run the command. + eval "$(printf '%q ' "${words[@]}")" + + # Clean up the anfuncs. + for ((; f>0; --f)); do + unset -f "_f$f" + done + + # Inhibit the real command's execution. + return 1 +} + + + +# ______________________________________________________________________ +# |__ StackTrace ________________________________________________________| +# +# stackTrace +# +# Output the current script's function execution stack. +# +stackTrace() { + + # Some general debug information. + printf "\t$bold%s$reset v$bold%s$reset" "$BASH" "$BASH_VERSION\n" + printf " Was running: $bold%s %s$reset" "$BASH_COMMAND" "$*\n" + printf "\n" + printf " [Shell : $bold%15s$reset] [Subshells : $bold%5s$reset]\n" "$SHLVL" "$BASH_SUBSHELL" + printf " [Locale : $bold%15s$reset] [Runtime : $bold%5s$reset]\n" "$LC_ALL" "${SECONDS}s" + printf "\n" + + # Search through the map. + local arg=0 + for i in ${!FUNCNAME[@]}; do + #if (( i )); then + + # Print this execution stack's location. + printf "$reset $bold-$reset $green" + [[ ${BASH_SOURCE[i+1]} ]] \ + && printf "%s$reset:$green$bold%s" "${BASH_SOURCE[i+1]}" "${BASH_LINENO[i]}" \ + || printf "${bold}Prompt" + + # Print this execution stack's function and positional parameters. + printf "$reset :\t$bold%s(" "${FUNCNAME[i]}" + [[ ${BASH_ARGC[i]} ]] && \ + for (( j = 0; j < ${BASH_ARGC[i]}; j++ )); do + (( j )) && printf ', ' + printf "%s" "${BASH_ARGV[arg]}" + let arg++ + done + + # Print the end of this execution stack's line. + printf ")$reset\n" + #fi + done + printf "\n" + +} # _____________________________________________________________________ + + + + + +# ______________________________________________________________________ +# | | +# | .:: ENTRY POINT ::. | +# |______________________________________________________________________| + +# Make sure this file is sourced and not executed. +( return 2>/dev/null ) || { + emit -R "You should source this file, not execute it." + exit 1 +} + +: +: .:: END SOURCING ::. +: ______________________________________________________________________ +: diff --git a/MasterPassword/C/build b/MasterPassword/C/build index 214d2bdd..ad543433 100755 --- a/MasterPassword/C/build +++ b/MasterPassword/C/build @@ -1,5 +1,9 @@ #!/usr/bin/env bash -e # Run with -DDEBUG to enable trace-level output. -gcc -c types.c -o types.o "$@" -gcc -I"lib/scrypt/lib" -I"lib/scrypt/libcperciva" -l "crypto_aesctr.o" -l "sha256.o" -l "crypto_scrypt-nosse.o" -l "memlimit.o" -l "scryptenc_cpuperf.o" -l"scryptenc.o" -l"types.o" -l"crypto" -L"." -L"lib/scrypt" mpw.c -o mpw "$@" +[[ -e lib/scrypt/scryptenc.o ]] || { echo >&2 "Missing scrypt. First get and build the scrypt source in lib/scrypt from <$(.\n"; exit 1; } + +deps=( -I"lib/scrypt/lib" -I"lib/scrypt/libcperciva" -l "crypto_aesctr.o" -l "sha256.o" -l "crypto_scrypt-nosse.o" -l "memlimit.o" -l "scryptenc_cpuperf.o" -l"scryptenc.o" -l"crypto" -L"." -L"lib/scrypt" ) + +gcc "${deps[@]}" -Qunused-arguments -c types.c -o types.o "$@" +gcc "${deps[@]}" -Qunused-arguments -l"types.o" mpw.c -o mpw "$@" diff --git a/MasterPassword/C/ciphers b/MasterPassword/C/ciphers deleted file mode 100644 index 0c5f6472..00000000 --- a/MasterPassword/C/ciphers +++ /dev/null @@ -1,78 +0,0 @@ - - - - - MPElementGeneratedEntity - - Maximum Security Password - - anoxxxxxxxxxxxxxxxxx - axxxxxxxxxxxxxxxxxno - - Long Password - - CvcvnoCvcvCvcv - CvcvCvcvnoCvcv - CvcvCvcvCvcvno - CvccnoCvcvCvcv - CvccCvcvnoCvcv - CvccCvcvCvcvno - CvcvnoCvccCvcv - CvcvCvccnoCvcv - CvcvCvccCvcvno - CvcvnoCvcvCvcc - CvcvCvcvnoCvcc - CvcvCvcvCvccno - CvccnoCvccCvcv - CvccCvccnoCvcv - CvccCvccCvcvno - CvcvnoCvccCvcc - CvcvCvccnoCvcc - CvcvCvccCvccno - CvccnoCvcvCvcc - CvccCvcvnoCvcc - CvccCvcvCvccno - - Medium Password - - CvcnoCvc - CvcCvcno - - Basic Password - - aaanaaan - aannaaan - aaannaaa - - Short Password - - Cvcn - - PIN - - nnnn - - - MPCharacterClasses - - V - AEIOU - C - BCDFGHJKLMNPQRSTVWXYZ - v - aeiou - c - bcdfghjklmnpqrstvwxyz - A - AEIOUBCDFGHJKLMNPQRSTVWXYZ - a - AEIOUaeiouBCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz - n - 0123456789 - o - @&%?,=[]_:-+*$#!'^~;()/. - x - AEIOUaeiouBCDFGHJKLMNPQRSTVWXYZbcdfghjklmnpqrstvwxyz0123456789!@#$%^&*() - - - diff --git a/MasterPassword/C/install b/MasterPassword/C/install index d6715f9d..1769e0a9 100755 --- a/MasterPassword/C/install +++ b/MasterPassword/C/install @@ -1,15 +1,53 @@ #!/usr/bin/env bash -BINDIR=${BINDIR:+${PREFIX:+$PREFIX/bin}} -[[ $BINDIR ]] && mkdir -p "$BINDIR" -if [[ ! -w $BINDIR ]]; then - for dir in /usr/local/bin ~/.bin ~/bin /usr/bin; do - [[ -w $dir ]] && BINDIR=$dir && break - done - if [[ ! -w $BINDIR ]]; then - echo >&2 "Could not find directory to install to." - echo >&2 "You can specify a prefix to install to, eg. PREFIX=/usr/local ./install" - echo >&2 "You can specify a bin directory to install to, eg. BINDIR=~/bin ./install" - echo >&2 "Make sure you have write permission to the bin directory." - fi +# +# Install the Master Password CLI tool. +set -e +cd "${BASH_SOURCE%/*}" +source bashlib + +inf "This will install the mpw tool." + +# Try to guess then ask for the bin dir to install to. +IFS=: read -a paths <<< "$PATH" +if inArray ~/bin "${paths[@]}"; then + bindir=~/bin +elif inArray ~/.bin "${paths[@]}"; then + bindir=~/.bin +elif inArray /usr/local/bin "${paths[@]}"; then + bindir=/usr/local/bin +else + bindir=~/bin fi -install -v -s mpw "$BINDIR" +bindir=$(ask -d "$bindir" "What bin directory should I install to?") +[[ -d "$bindir" ]] || mkdir "$bindir" || ftl 'Cannot create missing bin directory: %s' "$bindir" || exit +[[ -w "$bindir" ]] || ftl 'Cannot write to bin directory: %s' "$bindir" || exit + +# Install Master Password. +install mpw "$bindir" +[[ ! -e "$bindir/bashlib" ]] && install bashlib "$bindir" ||: + +# Convenience bash function. +inf "Installation successful!" +echo + +inf "To improve usability, you can install an mpw function in your bash shell." +inf "This function adds the following features:" +inf " - Automatically remember your user name in the shell if not set." +inf " - Automatically put the password in the clipboard (some platforms)." +echo +inf "To do this you need the following function in ~/.bashrc:\n%s" "$(> ~/.bashrc + inf "Done! Don't forget to run '%s' to apply the changes!" "source ~/.bashrc" +fi +echo + +inf "You can also save your user name in ~/.bashrc. Leave blank to skip this step." +if MP_USERNAME=$(ask "Your full name:") && [[ $MP_USERNAME ]] ; then + printf 'export MP_USERNAME=%q\n' "$MP_USERNAME" >> ~/.bashrc +fi +echo + +inf "To begin using Master Password, type: mpw [site name]" diff --git a/MasterPassword/C/lib/proplib/.source b/MasterPassword/C/lib/proplib/.source deleted file mode 100644 index b9266190..00000000 --- a/MasterPassword/C/lib/proplib/.source +++ /dev/null @@ -1 +0,0 @@ -https://code.google.com/p/portableproplib/ diff --git a/MasterPassword/C/mpw.bashrc b/MasterPassword/C/mpw.bashrc new file mode 100644 index 00000000..11543332 --- /dev/null +++ b/MasterPassword/C/mpw.bashrc @@ -0,0 +1,24 @@ +## Added by Master Password +source bashlib +mpw() { + _copy() { + if hash pbcopy 2>/dev/null; then + pbcopy + elif hash xclip 2>/dev/null; then + xclip + else + cat + return + fi + echo >&2 "Copied!" + } + + # Empty the clipboard + :| _copy 2>/dev/null + + # Ask for the user's name and password if not yet known. + MP_USERNAME=${MP_USERNAME:-$(ask -s 'Your Full Name:')} + + # Start Master Password and copy the output. + printf %s "$(MP_USERNAME=$MP_USERNAME command mpw "$@")" | _copy +} diff --git a/MasterPassword/C/mpw.c b/MasterPassword/C/mpw.c index e0980c2f..795153b8 100644 --- a/MasterPassword/C/mpw.c +++ b/MasterPassword/C/mpw.c @@ -32,6 +32,23 @@ #define MP_env_sitetype "MP_SITETYPE" #define MP_env_sitecounter "MP_SITECOUNTER" +void usage() { + fprintf(stderr, "Usage: mpw [-u name] [-t type] [-c counter] site\n\n"); + fprintf(stderr, " -u name Specify the full name of the user.\n" + " Defaults to %s in env.\n\n", MP_env_username); + fprintf(stderr, " -t type Specify the password's template.\n" + " Defaults to %s in env or 'long'.\n" + " x, max, maximum | 20 characters, contains symbols.\n" + " l, long | Copy-friendly, 14 characters, contains symbols.\n" + " m, med, medium | Copy-friendly, 8 characters, contains symbols.\n" + " b, basic | 8 characters, no symbols.\n" + " s, short | Copy-friendly, 4 characters, no symbols.\n" + " p, pin | 4 numbers.\n\n", MP_env_sitetype); + fprintf(stderr, " -c counter The value of the counter.\n" + " Defaults to %s in env or '1'.\n\n", MP_env_sitecounter); + exit(0); +} + char *homedir(const char *filename) { char *homedir = NULL; #if defined(__CYGWIN__) @@ -59,6 +76,9 @@ char *homedir(const char *filename) { int main(int argc, char *const argv[]) { + if (argc < 2) + usage(); + // Read the environment. const char *userName = getenv( MP_env_username ); const char *masterPassword = NULL; @@ -70,34 +90,37 @@ int main(int argc, char *const argv[]) { // Read the options. char opt; - while ((opt = getopt(argc, argv, "u:t:c:")) != -1) + while ((opt = getopt(argc, argv, "u:t:c:h")) != -1) switch (opt) { - case 'u': - userName = optarg; - break; - case 't': - siteTypeString = optarg; - break; - case 'c': - siteCounterString = optarg; - break; - case '?': - switch (optopt) { - case 'u': - fprintf(stderr, "Missing user name to option: -%c\n", optopt); + case 'h': + usage(); break; - case 't': - fprintf(stderr, "Missing type name to option: -%c\n", optopt); + case 'u': + userName = optarg; break; - case 'c': - fprintf(stderr, "Missing counter value to option: -%c\n", optopt); + case 't': + siteTypeString = optarg; break; - default: - fprintf(stderr, "Unknown option: -%c\n", optopt); - } - return 1; - default: - abort(); + case 'c': + siteCounterString = optarg; + break; + case '?': + switch (optopt) { + case 'u': + fprintf(stderr, "Missing user name to option: -%c\n", optopt); + break; + case 't': + fprintf(stderr, "Missing type name to option: -%c\n", optopt); + break; + case 'c': + fprintf(stderr, "Missing counter value to option: -%c\n", optopt); + break; + default: + fprintf(stderr, "Unknown option: -%c\n", optopt); + } + return 1; + default: + abort(); } if (optind < argc) siteName = argv[optind]; @@ -142,7 +165,7 @@ int main(int argc, char *const argv[]) { ssize_t linelen; while ((linelen = getline(&line, &linecap, mpwConfig)) > 0) if (strcmp(strsep(&line, ":"), userName) == 0) { - masterPassword = line; + masterPassword = strsep(&line, "\n"); break; } if (!masterPassword) { @@ -151,47 +174,75 @@ int main(int argc, char *const argv[]) { } trc("masterPassword: %s\n", masterPassword); + // Calculate the master key salt. + char *mpNameSpace = "com.lyndir.masterpassword"; + const uint32_t n_userNameLength = htonl(strlen(userName)); + size_t masterKeySaltLength = strlen(mpNameSpace) + sizeof(n_userNameLength) + strlen(userName); + char *masterKeySalt = malloc( masterKeySaltLength ); + if (!masterKeySalt) { + fprintf(stderr, "Could not allocate master key salt: %d\n", errno); + return 1; + } + + char *mKS = masterKeySalt; + memcpy(mKS, mpNameSpace, strlen(mpNameSpace)); mKS += strlen(mpNameSpace); + memcpy(mKS, &n_userNameLength, sizeof(n_userNameLength)); mKS += sizeof(n_userNameLength); + memcpy(mKS, userName, strlen(userName)); mKS += strlen(userName); + if (mKS - masterKeySalt != masterKeySaltLength) + abort(); + trc("masterKeySalt ID: %s\n", IDForBuf(masterKeySalt, masterKeySaltLength)); + // Calculate the master key. uint8_t *masterKey = malloc( MP_dkLen ); if (!masterKey) { fprintf(stderr, "Could not allocate master key: %d\n", errno); return 1; } - const uint32_t n_userNameLength = htonl(strlen(userName)); - char *masterKeySalt = NULL; - size_t masterKeySaltLength = asprintf(&masterKeySalt, "com.lyndir.masterpassword%s%s", (const char *) &n_userNameLength, userName); - if (!masterKeySalt) { - fprintf(stderr, "Could not allocate master key salt: %d\n", errno); - return 1; - } if (crypto_scrypt( (const uint8_t *)masterPassword, strlen(masterPassword), (const uint8_t *)masterKeySalt, masterKeySaltLength, MP_N, MP_r, MP_p, masterKey, MP_dkLen ) < 0) { fprintf(stderr, "Could not generate master key: %d\n", errno); return 1; } memset(masterKeySalt, 0, masterKeySaltLength); free(masterKeySalt); + trc("masterPassword Hex: %s\n", Hex(masterPassword, strlen(masterPassword))); + trc("masterPassword ID: %s\n", IDForBuf(masterPassword, strlen(masterPassword))); + trc("masterKey ID: %s\n", IDForBuf(masterKey, MP_dkLen)); // Calculate the site seed. - const uint32_t n_siteCounter = htonl(siteCounter), n_siteNameLength = htonl(strlen(siteName)); - char *sitePasswordInfo = NULL; - size_t sitePasswordInfoLength = asprintf(&sitePasswordInfo, "com.lyndir.masterpassword%s%s%s", (const char *) &n_siteNameLength, siteName, (const char *) &n_siteCounter); + const uint32_t n_siteNameLength = htonl(strlen(siteName)); + const uint32_t n_siteCounter = htonl(siteCounter); + size_t sitePasswordInfoLength = strlen(mpNameSpace) + sizeof(n_siteNameLength) + strlen(siteName) + sizeof(n_siteCounter); + char *sitePasswordInfo = malloc( sitePasswordInfoLength ); if (!sitePasswordInfo) { fprintf(stderr, "Could not allocate site seed: %d\n", errno); return 1; } + + char *sPI = sitePasswordInfo; + memcpy(sPI, mpNameSpace, strlen(mpNameSpace)); sPI += strlen(mpNameSpace); + memcpy(sPI, &n_siteNameLength, sizeof(n_siteNameLength)); sPI += sizeof(n_siteNameLength); + memcpy(sPI, siteName, strlen(siteName)); sPI += strlen(siteName); + memcpy(sPI, &n_siteCounter, sizeof(n_siteCounter)); sPI += sizeof(n_siteCounter); + if (sPI - sitePasswordInfo != sitePasswordInfoLength) + abort(); + trc("seed from: hmac-sha256(masterKey, 'com.lyndir.masterpassword' | %s | %s | %s)\n", Hex(&n_siteNameLength, sizeof(n_siteNameLength)), siteName, Hex(&n_siteCounter, sizeof(n_siteCounter))); + trc("sitePasswordInfo ID: %s\n", IDForBuf(sitePasswordInfo, sitePasswordInfoLength)); + uint8_t sitePasswordSeed[32]; HMAC_SHA256_Buf(masterKey, MP_dkLen, sitePasswordInfo, sitePasswordInfoLength, sitePasswordSeed); memset(masterKey, 0, MP_dkLen); memset(sitePasswordInfo, 0, sitePasswordInfoLength); free(masterKey); free(sitePasswordInfo); + trc("sitePasswordSeed ID: %s\n", IDForBuf(sitePasswordSeed, 32)); // Determine the cipher. const char *cipher = CipherForType(siteType, sitePasswordSeed[0]); trc("type %s, cipher: %s\n", siteTypeString, cipher); + if (strlen(cipher) > 32) + abort(); // Encode the password from the seed using the cipher. - //NSAssert([seed length] >= [cipher length] + 1, @"Insufficient seed bytes to encode cipher."); char *sitePassword = calloc(strlen(cipher) + 1, sizeof(char)); for (int c = 0; c < strlen(cipher); ++c) { sitePassword[c] = CharacterFromClass(cipher[c], sitePasswordSeed[c + 1]); diff --git a/MasterPassword/C/types.c b/MasterPassword/C/types.c index 5e5eb589..2ec38089 100644 --- a/MasterPassword/C/types.c +++ b/MasterPassword/C/types.c @@ -10,6 +10,9 @@ #include #include #include + +#include + #include "types.h" const MPElementType TypeWithName(const char *typeName) { @@ -118,4 +121,20 @@ const char CharacterFromClass(char characterClass, uint8_t seedByte) { return classCharacters[seedByte % strlen(classCharacters)]; } +const char *IDForBuf(const void *buf, size_t length) { + uint8_t hash[32]; + SHA256_Buf(buf, length, hash); + char *id = calloc(65, sizeof(char)); + for (int kH = 0; kH < 32; kH++) + sprintf(&(id[kH * 2]), "%02X", hash[kH]); + + return id; +} + +const char *Hex(const void *buf, size_t length) { + char *id = calloc(length*2+1, sizeof(char)); + for (int kH = 0; kH < length; kH++) + sprintf(&(id[kH * 2]), "%02X", ((const uint8_t*)buf)[kH]); + return id; +} diff --git a/MasterPassword/C/types.h b/MasterPassword/C/types.h index 6fa5a5c2..d275e457 100644 --- a/MasterPassword/C/types.h +++ b/MasterPassword/C/types.h @@ -47,3 +47,6 @@ typedef enum { const MPElementType TypeWithName(const char *typeName); const char *CipherForType(MPElementType type, uint8_t seedByte); const char CharacterFromClass(char characterClass, uint8_t seedByte); +const char *IDForBuf(const void *buf, size_t length); +const char *Hex(const void *buf, size_t length); +