test(bkgpslog):Test recipient string quoting
[EVA-2020-02.git] / exec / bkgpslog
index 92890646ebb2bb5562f01365f6153a01811f9287..397fe11308d85b453998ba374ec68a6b4b35e8ea 100755 (executable)
@@ -6,7 +6,7 @@
 
 #==BEGIN Define script parameters==
 ## Logging Behavior parameters
 
 #==BEGIN Define script parameters==
 ## Logging Behavior parameters
-BUFFER_TTL="60"; # time between file writes
+BUFFER_TTL="300"; # time between file writes
 SCRIPT_TTL="day"; # (day|hour)
 #### TZ="UTC"; export TZ; # Default time zone; overridden by '--time-zone=[str]' option
 DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
 SCRIPT_TTL="day"; # (day|hour)
 #### TZ="UTC"; export TZ; # Default time zone; overridden by '--time-zone=[str]' option
 DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
@@ -14,8 +14,11 @@ DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
 SCRIPT_TIME_START=$(date +%Y%m%dT%H%M%S.%N);
 PATH="$HOME/.local/bin:$PATH";   # Add "$(systemd-path user-binaries)" path in case apps saved there
 SCRIPT_HOSTNAME=$(hostname);     # Save hostname of system running this script.
 SCRIPT_TIME_START=$(date +%Y%m%dT%H%M%S.%N);
 PATH="$HOME/.local/bin:$PATH";   # Add "$(systemd-path user-binaries)" path in case apps saved there
 SCRIPT_HOSTNAME=$(hostname);     # Save hostname of system running this script.
-SCRIPT_VERSION="bkgpslog 0.2.1"; # Define version of script.
-SCRIPT_NAME="$(basename "$0")";  # Define basename of script file.
+SCRIPT_VERSION="0.3.7";          # Define version of script.
+SCRIPT_NAME="bkgpslog";          # Define basename of script file.
+SCRIPT_URL="https://gitlab.com/baltakatei/ninfacyzga-01"; # Define wesite hosting this script.
+AGE_VERSION="1.0.0-beta2";       # Define version of age (encryption program)
+AGE_URL="https://github.com/FiloSottile/age/releases/tag/v1.0.0-beta2"; # Define website hosting age.
 
 declare -Ag appRollCall # Associative array for storing app status
 declare -Ag fileRollCall # Associative array for storing file status
 
 declare -Ag appRollCall # Associative array for storing app status
 declare -Ag fileRollCall # Associative array for storing file status
@@ -331,76 +334,122 @@ timeUntilNextHour(){
 } # Report seconds until next hour
 dateTimeShort(){
     # Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
 } # Report seconds until next hour
 dateTimeShort(){
     # Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
-    # Usage: dateTimeShort
+    # Usage: dateTimeShort ([str date])
+    # Version 1.1.0
+    # Input: arg1: 'date'-parsable timestamp string (optional)
     # Output: stdout: timestamp (ISO-8601, no separators)
     # Output: stdout: timestamp (ISO-8601, no separators)
+    # Depends: yell
     local TIME_CURRENT TIME_CURRENT_SHORT
     local TIME_CURRENT TIME_CURRENT_SHORT
+
+    argTime="$1";
+    # Get Current Time
     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
-    TIME_CURRENT_SHORT="$(date -d "$TIME_CURRENT" +%Y%m%dT%H%M%S%z)"; # Produce separator-less current timestamp with resolution 1 second.
+    # Decide to parse current or supplied date
+    ## Check if time argument empty
+    if [[ -z "$argTime" ]]; then
+       ## T: Time argument empty, use current time
+       TIME_INPUT="$TIME_CURRENT";
+    else
+       ## F: Time argument exists, validate time
+       if date --date="$argTime" 1>/dev/null 2>&1; then
+           ### T: Time argument is valid; use it
+           TIME_INPUT="$argTime";
+       else
+           ### F: Time argument not valid; exit
+           yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
+       fi
+    fi
+    # Construct and deliver separator-les date string
+    TIME_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%dT%H%M%S%z)";
     echo "$TIME_CURRENT_SHORT";
 } # Get YYYYmmddTHHMMSS±zzzz
 dateShort(){
     # Desc: Date without separators (YYYYmmdd)
     echo "$TIME_CURRENT_SHORT";
 } # Get YYYYmmddTHHMMSS±zzzz
 dateShort(){
     # Desc: Date without separators (YYYYmmdd)
-    # Usage: dateShort
+    # Usage: dateShort ([str date])
+    # Version: 1.1.0
+    # Input: arg1: 'date'-parsable timestamp string (optional)
     # Output: stdout: date (ISO-8601, no separators)
     # Output: stdout: date (ISO-8601, no separators)
+    # Depends: yell
     local TIME_CURRENT DATE_CURRENT_SHORT
     local TIME_CURRENT DATE_CURRENT_SHORT
+
+    argTime="$1";
+    # Get Current Time
     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
-    DATE_CURRENT_SHORT="$(date -d "$TIME_CURRENT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
+    # Decide to parse current or supplied date
+    ## Check if time argument empty
+    if [[ -z "$argTime" ]]; then
+       ## T: Time argument empty, use current time
+       TIME_INPUT="$TIME_CURRENT";
+    else
+       ## F: Time argument exists, validate time
+       if date --date="$argTime" 1>/dev/null 2>&1; then
+           ### T: Time argument is valid; use it
+           TIME_INPUT="$argTime";
+       else
+           ### F: Time argument not valid; exit
+           yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
+       fi
+    fi
+    # Construct and deliver separator-les date string    
+    DATE_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
     echo "$DATE_CURRENT_SHORT";
 } # Get YYYYmmdd
 timeDuration(){
     echo "$DATE_CURRENT_SHORT";
 } # Get YYYYmmdd
 timeDuration(){
-    # Desc: Output approximate time duration string before given time (default:current date)
+    # Desc: Given seconds, output ISO-8601 duration string
     # Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
     # Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
     # Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
     # Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
-    # Usage: timeDuration [arg1] ([arg2])
-    # Version: 1.0.1
+    # Usage: timeDuration [1:seconds] ([2:precision])
+    # Version: 1.0.3
     # Input: arg1: seconds as base 10 integer >= 0  (ex: 3601)
     #        arg2: precision level (optional; default=2)
     # Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
     # Input: arg1: seconds as base 10 integer >= 0  (ex: 3601)
     #        arg2: precision level (optional; default=2)
     # Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
+    #         exit code 0: success
+    #         exit code 1: error_input
+    #         exit code 2: error_unknown
     # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
     # Depends: date 8 (gnucoreutils), yell, 
     # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
     # Depends: date 8 (gnucoreutils), yell, 
-    local returnState ARG1 ARG2 remainder precision witherPrecision
+    local returnState argSeconds argPrecision remainder precision witherPrecision
     local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
     local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
     local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
     
     local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
     local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
     local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
     
-    ARG1="$1";
-    ARG2="$2";
+    argSeconds="$1"; # read arg1 (seconds)
+    argPrecision="$2"; # read arg2 (precision)
     precision=2; # set default precision
     precision=2; # set default precision
-    returnState="true"; # set default return state
 
     # Check that between one and two arguments is supplied
     if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
        yell "ERROR:Invalid number of arguments:$# . Exiting.";
 
     # Check that between one and two arguments is supplied
     if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
        yell "ERROR:Invalid number of arguments:$# . Exiting.";
-       returnState="ERROR_INPUT"; fi
+       returnState="error_input"; fi
 
 
-    # Check that arg1 provided
+    # Check that argSeconds provided
     if [[ $# -ge 1 ]]; then
     if [[ $# -ge 1 ]]; then
-       ## Check that arg1 is a positive integer
-       if [[ "$ARG1" =~ ^[[:digit:]]+$ ]]; then
+       ## Check that argSeconds is a positive integer
+       if [[ "$argSeconds" =~ ^[[:digit:]]+$ ]]; then
            :
        else
            :
        else
-           yell "ERROR:ARG1 not a digit.";
-           returnState="ERROR_INPUT";
+           yell "ERROR:argSeconds not a digit.";
+           returnState="error_input";
        fi
     else
        yell "ERROR:No argument provided. Exiting.";
        exit 1;
     fi
 
        fi
     else
        yell "ERROR:No argument provided. Exiting.";
        exit 1;
     fi
 
-    # Consider whether arg2 was provided
+    # Consider whether argPrecision was provided
     if  [[ $# -eq 2 ]]; then
     if  [[ $# -eq 2 ]]; then
-       # Check that the second arg is a positive integer
-       if [[ "$ARG2" =~ ^[[:digit:]]+$ ]] && [[ "$ARG2" -gt 0 ]]; then
-       precision="$ARG2";
+       # Check that argPrecision is a positive integer
+       if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then
+       precision="$argPrecision";
        else
        else
-           yell "ERROR:ARG2 not a positive integer. (is $ARG2 ). Leaving early.";
-           returnState="ERROR_INPUT";
+           yell "ERROR:argPrecision not a positive integer. (is $argPrecision ). Leaving early.";
+           returnState="error_input";
        fi;
     else
        :
     fi;
     
        fi;
     else
        :
     fi;
     
-    remainder="$ARG1" ; # seconds
+    remainder="$argSeconds" ; # seconds
     ## Calculate full years Y, update remainder
     fullYears=$(( remainder / (365*24*60*60) ));
     remainder=$(( remainder - (fullYears*365*24*60*60) ));
     ## Calculate full years Y, update remainder
     fullYears=$(( remainder / (365*24*60*60) ));
     remainder=$(( remainder - (fullYears*365*24*60*60) ));
@@ -500,8 +549,6 @@ timeDuration(){
     fi;
     if $witherPrecision; then ((precision--)); fi;
 
     fi;
     if $witherPrecision; then ((precision--)); fi;
 
-
-
     ## Determine whether or not the "T" separator is needed to separate date and time elements
     if ( $displayHours || $displayMinutes || $displaySeconds); then
        displayDateTime="true"; else displayDateTime="false"; fi
     ## Determine whether or not the "T" separator is needed to separate date and time elements
     if ( $displayHours || $displayMinutes || $displaySeconds); then
        displayDateTime="true"; else displayDateTime="false"; fi
@@ -524,14 +571,17 @@ timeDuration(){
        OUTPUT=$OUTPUT$fullSeconds"S"; fi
 
     ## Output duration string to stdout
        OUTPUT=$OUTPUT$fullSeconds"S"; fi
 
     ## Output duration string to stdout
-    if [[ "$returnState" = "true" ]]; then echo "$OUTPUT"; fi
+    echo "$OUTPUT" && returnState="true";
 
     #===Determine function return code===
     if [ "$returnState" = "true" ]; then
        return 0;
 
     #===Determine function return code===
     if [ "$returnState" = "true" ]; then
        return 0;
-    else
-       echo "$returnState" 1>&2;
+    elif [ "$returnState" = "error_input" ]; then
+       yell "ERROR:input";
        return 1;
        return 1;
+    else
+       yell "ERROR:Unknown";
+       return 2;
     fi
 
 } # Get duration (ex: PT10M4S )
     fi
 
 } # Get duration (ex: PT10M4S )
@@ -663,7 +713,8 @@ checkMakeTar() {
 } # checks if arg1 is tar; creates one otherwise
 appendArgTar(){
     # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
 } # checks if arg1 is tar; creates one otherwise
 appendArgTar(){
     # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
-    # Usage: writeArg "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
+    # Usage: appendArgTar "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
+    # Version: 1.0.2
     # Input: arg1: data to be written
     #        arg2: file name of file to be inserted into tar
     #        arg3: tar archive path (must exist first)
     # Input: arg1: data to be written
     #        arg2: file name of file to be inserted into tar
     #        arg3: tar archive path (must exist first)
@@ -677,8 +728,8 @@ appendArgTar(){
     # Depends: bash 5
 
     # Save function name
     # Depends: bash 5
 
     # Save function name
-    local FN="${FUNCNAME[0]}"
-    yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
+    local FN="${FUNCNAME[0]}";
+    #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
     
     # Set file name
     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
     
     # Set file name
     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
@@ -695,60 +746,151 @@ appendArgTar(){
     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
 
     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
 
-    # Debug
-    yell "STATUS:$FN:CMD1:$CMD1"
-    yell "STATUS:$FN:CMD2:$CMD2"
-    yell "STATUS:$FN:CMD3:$CMD3"
-    yell "STATUS:$FN:CMD4:$CMD4"
-    yell "STATUS:$FN:FILENAME:$FILENAME"
-    yell "STATUS:$FN:TAR_PATH:$TAR_PATH"
-    yell "STATUS:$FN:TMP_DIR:$TMP_DIR"
+    # # Debug
+    # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
+    # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
+    # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
+    # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
+    # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
+    # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
+    # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
+    
     # Write to temporary working dir
     echo "$1" | $CMD1 | $CMD2 | $CMD3 | $CMD4 > "$TMP_DIR"/"$FILENAME";
 
     # Append to tar
     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
     # Write to temporary working dir
     echo "$1" | $CMD1 | $CMD2 | $CMD3 | $CMD4 > "$TMP_DIR"/"$FILENAME";
 
     # Append to tar
     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
-    yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
+    #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 } # Append Bash var to file appended to Tar archive
 } # Append Bash var to file appended to Tar archive
+appendFileTar(){
+    # Desc: Processes first file and then appends to tar
+    # Usage: appendFileTar [file path] [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
+    # Version: 1.0.1
+    # Input: arg1: path of file to be (processed and) written
+    #        arg2: name to use for file inserted into tar
+    #        arg3: tar archive path (must exist first)
+    #        arg4: temporary working dir
+    #        arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
+    # Output: file written to disk
+    # Example: decrypt multiple large files in parallel
+    #          appendFileTar /tmp/largefile1.gpg "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
+    #          appendFileTar /tmp/largefile2.gpg "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
+    #          appendFileTar /tmp/largefile3.gpg "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
+    # Depends: bash 5
+
+    # Save function name
+    local FN="${FUNCNAME[0]}";
+    #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
+    
+    # Set file name
+    if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
+    # Check tar path is a file
+    if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
+    # Check temp dir arg
+    if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
+    # Set command strings
+    if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
+    if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
+    if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
+    if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
+    # # Debug
+    # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
+    # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
+    # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
+    # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
+    # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
+    # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
+    # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
+    
+    # Write to temporary working dir
+    cat "$1" | $CMD1 | $CMD2 | $CMD3 | $CMD4 > "$TMP_DIR"/"$FILENAME";
+
+    # Append to tar
+    try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
+    #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
+} # Append file to Tar archive
 magicWriteVersion() {
     # Desc: Appends time-stamped VERSION to PATHOUT_TAR
     # Usage: magicWriteVersion
 magicWriteVersion() {
     # Desc: Appends time-stamped VERSION to PATHOUT_TAR
     # Usage: magicWriteVersion
+    # Version: 0.1.0
     # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
     # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
+    # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
+    # Output: appends tar PATHOUT_TAR
     # Depends: dateTimeShort, appendArgTar
     # Depends: dateTimeShort, appendArgTar
-    local CONTENT_VERSION
+    local CONTENT_VERSION pubKeyIndex
     
     
-    # Generate VERSION file in BashVar
+    # Set VERSION file name
     FILEOUT_VERSION="$(dateTimeShort)..VERSION";
     FILEOUT_VERSION="$(dateTimeShort)..VERSION";
-    CONTENT_VERSION="VERSION=$SCRIPT_VERSION";
-    CONTENT_VERSION="$CONTENT_VERSION""\n""SCRIPT_NAME=SCRIPT_NAME";
-    CONTENT_VERSION="$CONTENT_VERSION""\n""DATE=$(date --iso-8601=seconds)";
-    CONTENT_VERSION="$CONTENT_VERSION""\n""HOSTNAME=$SCRIPT_HOSTNAME";
+
+    # Gather VERSION data in CONTENT_VERSION
+    CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
+    #CONTENT_VERSION="$CONTENT_VERSION""\\n";
+    CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
+    CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
+    CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
+    CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
+    CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
+    CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
+    ## Add list of recipient pubkeys
+    for pubkey in "${recPubKeysValid[@]}"; do
+       ((pubKeyIndex++))
+       CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
+    done
+    ## Process newline escapes
     CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
 
     CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
 
-    # Create BashVar as file FILEOUT_VERSION and write-append to PATHOUT_TAR
+    # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
     appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
     appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
+    
 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
-magicWriteBuffer() {
+magicGatherWriteBuffer() {
     # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
     # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
-    # Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP
+    # Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
+    # Inputs: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
     # Depends: yell, try, vbm, appendArgTar, tar
     local FN="${FUNCNAME[0]}";
     wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
     # Depends: yell, try, vbm, appendArgTar, tar
     local FN="${FUNCNAME[0]}";
     wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
+    # Create buffer file with unique name
+    PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";
+    # Fill buffer
+    timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
+    timeBufferStart="$(dateTimeShort  "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time
     vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
     vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
-
+    # Determine file paths (time is start of buffer period)
+    FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
+    ## Files saved to DIR_TMP
+    FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
+    FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
+    FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
+    PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
+    PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
+    PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
+    ## Files saved to disk (DIR_OUT)
+    ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
+    PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
+       vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
+    # DEBUG: check vars
+    vbm "STATUS:DIR_TMP     :$DIR_TMP";
+    vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
+    vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
+    vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
+    vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
+    
+    
     # Validate PATHOUT_TAR as tar.
     checkMakeTar "$PATHOUT_TAR";
     ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
     if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
 
     # Write bufferBash to PATHOUT_TAR
     # Validate PATHOUT_TAR as tar.
     checkMakeTar "$PATHOUT_TAR";
     ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
     if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
 
     # Write bufferBash to PATHOUT_TAR
-    appendArgTar "$bufferBash" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
-    appendArgTar "$bufferBash" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
-    appendArgTar "$bufferBash" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
+    appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
+    appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
+    appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
+
     # Remove secured chunks from DIR_TMP
     # Remove secured chunks from DIR_TMP
-    try rm "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
-    yell "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
-} # bkgpslog write function
+    rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
+    vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
+} # write buffer to disk
 
 main() {
     processArguments "$@" # Process arguments.
 
 main() {
     processArguments "$@" # Process arguments.
@@ -782,38 +924,41 @@ main() {
     if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
        if checkapp age; then # Check that age is available.
            for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
     if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
        if checkapp age; then # Check that age is available.
            for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
-               vbm "DEBUG:Testing pubkey string:$pubkey"
+               vbm "DEBUG:Testing pubkey string:$pubkey";
                if echo "butts" | age -a -r "$pubkey" 1>/dev/null; then
                if echo "butts" | age -a -r "$pubkey" 1>/dev/null; then
-                   # Form age recipient string
-                   recipients="$recipients""-r $pubkey ";
+                   #### Form age recipient string
+                   recipients="$recipients""-r '$pubkey' ";
                    vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
                    vbm "DEBUG:recipients:""$recipients";
                    vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
                    vbm "DEBUG:recipients:""$recipients";
+                   #### Add validated pubkey to recPubKeysValid array
+                   recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
                else
                    yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
                fi
            done
            vbm "DEBUG:Finished processing recPubKeys array";
                else
                    yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
                fi
            done
            vbm "DEBUG:Finished processing recPubKeys array";
-           # Form age command string
-           CMD_ENCRYPT="age ""$recipients ";
-           CMD_ENCRYPT_SUFFIX=".age";
+
+           ##  Form age command string
+           CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
+           CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
        else
            yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
        fi
     else
        else
            yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
        fi
     else
-       CMD_ENCRYPT="tee /dev/null ";
-       CMD_ENCRYPT_SUFFIX="";
+       CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
+       CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
        vbm "DEBUG:Encryption not enabled."
     fi
     if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
        if checkapp gzip; then # Check if gzip available
        vbm "DEBUG:Encryption not enabled."
     fi
     if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
        if checkapp gzip; then # Check if gzip available
-           CMD_COMPRESS="gzip ";
-           CMD_COMPRESS_SUFFIX=".gz";
+           CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
+           CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
        else
            yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
        fi
     else
        else
            yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
        fi
     else
-       CMD_COMPRESS="tee /dev/null ";
-       CMD_COMPRESS_SUFFIX="";
+       CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
+       CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
        vbm "DEBUG:Compression not enabled.";
     fi
 
        vbm "DEBUG:Compression not enabled.";
     fi
 
@@ -839,47 +984,20 @@ main() {
     checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
     ## Append VERSION file to PATHOUT_TAR
     magicWriteVersion;
     checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
     ## Append VERSION file to PATHOUT_TAR
     magicWriteVersion;
-    
-    # Record gps data until script lifespan ends
-    declare debugCounter; debugCounter="0"; # set debug counter
+
+    # Define GPS conversion commands
+    CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
+    CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
+    CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
+
+    # MAIN LOOP:Record gps data until script lifespan ends
     while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
     while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
-       timeBufferStart="$(dateTimeShort)"; # Note start time
-       # Determine file paths (time is start of buffer period)
-       FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
-       ## Files saved to DIR_TMP
-       FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
-       FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
-       FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
-       PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
-       PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
-       PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
-       ## Files saved to disk (DIR_OUT)
-       ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
-       PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
-           vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
-       # Define GPS conversion commands
-       CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
-       CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
-       CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
-       # Fill Bash variable buffer
-       bufferBash="$(timeout "$BUFFER_TTL""s" gpspipe -r)" && vbm "STATUS:Successfully filled bufferBash variable with gpspipe data."; # Record gpspipe nmea data to buffer for bufferTTL seconds
-       # Process bufferBash, save secured chunk set to DIR_TMP
-       vbm "STATUS:Beginning to save data to $DIR_TMP";
-       magicWriteBuffer &
-       # Append each secured chunk in memory dir (DIR_TMP) to file on disk (PATHOUT_TAR in DIR_OUT)
-       vbm "STATUS:DIR_TMP     :$DIR_TMP";
-       vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
-       vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
-       vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
-       vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
-
-       # Reset buffer and filenames
-       unset bufferBash FILEOUT_BASENAME PATHOUT_NMEA PATHOUT_GPX PATHOUT_KML PATHOUT_TAR timeBufferStart;
-       vbm "DEBUG:Completed buffer session $debugCounter ." 1>&2;
-       ((debugCounter++))
-    done
+       magicGatherWriteBuffer &
+       sleep "$BUFFER_TTL";
+    done    
 
 
-    # Remove DIR_TMP
+    # Cleanup
+    ## Remove DIR_TMP
     try rm -r "$DIR_TMP";
 
     vbm "STATUS:Main function finished.";
     try rm -r "$DIR_TMP";
 
     vbm "STATUS:Main function finished.";