exec/bkgpslog

   1 #!/bin/bash
   2
   3 # Desc: Records gps data until midnight
   4 # Author: Steven Baltakatei Sandoval; License: GPLv3+
   5 # Usage: bkgpslog -o [output dir]
   6
   7 #==BEGIN Define script parameters==
   8 ## Logging Behavior parameters
   9 BUFFER_TTL="300"; # time between file writes
  10 SCRIPT_TTL_TE="day"; # (day|hour)
  11 #### TZ="UTC"; export TZ; # Default time zone; overridden by '--time-zone=[str]' option
  12 DIR_TMP_DEFAULT="/dev/shm"; # Default parent of working directory
  13
  14 SCRIPT_TIME_START=$(date +%Y%m%dT%H%M%S.%N);
  15 PATH="$HOME/.local/bin:$PATH";   # Add "$(systemd-path user-binaries)" path in case apps saved there
  16 SCRIPT_HOSTNAME=$(hostname);     # Save hostname of system running this script.
  17 SCRIPT_VERSION="0.4.4-alpha";          # Define version of script.
  18 SCRIPT_NAME="bkgpslog";          # Define basename of script file.
  19 SCRIPT_URL="https://gitlab.com/baltakatei/ninfacyzga-01"; # Define wesite hosting this script.
  20 AGE_VERSION="1.0.0-beta2";       # Define version of age (encryption program)
  21 AGE_URL="https://github.com/FiloSottile/age/releases/tag/v1.0.0-beta2"; # Define website hosting age.
  22
  23 declare -Ag appRollCall # Associative array for storing app status
  24 declare -Ag fileRollCall # Associative array for storing file status
  25 declare -Ag dirRollCall # Associative array for storing dir status
  26 declare -a argRecPubKeys # for processArguments function
  27 # declare -a errorHistory # for correcting buffer lag
  28
  29 ## Initialize variables
  30 OPTION_VERBOSE=""; OPTION_ENCRYPT=""; OPTION_COMPRESS=""; OPTION_TMPDIR="";
  31 errResetx10e3=0; BUFFER_TTL_ADJ_FLOAT="";
  32 ### PID Control factors
  33 K_P=10; # Gain for compensating buffer round lag
  34 T_I=2; # Consider this number of past buffer rounds to eliminate error
  35 T_D=1; # Predict value this number of buffer rounds into the future
  36
  37 #===BEGIN Declare local script functions===
  38 checkapp() {
  39     # Desc: If arg is a command, save result in assoc array 'appRollCall'
  40     # Usage: checkapp arg1 arg2 arg3 ...
  41     # Input: global assoc. array 'appRollCall'
  42     # Output: adds/updates key(value) to global assoc array 'appRollCall'
  43     local returnState
  44     #echo "DEBUG:$(date +%S.%N)..Starting checkapp function."
  45     #echo "DEBUG:args: $@"
  46     #echo "DEBUG:returnState:$returnState"
  47
  48     #===Process Args===
  49     for arg in "$@"; do
  50         #echo "DEBUG:processing arg:$arg"
  51         if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
  52             appRollCall[$arg]="true";
  53             #echo "DEBUG:appRollCall[$arg]:"${appRollCall[$arg]}
  54             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
  55         else
  56             appRollCall[$arg]="false"; returnState="false";
  57         fi
  58     done
  59
  60     #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
  61     #echo "DEBUG:evaluating returnstate. returnState:"$returnState
  62
  63     #===Determine function return code===
  64     if [ "$returnState" = "true" ]; then
  65         #echo "DEBUG:checkapp returns true for $arg";
  66         return 0;
  67     else
  68         #echo "DEBUG:checkapp returns false for $arg";
  69         return 1;
  70     fi
  71 } # Check that app exists
  72 checkfile() {
  73     # Desc: If arg is a file path, save result in assoc array 'fileRollCall'
  74     # Usage: checkfile arg1 arg2 arg3 ...
  75     # Input: global assoc. array 'fileRollCall'
  76     # Output: adds/updates key(value) to global assoc array 'fileRollCall';
  77     # Output: returns 0 if app found, 1 otherwise
  78     local returnState
  79
  80     #===Process Args===
  81     for arg in "$@"; do
  82         #echo "DEBUG:processing arg:$arg"
  83         if [ -f "$arg" ]; then
  84             fileRollCall["$arg"]="true";
  85             #echo "DEBUG:fileRollCall[\"$arg\"]:"${fileRollCall["$arg"]}
  86             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
  87         else
  88             fileRollCall["$arg"]="false"; returnState="false";
  89         fi
  90     done
  91
  92     #for key in "${!fileRollCall[@]}"; do echo "DEBUG:fileRollCall key [$key] is:${fileRollCall[$key]}"; done
  93     #echo "DEBUG:evaluating returnstate. returnState:"$returnState
  94
  95     #===Determine function return code===
  96     if [ "$returnState" = "true" ]; then
  97         #echo "DEBUG:checkapp returns true for $arg";
  98         return 0;
  99     else
 100         #echo "DEBUG:checkapp returns false for $arg";
 101         return 1;
 102     fi
 103 } # Check that file exists
 104 checkdir() {
 105     # Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
 106     # Usage: checkdir arg1 arg2 arg3 ...
 107     # Input: global assoc. array 'dirRollCall'
 108     # Output: adds/updates key(value) to global assoc array 'dirRollCall';
 109     # Output: returns 0 if app found, 1 otherwise
 110     local returnState
 111
 112     #===Process Args===
 113     for arg in "$@"; do
 114         #echo "DEBUG:processing arg:$arg"
 115         if [ -d "$arg" ]; then
 116             dirRollCall["$arg"]="true";
 117             #echo "DEBUG:dirRollCall[\"$arg\"]:"${dirRollCall["$arg"]}
 118             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
 119         elif [ "$arg" = "" ]; then
 120             dirRollCall["$arg"]="false"; returnState="false";
 121         else
 122             returnState="false";
 123         fi
 124     done
 125
 126     #for key in "${!dirRollCall[@]}"; do echo "DEBUG:dirRollCall key [$key] is:${dirRollCall[$key]}"; done
 127     #echo "DEBUG:evaluating returnstate. returnState:"$returnState
 128
 129     #===Determine function return code===
 130     if [ "$returnState" = "true" ]; then
 131         #echo "DEBUG:checkapp returns true for $arg";
 132         return 0;
 133     else
 134         #echo "DEBUG:checkapp returns false for $arg";
 135         return 1;
 136     fi
 137 } # Check that dir exists
 138
 139 # Yell, Die, Try Three-Fingered Claw technique
 140 # Ref/Attrib: https://stackoverflow.com/a/25515370
 141 yell() { echo "$0: $*" >&2; }
 142 die() { yell "$*"; exit 111; }
 143 try() { "$@" || die "cannot $*"; }
 144
 145 echoerr() {
 146     echo "$@" 1>&2; # Define stderr echo function.
 147 } # Define stderr message function.
 148 showUsage() {
 149     echoerr "USAGE:"
 150     echoerr "    bkgpslog [ options ]"
 151     echoerr
 152     echoerr "OPTIONS:"
 153     echoerr "    -h, --help"
 154     echoerr "            Display help information."
 155     echoerr "    --version"
 156     echoerr "            Display script version."
 157     echoerr "    -v, --verbose"
 158     echoerr "            Display debugging info."
 159     echoerr "    -e, --encrypt"
 160     echoerr "            Encrypt output."
 161     echoerr "    -r, --recipient [ string pubkey ]"
 162     echoerr "            Specify recipient. May be age or ssh pubkey."
 163     echoerr "            May be specified multiple times for multiple pubkeys."
 164     echoerr "            See https://github.com/FiloSottile/age"
 165     echoerr "    -o, --output [ path dir ]"
 166     echoerr "            Specify output directory to save logs."
 167     echoerr "    -c, --compress"
 168     echoerr "            Compress output with gzip (before encryption if enabled)."
 169     echoerr "    -z, --time-zone"
 170     echoerr "            Specify time zone. (ex: \"America/New_York\")"
 171     echoerr "    -t, --temp-dir [path dir]"
 172     echoerr "            Specify parent directory for temporary working directory."
 173     echoerr "            Default: \"/dev/shm\""
 174     echoerr "    -R, --recipient-dir [path dir]"
 175     echoerr "            Specify directory containing files whose first lines are"
 176     echoerr "            to be interpreted as pubkey strings (see \\'-r\\' option)."
 177     echoerr "    -b, --buffer-ttl [integer]"
 178     echoerr "            Specify custom buffer period in seconds (default: 300 seconds)"
 179     echoerr "    -B, --script-ttl [integer]"
 180     echoerr "            Specify custom script time-to-live in seconds (default: \"day\")"
 181     echoerr
 182     echoerr "EXAMPLE: (bash script lines)"
 183     echoerr "/bin/bash bkgpslog -v -e -c \\"
 184     echoerr "-z \"UTC\" -t \"/dev/shm\" \\"
 185     echoerr "-r age1mrmfnwhtlprn4jquex0ukmwcm7y2nxlphuzgsgv8ew2k9mewy3rs8u7su5 \\"
 186     echoerr "-r age1ala848kqrvxc88rzaauc6vc5v0fqrvef9dxyk79m0vjea3hagclswu0lgq \\"
 187     echoerr "-o ~/Sync/Location"
 188 } # Display information on how to use this script.
 189 showVersion() {
 190     echoerr "$SCRIPT_VERSION"
 191 } # Display script version.
 192 vbm() {
 193     # Usage: vbm "DEBUG:verbose message here"
 194     # Description: Prints verbose message ("vbm") to stderr if OPTION_VERBOSE is set to "true".
 195     # Input:
 196     #   - OPTION_VERBOSE  variable set by processArguments function. (ex: "true", "false")
 197     #   - "$@"            positional arguments fed to this function.
 198     # Output: stderr
 199     # Script function dependencies: echoerr
 200     # External function dependencies: echo
 201     # Last modified: 2020-04-11T23:57Z
 202     # Last modified by: Steven Baltakatei Sandoval
 203     # License: GPLv3+
 204     # Ref./Attrib:
 205
 206     if [ "$OPTION_VERBOSE" = "true" ]; then
 207         FUNCTION_TIME=$(date --iso-8601=ns); # Save current time in nano seconds.
 208         echoerr "[$FUNCTION_TIME] ""$*"; # Display argument text.
 209     fi
 210
 211     # End function
 212     return 0; # Function finished.
 213 } # Verbose message display function.
 214 processArguments() {
 215     while [ ! $# -eq 0 ]; do   # While number of arguments ($#) is not (!) equal to (-eq) zero (0).
 216         #echoerr "DEBUG:Starting processArguments while loop."
 217         #echoerr "DEBUG:Provided arguments are:""$*"
 218         case "$1" in
 219             -h | --help) showUsage; exit 1;; # Display usage.
 220             --version) showVersion; exit 1;; # Show version
 221             -v | --verbose) OPTION_VERBOSE="true"; vbm "DEBUG:Verbose mode enabled.";; # Enable verbose mode.
 222             -o | --output) if [ -d "$2" ]; then DIR_OUT="$2"; vbm "DEBUG:DIR_OUT:$DIR_OUT"; shift; fi ;; # Define output directory.
 223             -e | --encrypt) OPTION_ENCRYPT="true"; vbm "DEBUG:Encrypted output mode enabled.";; # Enable encryption
 224             -r | --recipient) OPTION_RECIPIENTS="true"; argRecPubKeys+=("$2"); vbm "STATUS:pubkey added:""$2"; shift;; # Add recipients
 225             -c | --compress) OPTION_COMPRESS="true"; vbm "DEBUG:Compressed output mode enabled.";; # Enable compression
 226             -z | --time-zone) try setTimeZoneEV "$2"; shift;; # Set timestamp timezone
 227             -t | --temp-dir) OPTION_TMPDIR="true" && argTempDirPriority="$2"; shift;; # Set time zone
 228             -R | --recipient-dir) OPTION_RECIPIENTS="true"; OPTION_RECDIR="true" && argRecDir="$2"; shift;; # Add recipient watch dir
 229             -b | --buffer-ttl) OPTION_CUSTOM_BUFFERTTL="true" && argCustomBufferTTL="$2"; shift;; # Set custom buffer period (default: 300 seconds)
 230             -B | --script-ttl) OPTION_CUSTOM_SCRIPTTTL_TE="true" && argCustomScriptTTL="$2"; shift;; # Set custom script TTL (default: "day")
 231             *) echoerr "ERROR: Unrecognized argument: $1"; echoerr "STATUS:All arguments:$*"; exit 1;; # Handle unrecognized options.
 232         esac
 233         shift
 234     done
 235 } # Argument Processing
 236 setTimeZoneEV(){
 237     # Desc: Set time zone environment variable TZ
 238     # Usage: setTimeZoneEV arg1
 239     # Input: arg1: 'date'-compatible timezone string (ex: "America/New_York")
 240     #        TZDIR env var (optional; default: "/usr/share/zoneinfo")
 241     # Output: exports TZ
 242     #         exit code 0 on success
 243     #         exit code 1 on incorrect number of arguments
 244     #         exit code 2 if unable to validate arg1
 245     # Depends: yell, printenv, bash 5
 246     # Tested on: Debian 10
 247     ARG1="$1"
 248     local tzDir returnState
 249     if ! [[ $# -eq 1 ]]; then
 250         yell "ERROR:Invalid argument count.";
 251         return 1;
 252     fi
 253
 254     # Read TZDIR env var if available
 255     if printenv TZDIR 1>/dev/null 2>&1; then
 256         tzDir="$(printenv TZDIR)";
 257     else
 258         tzDir="/usr/share/zoneinfo";
 259     fi
 260
 261     # Validate TZ string
 262     if ! [[ -f "$tzDir"/"$ARG1" ]]; then
 263         yell "ERROR:Invalid time zone argument.";
 264         return 2;
 265     else
 266     # Export ARG1 as TZ environment variable
 267         TZ="$ARG1" && export TZ && returnState="true";
 268     fi
 269
 270     # Determine function return code
 271     if [ "$returnState" = "true" ]; then
 272         return 0;
 273     fi
 274 } # Exports TZ environment variable
 275 timeUntilNextDay(){
 276     # Desc: Report seconds until next day.
 277     # Version: 1.0.0
 278     # Output: stdout: integer seconds until next day
 279     # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
 280     # Usage: timeUntilNextDay
 281     # Usage: if ! myTTL="$(timeUntilNextDay)"; then yell "ERROR in if statement"; exit 1; fi
 282     # Depends: date 8, echo 8, yell, try
 283
 284     local returnState TIME_CURRENT TIME_NEXT_DAY SECONDS_UNTIL_NEXT_DAY
 285
 286     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
 287     TIME_NEXT_DAY="$(date -d "$TIME_CURRENT next day" --iso-8601=date)"; # Produce timestamp of beginning of tomorrow with resolution of 1 second.
 288     SECONDS_UNTIL_NEXT_DAY="$(( $(date +%s -d "$TIME_NEXT_DAY") - $(date +%s -d "$TIME_CURRENT") ))" ; # Calculate seconds until closest future midnight (res. 1 second).
 289     if [[ "$SECONDS_UNTIL_NEXT_DAY" -gt 0 ]]; then
 290         returnState="true";
 291     elif [[ "$SECONDS_UNTIL_NEXT_DAY" -eq 0 ]]; then
 292         returnState="warning_zero";
 293         yell "WARNING:Reported time until next day exactly zero.";
 294     elif [[ "$SECONDS_UNTIL_NEXT_DAY" -lt 0 ]]; then
 295         returnState="warning_negative";
 296         yell "WARNING:Reported time until next day is negative.";
 297     fi
 298
 299     try echo "$SECONDS_UNTIL_NEXT_DAY"; # Report
 300
 301     # Determine function return code
 302     if [[ "$returnState" = "true" ]]; then
 303         return 0;
 304     elif [[ "$returnState" = "warning_zero" ]]; then
 305         return 1;
 306     elif [[ "$returnState" = "warning_negative" ]]; then
 307         return 2;
 308     fi
 309 } # Report seconds until next day
 310 timeUntilNextHour(){
 311     # Desc: Report seconds until next hour
 312     # Version 1.0.0
 313     # Output: stdout: integer seconds until next hour
 314     # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
 315     # Usage: timeUntilNextHour
 316     # Usage: if ! myTTL="$(timeUntilNextHour)"; then yell "ERROR in if statement"; exit 1; fi
 317
 318     local returnState TIME_CURRENT TIME_NEXT_HOUR SECONDS_UNTIL_NEXT_HOUR
 319     TIME_CURRENT="$(date --iso-8601=seconds)"; # Produce `date`-parsable current timestamp with resolution of 1 second.
 320     TIME_NEXT_HOUR="$(date -d "$TIME_CURRENT next hour" --iso-8601=hours)"; # Produce `date`-parsable current time stamp with resolution of 1 second.
 321     SECONDS_UNTIL_NEXT_HOUR="$(( $(date +%s -d "$TIME_NEXT_HOUR") - $(date +%s -d "$TIME_CURRENT") ))"; # Calculate seconds until next hour (res. 1 second).
 322     if [[ "$SECONDS_UNTIL_NEXT_HOUR" -gt 0 ]]; then
 323         returnState="true";
 324     elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -eq 0 ]]; then
 325         returnState="warning_zero";
 326         yell "WARNING:Reported time until next hour exactly zero.";
 327     elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -lt 0 ]]; then
 328         returnState="warning_negative";
 329         yell "WARNING:Reported time until next hour is negative.";
 330     fi
 331
 332     try echo "$SECONDS_UNTIL_NEXT_HOUR"; # Report
 333
 334     # Determine function return code
 335     if [[ "$returnState" = "true" ]]; then
 336         return 0;
 337     elif [[ "$returnState" = "warning_zero" ]]; then
 338         return 1;
 339     elif [[ "$returnState" = "warning_negative" ]]; then
 340         return 2;
 341     fi
 342 } # Report seconds until next hour
 343 dateTimeShort(){
 344     # Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
 345     # Usage: dateTimeShort ([str date])
 346     # Version 1.1.0
 347     # Input: arg1: 'date'-parsable timestamp string (optional)
 348     # Output: stdout: timestamp (ISO-8601, no separators)
 349     # Depends: yell
 350     local TIME_CURRENT TIME_CURRENT_SHORT
 351
 352     argTime="$1";
 353     # Get Current Time
 354     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
 355     # Decide to parse current or supplied date
 356     ## Check if time argument empty
 357     if [[ -z "$argTime" ]]; then
 358         ## T: Time argument empty, use current time
 359         TIME_INPUT="$TIME_CURRENT";
 360     else
 361         ## F: Time argument exists, validate time
 362         if date --date="$argTime" 1>/dev/null 2>&1; then
 363             ### T: Time argument is valid; use it
 364             TIME_INPUT="$argTime";
 365         else
 366             ### F: Time argument not valid; exit
 367             yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
 368         fi
 369     fi
 370     # Construct and deliver separator-les date string
 371     TIME_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%dT%H%M%S%z)";
 372     echo "$TIME_CURRENT_SHORT";
 373 } # Get YYYYmmddTHHMMSS±zzzz
 374 dateShort(){
 375     # Desc: Date without separators (YYYYmmdd)
 376     # Usage: dateShort ([str date])
 377     # Version: 1.1.0
 378     # Input: arg1: 'date'-parsable timestamp string (optional)
 379     # Output: stdout: date (ISO-8601, no separators)
 380     # Depends: yell
 381     local TIME_CURRENT DATE_CURRENT_SHORT
 382
 383     argTime="$1";
 384     # Get Current Time
 385     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
 386     # Decide to parse current or supplied date
 387     ## Check if time argument empty
 388     if [[ -z "$argTime" ]]; then
 389         ## T: Time argument empty, use current time
 390         TIME_INPUT="$TIME_CURRENT";
 391     else
 392         ## F: Time argument exists, validate time
 393         if date --date="$argTime" 1>/dev/null 2>&1; then
 394             ### T: Time argument is valid; use it
 395             TIME_INPUT="$argTime";
 396         else
 397             ### F: Time argument not valid; exit
 398             yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
 399         fi
 400     fi
 401     # Construct and deliver separator-les date string
 402     DATE_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
 403     echo "$DATE_CURRENT_SHORT";
 404 } # Get YYYYmmdd
 405 timeDuration(){
 406     # Desc: Given seconds, output ISO-8601 duration string
 407     # Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
 408     # Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
 409     # Usage: timeDuration [1:seconds] ([2:precision])
 410     # Version: 1.0.3
 411     # Input: arg1: seconds as base 10 integer >= 0  (ex: 3601)
 412     #        arg2: precision level (optional; default=2)
 413     # Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
 414     #         exit code 0: success
 415     #         exit code 1: error_input
 416     #         exit code 2: error_unknown
 417     # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
 418     # Depends: date 8 (gnucoreutils), yell,
 419     local returnState argSeconds argPrecision remainder precision witherPrecision
 420     local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
 421     local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
 422     local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
 423
 424     argSeconds="$1"; # read arg1 (seconds)
 425     argPrecision="$2"; # read arg2 (precision)
 426     precision=2; # set default precision
 427
 428     # Check that between one and two arguments is supplied
 429     if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
 430         yell "ERROR:Invalid number of arguments:$# . Exiting.";
 431         returnState="error_input"; fi
 432
 433     # Check that argSeconds provided
 434     if [[ $# -ge 1 ]]; then
 435         ## Check that argSeconds is a positive integer
 436         if [[ "$argSeconds" =~ ^[[:digit:]]+$ ]]; then
 437             :
 438         else
 439             yell "ERROR:argSeconds not a digit.";
 440             returnState="error_input";
 441         fi
 442     else
 443         yell "ERROR:No argument provided. Exiting.";
 444         exit 1;
 445     fi
 446
 447     # Consider whether argPrecision was provided
 448     if  [[ $# -eq 2 ]]; then
 449         # Check that argPrecision is a positive integer
 450         if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then
 451         precision="$argPrecision";
 452         else
 453             yell "ERROR:argPrecision not a positive integer. (is $argPrecision ). Leaving early.";
 454             returnState="error_input";
 455         fi;
 456     else
 457         :
 458     fi;
 459
 460     remainder="$argSeconds" ; # seconds
 461     ## Calculate full years Y, update remainder
 462     fullYears=$(( remainder / (365*24*60*60) ));
 463     remainder=$(( remainder - (fullYears*365*24*60*60) ));
 464     ## Calculate full months M, update remainder
 465     fullMonths=$(( remainder / (30*24*60*60) ));
 466     remainder=$(( remainder - (fullMonths*30*24*60*60) ));
 467     ## Calculate full days D, update remainder
 468     fullDays=$(( remainder / (24*60*60) ));
 469     remainder=$(( remainder - (fullDays*24*60*60) ));
 470     ## Calculate full hours H, update remainder
 471     fullHours=$(( remainder / (60*60) ));
 472     remainder=$(( remainder - (fullHours*60*60) ));
 473     ## Calculate full minutes M, update remainder
 474     fullMinutes=$(( remainder / (60) ));
 475     remainder=$(( remainder - (fullMinutes*60) ));
 476     ## Calculate full seconds S, update remainder
 477     fullSeconds=$(( remainder / (1) ));
 478     remainder=$(( remainder - (remainder*1) ));
 479     ## Check which fields filled
 480     if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi
 481     if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi
 482     if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi
 483     if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi
 484     if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi
 485     if [[ $fullSeconds -gt 0 ]]; then hasSeconds="true"; else hasSeconds="false"; fi
 486
 487     ## Determine which fields to display (see ISO-8601:2004 §4.4.3.2)
 488     witherPrecision="false"
 489
 490     ### Years
 491     if $hasYears && [[ $precision -gt 0 ]]; then
 492         displayYears="true";
 493         witherPrecision="true";
 494     else
 495         displayYears="false";
 496     fi;
 497     if $witherPrecision; then ((precision--)); fi;
 498
 499     ### Months
 500     if $hasMonths && [[ $precision -gt 0 ]]; then
 501         displayMonths="true";
 502         witherPrecision="true";
 503     else
 504         displayMonths="false";
 505     fi;
 506     if $witherPrecision && [[ $precision -gt 0 ]]; then
 507         displayMonths="true";
 508     fi;
 509     if $witherPrecision; then ((precision--)); fi;
 510
 511     ### Days
 512     if $hasDays && [[ $precision -gt 0 ]]; then
 513         displayDays="true";
 514         witherPrecision="true";
 515     else
 516         displayDays="false";
 517     fi;
 518     if $witherPrecision && [[ $precision -gt 0 ]]; then
 519         displayDays="true";
 520     fi;
 521     if $witherPrecision; then ((precision--)); fi;
 522
 523     ### Hours
 524     if $hasHours && [[ $precision -gt 0 ]]; then
 525         displayHours="true";
 526         witherPrecision="true";
 527     else
 528         displayHours="false";
 529     fi;
 530     if $witherPrecision && [[ $precision -gt 0 ]]; then
 531         displayHours="true";
 532     fi;
 533     if $witherPrecision; then ((precision--)); fi;
 534
 535     ### Minutes
 536     if $hasMinutes && [[ $precision -gt 0 ]]; then
 537         displayMinutes="true";
 538         witherPrecision="true";
 539     else
 540         displayMinutes="false";
 541     fi;
 542     if $witherPrecision && [[ $precision -gt 0 ]]; then
 543         displayMinutes="true";
 544     fi;
 545     if $witherPrecision; then ((precision--)); fi;
 546
 547     ### Seconds
 548
 549     if $hasSeconds && [[ $precision -gt 0 ]]; then
 550         displaySeconds="true";
 551         witherPrecision="true";
 552     else
 553         displaySeconds="false";
 554     fi;
 555     if $witherPrecision && [[ $precision -gt 0 ]]; then
 556         displaySeconds="true";
 557     fi;
 558     if $witherPrecision; then ((precision--)); fi;
 559
 560     ## Determine whether or not the "T" separator is needed to separate date and time elements
 561     if ( $displayHours || $displayMinutes || $displaySeconds); then
 562         displayDateTime="true"; else displayDateTime="false"; fi
 563
 564     ## Construct duration output string
 565     OUTPUT="P"
 566     if $displayYears; then
 567         OUTPUT=$OUTPUT$fullYears"Y"; fi
 568     if $displayMonths; then
 569         OUTPUT=$OUTPUT$fullMonths"M"; fi
 570     if $displayDays; then
 571         OUTPUT=$OUTPUT$fullDays"D"; fi
 572     if $displayDateTime; then
 573         OUTPUT=$OUTPUT"T"; fi
 574     if $displayHours; then
 575         OUTPUT=$OUTPUT$fullHours"H"; fi
 576     if $displayMinutes; then
 577         OUTPUT=$OUTPUT$fullMinutes"M"; fi
 578     if $displaySeconds; then
 579         OUTPUT=$OUTPUT$fullSeconds"S"; fi
 580
 581     ## Output duration string to stdout
 582     echo "$OUTPUT" && returnState="true";
 583
 584     #===Determine function return code===
 585     if [ "$returnState" = "true" ]; then
 586         return 0;
 587     elif [ "$returnState" = "error_input" ]; then
 588         yell "ERROR:input";
 589         return 1;
 590     else
 591         yell "ERROR:Unknown";
 592         return 2;
 593     fi
 594
 595 } # Get duration (ex: PT10M4S )
 596 displayMissing() {
 597     # Desc: Displays missing apps, files, and dirs
 598     # Usage: displayMissing
 599     # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
 600     # Output: stderr messages
 601     #==BEGIN Display errors==
 602     #===BEGIN Display Missing Apps===
 603     missingApps="Missing apps  :"
 604     #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
 605     for key in "${!appRollCall[@]}"; do
 606         value="${appRollCall[$key]}"
 607         if [ "$value" = "false" ]; then
 608             #echo "DEBUG:Missing apps: $key => $value";
 609             missingApps="$missingApps""$key "
 610             appMissing="true"
 611         fi
 612     done
 613     if [ "$appMissing" = "true" ]; then  # Only indicate if an app is missing.
 614         echo "$missingApps" 1>&2;
 615     fi
 616     #===END Display Missing Apps===
 617
 618     #===BEGIN Display Missing Files===
 619     missingFiles="Missing files:"
 620     #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
 621     for key in "${!fileRollCall[@]}"; do
 622         value="${fileRollCall[$key]}"
 623         if [ "$value" = "false" ]; then
 624             #echo "DEBUG:Missing files: $key => $value";
 625             missingFiles="$missingFiles""$key "
 626             fileMissing="true"
 627         fi
 628     done
 629     if [ "$fileMissing" = "true" ]; then  # Only indicate if an app is missing.
 630         echo "$missingFiles" 1>&2;
 631     fi
 632     #===END Display Missing Files===
 633
 634     #===BEGIN Display Missing Directories===
 635     missingDirs="Missing dirs:"
 636     #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
 637     for key in "${!dirRollCall[@]}"; do
 638         value="${dirRollCall[$key]}"
 639         if [ "$value" = "false" ]; then
 640             #echo "DEBUG:Missing dirs: $key => $value";
 641             missingDirs="$missingDirs""$key "
 642             dirMissing="true"
 643         fi
 644     done
 645     if [ "$dirMissing" = "true" ]; then  # Only indicate if an dir is missing.
 646         echo "$missingDirs" 1>&2;
 647     fi
 648     #===END Display Missing Directories===
 649
 650     #==END Display errors==
 651 } # Display missing apps, files, dirs
 652 magicSetScriptTTL() {
 653     #Desc: Sets script_TTL seconds from provided time_element string argument
 654     #Usage: magicSetScriptTTL [str time_element]
 655     #Input: arg1: string (Ex: SCRIPT_TTL_TE; "day" or "hour")
 656     #Output: var: SCRIPT_TTL (integer seconds)
 657     #Depends: timeUntilNextHour, timeUntilNextDay
 658     local argTimeElement
 659     argTimeElement="$1"
 660     if [[ "$argTimeElement" = "day" ]]; then
 661             # Set script lifespan to end at start of next day
 662         if ! SCRIPT_TTL="$(timeUntilNextDay)"; then
 663             if [[ "$SCRIPT_TTL" -eq 0 ]]; then
 664             ((SCRIPT_TTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
 665             else
 666             yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
 667             fi;
 668         fi;
 669     elif [[ "$argTimeElement" = "hour" ]]; then
 670         # Set script lifespan to end at start of next hour
 671         if ! SCRIPT_TTL="$(timeUntilNextHour)"; then
 672             if [[ "$SCRIPT_TTL" -eq 0 ]]; then
 673                 ((SCRIPT_TTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
 674             else
 675                 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
 676             fi;
 677         fi;
 678     else
 679         yell "ERROR:Invalid argument for setScriptTTL function:$argTimeElement"; exit 1;
 680     fi
 681 } # Seconds until next (day|hour).
 682 checkMakeTar() {
 683     # Desc: Checks that a valid tar archive exists, creates one otherwise
 684     # Usage: checkMakeTar [ path ]
 685     # Version: 1.0.1
 686     # Input: arg1: path of tar archive
 687     # Output: exit code 0 : tar readable
 688     #         exit code 1 : tar missing; created
 689     #         exit code 2 : tar not readable; moved; replaced
 690     # Depends: try, tar, date
 691     local PATH_TAR returnFlag0 returnFlag1 returnFlag2
 692     PATH_TAR="$1"
 693
 694     # Check if file is a valid tar archive
 695     if tar --list --file="$PATH_TAR" 1>/dev/null 2>&1; then
 696         ## T1: return success
 697         returnFlag0="tar valid";
 698     else
 699         ## F1: Check if file exists
 700         if [[ -f "$PATH_TAR" ]]; then
 701             ### T: Rename file
 702             try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
 703                 returnFlag1="tar moved";
 704         else
 705             ### F: -
 706             :
 707         fi
 708         ## F2: Create tar archive, return 0
 709         try tar --create --file="$PATH_TAR" --files-from=/dev/null && \
 710             returnFlag2="tar created";
 711     fi
 712
 713     # Determine function return code
 714     if [[ "$returnFlag0" = "tar valid" ]]; then
 715         return 0;
 716     elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then
 717         return 1; # tar missing so created
 718     elif [[ "$returnFlag2" = "tar created" ]] && [[ "$returnFlag1" = "tar moved" ]]; then
 719         return 2; # tar not readable so moved; replaced
 720     fi
 721 } # checks if arg1 is tar; creates one otherwise
 722 appendArgTar(){
 723     # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
 724     # Usage: appendArgTar "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
 725     # Version: 1.0.3
 726     # Input: arg1: data to be written
 727     #        arg2: file name of file to be inserted into tar
 728     #        arg3: tar archive path (must exist first)
 729     #        arg4: temporary working dir
 730     #        arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
 731     # Output: file written to disk
 732     # Example: decrypt multiple large files in parallel
 733     #          appendArgTar "$(cat /tmp/largefile1.gpg)" "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
 734     #          appendArgTar "$(cat /tmp/largefile2.gpg)" "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
 735     #          appendArgTar "$(cat /tmp/largefile3.gpg)" "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
 736     # Depends: bash 5
 737     # Ref/Attrib: Using 'eval' to construct command strings https://askubuntu.com/a/476533
 738
 739     # Save function name
 740     local FN="${FUNCNAME[0]}";
 741     #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 742
 743     # Set file name
 744     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
 745
 746     # Check tar path is a file
 747     if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
 748
 749     # Check temp dir arg
 750     if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
 751
 752     # Set command strings
 753     if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
 754     if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
 755     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
 756     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
 757
 758     # Input command
 759     CMD0="echo \"\$1\""
 760
 761     # # Debug
 762     # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
 763     # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
 764     # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
 765     # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
 766     # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
 767     # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
 768     # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
 769     # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
 770
 771     # Write to temporary working dir
 772     eval "$CMD0"" | ""$CMD1"" | ""$CMD2"" | ""$CMD3"" | ""$CMD4" > "$TMP_DIR"/"$FILENAME";
 773
 774     # Append to tar
 775     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
 776     #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 777 } # Append Bash var to file appended to Tar archive
 778 appendFileTar(){
 779     # Desc: Processes first file and then appends to tar
 780     # Usage: appendFileTar [file path] [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
 781     # Version: 1.0.2
 782     # Input: arg1: path of file to be (processed and) written
 783     #        arg2: name to use for file inserted into tar
 784     #        arg3: tar archive path (must exist first)
 785     #        arg4: temporary working dir
 786     #        arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
 787     # Output: file written to disk
 788     # Example: decrypt multiple large files in parallel
 789     #          appendFileTar /tmp/largefile1.gpg "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
 790     #          appendFileTar /tmp/largefile2.gpg "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
 791     #          appendFileTar /tmp/largefile3.gpg "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
 792     # Depends: bash 5
 793
 794     # Save function name
 795     local FN="${FUNCNAME[0]}";
 796     #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
 797
 798     # Set file name
 799     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
 800     # Check tar path is a file
 801     if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
 802     # Check temp dir arg
 803     if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
 804     # Set command strings
 805     if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
 806     if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
 807     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
 808     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
 809
 810     # Input command string
 811     CMD0="cat \"\$1\""
 812
 813     # # Debug
 814     # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
 815     # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
 816     # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
 817     # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
 818     # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
 819     # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
 820     # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
 821     # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
 822
 823     # Write to temporary working dir
 824     eval "$CMD0 | $CMD1 | $CMD2 | $CMD3 | $CMD4" > "$TMP_DIR"/"$FILENAME";
 825
 826     # Append to tar
 827     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
 828     #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
 829 } # Append file to Tar archive
 830 checkAgePubkey() {
 831     # Desc: Checks if string is an age-compatible pubkey
 832     # Usage: checkAgePubkey [str pubkey]
 833     # Version: 0.1.2
 834     # Input: arg1: string
 835     # Output: return code 0: string is age-compatible pubkey
 836     #         return code 1: string is NOT an age-compatible pubkey
 837     #         age stderr (ex: there is stderr if invalid string provided)
 838     # Depends: age (v0.1.0-beta2; https://github.com/FiloSottile/age/releases/tag/v1.0.0-beta2 )
 839
 840     argPubkey="$1";
 841
 842     if echo "test" | age -a -r "$argPubkey" 1>/dev/null; then
 843         return 0;
 844     else
 845         return 1;
 846     fi;
 847 } # Check age pubkey
 848 validateInput() {
 849     # Desc: Validates Input
 850     # Usage: validateInput [str input] [str input type]
 851     # Version: 0.3.0
 852     # Input: arg1: string to validate
 853     #        arg2: string specifying input type (ex:"ssh_pubkey")
 854     # Output: return code 0: if input string matched specified string type
 855     # Depends: bash 5, yell
 856
 857     # Save function name
 858     local FN="${FUNCNAME[0]}";
 859
 860     # Process arguments
 861     argInput="$1";
 862     argType="$2";
 863     if [[ $# -gt 2 ]]; then yell "ERROR:$0:$FN:Too many arguments."; exit 1; fi;
 864
 865     # Check for blank
 866     if [[ -z "$argInput" ]]; then return 1; fi
 867
 868     # Define input types
 869     ## ssh_pubkey
 870     ### Check for alnum/dash base64 (ex: "ssh-rsa AAAAB3NzaC1yc2EAAA")
 871     if [[ "$argType" = "ssh_pubkey" ]]; then
 872         if [[ "$argInput" =~ ^[[:alnum:]-]*[\ ]*[[:alnum:]+/=]*$ ]]; then
 873             return 0; fi; fi;
 874
 875     ## age_pubkey
 876     ### Check for age1[:bech32:]
 877     if [[ "$argType" = "age_pubkey" ]]; then
 878         if [[ "$argInput" =~ ^age1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*$ ]]; then
 879             return 0; fi; fi
 880
 881     ## integer
 882     if [[ "$argType" = "integer" ]]; then
 883         if [[ "$argInput" =~ ^[[:digit:]]*$ ]]; then
 884             return 0; fi; fi;
 885
 886     ## time element (year, month, week, day, hour, minute, second)
 887     if [[ "$argType" = "time_element" ]]; then
 888         if [[ "$argInput" = "year" ]] || \
 889                [[ "$argInput" = "month" ]] || \
 890                [[ "$argInput" = "week" ]] || \
 891                [[ "$argInput" = "day" ]] || \
 892                [[ "$argInput" = "hour" ]] || \
 893                [[ "$argInput" = "minute" ]] || \
 894                [[ "$argInput" = "second" ]]; then
 895             return 0; fi; fi;
 896
 897     # Return error if no condition matched.
 898     return 1;
 899 } # Validates strings
 900 timeEpochNS() {
 901     # Desc: Get epoch nanoseconds
 902     # Usage: timeEpochNS
 903     # Version 0.2.2
 904     # Input: arg1: 'date'-parsable timestamp string (optional)
 905     # Output: Nanoseconds since 1970-01-01
 906     # Depends: date 8, yell()
 907     # Ref/Attrib: Force base 10 Bash arith with '10#'. https://stackoverflow.com/a/24777667
 908     local TIME_CURRENT TIME_INPUT TIME_EPOCH_FLOAT TIME_EPOCH_NSFRAC
 909     local TIME_EPOCH_NS
 910
 911     argTime="$1";
 912
 913     # Get Current Time
 914     TIME_CURRENT="$(date --iso-8601=ns)"; # Produce `date`-parsable current timestamp with resolution of 1 nanosecond.
 915
 916     # Decide to parse current or supplied time
 917     ## Check if time argument empty
 918     if [[ -z "$argTime" ]]; then
 919         ## T: Time argument empty, use current time
 920         TIME_INPUT="$TIME_CURRENT";
 921     else
 922         ## F: Time argument exists, validate time
 923         if date --date="$argTime" 1>/dev/null 2>&1; then
 924             ### T: Time argument is valid; use it
 925             TIME_INPUT="$argTime";
 926         else
 927             ### F: Time argument not valid; exit
 928             yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
 929         fi;
 930     fi;
 931     # Construct and deliver nanoseconds since 1970-01-01
 932     TIME_EPOCH_FLOAT="$(date --date="$TIME_INPUT" +%s.%N)"; # Save ssss.NNNNNNNNN
 933     TIME_EPOCH_INT="$(echo "$TIME_EPOCH_FLOAT" | cut -d. -f1)"; # Get ssss
 934     TIME_EPOCH_NSFRAC="$(echo "$TIME_EPOCH_FLOAT" | cut -d. -f2)"; # Get NNNNNNNNN
 935     TIME_EPOCH_NS="$(( (10#"$TIME_EPOCH_INT" * 10**9) + (10#"$TIME_EPOCH_NSFRAC") ))";
 936     echo "$TIME_EPOCH_NS";
 937 } # Nanoseconds since 1970-01-01
 938 magicBufferSleepPID() {
 939     # Desc: Compensates for lag so buffer rounds start every BUFFER_TTL seconds
 940     # Input: vars: BUFFER_TTL, errResetx10e3, K_P, T_I, T_D
 941     # # Input: array: errorHistory
 942     # Output: vars: BUFFER_TTL_ADJ_FLOAT
 943     # Re/Attrib: https://en.wikipedia.org/wiki/PID_controller#Standard_versus_parallel_(ideal)_form
 944     local BUFFER_TTL_NS
 945     local timeBufferStartNS timeBufferStartNSExp errNS errNSx10e3
 946     local errResetx10e3 errRatex10e3 ADJ BUFFER_TTL_ADJ_NS BUFFER_TTL_ADJ_INT
 947     local BUFFER_TTL_ADJ_FLOATFRAC
 948     # local errorHistorySize
 949
 950     # ## Define errorHistorySize
 951     # errorHistorySize=100;
 952     ## Define BUFFER_TTL in nanoseconds
 953     BUFFER_TTL_NS=$((BUFFER_TTL * 10**9));
 954
 955     # Calculate Error, errNS, in nanoseconds
 956     ## Get current time
 957     timeBufferStartNS="$(timeEpochNS)";
 958     ## Calculate expected time (from start time, current buffer round number, nominal BUFFER_TTL)
 959     timeBufferStartNSExp="$(( (timeBufferFirstNS) + (BUFFER_TTL_NS * bufferRound) ))";
 960     ## Calculate error (diff between timeBufferStartNSExp and timeBufferStartNS; usually negative)
 961     errNS="$(( timeBufferStartNSExp - timeBufferStartNS ))";
 962     errNSx10e3="$((errNS*10**3))";
 963     # ## Append error to errorHistory
 964     # errorHistory+=("errNS");
 965     # ### Trim errorHistory array if over errorHistorySize
 966     # while [[ "${#errorHistory[@]}" -gt "errorHistorySize" ]]; then do
 967     #   unset "errorHistory[0]"; # remove oldest entry, creating sparse array
 968     #   errorHistory=("${errorHistory[@]}"); # reindex sparse array
 969     #   vbm "STATUS:Trimmed errorHistory array. Entry count:${#errorHistory[@]}";
 970     # done;
 971
 972     # Calculate errReset in nanoseconds^2
 973     ## errReset = int(errHistory(t),wrt(delta_BUFFER_TTL))
 974     ## Integrate errorHistory with respect to time
 975     # for value in "${errorHistory[@]}"; do
 976     #   errReset=$(( errReset + ( value*BUFFER_TTL_NS ) ));
 977     # done;
 978     errResetx10e3="$(( ( errResetx10e3 + ( errNS * BUFFER_TTL_NS ) )*10**3 ))";
 979
 980     # Calculate errRate in nanoseconds per 1000 nanoseconds
 981     errRatex10e3="$(( ( errNSx10e3 ) / BUFFER_TTL_NS ))";
 982
 983     # Calculate PID control signal
 984     ## ADJ = K_P * (errNS + errReset/T_I + errRate*T_D)
 985     ADJ="$((K_P*(errNSx10e3 + (errResetx10e3/T_I) + (errRatex10e3*T_D) )/10**3))";
 986
 987     # Calculate BUFFER_TTL_ADJ_FLOAT from ADJ (ns)
 988     ## Calculate BUFFER_TTL_ADJ in nanoseconds (BUFFER_TTL_ADJ_NS = BUFFER_TTL_NS + ADJ)
 989     BUFFER_TTL_ADJ_NS="$((BUFFER_TTL_NS + ADJ))";
 990     ## Calculate integer seconds
 991     BUFFER_TTL_ADJ_INT="$((BUFFER_TTL_ADJ_NS/(10**9)))";
 992     ## Calculate nanosecond remainder
 993     BUFFER_TTL_ADJ_FLOATFRAC="$((BUFFER_TTL_NS - (BUFFER_TTL_ADJ_INT*(10**9)) ))";
 994     ## Form float BUFFER_TTL_ADJ_FLOAT
 995     BUFFER_TTL_ADJ_FLOAT="$BUFFER_TTL_ADJ_INT"."$BUFFER_TTL_ADJ_FLOATFRAC";
 996     vbm "STATUS:Calculated adjusted BUFFER_TTL (seconds):$BUFFER_TTL_ADJ_FLOAT";
 997 } # Calc BUFFER_TTL_ADJ_FLOAT so buffer starts every BUFFER_TTL seconds
 998 magicWriteVersion() {
 999     # Desc: Appends time-stamped VERSION to PATHOUT_TAR
1000     # Usage: magicWriteVersion
1001     # Version: 0.1.0
1002     # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
1003     # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
1004     # Output: appends tar PATHOUT_TAR
1005     # Depends: dateTimeShort, appendArgTar
1006     local CONTENT_VERSION pubKeyIndex
1007
1008     # Set VERSION file name
1009     FILEOUT_VERSION="$(dateTimeShort)..VERSION";
1010
1011     # Gather VERSION data in CONTENT_VERSION
1012     CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
1013     #CONTENT_VERSION="$CONTENT_VERSION""\\n";
1014     CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
1015     CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
1016     CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
1017     CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
1018     CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
1019     CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
1020     ## Add list of recipient pubkeys
1021     for pubkey in "${recPubKeysValid[@]}"; do
1022         ((pubKeyIndex++))
1023         CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
1024     done
1025     ## Process newline escapes
1026     CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
1027
1028     # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
1029     appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
1030
1031 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
1032 magicGatherWriteBuffer() {
1033     # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
1034     # Inputs: vars: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
1035     # Inputs: vars: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
1036     # Output: file: (PATHOUT_TAR)
1037     # Depends: yell(), try(), vbm(), appendArgTar(), tar 1, sleep 8, checkMakeTar()
1038     # Depends: magicWriteVersion(), appendFileTar()
1039     local FN
1040
1041     # Debug:Get function name
1042     FN="${FUNCNAME[0]}";
1043
1044     # Create buffer file with unique name
1045     PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";
1046     # Fill buffer
1047     timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
1048     timeBufferStart="$(dateTimeShort  "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time
1049     vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
1050     # Determine file paths (time is start of buffer period)
1051     FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
1052     ## Files saved to DIR_TMP
1053     FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
1054     FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
1055     FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
1056     PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
1057     PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
1058     PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
1059     ## Files saved to disk (DIR_OUT)
1060     ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
1061     PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
1062         vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
1063     # DEBUG: check vars
1064     vbm "STATUS:DIR_TMP     :$DIR_TMP";
1065     vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
1066     vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
1067     vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
1068     vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
1069
1070
1071     # Validate PATHOUT_TAR as tar.
1072     checkMakeTar "$PATHOUT_TAR";
1073     ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
1074     if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
1075
1076     # Write bufferBash to PATHOUT_TAR
1077     wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
1078     appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
1079     appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
1080     appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
1081
1082     # Remove secured chunks from DIR_TMP
1083     rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
1084     vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
1085 } # write buffer to disk
1086 magicParseRecipientDir() {
1087     # Desc: Updates recPubKeysValid with pubkeys in dir specified by '-R' option ("recipient directory")
1088     # Inputs:  vars: OPTION_RECDIR, argRecDir, OPTION_ENCRYPT
1089     #          arry: recPubKeysValid
1090     # Outputs: arry: recPubKeysValid
1091     # Depends: processArguments,
1092     local recFileLine updateRecipients recipientDir
1093     declare -a candRecPubKeysValid
1094
1095     # Check that '-e' and '-R' set
1096     if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECDIR" = "true" ]]; then
1097         ### Check that argRecDir is a directory.
1098         if [[ -d "$argRecDir" ]]; then
1099             recipientDir="$argRecDir" && vbm "STATUS:Recipient watch directory detected:\"$recipientDir\"";
1100             #### Initialize variable indicating outcome of pubkey review
1101             unset updateRecipients
1102             #### Add existing recipients
1103             candRecPubKeysValid=("${recPubKeysValidStatic[@]}");
1104             #### Parse files in recipientDir
1105             for file in "$recipientDir"/*; do
1106                 ##### Read first line of each file
1107                 recFileLine="$(head -n1 "$file")" && vbm "STATUS:Checking if pubkey:\"$recFileLine\"";
1108                 ##### check if first line is a valid pubkey
1109                 if checkAgePubkey "$recFileLine" && \
1110                         ( validateInput "$recFileLine" "ssh_pubkey" || validateInput "$recFileLine" "age_pubkey"); then
1111                     ###### T: add candidate pubkey to candRecPubKeysValid
1112                     candRecPubKeysValid+=("$recFileLine") && vbm "STATUS:RecDir pubkey is valid pubkey:\"$recFileLine\"";
1113                 else
1114                     ###### F: throw warning;
1115                     yell "ERROR:Invalid recipient file detected. Not modifying recipient list."
1116                     updateRecipients="false";
1117                 fi;
1118             done
1119             #### Write updated recPubKeysValid array to recPubKeysValid if no failure detected
1120             if ! [[ "$updateRecipients" = "false" ]]; then
1121                 recPubKeysValid=("${candRecPubKeysValid[@]}") && vbm "STATUS:Wrote candRecPubkeysValid to recPubKeysValid:\"${recPubKeysValid[*]}\"";
1122             fi;
1123         else
1124             yell "ERROR:$0:Recipient directory $argRecDir does not exist. Exiting."; exit 1;
1125         fi;
1126     fi;
1127     # Handle case if '-R' set but '-e' not set
1128     if [[ ! "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECDIR" = "true" ]]; then
1129         yell "ERROR: \\'-R\\' is set but \\'-e\\' is not set."; fi;
1130 } # Update recPubKeysValid with argRecDir
1131 magicParseRecipientArgs() {
1132     # Desc: Parses recipient arguments specified by '-r' option
1133     # Input:  vars: OPTION_ENCRYPT from processArguments()
1134     #         arry: argRecPubKeys from processArguments()
1135     # Output: vars: CMD_ENCRYPT, CMD_ENCRYPT_SUFFIX
1136     #         arry: recPubKeysValid, recPubKeysValidStatic
1137     # Depends: checkapp(), checkAgePubkey(), validateInput(), processArguments()
1138     local recipients
1139
1140     # Check if encryption option active.
1141     if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECIPIENTS" = "true" ]]; then
1142         if checkapp age; then # Check that age is available.
1143             for pubkey in "${argRecPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
1144                 vbm "DEBUG:Testing pubkey string:$pubkey";
1145                 if checkAgePubkey "$pubkey" && \
1146                         ( validateInput "$pubkey" "ssh_pubkey" || validateInput "$pubkey" "age_pubkey"); then
1147                     #### Form age recipient string
1148                     recipients="$recipients""-r '$pubkey' ";
1149                     vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
1150                     vbm "DEBUG:recipients:""$recipients";
1151                     #### Add validated pubkey to recPubKeysValid array
1152                     recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
1153                 else
1154                     yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
1155                 fi;
1156             done
1157             vbm "DEBUG:Finished processing argRecPubKeys array";
1158             vbm "STATUS:Array of validated pubkeys:${recPubKeysValid[*]}";
1159             recPubKeysValidStatic=("${recPubKeysValid[@]}"); # Save static image of pubkeys validated by this function
1160
1161             ##  Form age command string
1162             CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
1163             CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
1164         else
1165             yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
1166         fi;
1167     else
1168         CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
1169         CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
1170         vbm "DEBUG:Encryption not enabled."
1171     fi;
1172     # Catch case if '-e' is set but '-r' or '-R' is not
1173     if [[ "$OPTION_ENCRYPT" = "true" ]] && [[ ! "$OPTION_RECIPIENTS" = "true" ]]; then
1174         yell "ERROR:\\'-e\\' set but no \\'-r\\' or \\'-R\\' set."; exit 1; fi;
1175     # Catch case if '-r' or '-R' set but '-e' is not
1176     if [[ ! "$OPTION_ENCRYPT" = "true" ]] && [[ "$OPTION_RECIPIENTS" = "true" ]]; then
1177         yell "ERROR:\\'-r\\' or \\'-R\\' set but \\'-e\\' is not set."; exit 1; fi;
1178 } # Populate recPubKeysValid with argRecPubKeys; form encryption cmd string and filename suffix
1179 magicParseCompressionArg() {
1180     # Desc: Parses compression arguments specified by '-c' option
1181     # Input:  vars: OPTION_COMPRESS
1182     # Output: CMD_COMPRESS, CMD_COMPRESS_SUFFIX
1183     # Depends: checkapp(), vbm(), gzip,
1184     if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
1185         if checkapp gzip; then # Check if gzip available
1186             CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
1187             CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
1188         else
1189             yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
1190         fi
1191     else
1192         CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
1193         CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
1194         vbm "DEBUG:Compression not enabled.";
1195     fi
1196 } # Form compression cmd string and filename suffix
1197 magicInitWorkingDir() {
1198     # Desc: Determine temporary working directory from defaults or user input
1199     # Usage: magicInitWorkignDir
1200     # Input:  vars: OPTION_TEMPDIR, argTempDirPriority, DIR_TMP_DEFAULT
1201     # Input:  vars: SCRIPT_TIME_START
1202     # Output: vars: DIR_TMP
1203     # Depends: processArguments(), vbm(), yell()
1204     # Parse '-t' option (user-specified temporary working dir)
1205     ## Set DIR_TMP_PARENT to user-specified value if specified
1206     local DIR_TMP_PARENT
1207
1208     if [[ "$OPTION_TMPDIR" = "true" ]]; then
1209         if [[ -d "$argTempDirPriority" ]]; then
1210             DIR_TMP_PARENT="$argTempDirPriority";
1211         else
1212             yell "WARNING:Specified temporary working directory not valid:$argTempDirPriority";
1213             exit 1; # Exit since user requires a specific temp dir and it is not available.
1214         fi;
1215     else
1216     ## Set DIR_TMP_PARENT to default or fallback otherwise
1217         if [[ -d "$DIR_TMP_DEFAULT" ]]; then
1218             DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
1219         elif [[ -d /tmp ]]; then
1220             yell "WARNING:$DIR_TMP_DEFAULT not available. Falling back to /tmp .";
1221             DIR_TMP_PARENT="/tmp";
1222         else
1223             yell "ERROR:No valid working directory available. Exiting.";
1224             exit 1;
1225         fi
1226     fi;
1227     ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
1228     DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
1229 } # Sets working dir
1230 magicParseCustomTTL() {
1231     # Desc: Set user-specified TTLs for buffer and script
1232     # Input: vars: argCustomBufferTTL (integer), argCustomScriptTTL_TE (string)
1233     # Input: vars: OPTION_CUSTOM_BUFFERTTL, OPTION_CUSTOM_SCRIPTTTL
1234     # Input: vars: BUFFER_TTL (integer), SCRIPT_TTL_TE (string)
1235     # Output: BUFFER_TTL (integer), SCRIPT_TTL_TE (string)
1236     # Depends validateInput(), showUsage(), yell
1237
1238     # React to '-b, --buffer-ttl' option
1239     if [[ "$OPTION_CUSTOM_BUFFERTTL" = "true" ]]; then
1240         ## T: Check if argCustomBufferTTL is an integer
1241         if validateInput "$argCustomBufferTTL" "integer"; then
1242             ### T: argCustomBufferTTL is an integer
1243             BUFFER_TTL="$argCustomBufferTTL";
1244         else
1245             ### F: argcustomBufferTTL is not an integer
1246             yell "ERROR:Invalid integer argument for custom buffer time-to-live."; showUsage; exit 1;
1247         fi;
1248         ## F: do not change BUFFER_TTL
1249     fi;
1250
1251     # React to '-B, --script-ttl' option
1252     if [[ "$OPTION_CUSTOM_SCRIPTTTL_TE" = "true" ]]; then
1253         ## T: Check if argCustomScriptTTL is a time element (ex: "day", "hour")
1254         if validateInput "$argCustomScriptTTL" "time_element"; then
1255             ### T: argCustomScriptTTL is a time element
1256             SCRIPT_TTL_TE="$argCustomScriptTTL";
1257         else
1258             ### F: argcustomScriptTTL is not a time element
1259             yell "ERROR:Invalid time element argument for custom script time-to-live."; showUsage; exit 1;
1260         fi;
1261         ## F: do not change SCRIPT_TTL_TE
1262     fi;
1263 } # Sets custom script or buffer TTL if specified
1264
1265
1266 main() {
1267     # Process arguments
1268     processArguments "$@";
1269     ## Act upon arguments
1270     ### Determine working directory
1271     magicInitWorkingDir; # Sets DIR_TMP from argTempDirPriority
1272     ### Set output encryption and compression option strings
1273     #### React to "-r" ("encryption recipients") option
1274     magicParseRecipientArgs; # Updates recPubKeysValid, CMD_ENCRYPT[_SUFFIX] from argRecPubKeys
1275     #### React to "-c" ("compression") option
1276     magicParseCompressionArg; # Updates CMD_COMPRESS[_SUFFIX]
1277     #### React to "-R" ("recipient directory") option
1278     magicParseRecipientDir; # Updates recPubKeysValid
1279     #### React to custom buffer and script TTL options ("-b", "-B")
1280     magicParseCustomTTL; # Sets custom SCRIPT_TTL_TE and/or BUFFER_TTL if specified
1281
1282     # Check that critical apps and dirs are available, display missing ones.
1283     if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "DIR_TMP"; then
1284         yell "ERROR:Critical components missing.";
1285         displayMissing; yell "Exiting."; exit 1; fi
1286
1287     # Set script lifespan (SCRIPT_TTL from SCRIPT_TTL_TE)
1288     magicSetScriptTTL "$SCRIPT_TTL_TE";
1289     ## Note: SCRIPT_TTL_TE is time element string (ex: "day") while SCRIPT_TTL is integer seconds
1290
1291     # File name substring (ISO-8601 duration from BUFFER_TTL)
1292     bufferTTL_STR="$(timeDuration "$BUFFER_TTL")";
1293
1294     # Init temp working dir
1295     try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
1296
1297     # Initialize 'tar' archive
1298     ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
1299     PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
1300         vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
1301     ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
1302     checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
1303     ## Append VERSION file to PATHOUT_TAR
1304     magicWriteVersion;
1305
1306     # Define GPS conversion commands
1307     CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
1308     CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
1309     CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
1310
1311     # MAIN LOOP:Record gps data until script lifespan ends
1312     timeBufferFirstNS="$(timeEpochNS)"; bufferRound=0
1313     while [[ "$SECONDS" -lt "$SCRIPT_TTL" ]]; do
1314         magicParseRecipientDir;
1315         magicGatherWriteBuffer &
1316         magicBufferSleepPID; # Calculates BUFFER_TTL_ADJ from BUFFER_TTL given buffer expected start time vs. actual
1317         sleep "$BUFFER_TTL_ADJ_FLOAT";
1318         ((bufferRound++));
1319     done
1320
1321     # Cleanup
1322     ## Remove DIR_TMP
1323     try rm -r "$DIR_TMP";
1324
1325     vbm "STATUS:Main function finished.";
1326 } # Main function.
1327 #===END Declare local script functions===
1328 #==END Define script parameters==
1329
1330
1331 #==BEGIN Perform work and exit==
1332 main "$@" # Run main function.
1333 exit 0;
1334 #==END Perform work and exit==