X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=src%2Fcommon;h=f6000d31d223d9245c967d6bc0324575cc84a1ca;hb=ff9ffb70eed7d4c2c33f4a5ba1f5a5f02547b2ab;hp=7768335082be95af78567a26983897e38a6229f1;hpb=7dab6df00804017844dab244f11e72cc73199fd8;p=monkeysphere.git

diff --git a/src/common b/src/common
index 7768335..f6000d3 100644
--- a/src/common
+++ b/src/common
@@ -16,15 +16,15 @@
 ### COMMON VARIABLES
 
 # managed directories
-ETC="/etc/monkeysphere"
-export ETC
+SYSCONFIGDIR=${MONKEYSPHERE_SYSCONFIGDIR:-"/etc/monkeysphere"}
+export SYSCONFIGDIR
 
 ########################################################################
 ### UTILITY FUNCTIONS
 
 # failure function.  exits with code 255, unless specified otherwise.
 failure() {
-    echo "$1" >&2
+    [ "$1" ] && echo "$1" >&2
     exit ${2:-'255'}
 }
 
@@ -91,6 +91,97 @@ cutline() {
     head --line="$1" "$2" | tail -1
 }
 
+# this is a wrapper for doing lock functions.
+#
+# it lets us depend on either lockfile-progs (preferred) or procmail's
+# lockfile, and should
+lock() {
+    local use_lockfileprogs=true
+    local action="$1"
+    local file="$2"
+
+    if ! ( which lockfile-create >/dev/null 2>/dev/null ) ; then
+	if ! ( which lockfile >/dev/null ); then
+	    failure "Neither lockfile-create nor lockfile are in the path!"
+	fi
+	use_lockfileprogs=
+    fi
+    
+    case "$action" in
+	create)
+	    if [ -n "$use_lockfileprogs" ] ; then
+		lockfile-create "$file" || failure "unable to lock '$file'"
+	    else
+		lockfile -r 20 "${file}.lock" || failure "unable to lock '$file'"
+	    fi
+	    ;;
+	touch)	
+	    if [ -n "$use_lockfileprogs" ] ; then
+		lockfile-touch --oneshot "$file"
+	    else
+		: Nothing to do here
+	    fi
+	    ;;
+	remove)
+	    if [ -n "$use_lockfileprogs" ] ; then
+		lockfile-remove "$file"
+	    else
+		rm -f "${file}.lock"
+	    fi
+	    ;;
+	*)
+	    failure "bad argument for lock subfunction '$action'"
+    esac
+}
+
+
+# for portability, between gnu date and BSD date.
+# arguments should be:  number longunits format
+
+# e.g. advance_date 20 seconds +%F
+advance_date() {
+    local gnutry
+    local number="$1"
+    local longunits="$2"
+    local format="$3"
+    local shortunits
+
+    # try things the GNU way first 
+    if date -d "$number $longunits" "$format" >/dev/null 2>&1; then
+	date -d "$number $longunits" "$format"
+    else
+	# otherwise, convert to (a limited version of) BSD date syntax:
+	case "$longunits" in
+	    years)
+		shortunits=y
+		;;
+	    months)
+		shortunits=m
+		;;
+	    weeks)
+		shortunits=w
+		;;
+	    days)
+		shortunits=d
+		;;
+	    hours)
+		shortunits=H
+		;;
+	    minutes)
+		shortunits=M
+		;;
+	    seconds)
+		shortunits=S
+		;;
+	    *)
+		# this is a longshot, and will likely fail; oh well.
+		shortunits="$longunits"
+	esac
+	date "-v+${number}${shortunits}" "$format"
+    fi
+}
+
+
 # check that characters are in a string (in an AND fashion).
 # used for checking key capability
 # check_capability capability a [b...]
@@ -222,6 +313,7 @@ vnQCFl3+QFSe4zinqykHnLwGPMXv428d/ZjkIc2ju8dRsn4=
 remove_line() {
     local file
     local string
+    local tempfile
 
     file="$1"
     string="$2"
@@ -236,8 +328,13 @@ remove_line() {
 
     # if the string is in the file...
     if grep -q -F "$string" "$file" 2> /dev/null ; then
+	tempfile=$(mktemp "${file}.XXXXXXX") || \
+	    failure "Unable to make temp file '${file}.XXXXXXX'"
+	
 	# remove the line with the string, and return 0
-	grep -v -F "$string" "$file" | sponge "$file"
+	grep -v -F "$string" "$file" >"$tempfile"
+	cat "$tempfile" > "$file"
+	rm "$tempfile"
 	return 0
     # otherwise return 1
     else
@@ -248,6 +345,7 @@ remove_line() {
 # remove all lines with MonkeySphere strings in file
 remove_monkeysphere_lines() {
     local file
+    local tempfile
 
     file="$1"
 
@@ -259,8 +357,13 @@ remove_monkeysphere_lines() {
 	return 1
     fi
 
+    tempfile=$(mktemp "${file}.XXXXXXX") || \
+	failure "Could not make temporary file '${file}.XXXXXXX'."
+
     egrep -v '^MonkeySphere[[:digit:]]{4}(-[[:digit:]]{2}){2}T[[:digit:]]{2}(:[[:digit:]]{2}){2}$' \
-	"$file" | sponge "$file"
+	"$file" >"$tempfile"
+    cat "$tempfile" > "$file"
+    rm "$tempfile"
 }
 
 # translate ssh-style path variables %h and %u
@@ -290,42 +393,48 @@ test_gpg_expire() {
 # check that a file is properly owned, and that all it's parent
 # directories are not group/other writable
 check_key_file_permissions() {
-    local user
+    local uname
     local path
+    local stat
     local access
     local gAccess
     local oAccess
 
-    # function to check that an octal corresponds to writability
+    # function to check that the given permission corresponds to writability
     is_write() {
-	[ "$1" -eq 2 -o "$1" -eq 3 -o "$1" -eq 6 -o "$1" -eq 7 ]
+	[ "$1" = "w" ]
     }
 
-    user="$1"
+    uname="$1"
     path="$2"
 
-    # return 0 is path does not exist
-    [ -e "$path" ] || return 0
+    # return 255 if cannot stat file
+    if ! stat=$(ls -ld "$path" 2>/dev/null) ; then
+        log error "could not stat path '$path'."
+	return 255
+    fi
 
-    owner=$(stat --format '%U' "$path")
-    access=$(stat --format '%a' "$path")
-    gAccess=$(echo "$access" | cut -c2)
-    oAccess=$(echo "$access" | cut -c3)
+    owner=$(echo "$stat" | awk '{ print $3 }')
+    gAccess=$(echo "$stat" | cut -c6)
+    oAccess=$(echo "$stat" | cut -c9)
 
-    # check owner
-    if [ "$owner" != "$user" -a "$owner" != 'root' ] ; then
+    # return 1 if path has invalid owner
+    if [ "$owner" != "$uname" -a "$owner" != 'root' ] ; then
+	log error "improper ownership on path '$path'."
 	return 1
     fi
 
-    # check group/other writability
+    # return 2 if path has group or other writability
     if is_write "$gAccess" || is_write "$oAccess" ; then
+	log error "improper group or other writability on path '$path'."
 	return 2
     fi
 
+    # return zero if all clear, or go to next path
     if [ "$path" = '/' ] ; then
 	return 0
     else
-	check_key_file_permissions $(dirname "$path")
+	check_key_file_permissions "$uname" $(dirname "$path")
     fi
 }
 
@@ -413,7 +522,7 @@ gpg_fetch_userid() {
 
     userID="$1"
 
-    log info " checking keyserver $KEYSERVER... "
+    log verbose " checking keyserver $KEYSERVER... "
     echo 1,2,3,4,5 | \
 	gpg --quiet --batch --with-colons \
 	--command-fd 0 --keyserver "$KEYSERVER" \
@@ -506,17 +615,17 @@ process_user_id() {
 
 		# if overall key is not valid, skip
 		if [ "$validity" != 'u' -a "$validity" != 'f' ] ; then
-		    log error "  - unacceptable primary key validity ($validity)."
+		    log debug "  - unacceptable primary key validity ($validity)."
 		    continue
 		fi
 		# if overall key is disabled, skip
 		if check_capability "$usage" 'D' ; then
-		    log error "  - key disabled."
+		    log debug "  - key disabled."
 		    continue
 		fi
 		# if overall key capability is not ok, skip
 		if ! check_capability "$usage" $requiredPubCapability ; then
-		    log error "  - unacceptable primary key capability ($usage)."
+		    log debug "  - unacceptable primary key capability ($usage)."
 		    continue
 		fi
 
@@ -530,7 +639,7 @@ process_user_id() {
 		;;
 	    'uid') # user ids
 		if [ "$lastKey" != pub ] ; then
-		    log error " - got a user ID after a sub key?!  user IDs should only follow primary keys!"
+		    log verbose " ! got a user ID after a sub key?!  user IDs should only follow primary keys!"
 		    continue
 		fi
 		# if an acceptable user ID was already found, skip
@@ -543,6 +652,8 @@ process_user_id() {
 		    if [ "$validity" = 'u' -o "$validity" = 'f' ] ; then
 			# mark user ID acceptable
 			uidOK=true
+		    else
+			log debug "  - unacceptable user ID validity ($validity)."
 		    fi
 		else
 		    continue
@@ -558,9 +669,9 @@ process_user_id() {
 			echo "0:${sshKey}"
 		    fi
 		else
-		    log error "  - unacceptable primary key."
+		    log debug "  - unacceptable primary key."
 		    if [ -z "$sshKey" ] ; then
-			log error "   ! primary key could not be translated (not RSA or DSA?)."
+			log error "    ! primary key could not be translated (not RSA or DSA?)."
 		    else
 			echo "1:${sshKey}"
 		    fi
@@ -584,10 +695,12 @@ process_user_id() {
 		
 		# if sub key validity is not ok, skip
 		if [ "$validity" != 'u' -a "$validity" != 'f' ] ; then
+		    log debug "  - unacceptable sub key validity ($validity)."
 		    continue
 		fi
 		# if sub key capability is not ok, skip
 		if ! check_capability "$usage" $requiredCapability ; then
+		    log debug "  - unacceptable sub key capability ($usage)."
 		    continue
 		fi
 
@@ -614,7 +727,7 @@ process_user_id() {
 			echo "0:${sshKey}"
 		    fi
 		else
-		    log error "  - unacceptable sub key."
+		    log debug "  - unacceptable sub key."
 		    if [ -z "$sshKey" ] ; then
 			log error "    ! sub key could not be translated (not RSA or DSA?)."
 		    else
@@ -633,6 +746,7 @@ process_user_id() {
 process_host_known_hosts() {
     local host
     local userID
+    local noKey=
     local nKeys
     local nKeysOK
     local ok
@@ -659,8 +773,9 @@ process_host_known_hosts() {
             continue
         fi
 
-	# remove the old host key line, and note if removed
-	remove_line "$KNOWN_HOSTS" "$sshKey"
+	# remove any old host key line, and note if removed nothing is
+	# removed
+	remove_line "$KNOWN_HOSTS" "$sshKey" || noKey=true
 
 	# if key OK, add new host line
 	if [ "$ok" -eq '0' ] ; then
@@ -671,7 +786,7 @@ process_host_known_hosts() {
 	    if [ "$HASH_KNOWN_HOSTS" = 'true' ] ; then
 		# FIXME: this is really hackish cause ssh-keygen won't
 		# hash from stdin to stdout
-		tmpfile=$(mktemp)
+		tmpfile=$(mktemp ${TMPDIR:-/tmp}/tmp.XXXXXXXXXX)
 		ssh2known_hosts "$host" "$sshKey" > "$tmpfile"
 		ssh-keygen -H -f "$tmpfile" 2> /dev/null
 		cat "$tmpfile" >> "$KNOWN_HOSTS"
@@ -679,6 +794,11 @@ process_host_known_hosts() {
 	    else
 		ssh2known_hosts "$host" "$sshKey" >> "$KNOWN_HOSTS"
 	    fi
+
+	    # log if this is a new key to the known_hosts file
+	    if [ "$noKey" ] ; then
+		log info "* new key for $host added to known_hosts file."
+	    fi
 	fi
     done
 
@@ -712,11 +832,10 @@ update_known_hosts() {
     nHostsOK=0
     nHostsBAD=0
 
-    # set the trap to remove any lockfiles on exit
-    trap "lockfile-remove $KNOWN_HOSTS" EXIT
-
-    # create a lockfile on known_hosts
-    lockfile-create "$KNOWN_HOSTS"
+    # create a lockfile on known_hosts:
+    lock create "$KNOWN_HOSTS"
+    # FIXME: we're discarding any pre-existing EXIT trap; is this bad?
+    trap "lock remove $KNOWN_HOSTS" EXIT
 
     # note pre update file checksum
     fileCheck="$(file_hash "$KNOWN_HOSTS")"
@@ -735,15 +854,16 @@ update_known_hosts() {
 	esac
 
 	# touch the lockfile, for good measure.
-	lockfile-touch --oneshot "$KNOWN_HOSTS"
+	lock touch "$KNOWN_HOSTS"
     done
 
-    # remove the lockfile
-    lockfile-remove "$KNOWN_HOSTS"
+    # remove the lockfile and the trap
+    lock remove "$KNOWN_HOSTS"
+    trap - EXIT
 
     # note if the known_hosts file was updated
     if [ "$(file_hash "$KNOWN_HOSTS")" != "$fileCheck" ] ; then
-	log verbose "known_hosts file updated."
+	log debug "known_hosts file updated."
     fi
 
     # if an acceptable host was found, return 0
@@ -766,12 +886,12 @@ update_known_hosts() {
 process_known_hosts() {
     local hosts
 
-    log verbose "processing known_hosts file..."
+    log debug "processing known_hosts file..."
 
     hosts=$(meat "$KNOWN_HOSTS" | cut -d ' ' -f 1 | grep -v '^|.*$' | tr , ' ' | tr '\n' ' ')
 
     if [ -z "$hosts" ] ; then
-	log error "no hosts to process."
+	log debug "no hosts to process."
 	return
     fi
 
@@ -850,11 +970,10 @@ update_authorized_keys() {
     nIDsOK=0
     nIDsBAD=0
 
-    # set the trap to remove any lockfiles on exit
-    trap "lockfile-remove $AUTHORIZED_KEYS" EXIT
-
     # create a lockfile on authorized_keys
-    lockfile-create "$AUTHORIZED_KEYS"
+    lock create "$AUTHORIZED_KEYS"
+    # FIXME: we're discarding any pre-existing EXIT trap; is this bad?
+    trap "lock remove $AUTHORIZED_KEYS" EXIT
 
     # note pre update file checksum
     fileCheck="$(file_hash "$AUTHORIZED_KEYS")"
@@ -878,15 +997,16 @@ update_authorized_keys() {
 	esac
 
 	# touch the lockfile, for good measure.
-	lockfile-touch --oneshot "$AUTHORIZED_KEYS"
+	lock touch "$AUTHORIZED_KEYS"
     done
 
-    # remove the lockfile
-    lockfile-remove "$AUTHORIZED_KEYS"
+    # remove the lockfile and the trap
+    lock remove "$AUTHORIZED_KEYS"
+    trap - EXIT
 
     # note if the authorized_keys file was updated
     if [ "$(file_hash "$AUTHORIZED_KEYS")" != "$fileCheck" ] ; then
-	log verbose "authorized_keys file updated."
+	log debug "authorized_keys file updated."
     fi
 
     # if an acceptable id was found, return 0
@@ -913,10 +1033,10 @@ process_authorized_user_ids() {
 
     authorizedUserIDs="$1"
 
-    log verbose "processing authorized_user_ids file..."
+    log debug "processing authorized_user_ids file..."
 
     if ! meat "$authorizedUserIDs" > /dev/null ; then
-	log error "no user IDs to process."
+	log debug " no user IDs to process."
 	return
     fi