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="60"; # time between file writes
  10 SCRIPT_TTL="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.2.2";          # 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 recPubKeys # for processArguments function
  27 declare recipients # for main function
  28
  29 ## Initialize variables
  30 OPTION_VERBOSE=""; OPTION_ENCRYPT=""; OPTION_COMPRESS=""; OPTION_TMPDIR="";
  31
  32 #===BEGIN Declare local script functions===
  33 checkapp() {
  34     # Desc: If arg is a command, save result in assoc array 'appRollCall'
  35     # Usage: checkapp arg1 arg2 arg3 ...
  36     # Input: global assoc. array 'appRollCall'
  37     # Output: adds/updates key(value) to global assoc array 'appRollCall'
  38     local returnState
  39     #echo "DEBUG:$(date +%S.%N)..Starting checkapp function."
  40     #echo "DEBUG:args: $@"
  41     #echo "DEBUG:returnState:$returnState"
  42
  43     #===Process Args===
  44     for arg in "$@"; do
  45         #echo "DEBUG:processing arg:$arg"
  46         if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command
  47             appRollCall[$arg]="true";
  48             #echo "DEBUG:appRollCall[$arg]:"${appRollCall[$arg]}
  49             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
  50         else
  51             appRollCall[$arg]="false"; returnState="false";
  52         fi
  53     done
  54
  55     #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
  56     #echo "DEBUG:evaluating returnstate. returnState:"$returnState
  57
  58     #===Determine function return code===
  59     if [ "$returnState" = "true" ]; then
  60         #echo "DEBUG:checkapp returns true for $arg";
  61         return 0;
  62     else
  63         #echo "DEBUG:checkapp returns false for $arg";
  64         return 1;
  65     fi
  66 } # Check that app exists
  67 checkfile() {
  68     # Desc: If arg is a file path, save result in assoc array 'fileRollCall'
  69     # Usage: checkfile arg1 arg2 arg3 ...
  70     # Input: global assoc. array 'fileRollCall'
  71     # Output: adds/updates key(value) to global assoc array 'fileRollCall';
  72     # Output: returns 0 if app found, 1 otherwise
  73     local returnState
  74
  75     #===Process Args===
  76     for arg in "$@"; do
  77         #echo "DEBUG:processing arg:$arg"
  78         if [ -f "$arg" ]; then
  79             fileRollCall["$arg"]="true";
  80             #echo "DEBUG:fileRollCall[\"$arg\"]:"${fileRollCall["$arg"]}
  81             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
  82         else
  83             fileRollCall["$arg"]="false"; returnState="false";
  84         fi
  85     done
  86
  87     #for key in "${!fileRollCall[@]}"; do echo "DEBUG:fileRollCall key [$key] is:${fileRollCall[$key]}"; done
  88     #echo "DEBUG:evaluating returnstate. returnState:"$returnState
  89
  90     #===Determine function return code===
  91     if [ "$returnState" = "true" ]; then
  92         #echo "DEBUG:checkapp returns true for $arg";
  93         return 0;
  94     else
  95         #echo "DEBUG:checkapp returns false for $arg";
  96         return 1;
  97     fi
  98 } # Check that file exists
  99 checkdir() {
 100     # Desc: If arg is a dir path, save result in assoc array 'dirRollCall'
 101     # Usage: checkdir arg1 arg2 arg3 ...
 102     # Input: global assoc. array 'dirRollCall'
 103     # Output: adds/updates key(value) to global assoc array 'dirRollCall';
 104     # Output: returns 0 if app found, 1 otherwise
 105     local returnState
 106
 107     #===Process Args===
 108     for arg in "$@"; do
 109         #echo "DEBUG:processing arg:$arg"
 110         if [ -d "$arg" ]; then
 111             dirRollCall["$arg"]="true";
 112             #echo "DEBUG:dirRollCall[\"$arg\"]:"${dirRollCall["$arg"]}
 113             if ! [ "$returnState" = "false" ]; then returnState="true"; fi
 114         elif [ "$arg" = "" ]; then
 115             dirRollCall["$arg"]="false"; returnState="false";
 116         else
 117             returnState="false";
 118         fi
 119     done
 120
 121     #for key in "${!dirRollCall[@]}"; do echo "DEBUG:dirRollCall key [$key] is:${dirRollCall[$key]}"; done
 122     #echo "DEBUG:evaluating returnstate. returnState:"$returnState
 123
 124     #===Determine function return code===
 125     if [ "$returnState" = "true" ]; then
 126         #echo "DEBUG:checkapp returns true for $arg";
 127         return 0;
 128     else
 129         #echo "DEBUG:checkapp returns false for $arg";
 130         return 1;
 131     fi
 132 } # Check that dir exists
 133
 134 # Yell, Die, Try Three-Fingered Claw technique
 135 # Ref/Attrib: https://stackoverflow.com/a/25515370
 136 yell() { echo "$0: $*" >&2; }
 137 die() { yell "$*"; exit 111; }
 138 try() { "$@" || die "cannot $*"; }
 139
 140 echoerr() {
 141     echo "$@" 1>&2; # Define stderr echo function.
 142 } # Define stderr message function.
 143 showUsage() {
 144     echoerr "USAGE:"
 145     echoerr "    bkgpslog [ options ]"
 146     echoerr
 147     echoerr "OPTIONS:"
 148     echoerr "    -h, --help"
 149     echoerr "            Display help information."
 150     echoerr
 151     echoerr "    --version"
 152     echoerr "            Display script version."
 153     echoerr
 154     echoerr "    -v, --verbose"
 155     echoerr "            Display debugging info."
 156     echoerr
 157     echoerr "    -e, --encrypt"
 158     echoerr "            Encrypt output."
 159     echoerr
 160     echoerr "    -r, --recipient [ pubkey string ]"
 161     echoerr "            Specify recipient. May be age or ssh pubkey."
 162     echoerr "            See https://github.com/FiloSottile/age"
 163     echoerr
 164     echoerr "    -o, --output [ directory ]"
 165     echoerr "            Specify output directory to save logs."
 166     echoerr
 167     echoerr "    -c, --compress"
 168     echoerr "            Compress output with gzip (before encryption if enabled)."
 169     echoerr
 170     echoerr "    -z, --time-zone"
 171     echoerr "            Specify time zone. (ex: \"America/New_York\")"
 172     echoerr
 173     echoerr "    -t, --temp-dir"
 174     echoerr "            Specify parent directory for temporary working directory."
 175     echoerr "            Default: \"/dev/shm\""
 176     echoerr
 177     echoerr "EXAMPLE: (bash script lines)"
 178     echoerr "/bin/bash bkgpslog -e -c \\"
 179     echoerr "-r age1mrmfnwhtlprn4jquex0ukmwcm7y2nxlphuzgsgv8ew2k9mewy3rs8u7su5 \\"
 180     echoerr "-r age1ala848kqrvxc88rzaauc6vc5v0fqrvef9dxyk79m0vjea3hagclswu0lgq \\"
 181     echoerr "-o ~/Sync/Location"
 182 } # Display information on how to use this script.
 183 showVersion() {
 184     echoerr "$SCRIPT_VERSION"
 185 } # Display script version.
 186 vbm() {
 187     # Usage: vbm "DEBUG:verbose message here"
 188     # Description: Prints verbose message ("vbm") to stderr if OPTION_VERBOSE is set to "true".
 189     # Input:
 190     #   - OPTION_VERBOSE  variable set by processArguments function. (ex: "true", "false")
 191     #   - "$@"            positional arguments fed to this function.
 192     # Output: stderr
 193     # Script function dependencies: echoerr
 194     # External function dependencies: echo
 195     # Last modified: 2020-04-11T23:57Z
 196     # Last modified by: Steven Baltakatei Sandoval
 197     # License: GPLv3+
 198     # Ref./Attrib:
 199
 200     if [ "$OPTION_VERBOSE" = "true" ]; then
 201         FUNCTION_TIME=$(date --iso-8601=ns); # Save current time in nano seconds.
 202         echoerr "[$FUNCTION_TIME] ""$*"; # Display argument text.
 203     fi
 204
 205     # End function
 206     return 0; # Function finished.
 207 } # Verbose message display function.
 208 processArguments() {
 209     while [ ! $# -eq 0 ]; do   # While number of arguments ($#) is not (!) equal to (-eq) zero (0).
 210         #echoerr "DEBUG:Starting processArguments while loop."
 211         #echoerr "DEBUG:Provided arguments are:""$*"
 212         case "$1" in
 213             -h | --help) showUsage; exit 1;; # Display usage.
 214             --version) showVersion; exit 1;; # Show version
 215             -v | --verbose) OPTION_VERBOSE="true"; vbm "DEBUG:Verbose mode enabled.";; # Enable verbose mode.
 216             -o | --output) if [ -d "$2" ]; then DIR_OUT="$2"; vbm "DEBUG:DIR_OUT:$DIR_OUT"; shift; fi ;; # Define output directory.
 217             -e | --encrypt) OPTION_ENCRYPT="true"; vbm "DEBUG:Encrypted output mode enabled.";;
 218             -r | --recipient) # Add 'age' recipient via public key string
 219                 recPubKeys+=("$2"); vbm "STATUS:pubkey added:""$2"; shift;;
 220             -c | --compress) OPTION_COMPRESS="true"; vbm "DEBUG:Compressed output mode enabled.";;
 221             -z | --time-zone) try setTimeZoneEV "$2"; shift;;
 222             -t | --temp-dir) OPTION_TMPDIR="true" && TMP_DIR_PRIORITY="$2"; shift;;
 223             *) echoerr "ERROR: Unrecognized argument: $1"; echoerr "STATUS:All arguments:$*"; exit 1;; # Handle unrecognized options.
 224         esac
 225         shift
 226     done
 227 } # Argument Processing
 228 setTimeZoneEV(){
 229     # Desc: Set time zone environment variable TZ
 230     # Usage: setTimeZoneEV arg1
 231     # Input: arg1: 'date'-compatible timezone string (ex: "America/New_York")
 232     #        TZDIR env var (optional; default: "/usr/share/zoneinfo")
 233     # Output: exports TZ
 234     #         exit code 0 on success
 235     #         exit code 1 on incorrect number of arguments
 236     #         exit code 2 if unable to validate arg1
 237     # Depends: yell, printenv, bash 5
 238     # Tested on: Debian 10
 239     ARG1="$1"
 240     local tzDir returnState
 241     if ! [[ $# -eq 1 ]]; then
 242         yell "ERROR:Invalid argument count.";
 243         return 1;
 244     fi
 245
 246     # Read TZDIR env var if available
 247     if printenv TZDIR 1>/dev/null 2>&1; then
 248         tzDir="$(printenv TZDIR)";
 249     else
 250         tzDir="/usr/share/zoneinfo";
 251     fi
 252
 253     # Validate TZ string
 254     if ! [[ -f "$tzDir"/"$ARG1" ]]; then
 255         yell "ERROR:Invalid time zone argument.";
 256         return 2;
 257     else
 258     # Export ARG1 as TZ environment variable
 259         TZ="$ARG1" && export TZ && returnState="true";
 260     fi
 261
 262     # Determine function return code
 263     if [ "$returnState" = "true" ]; then
 264         return 0;
 265     fi
 266 } # Exports TZ environment variable
 267 timeUntilNextDay(){
 268     # Desc: Report seconds until next day.
 269     # Version: 1.0.0
 270     # Output: stdout: integer seconds until next day
 271     # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
 272     # Usage: timeUntilNextDay
 273     # Usage: if ! myTTL="$(timeUntilNextDay)"; then yell "ERROR in if statement"; exit 1; fi
 274     # Depends: date 8, echo 8, yell, try
 275
 276     local returnState TIME_CURRENT TIME_NEXT_DAY SECONDS_UNTIL_NEXT_DAY
 277
 278     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
 279     TIME_NEXT_DAY="$(date -d "$TIME_CURRENT next day" --iso-8601=date)"; # Produce timestamp of beginning of tomorrow with resolution of 1 second.
 280     SECONDS_UNTIL_NEXT_DAY="$(( $(date +%s -d "$TIME_NEXT_DAY") - $(date +%s -d "$TIME_CURRENT") ))" ; # Calculate seconds until closest future midnight (res. 1 second).
 281     if [[ "$SECONDS_UNTIL_NEXT_DAY" -gt 0 ]]; then
 282         returnState="true";
 283     elif [[ "$SECONDS_UNTIL_NEXT_DAY" -eq 0 ]]; then
 284         returnState="warning_zero";
 285         yell "WARNING:Reported time until next day exactly zero.";
 286     elif [[ "$SECONDS_UNTIL_NEXT_DAY" -lt 0 ]]; then
 287         returnState="warning_negative";
 288         yell "WARNING:Reported time until next day is negative.";
 289     fi
 290
 291     try echo "$SECONDS_UNTIL_NEXT_DAY"; # Report
 292
 293     # Determine function return code
 294     if [[ "$returnState" = "true" ]]; then
 295         return 0;
 296     elif [[ "$returnState" = "warning_zero" ]]; then
 297         return 1;
 298     elif [[ "$returnState" = "warning_negative" ]]; then
 299         return 2;
 300     fi
 301 } # Report seconds until next day
 302 timeUntilNextHour(){
 303     # Desc: Report seconds until next hour
 304     # Version 1.0.0
 305     # Output: stdout: integer seconds until next hour
 306     # Output: exit code 0 if stdout > 0; 1 if stdout = 0; 2 if stdout < 0
 307     # Usage: timeUntilNextHour
 308     # Usage: if ! myTTL="$(timeUntilNextHour)"; then yell "ERROR in if statement"; exit 1; fi
 309
 310     local returnState TIME_CURRENT TIME_NEXT_HOUR SECONDS_UNTIL_NEXT_HOUR
 311     TIME_CURRENT="$(date --iso-8601=seconds)"; # Produce `date`-parsable current timestamp with resolution of 1 second.
 312     TIME_NEXT_HOUR="$(date -d "$TIME_CURRENT next hour" --iso-8601=hours)"; # Produce `date`-parsable current time stamp with resolution of 1 second.
 313     SECONDS_UNTIL_NEXT_HOUR="$(( $(date +%s -d "$TIME_NEXT_HOUR") - $(date +%s -d "$TIME_CURRENT") ))"; # Calculate seconds until next hour (res. 1 second).
 314     if [[ "$SECONDS_UNTIL_NEXT_HOUR" -gt 0 ]]; then
 315         returnState="true";
 316     elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -eq 0 ]]; then
 317         returnState="warning_zero";
 318         yell "WARNING:Reported time until next hour exactly zero.";
 319     elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -lt 0 ]]; then
 320         returnState="warning_negative";
 321         yell "WARNING:Reported time until next hour is negative.";
 322     fi
 323
 324     try echo "$SECONDS_UNTIL_NEXT_HOUR"; # Report
 325
 326     # Determine function return code
 327     if [[ "$returnState" = "true" ]]; then
 328         return 0;
 329     elif [[ "$returnState" = "warning_zero" ]]; then
 330         return 1;
 331     elif [[ "$returnState" = "warning_negative" ]]; then
 332         return 2;
 333     fi
 334 } # Report seconds until next hour
 335 dateTimeShort(){
 336     # Desc: Timestamp without separators (YYYYmmddTHHMMSS+zzzz)
 337     # Usage: dateTimeShort
 338     # Output: stdout: timestamp (ISO-8601, no separators)
 339     local TIME_CURRENT TIME_CURRENT_SHORT
 340     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
 341     TIME_CURRENT_SHORT="$(date -d "$TIME_CURRENT" +%Y%m%dT%H%M%S%z)"; # Produce separator-less current timestamp with resolution 1 second.
 342     echo "$TIME_CURRENT_SHORT";
 343 } # Get YYYYmmddTHHMMSS±zzzz
 344 dateShort(){
 345     # Desc: Date without separators (YYYYmmdd)
 346     # Usage: dateShort
 347     # Output: stdout: date (ISO-8601, no separators)
 348     local TIME_CURRENT DATE_CURRENT_SHORT
 349     TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
 350     DATE_CURRENT_SHORT="$(date -d "$TIME_CURRENT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
 351     echo "$DATE_CURRENT_SHORT";
 352 } # Get YYYYmmdd
 353 timeDuration(){
 354     # Desc: Output approximate time duration string before given time (default:current date)
 355     # Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
 356     # Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
 357     # Usage: timeDuration [arg1] ([arg2])
 358     # Version: 1.0.1
 359     # Input: arg1: seconds as base 10 integer >= 0  (ex: 3601)
 360     #        arg2: precision level (optional; default=2)
 361     # Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
 362     # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
 363     # Depends: date 8 (gnucoreutils), yell,
 364     local returnState ARG1 ARG2 remainder precision witherPrecision
 365     local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
 366     local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
 367     local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
 368
 369     ARG1="$1";
 370     ARG2="$2";
 371     precision=2; # set default precision
 372     returnState="true"; # set default return state
 373
 374     # Check that between one and two arguments is supplied
 375     if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
 376         yell "ERROR:Invalid number of arguments:$# . Exiting.";
 377         returnState="ERROR_INPUT"; fi
 378
 379     # Check that arg1 provided
 380     if [[ $# -ge 1 ]]; then
 381         ## Check that arg1 is a positive integer
 382         if [[ "$ARG1" =~ ^[[:digit:]]+$ ]]; then
 383             :
 384         else
 385             yell "ERROR:ARG1 not a digit.";
 386             returnState="ERROR_INPUT";
 387         fi
 388     else
 389         yell "ERROR:No argument provided. Exiting.";
 390         exit 1;
 391     fi
 392
 393     # Consider whether arg2 was provided
 394     if  [[ $# -eq 2 ]]; then
 395         # Check that the second arg is a positive integer
 396         if [[ "$ARG2" =~ ^[[:digit:]]+$ ]] && [[ "$ARG2" -gt 0 ]]; then
 397         precision="$ARG2";
 398         else
 399             yell "ERROR:ARG2 not a positive integer. (is $ARG2 ). Leaving early.";
 400             returnState="ERROR_INPUT";
 401         fi;
 402     else
 403         :
 404     fi;
 405
 406     remainder="$ARG1" ; # seconds
 407     ## Calculate full years Y, update remainder
 408     fullYears=$(( remainder / (365*24*60*60) ));
 409     remainder=$(( remainder - (fullYears*365*24*60*60) ));
 410     ## Calculate full months M, update remainder
 411     fullMonths=$(( remainder / (30*24*60*60) ));
 412     remainder=$(( remainder - (fullMonths*30*24*60*60) ));
 413     ## Calculate full days D, update remainder
 414     fullDays=$(( remainder / (24*60*60) ));
 415     remainder=$(( remainder - (fullDays*24*60*60) ));
 416     ## Calculate full hours H, update remainder
 417     fullHours=$(( remainder / (60*60) ));
 418     remainder=$(( remainder - (fullHours*60*60) ));
 419     ## Calculate full minutes M, update remainder
 420     fullMinutes=$(( remainder / (60) ));
 421     remainder=$(( remainder - (fullMinutes*60) ));
 422     ## Calculate full seconds S, update remainder
 423     fullSeconds=$(( remainder / (1) ));
 424     remainder=$(( remainder - (remainder*1) ));
 425     ## Check which fields filled
 426     if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi
 427     if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi
 428     if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi
 429     if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi
 430     if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi
 431     if [[ $fullSeconds -gt 0 ]]; then hasSeconds="true"; else hasSeconds="false"; fi
 432
 433     ## Determine which fields to display (see ISO-8601:2004 §4.4.3.2)
 434     witherPrecision="false"
 435
 436     ### Years
 437     if $hasYears && [[ $precision -gt 0 ]]; then
 438         displayYears="true";
 439         witherPrecision="true";
 440     else
 441         displayYears="false";
 442     fi;
 443     if $witherPrecision; then ((precision--)); fi;
 444
 445     ### Months
 446     if $hasMonths && [[ $precision -gt 0 ]]; then
 447         displayMonths="true";
 448         witherPrecision="true";
 449     else
 450         displayMonths="false";
 451     fi;
 452     if $witherPrecision && [[ $precision -gt 0 ]]; then
 453         displayMonths="true";
 454     fi;
 455     if $witherPrecision; then ((precision--)); fi;
 456
 457     ### Days
 458     if $hasDays && [[ $precision -gt 0 ]]; then
 459         displayDays="true";
 460         witherPrecision="true";
 461     else
 462         displayDays="false";
 463     fi;
 464     if $witherPrecision && [[ $precision -gt 0 ]]; then
 465         displayDays="true";
 466     fi;
 467     if $witherPrecision; then ((precision--)); fi;
 468
 469     ### Hours
 470     if $hasHours && [[ $precision -gt 0 ]]; then
 471         displayHours="true";
 472         witherPrecision="true";
 473     else
 474         displayHours="false";
 475     fi;
 476     if $witherPrecision && [[ $precision -gt 0 ]]; then
 477         displayHours="true";
 478     fi;
 479     if $witherPrecision; then ((precision--)); fi;
 480
 481     ### Minutes
 482     if $hasMinutes && [[ $precision -gt 0 ]]; then
 483         displayMinutes="true";
 484         witherPrecision="true";
 485     else
 486         displayMinutes="false";
 487     fi;
 488     if $witherPrecision && [[ $precision -gt 0 ]]; then
 489         displayMinutes="true";
 490     fi;
 491     if $witherPrecision; then ((precision--)); fi;
 492
 493     ### Seconds
 494
 495     if $hasSeconds && [[ $precision -gt 0 ]]; then
 496         displaySeconds="true";
 497         witherPrecision="true";
 498     else
 499         displaySeconds="false";
 500     fi;
 501     if $witherPrecision && [[ $precision -gt 0 ]]; then
 502         displaySeconds="true";
 503     fi;
 504     if $witherPrecision; then ((precision--)); fi;
 505
 506
 507
 508     ## Determine whether or not the "T" separator is needed to separate date and time elements
 509     if ( $displayHours || $displayMinutes || $displaySeconds); then
 510         displayDateTime="true"; else displayDateTime="false"; fi
 511
 512     ## Construct duration output string
 513     OUTPUT="P"
 514     if $displayYears; then
 515         OUTPUT=$OUTPUT$fullYears"Y"; fi
 516     if $displayMonths; then
 517         OUTPUT=$OUTPUT$fullMonths"M"; fi
 518     if $displayDays; then
 519         OUTPUT=$OUTPUT$fullDays"D"; fi
 520     if $displayDateTime; then
 521         OUTPUT=$OUTPUT"T"; fi
 522     if $displayHours; then
 523         OUTPUT=$OUTPUT$fullHours"H"; fi
 524     if $displayMinutes; then
 525         OUTPUT=$OUTPUT$fullMinutes"M"; fi
 526     if $displaySeconds; then
 527         OUTPUT=$OUTPUT$fullSeconds"S"; fi
 528
 529     ## Output duration string to stdout
 530     if [[ "$returnState" = "true" ]]; then echo "$OUTPUT"; fi
 531
 532     #===Determine function return code===
 533     if [ "$returnState" = "true" ]; then
 534         return 0;
 535     else
 536         echo "$returnState" 1>&2;
 537         return 1;
 538     fi
 539
 540 } # Get duration (ex: PT10M4S )
 541 displayMissing() {
 542     # Desc: Displays missing apps, files, and dirs
 543     # Usage: displayMissing
 544     # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
 545     # Output: stderr messages
 546     #==BEGIN Display errors==
 547     #===BEGIN Display Missing Apps===
 548     missingApps="Missing apps  :"
 549     #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
 550     for key in "${!appRollCall[@]}"; do
 551         value="${appRollCall[$key]}"
 552         if [ "$value" = "false" ]; then
 553             #echo "DEBUG:Missing apps: $key => $value";
 554             missingApps="$missingApps""$key "
 555             appMissing="true"
 556         fi
 557     done
 558     if [ "$appMissing" = "true" ]; then  # Only indicate if an app is missing.
 559         echo "$missingApps" 1>&2;
 560     fi
 561     #===END Display Missing Apps===
 562
 563     #===BEGIN Display Missing Files===
 564     missingFiles="Missing files:"
 565     #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
 566     for key in "${!fileRollCall[@]}"; do
 567         value="${fileRollCall[$key]}"
 568         if [ "$value" = "false" ]; then
 569             #echo "DEBUG:Missing files: $key => $value";
 570             missingFiles="$missingFiles""$key "
 571             fileMissing="true"
 572         fi
 573     done
 574     if [ "$fileMissing" = "true" ]; then  # Only indicate if an app is missing.
 575         echo "$missingFiles" 1>&2;
 576     fi
 577     #===END Display Missing Files===
 578
 579     #===BEGIN Display Missing Directories===
 580     missingDirs="Missing dirs:"
 581     #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
 582     for key in "${!dirRollCall[@]}"; do
 583         value="${dirRollCall[$key]}"
 584         if [ "$value" = "false" ]; then
 585             #echo "DEBUG:Missing dirs: $key => $value";
 586             missingDirs="$missingDirs""$key "
 587             dirMissing="true"
 588         fi
 589     done
 590     if [ "$dirMissing" = "true" ]; then  # Only indicate if an dir is missing.
 591         echo "$missingDirs" 1>&2;
 592     fi
 593     #===END Display Missing Directories===
 594
 595     #==END Display errors==
 596 } # Display missing apps, files, dirs
 597 setScriptTTL() {
 598     #Desc: Sets script TTL
 599     #Usage: setScriptTTL arg1
 600     #Input: arg1: "day" or "hour"
 601     #Output: scriptTTL
 602     #Depends: timeUntilNextHour or timeUntilNextDay
 603     local ARG1
 604     ARG1="$1"
 605     if [[ "$ARG1" = "day" ]]; then
 606             # Set script lifespan to end at start of next day
 607         if ! scriptTTL="$(timeUntilNextDay)"; then
 608             if [[ "$scriptTTL" -eq 0 ]]; then
 609             ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
 610             else
 611             yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
 612             fi;
 613         fi;
 614     elif [[ "$ARG1" = "hour" ]]; then
 615         # Set script lifespan to end at start of next hour
 616         if ! scriptTTL="$(timeUntilNextHour)"; then
 617             if [[ "$scriptTTL" -eq 0 ]]; then
 618                 ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
 619             else
 620                 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
 621             fi;
 622         fi;
 623     else
 624         yell "ERROR:Invalid argument for setScriptTTL function."; exit 1;
 625     fi
 626 } # Seconds until next (day|hour).
 627 checkMakeTar() {
 628     # Desc: Checks that a valid tar archive exists, creates one otherwise
 629     # Usage: checkMakeTar [ path ]
 630     # Version: 1.0.1
 631     # Input: arg1: path of tar archive
 632     # Output: exit code 0 : tar readable
 633     #         exit code 1 : tar missing; created
 634     #         exit code 2 : tar not readable; moved; replaced
 635     # Depends: try, tar, date
 636     local PATH_TAR returnFlag0 returnFlag1 returnFlag2
 637     PATH_TAR="$1"
 638
 639     # Check if file is a valid tar archive
 640     if tar --list --file="$PATH_TAR" 1>/dev/null 2>&1; then
 641         ## T1: return success
 642         returnFlag0="tar valid";
 643     else
 644         ## F1: Check if file exists
 645         if [[ -f "$PATH_TAR" ]]; then
 646             ### T: Rename file
 647             try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
 648                 returnFlag1="tar moved";
 649         else
 650             ### F: -
 651             :
 652         fi
 653         ## F2: Create tar archive, return 0
 654         try tar --create --file="$PATH_TAR" --files-from=/dev/null && \
 655             returnFlag2="tar created";
 656     fi
 657
 658     # Determine function return code
 659     if [[ "$returnFlag0" = "tar valid" ]]; then
 660         return 0;
 661     elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then
 662         return 1; # tar missing so created
 663     elif [[ "$returnFlag2" = "tar created" ]] && [[ "$returnFlag1" = "tar moved" ]]; then
 664         return 2; # tar not readable so moved; replaced
 665     fi
 666 } # checks if arg1 is tar; creates one otherwise
 667 appendArgTar(){
 668     # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
 669     # Usage: writeArg "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
 670     # Input: arg1: data to be written
 671     #        arg2: file name of file to be inserted into tar
 672     #        arg3: tar archive path (must exist first)
 673     #        arg4: temporary working dir
 674     #        arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
 675     # Output: file written to disk
 676     # Example: decrypt multiple large files in parallel
 677     #          appendArgTar "$(cat /tmp/largefile1.gpg)" "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
 678     #          appendArgTar "$(cat /tmp/largefile2.gpg)" "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
 679     #          appendArgTar "$(cat /tmp/largefile3.gpg)" "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
 680     # Depends: bash 5
 681
 682     # Save function name
 683     local FN="${FUNCNAME[0]}"
 684     yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 685
 686     # Set file name
 687     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
 688
 689     # Check tar path is a file
 690     if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
 691
 692     # Check temp dir arg
 693     if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
 694
 695     # Set command strings
 696     if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
 697     if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
 698     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
 699     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
 700
 701     # Debug
 702     yell "STATUS:$FN:CMD1:$CMD1"
 703     yell "STATUS:$FN:CMD2:$CMD2"
 704     yell "STATUS:$FN:CMD3:$CMD3"
 705     yell "STATUS:$FN:CMD4:$CMD4"
 706     yell "STATUS:$FN:FILENAME:$FILENAME"
 707     yell "STATUS:$FN:TAR_PATH:$TAR_PATH"
 708     yell "STATUS:$FN:TMP_DIR:$TMP_DIR"
 709     # Write to temporary working dir
 710     echo "$1" | $CMD1 | $CMD2 | $CMD3 | $CMD4 > "$TMP_DIR"/"$FILENAME";
 711
 712     # Append to tar
 713     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
 714     yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 715 } # Append Bash var to file appended to Tar archive
 716 magicWriteVersion() {
 717     # Desc: Appends time-stamped VERSION to PATHOUT_TAR
 718     # Usage: magicWriteVersion
 719     # Version: 0.1.0
 720     # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
 721     # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
 722     # Output: appends tar PATHOUT_TAR
 723     # Depends: dateTimeShort, appendArgTar
 724     local CONTENT_VERSION pubKeyIndex
 725
 726     # Set VERSION file name
 727     FILEOUT_VERSION="$(dateTimeShort)..VERSION";
 728
 729     # Gather VERSION data in CONTENT_VERSION
 730     CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
 731     #CONTENT_VERSION="$CONTENT_VERSION""\n";
 732     CONTENT_VERSION="$CONTENT_VERSION""\n""SCRIPT_NAME=$SCRIPT_NAME";
 733     CONTENT_VERSION="$CONTENT_VERSION""\n""SCRIPT_URL=$SCRIPT_URL";
 734     CONTENT_VERSION="$CONTENT_VERSION""\n""AGE_VERSION=$AGE_VERSION";
 735     CONTENT_VERSION="$CONTENT_VERSION""\n""AGE_URL=$AGE_URL";
 736     CONTENT_VERSION="$CONTENT_VERSION""\n""DATE=$(date --iso-8601=seconds)";
 737     CONTENT_VERSION="$CONTENT_VERSION""\n""HOSTNAME=$SCRIPT_HOSTNAME";
 738     ## Add list of recipient pubkeys
 739     for pubkey in "${recPubKeysValid[@]}"; do
 740         ((pubKeyIndex++))
 741         CONTENT_VERSION="$CONTENT_VERSION""\n""PUBKEY_$pubKeyIndex=$pubkey";
 742     done
 743     ## Process newline escapes
 744     CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
 745
 746     # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
 747     appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
 748
 749 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
 750 magicWriteBuffer() {
 751     # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
 752     # Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP
 753     # Depends: yell, try, vbm, appendArgTar, tar
 754     local FN="${FUNCNAME[0]}";
 755     wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
 756     vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
 757
 758     # Validate PATHOUT_TAR as tar.
 759     checkMakeTar "$PATHOUT_TAR";
 760     ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
 761     if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
 762
 763     # Write bufferBash to PATHOUT_TAR
 764     appendArgTar "$bufferBash" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
 765     appendArgTar "$bufferBash" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
 766     appendArgTar "$bufferBash" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
 767     # Remove secured chunks from DIR_TMP
 768     try rm "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
 769     yell "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
 770 } # bkgpslog write function
 771
 772 main() {
 773     processArguments "$@" # Process arguments.
 774
 775     # Determine working directory
 776     ## Set DIR_TMP_PARENT to user-specified value if specified
 777     if [[ "$OPTION_TMPDIR" = "true" ]]; then
 778             if [[ -d "$TMP_DIR_PRIORITY" ]]; then
 779             DIR_TMP_PARENT="$OPTION_TMPDIR";
 780         else
 781             yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";
 782             exit 1;
 783         fi
 784     fi
 785
 786     ## Set DIR_TMP_PARENT to default or fallback otherwise
 787     if [[ -d "$DIR_TMP_DEFAULT" ]]; then
 788         DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
 789     elif [[ -d /tmp ]]; then
 790         yell "WARNING:/dev/shm not available. Falling back to /tmp .";
 791         DIR_TMP_PARENT="/tmp";
 792     else
 793         yell "ERROR:No valid working directory available. Exiting.";
 794         exit 1;
 795     fi
 796
 797     ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
 798     DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
 799
 800     # Set output encryption and compression option strings
 801     if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
 802         if checkapp age; then # Check that age is available.
 803             for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
 804                 vbm "DEBUG:Testing pubkey string:$pubkey"
 805                 if echo "butts" | age -a -r "$pubkey" 1>/dev/null; then
 806                     #### Form age recipient string
 807                     recipients="$recipients""-r $pubkey ";
 808                     vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
 809                     vbm "DEBUG:recipients:""$recipients";
 810                     #### Add validated pubkey to recPubKeysValid array
 811                     recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
 812                 else
 813                     yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
 814                 fi
 815             done
 816             vbm "DEBUG:Finished processing recPubKeys array";
 817
 818             ##  Form age command string
 819             CMD_ENCRYPT="age ""$recipients ";
 820             CMD_ENCRYPT_SUFFIX=".age";
 821         else
 822             yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
 823         fi
 824     else
 825         CMD_ENCRYPT="tee /dev/null ";
 826         CMD_ENCRYPT_SUFFIX="";
 827         vbm "DEBUG:Encryption not enabled."
 828     fi
 829     if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
 830         if checkapp gzip; then # Check if gzip available
 831             CMD_COMPRESS="gzip ";
 832             CMD_COMPRESS_SUFFIX=".gz";
 833         else
 834             yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
 835         fi
 836     else
 837         CMD_COMPRESS="tee /dev/null ";
 838         CMD_COMPRESS_SUFFIX="";
 839         vbm "DEBUG:Compression not enabled.";
 840     fi
 841
 842     # Check that critical apps and dirs are available, displag missing ones.
 843     if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then
 844         yell "ERROR:Critical components missing.";
 845         displayMissing; yell "Exiting."; exit 1; fi
 846
 847     # Set script lifespan
 848     setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")
 849
 850     # File name substring: encoded bufferTTL
 851     bufferTTL_STR="$(timeDuration $BUFFER_TTL)";
 852
 853     # Init temp working dir
 854     try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
 855
 856     # Initialize 'tar' archive
 857     ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
 858     PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
 859         vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
 860     ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
 861     checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
 862     ## Append VERSION file to PATHOUT_TAR
 863     magicWriteVersion;
 864
 865     # Record gps data until script lifespan ends
 866     declare debugCounter; debugCounter="0"; # set debug counter
 867     while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
 868         timeBufferStart="$(dateTimeShort)"; # Note start time
 869         # Determine file paths (time is start of buffer period)
 870         FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
 871         ## Files saved to DIR_TMP
 872         FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
 873         FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
 874         FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
 875         PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
 876         PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
 877         PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
 878         ## Files saved to disk (DIR_OUT)
 879         ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
 880         PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
 881             vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
 882         # Define GPS conversion commands
 883         CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
 884         CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
 885         CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
 886         # Fill Bash variable buffer
 887         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
 888         # Process bufferBash, save secured chunk set to DIR_TMP
 889         vbm "STATUS:Beginning to save data to $DIR_TMP";
 890         magicWriteBuffer &
 891         # Append each secured chunk in memory dir (DIR_TMP) to file on disk (PATHOUT_TAR in DIR_OUT)
 892         vbm "STATUS:DIR_TMP     :$DIR_TMP";
 893         vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
 894         vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
 895         vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
 896         vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
 897
 898         # Reset buffer and filenames
 899         unset bufferBash FILEOUT_BASENAME PATHOUT_NMEA PATHOUT_GPX PATHOUT_KML PATHOUT_TAR timeBufferStart;
 900         vbm "DEBUG:Completed buffer session $debugCounter ." 1>&2;
 901         ((debugCounter++))
 902     done
 903
 904     # Remove DIR_TMP
 905     try rm -r "$DIR_TMP";
 906
 907     vbm "STATUS:Main function finished.";
 908 } # Main function.
 909 #===END Declare local script functions===
 910 #==END Define script parameters==
 911
 912
 913 #==BEGIN Perform work and exit==
 914 main "$@" # Run main function.
 915 exit 0;
 916 #==END Perform work and exit==