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