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: Given seconds, output ISO-8601 duration string
 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 [1:seconds] ([2:precision])
 358     # Version: 1.0.3
 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     #         exit code 0: success
 363     #         exit code 1: error_input
 364     #         exit code 2: error_unknown
 365     # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
 366     # Depends: date 8 (gnucoreutils), yell,
 367     local returnState argSeconds argPrecision remainder precision witherPrecision
 368     local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
 369     local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
 370     local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
 371
 372     argSeconds="$1"; # read arg1 (seconds)
 373     argPrecision="$2"; # read arg2 (precision)
 374     precision=2; # set default precision
 375
 376     # Check that between one and two arguments is supplied
 377     if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
 378         yell "ERROR:Invalid number of arguments:$# . Exiting.";
 379         returnState="error_input"; fi
 380
 381     # Check that argSeconds provided
 382     if [[ $# -ge 1 ]]; then
 383         ## Check that argSeconds is a positive integer
 384         if [[ "$argSeconds" =~ ^[[:digit:]]+$ ]]; then
 385             :
 386         else
 387             yell "ERROR:argSeconds not a digit.";
 388             returnState="error_input";
 389         fi
 390     else
 391         yell "ERROR:No argument provided. Exiting.";
 392         exit 1;
 393     fi
 394
 395     # Consider whether argPrecision was provided
 396     if  [[ $# -eq 2 ]]; then
 397         # Check that argPrecision is a positive integer
 398         if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then
 399         precision="$argPrecision";
 400         else
 401             yell "ERROR:argPrecision not a positive integer. (is $argPrecision ). Leaving early.";
 402             returnState="error_input";
 403         fi;
 404     else
 405         :
 406     fi;
 407
 408     remainder="$argSeconds" ; # seconds
 409     ## Calculate full years Y, update remainder
 410     fullYears=$(( remainder / (365*24*60*60) ));
 411     remainder=$(( remainder - (fullYears*365*24*60*60) ));
 412     ## Calculate full months M, update remainder
 413     fullMonths=$(( remainder / (30*24*60*60) ));
 414     remainder=$(( remainder - (fullMonths*30*24*60*60) ));
 415     ## Calculate full days D, update remainder
 416     fullDays=$(( remainder / (24*60*60) ));
 417     remainder=$(( remainder - (fullDays*24*60*60) ));
 418     ## Calculate full hours H, update remainder
 419     fullHours=$(( remainder / (60*60) ));
 420     remainder=$(( remainder - (fullHours*60*60) ));
 421     ## Calculate full minutes M, update remainder
 422     fullMinutes=$(( remainder / (60) ));
 423     remainder=$(( remainder - (fullMinutes*60) ));
 424     ## Calculate full seconds S, update remainder
 425     fullSeconds=$(( remainder / (1) ));
 426     remainder=$(( remainder - (remainder*1) ));
 427     ## Check which fields filled
 428     if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi
 429     if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi
 430     if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi
 431     if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi
 432     if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi
 433     if [[ $fullSeconds -gt 0 ]]; then hasSeconds="true"; else hasSeconds="false"; fi
 434
 435     ## Determine which fields to display (see ISO-8601:2004 §4.4.3.2)
 436     witherPrecision="false"
 437
 438     ### Years
 439     if $hasYears && [[ $precision -gt 0 ]]; then
 440         displayYears="true";
 441         witherPrecision="true";
 442     else
 443         displayYears="false";
 444     fi;
 445     if $witherPrecision; then ((precision--)); fi;
 446
 447     ### Months
 448     if $hasMonths && [[ $precision -gt 0 ]]; then
 449         displayMonths="true";
 450         witherPrecision="true";
 451     else
 452         displayMonths="false";
 453     fi;
 454     if $witherPrecision && [[ $precision -gt 0 ]]; then
 455         displayMonths="true";
 456     fi;
 457     if $witherPrecision; then ((precision--)); fi;
 458
 459     ### Days
 460     if $hasDays && [[ $precision -gt 0 ]]; then
 461         displayDays="true";
 462         witherPrecision="true";
 463     else
 464         displayDays="false";
 465     fi;
 466     if $witherPrecision && [[ $precision -gt 0 ]]; then
 467         displayDays="true";
 468     fi;
 469     if $witherPrecision; then ((precision--)); fi;
 470
 471     ### Hours
 472     if $hasHours && [[ $precision -gt 0 ]]; then
 473         displayHours="true";
 474         witherPrecision="true";
 475     else
 476         displayHours="false";
 477     fi;
 478     if $witherPrecision && [[ $precision -gt 0 ]]; then
 479         displayHours="true";
 480     fi;
 481     if $witherPrecision; then ((precision--)); fi;
 482
 483     ### Minutes
 484     if $hasMinutes && [[ $precision -gt 0 ]]; then
 485         displayMinutes="true";
 486         witherPrecision="true";
 487     else
 488         displayMinutes="false";
 489     fi;
 490     if $witherPrecision && [[ $precision -gt 0 ]]; then
 491         displayMinutes="true";
 492     fi;
 493     if $witherPrecision; then ((precision--)); fi;
 494
 495     ### Seconds
 496
 497     if $hasSeconds && [[ $precision -gt 0 ]]; then
 498         displaySeconds="true";
 499         witherPrecision="true";
 500     else
 501         displaySeconds="false";
 502     fi;
 503     if $witherPrecision && [[ $precision -gt 0 ]]; then
 504         displaySeconds="true";
 505     fi;
 506     if $witherPrecision; then ((precision--)); fi;
 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     echo "$OUTPUT" && returnState="true";
 531
 532     #===Determine function return code===
 533     if [ "$returnState" = "true" ]; then
 534         return 0;
 535     elif [ "$returnState" = "error_input" ]; then
 536         yell "ERROR:input";
 537         return 1;
 538     else
 539         yell "ERROR:Unknown";
 540         return 2;
 541     fi
 542
 543 } # Get duration (ex: PT10M4S )
 544 displayMissing() {
 545     # Desc: Displays missing apps, files, and dirs
 546     # Usage: displayMissing
 547     # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
 548     # Output: stderr messages
 549     #==BEGIN Display errors==
 550     #===BEGIN Display Missing Apps===
 551     missingApps="Missing apps  :"
 552     #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
 553     for key in "${!appRollCall[@]}"; do
 554         value="${appRollCall[$key]}"
 555         if [ "$value" = "false" ]; then
 556             #echo "DEBUG:Missing apps: $key => $value";
 557             missingApps="$missingApps""$key "
 558             appMissing="true"
 559         fi
 560     done
 561     if [ "$appMissing" = "true" ]; then  # Only indicate if an app is missing.
 562         echo "$missingApps" 1>&2;
 563     fi
 564     #===END Display Missing Apps===
 565
 566     #===BEGIN Display Missing Files===
 567     missingFiles="Missing files:"
 568     #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
 569     for key in "${!fileRollCall[@]}"; do
 570         value="${fileRollCall[$key]}"
 571         if [ "$value" = "false" ]; then
 572             #echo "DEBUG:Missing files: $key => $value";
 573             missingFiles="$missingFiles""$key "
 574             fileMissing="true"
 575         fi
 576     done
 577     if [ "$fileMissing" = "true" ]; then  # Only indicate if an app is missing.
 578         echo "$missingFiles" 1>&2;
 579     fi
 580     #===END Display Missing Files===
 581
 582     #===BEGIN Display Missing Directories===
 583     missingDirs="Missing dirs:"
 584     #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
 585     for key in "${!dirRollCall[@]}"; do
 586         value="${dirRollCall[$key]}"
 587         if [ "$value" = "false" ]; then
 588             #echo "DEBUG:Missing dirs: $key => $value";
 589             missingDirs="$missingDirs""$key "
 590             dirMissing="true"
 591         fi
 592     done
 593     if [ "$dirMissing" = "true" ]; then  # Only indicate if an dir is missing.
 594         echo "$missingDirs" 1>&2;
 595     fi
 596     #===END Display Missing Directories===
 597
 598     #==END Display errors==
 599 } # Display missing apps, files, dirs
 600 setScriptTTL() {
 601     #Desc: Sets script TTL
 602     #Usage: setScriptTTL arg1
 603     #Input: arg1: "day" or "hour"
 604     #Output: scriptTTL
 605     #Depends: timeUntilNextHour or timeUntilNextDay
 606     local ARG1
 607     ARG1="$1"
 608     if [[ "$ARG1" = "day" ]]; then
 609             # Set script lifespan to end at start of next day
 610         if ! scriptTTL="$(timeUntilNextDay)"; then
 611             if [[ "$scriptTTL" -eq 0 ]]; then
 612             ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
 613             else
 614             yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
 615             fi;
 616         fi;
 617     elif [[ "$ARG1" = "hour" ]]; then
 618         # Set script lifespan to end at start of next hour
 619         if ! scriptTTL="$(timeUntilNextHour)"; then
 620             if [[ "$scriptTTL" -eq 0 ]]; then
 621                 ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
 622             else
 623                 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
 624             fi;
 625         fi;
 626     else
 627         yell "ERROR:Invalid argument for setScriptTTL function."; exit 1;
 628     fi
 629 } # Seconds until next (day|hour).
 630 checkMakeTar() {
 631     # Desc: Checks that a valid tar archive exists, creates one otherwise
 632     # Usage: checkMakeTar [ path ]
 633     # Version: 1.0.1
 634     # Input: arg1: path of tar archive
 635     # Output: exit code 0 : tar readable
 636     #         exit code 1 : tar missing; created
 637     #         exit code 2 : tar not readable; moved; replaced
 638     # Depends: try, tar, date
 639     local PATH_TAR returnFlag0 returnFlag1 returnFlag2
 640     PATH_TAR="$1"
 641
 642     # Check if file is a valid tar archive
 643     if tar --list --file="$PATH_TAR" 1>/dev/null 2>&1; then
 644         ## T1: return success
 645         returnFlag0="tar valid";
 646     else
 647         ## F1: Check if file exists
 648         if [[ -f "$PATH_TAR" ]]; then
 649             ### T: Rename file
 650             try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
 651                 returnFlag1="tar moved";
 652         else
 653             ### F: -
 654             :
 655         fi
 656         ## F2: Create tar archive, return 0
 657         try tar --create --file="$PATH_TAR" --files-from=/dev/null && \
 658             returnFlag2="tar created";
 659     fi
 660
 661     # Determine function return code
 662     if [[ "$returnFlag0" = "tar valid" ]]; then
 663         return 0;
 664     elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then
 665         return 1; # tar missing so created
 666     elif [[ "$returnFlag2" = "tar created" ]] && [[ "$returnFlag1" = "tar moved" ]]; then
 667         return 2; # tar not readable so moved; replaced
 668     fi
 669 } # checks if arg1 is tar; creates one otherwise
 670 appendArgTar(){
 671     # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
 672     # Usage: writeArg "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
 673     # Input: arg1: data to be written
 674     #        arg2: file name of file to be inserted into tar
 675     #        arg3: tar archive path (must exist first)
 676     #        arg4: temporary working dir
 677     #        arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
 678     # Output: file written to disk
 679     # Example: decrypt multiple large files in parallel
 680     #          appendArgTar "$(cat /tmp/largefile1.gpg)" "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
 681     #          appendArgTar "$(cat /tmp/largefile2.gpg)" "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
 682     #          appendArgTar "$(cat /tmp/largefile3.gpg)" "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
 683     # Depends: bash 5
 684
 685     # Save function name
 686     local FN="${FUNCNAME[0]}"
 687     yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 688
 689     # Set file name
 690     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
 691
 692     # Check tar path is a file
 693     if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
 694
 695     # Check temp dir arg
 696     if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
 697
 698     # Set command strings
 699     if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
 700     if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
 701     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
 702     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
 703
 704     # Debug
 705     yell "STATUS:$FN:CMD1:$CMD1"
 706     yell "STATUS:$FN:CMD2:$CMD2"
 707     yell "STATUS:$FN:CMD3:$CMD3"
 708     yell "STATUS:$FN:CMD4:$CMD4"
 709     yell "STATUS:$FN:FILENAME:$FILENAME"
 710     yell "STATUS:$FN:TAR_PATH:$TAR_PATH"
 711     yell "STATUS:$FN:TMP_DIR:$TMP_DIR"
 712     # Write to temporary working dir
 713     echo "$1" | $CMD1 | $CMD2 | $CMD3 | $CMD4 > "$TMP_DIR"/"$FILENAME";
 714
 715     # Append to tar
 716     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
 717     yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
 718 } # Append Bash var to file appended to Tar archive
 719 magicWriteVersion() {
 720     # Desc: Appends time-stamped VERSION to PATHOUT_TAR
 721     # Usage: magicWriteVersion
 722     # Version: 0.1.0
 723     # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
 724     # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
 725     # Output: appends tar PATHOUT_TAR
 726     # Depends: dateTimeShort, appendArgTar
 727     local CONTENT_VERSION pubKeyIndex
 728
 729     # Set VERSION file name
 730     FILEOUT_VERSION="$(dateTimeShort)..VERSION";
 731
 732     # Gather VERSION data in CONTENT_VERSION
 733     CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
 734     #CONTENT_VERSION="$CONTENT_VERSION""\n";
 735     CONTENT_VERSION="$CONTENT_VERSION""\n""SCRIPT_NAME=$SCRIPT_NAME";
 736     CONTENT_VERSION="$CONTENT_VERSION""\n""SCRIPT_URL=$SCRIPT_URL";
 737     CONTENT_VERSION="$CONTENT_VERSION""\n""AGE_VERSION=$AGE_VERSION";
 738     CONTENT_VERSION="$CONTENT_VERSION""\n""AGE_URL=$AGE_URL";
 739     CONTENT_VERSION="$CONTENT_VERSION""\n""DATE=$(date --iso-8601=seconds)";
 740     CONTENT_VERSION="$CONTENT_VERSION""\n""HOSTNAME=$SCRIPT_HOSTNAME";
 741     ## Add list of recipient pubkeys
 742     for pubkey in "${recPubKeysValid[@]}"; do
 743         ((pubKeyIndex++))
 744         CONTENT_VERSION="$CONTENT_VERSION""\n""PUBKEY_$pubKeyIndex=$pubkey";
 745     done
 746     ## Process newline escapes
 747     CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
 748
 749     # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
 750     appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
 751
 752 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
 753 magicWriteBuffer() {
 754     # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
 755     # Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP
 756     # Depends: yell, try, vbm, appendArgTar, tar
 757     local FN="${FUNCNAME[0]}";
 758     wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
 759     vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
 760
 761     # Validate PATHOUT_TAR as tar.
 762     checkMakeTar "$PATHOUT_TAR";
 763     ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
 764     if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
 765
 766     # Write bufferBash to PATHOUT_TAR
 767     appendArgTar "$bufferBash" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
 768     appendArgTar "$bufferBash" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
 769     appendArgTar "$bufferBash" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
 770     # Remove secured chunks from DIR_TMP
 771     try rm "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
 772     yell "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
 773 } # bkgpslog write function
 774
 775 main() {
 776     processArguments "$@" # Process arguments.
 777
 778     # Determine working directory
 779     ## Set DIR_TMP_PARENT to user-specified value if specified
 780     if [[ "$OPTION_TMPDIR" = "true" ]]; then
 781             if [[ -d "$TMP_DIR_PRIORITY" ]]; then
 782             DIR_TMP_PARENT="$OPTION_TMPDIR";
 783         else
 784             yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";
 785             exit 1;
 786         fi
 787     fi
 788
 789     ## Set DIR_TMP_PARENT to default or fallback otherwise
 790     if [[ -d "$DIR_TMP_DEFAULT" ]]; then
 791         DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
 792     elif [[ -d /tmp ]]; then
 793         yell "WARNING:/dev/shm not available. Falling back to /tmp .";
 794         DIR_TMP_PARENT="/tmp";
 795     else
 796         yell "ERROR:No valid working directory available. Exiting.";
 797         exit 1;
 798     fi
 799
 800     ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
 801     DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
 802
 803     # Set output encryption and compression option strings
 804     if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
 805         if checkapp age; then # Check that age is available.
 806             for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
 807                 vbm "DEBUG:Testing pubkey string:$pubkey"
 808                 if echo "butts" | age -a -r "$pubkey" 1>/dev/null; then
 809                     #### Form age recipient string
 810                     recipients="$recipients""-r $pubkey ";
 811                     vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
 812                     vbm "DEBUG:recipients:""$recipients";
 813                     #### Add validated pubkey to recPubKeysValid array
 814                     recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
 815                 else
 816                     yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
 817                 fi
 818             done
 819             vbm "DEBUG:Finished processing recPubKeys array";
 820
 821             ##  Form age command string
 822             CMD_ENCRYPT="age ""$recipients ";
 823             CMD_ENCRYPT_SUFFIX=".age";
 824         else
 825             yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
 826         fi
 827     else
 828         CMD_ENCRYPT="tee /dev/null ";
 829         CMD_ENCRYPT_SUFFIX="";
 830         vbm "DEBUG:Encryption not enabled."
 831     fi
 832     if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
 833         if checkapp gzip; then # Check if gzip available
 834             CMD_COMPRESS="gzip ";
 835             CMD_COMPRESS_SUFFIX=".gz";
 836         else
 837             yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
 838         fi
 839     else
 840         CMD_COMPRESS="tee /dev/null ";
 841         CMD_COMPRESS_SUFFIX="";
 842         vbm "DEBUG:Compression not enabled.";
 843     fi
 844
 845     # Check that critical apps and dirs are available, displag missing ones.
 846     if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then
 847         yell "ERROR:Critical components missing.";
 848         displayMissing; yell "Exiting."; exit 1; fi
 849
 850     # Set script lifespan
 851     setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")
 852
 853     # File name substring: encoded bufferTTL
 854     bufferTTL_STR="$(timeDuration $BUFFER_TTL)";
 855
 856     # Init temp working dir
 857     try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
 858
 859     # Initialize 'tar' archive
 860     ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
 861     PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
 862         vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
 863     ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
 864     checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
 865     ## Append VERSION file to PATHOUT_TAR
 866     magicWriteVersion;
 867
 868     # Record gps data until script lifespan ends
 869     declare debugCounter; debugCounter="0"; # set debug counter
 870     while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
 871         timeBufferStart="$(dateTimeShort)"; # Note start time
 872         # Determine file paths (time is start of buffer period)
 873         FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
 874         ## Files saved to DIR_TMP
 875         FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
 876         FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
 877         FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
 878         PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
 879         PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
 880         PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
 881         ## Files saved to disk (DIR_OUT)
 882         ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
 883         PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
 884             vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
 885         # Define GPS conversion commands
 886         CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
 887         CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
 888         CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
 889         # Fill Bash variable buffer
 890         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
 891         # Process bufferBash, save secured chunk set to DIR_TMP
 892         vbm "STATUS:Beginning to save data to $DIR_TMP";
 893         magicWriteBuffer &
 894         # Append each secured chunk in memory dir (DIR_TMP) to file on disk (PATHOUT_TAR in DIR_OUT)
 895         vbm "STATUS:DIR_TMP     :$DIR_TMP";
 896         vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
 897         vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
 898         vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
 899         vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
 900
 901         # Reset buffer and filenames
 902         unset bufferBash FILEOUT_BASENAME PATHOUT_NMEA PATHOUT_GPX PATHOUT_KML PATHOUT_TAR timeBufferStart;
 903         vbm "DEBUG:Completed buffer session $debugCounter ." 1>&2;
 904         ((debugCounter++))
 905     done
 906
 907     # Remove DIR_TMP
 908     try rm -r "$DIR_TMP";
 909
 910     vbm "STATUS:Main function finished.";
 911 } # Main function.
 912 #===END Declare local script functions===
 913 #==END Define script parameters==
 914
 915
 916 #==BEGIN Perform work and exit==
 917 main "$@" # Run main function.
 918 exit 0;
 919 #==END Perform work and exit==