9dba7bc1ea2f1a405f06fbfd3e4d02c38213195b
[EVA-2020-02.git] / exec / bkgpslog
1 #!/bin/bash
2
3 # Desc: Records gps data until midnight
4 # Author: Steven Baltakatei Sandoval; License: GPLv3+
5 # Usage: bkgpslog -o [output dir]
6
7 #==BEGIN Define script parameters==
8 ## Logging Behavior parameters
9 BUFFER_TTL="300"; # time between file writes
10 SCRIPT_TTL="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.3.8"; # 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 ([str date])
338 # Version 1.1.0
339 # Input: arg1: 'date'-parsable timestamp string (optional)
340 # Output: stdout: timestamp (ISO-8601, no separators)
341 # Depends: yell
342 local TIME_CURRENT TIME_CURRENT_SHORT
343
344 argTime="$1";
345 # Get Current Time
346 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
347 # Decide to parse current or supplied date
348 ## Check if time argument empty
349 if [[ -z "$argTime" ]]; then
350 ## T: Time argument empty, use current time
351 TIME_INPUT="$TIME_CURRENT";
352 else
353 ## F: Time argument exists, validate time
354 if date --date="$argTime" 1>/dev/null 2>&1; then
355 ### T: Time argument is valid; use it
356 TIME_INPUT="$argTime";
357 else
358 ### F: Time argument not valid; exit
359 yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
360 fi
361 fi
362 # Construct and deliver separator-les date string
363 TIME_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%dT%H%M%S%z)";
364 echo "$TIME_CURRENT_SHORT";
365 } # Get YYYYmmddTHHMMSS±zzzz
366 dateShort(){
367 # Desc: Date without separators (YYYYmmdd)
368 # Usage: dateShort ([str date])
369 # Version: 1.1.0
370 # Input: arg1: 'date'-parsable timestamp string (optional)
371 # Output: stdout: date (ISO-8601, no separators)
372 # Depends: yell
373 local TIME_CURRENT DATE_CURRENT_SHORT
374
375 argTime="$1";
376 # Get Current Time
377 TIME_CURRENT="$(date --iso-8601=seconds)" ; # Produce `date`-parsable current timestamp with resolution of 1 second.
378 # Decide to parse current or supplied date
379 ## Check if time argument empty
380 if [[ -z "$argTime" ]]; then
381 ## T: Time argument empty, use current time
382 TIME_INPUT="$TIME_CURRENT";
383 else
384 ## F: Time argument exists, validate time
385 if date --date="$argTime" 1>/dev/null 2>&1; then
386 ### T: Time argument is valid; use it
387 TIME_INPUT="$argTime";
388 else
389 ### F: Time argument not valid; exit
390 yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;
391 fi
392 fi
393 # Construct and deliver separator-les date string
394 DATE_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.
395 echo "$DATE_CURRENT_SHORT";
396 } # Get YYYYmmdd
397 timeDuration(){
398 # Desc: Given seconds, output ISO-8601 duration string
399 # Ref/Attrib: ISO-8601:2004(E), §4.4.4.2 Representations of time intervals by duration and context information
400 # Note: "1 month" ("P1M") is assumed to be "30 days" (see ISO-8601:2004(E), §2.2.1.2)
401 # Usage: timeDuration [1:seconds] ([2:precision])
402 # Version: 1.0.3
403 # Input: arg1: seconds as base 10 integer >= 0 (ex: 3601)
404 # arg2: precision level (optional; default=2)
405 # Output: stdout: ISO-8601 duration string (ex: "P1H1S", "P2Y10M15DT10H30M20S")
406 # exit code 0: success
407 # exit code 1: error_input
408 # exit code 2: error_unknown
409 # Example: 'timeDuration 111111 3' yields 'P1DT6H51M'
410 # Depends: date 8 (gnucoreutils), yell,
411 local returnState argSeconds argPrecision remainder precision witherPrecision
412 local fullYears fullMonths fullDays fullHours fullMinutes fullSeconds
413 local displayYears displayMonths displayDays displayHours displayMinutes displaySeconds
414 local hasYears hasMonths hasDays hasHours hasMinutes hasSeconds
415
416 argSeconds="$1"; # read arg1 (seconds)
417 argPrecision="$2"; # read arg2 (precision)
418 precision=2; # set default precision
419
420 # Check that between one and two arguments is supplied
421 if ! { [[ $# -ge 1 ]] && [[ $# -le 2 ]]; }; then
422 yell "ERROR:Invalid number of arguments:$# . Exiting.";
423 returnState="error_input"; fi
424
425 # Check that argSeconds provided
426 if [[ $# -ge 1 ]]; then
427 ## Check that argSeconds is a positive integer
428 if [[ "$argSeconds" =~ ^[[:digit:]]+$ ]]; then
429 :
430 else
431 yell "ERROR:argSeconds not a digit.";
432 returnState="error_input";
433 fi
434 else
435 yell "ERROR:No argument provided. Exiting.";
436 exit 1;
437 fi
438
439 # Consider whether argPrecision was provided
440 if [[ $# -eq 2 ]]; then
441 # Check that argPrecision is a positive integer
442 if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then
443 precision="$argPrecision";
444 else
445 yell "ERROR:argPrecision not a positive integer. (is $argPrecision ). Leaving early.";
446 returnState="error_input";
447 fi;
448 else
449 :
450 fi;
451
452 remainder="$argSeconds" ; # seconds
453 ## Calculate full years Y, update remainder
454 fullYears=$(( remainder / (365*24*60*60) ));
455 remainder=$(( remainder - (fullYears*365*24*60*60) ));
456 ## Calculate full months M, update remainder
457 fullMonths=$(( remainder / (30*24*60*60) ));
458 remainder=$(( remainder - (fullMonths*30*24*60*60) ));
459 ## Calculate full days D, update remainder
460 fullDays=$(( remainder / (24*60*60) ));
461 remainder=$(( remainder - (fullDays*24*60*60) ));
462 ## Calculate full hours H, update remainder
463 fullHours=$(( remainder / (60*60) ));
464 remainder=$(( remainder - (fullHours*60*60) ));
465 ## Calculate full minutes M, update remainder
466 fullMinutes=$(( remainder / (60) ));
467 remainder=$(( remainder - (fullMinutes*60) ));
468 ## Calculate full seconds S, update remainder
469 fullSeconds=$(( remainder / (1) ));
470 remainder=$(( remainder - (remainder*1) ));
471 ## Check which fields filled
472 if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi
473 if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi
474 if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi
475 if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi
476 if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi
477 if [[ $fullSeconds -gt 0 ]]; then hasSeconds="true"; else hasSeconds="false"; fi
478
479 ## Determine which fields to display (see ISO-8601:2004 §4.4.3.2)
480 witherPrecision="false"
481
482 ### Years
483 if $hasYears && [[ $precision -gt 0 ]]; then
484 displayYears="true";
485 witherPrecision="true";
486 else
487 displayYears="false";
488 fi;
489 if $witherPrecision; then ((precision--)); fi;
490
491 ### Months
492 if $hasMonths && [[ $precision -gt 0 ]]; then
493 displayMonths="true";
494 witherPrecision="true";
495 else
496 displayMonths="false";
497 fi;
498 if $witherPrecision && [[ $precision -gt 0 ]]; then
499 displayMonths="true";
500 fi;
501 if $witherPrecision; then ((precision--)); fi;
502
503 ### Days
504 if $hasDays && [[ $precision -gt 0 ]]; then
505 displayDays="true";
506 witherPrecision="true";
507 else
508 displayDays="false";
509 fi;
510 if $witherPrecision && [[ $precision -gt 0 ]]; then
511 displayDays="true";
512 fi;
513 if $witherPrecision; then ((precision--)); fi;
514
515 ### Hours
516 if $hasHours && [[ $precision -gt 0 ]]; then
517 displayHours="true";
518 witherPrecision="true";
519 else
520 displayHours="false";
521 fi;
522 if $witherPrecision && [[ $precision -gt 0 ]]; then
523 displayHours="true";
524 fi;
525 if $witherPrecision; then ((precision--)); fi;
526
527 ### Minutes
528 if $hasMinutes && [[ $precision -gt 0 ]]; then
529 displayMinutes="true";
530 witherPrecision="true";
531 else
532 displayMinutes="false";
533 fi;
534 if $witherPrecision && [[ $precision -gt 0 ]]; then
535 displayMinutes="true";
536 fi;
537 if $witherPrecision; then ((precision--)); fi;
538
539 ### Seconds
540
541 if $hasSeconds && [[ $precision -gt 0 ]]; then
542 displaySeconds="true";
543 witherPrecision="true";
544 else
545 displaySeconds="false";
546 fi;
547 if $witherPrecision && [[ $precision -gt 0 ]]; then
548 displaySeconds="true";
549 fi;
550 if $witherPrecision; then ((precision--)); fi;
551
552 ## Determine whether or not the "T" separator is needed to separate date and time elements
553 if ( $displayHours || $displayMinutes || $displaySeconds); then
554 displayDateTime="true"; else displayDateTime="false"; fi
555
556 ## Construct duration output string
557 OUTPUT="P"
558 if $displayYears; then
559 OUTPUT=$OUTPUT$fullYears"Y"; fi
560 if $displayMonths; then
561 OUTPUT=$OUTPUT$fullMonths"M"; fi
562 if $displayDays; then
563 OUTPUT=$OUTPUT$fullDays"D"; fi
564 if $displayDateTime; then
565 OUTPUT=$OUTPUT"T"; fi
566 if $displayHours; then
567 OUTPUT=$OUTPUT$fullHours"H"; fi
568 if $displayMinutes; then
569 OUTPUT=$OUTPUT$fullMinutes"M"; fi
570 if $displaySeconds; then
571 OUTPUT=$OUTPUT$fullSeconds"S"; fi
572
573 ## Output duration string to stdout
574 echo "$OUTPUT" && returnState="true";
575
576 #===Determine function return code===
577 if [ "$returnState" = "true" ]; then
578 return 0;
579 elif [ "$returnState" = "error_input" ]; then
580 yell "ERROR:input";
581 return 1;
582 else
583 yell "ERROR:Unknown";
584 return 2;
585 fi
586
587 } # Get duration (ex: PT10M4S )
588 displayMissing() {
589 # Desc: Displays missing apps, files, and dirs
590 # Usage: displayMissing
591 # Input: associative arrays: appRollCall, fileRollCall, dirRollCall
592 # Output: stderr messages
593 #==BEGIN Display errors==
594 #===BEGIN Display Missing Apps===
595 missingApps="Missing apps :"
596 #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done
597 for key in "${!appRollCall[@]}"; do
598 value="${appRollCall[$key]}"
599 if [ "$value" = "false" ]; then
600 #echo "DEBUG:Missing apps: $key => $value";
601 missingApps="$missingApps""$key "
602 appMissing="true"
603 fi
604 done
605 if [ "$appMissing" = "true" ]; then # Only indicate if an app is missing.
606 echo "$missingApps" 1>&2;
607 fi
608 #===END Display Missing Apps===
609
610 #===BEGIN Display Missing Files===
611 missingFiles="Missing files:"
612 #for key in "${!fileRollCall[@]}"; do echo "DEBUG:$key => ${fileRollCall[$key]}"; done
613 for key in "${!fileRollCall[@]}"; do
614 value="${fileRollCall[$key]}"
615 if [ "$value" = "false" ]; then
616 #echo "DEBUG:Missing files: $key => $value";
617 missingFiles="$missingFiles""$key "
618 fileMissing="true"
619 fi
620 done
621 if [ "$fileMissing" = "true" ]; then # Only indicate if an app is missing.
622 echo "$missingFiles" 1>&2;
623 fi
624 #===END Display Missing Files===
625
626 #===BEGIN Display Missing Directories===
627 missingDirs="Missing dirs:"
628 #for key in "${!dirRollCall[@]}"; do echo "DEBUG:$key => ${dirRollCall[$key]}"; done
629 for key in "${!dirRollCall[@]}"; do
630 value="${dirRollCall[$key]}"
631 if [ "$value" = "false" ]; then
632 #echo "DEBUG:Missing dirs: $key => $value";
633 missingDirs="$missingDirs""$key "
634 dirMissing="true"
635 fi
636 done
637 if [ "$dirMissing" = "true" ]; then # Only indicate if an dir is missing.
638 echo "$missingDirs" 1>&2;
639 fi
640 #===END Display Missing Directories===
641
642 #==END Display errors==
643 } # Display missing apps, files, dirs
644 setScriptTTL() {
645 #Desc: Sets script TTL
646 #Usage: setScriptTTL arg1
647 #Input: arg1: "day" or "hour"
648 #Output: scriptTTL
649 #Depends: timeUntilNextHour or timeUntilNextDay
650 local ARG1
651 ARG1="$1"
652 if [[ "$ARG1" = "day" ]]; then
653 # Set script lifespan to end at start of next day
654 if ! scriptTTL="$(timeUntilNextDay)"; then
655 if [[ "$scriptTTL" -eq 0 ]]; then
656 ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
657 else
658 yell "ERROR: timeUntilNextDay exit code $?"; exit 1;
659 fi;
660 fi;
661 elif [[ "$ARG1" = "hour" ]]; then
662 # Set script lifespan to end at start of next hour
663 if ! scriptTTL="$(timeUntilNextHour)"; then
664 if [[ "$scriptTTL" -eq 0 ]]; then
665 ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.
666 else
667 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;
668 fi;
669 fi;
670 else
671 yell "ERROR:Invalid argument for setScriptTTL function."; exit 1;
672 fi
673 } # Seconds until next (day|hour).
674 checkMakeTar() {
675 # Desc: Checks that a valid tar archive exists, creates one otherwise
676 # Usage: checkMakeTar [ path ]
677 # Version: 1.0.1
678 # Input: arg1: path of tar archive
679 # Output: exit code 0 : tar readable
680 # exit code 1 : tar missing; created
681 # exit code 2 : tar not readable; moved; replaced
682 # Depends: try, tar, date
683 local PATH_TAR returnFlag0 returnFlag1 returnFlag2
684 PATH_TAR="$1"
685
686 # Check if file is a valid tar archive
687 if tar --list --file="$PATH_TAR" 1>/dev/null 2>&1; then
688 ## T1: return success
689 returnFlag0="tar valid";
690 else
691 ## F1: Check if file exists
692 if [[ -f "$PATH_TAR" ]]; then
693 ### T: Rename file
694 try mv "$PATH_TAR" "$PATH_TAR""--broken--""$(date +%Y%m%dT%H%M%S)" && \
695 returnFlag1="tar moved";
696 else
697 ### F: -
698 :
699 fi
700 ## F2: Create tar archive, return 0
701 try tar --create --file="$PATH_TAR" --files-from=/dev/null && \
702 returnFlag2="tar created";
703 fi
704
705 # Determine function return code
706 if [[ "$returnFlag0" = "tar valid" ]]; then
707 return 0;
708 elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then
709 return 1; # tar missing so created
710 elif [[ "$returnFlag2" = "tar created" ]] && [[ "$returnFlag1" = "tar moved" ]]; then
711 return 2; # tar not readable so moved; replaced
712 fi
713 } # checks if arg1 is tar; creates one otherwise
714 appendArgTar(){
715 # Desc: Writes first argument to temporary file with arguments as options, then appends file to tar
716 # Usage: appendArgTar "$(echo "Data to be written.")" [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
717 # Version: 1.0.3
718 # Input: arg1: data to be written
719 # arg2: file name of file to be inserted into tar
720 # arg3: tar archive path (must exist first)
721 # arg4: temporary working dir
722 # arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
723 # Output: file written to disk
724 # Example: decrypt multiple large files in parallel
725 # appendArgTar "$(cat /tmp/largefile1.gpg)" "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
726 # appendArgTar "$(cat /tmp/largefile2.gpg)" "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
727 # appendArgTar "$(cat /tmp/largefile3.gpg)" "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
728 # Depends: bash 5
729 # Ref/Attrib: Using 'eval' to construct command strings https://askubuntu.com/a/476533
730
731 # Save function name
732 local FN="${FUNCNAME[0]}";
733 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
734
735 # Set file name
736 if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
737
738 # Check tar path is a file
739 if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
740
741 # Check temp dir arg
742 if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
743
744 # Set command strings
745 if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
746 if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
747 if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
748 if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
749
750 # Input command
751 CMD0="echo \"\$1\""
752
753 # # Debug
754 # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
755 # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
756 # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
757 # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
758 # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
759 # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
760 # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
761 # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
762
763 # Write to temporary working dir
764 eval "$CMD0"" | ""$CMD1"" | ""$CMD2"" | ""$CMD3"" | ""$CMD4" > "$TMP_DIR"/"$FILENAME";
765
766 # Append to tar
767 try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
768 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
769 } # Append Bash var to file appended to Tar archive
770 appendFileTar(){
771 # Desc: Processes first file and then appends to tar
772 # Usage: appendFileTar [file path] [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
773 # Version: 1.0.2
774 # Input: arg1: path of file to be (processed and) written
775 # arg2: name to use for file inserted into tar
776 # arg3: tar archive path (must exist first)
777 # arg4: temporary working dir
778 # arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
779 # Output: file written to disk
780 # Example: decrypt multiple large files in parallel
781 # appendFileTar /tmp/largefile1.gpg "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
782 # appendFileTar /tmp/largefile2.gpg "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
783 # appendFileTar /tmp/largefile3.gpg "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
784 # Depends: bash 5
785
786 # Save function name
787 local FN="${FUNCNAME[0]}";
788 #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
789
790 # Set file name
791 if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
792 # Check tar path is a file
793 if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
794 # Check temp dir arg
795 if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
796 # Set command strings
797 if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
798 if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
799 if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
800 if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
801
802 # Input command string
803 CMD0="cat \"\$1\""
804
805 # # Debug
806 # yell "DEBUG:STATUS:$FN:CMD0:$CMD0"
807 # yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
808 # yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
809 # yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
810 # yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
811 # yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
812 # yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
813 # yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
814
815 # Write to temporary working dir
816 eval "$CMD0 | $CMD1 | $CMD2 | $CMD3 | $CMD4" > "$TMP_DIR"/"$FILENAME";
817
818 # Append to tar
819 try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
820 #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
821 } # Append file to Tar archive
822 magicWriteVersion() {
823 # Desc: Appends time-stamped VERSION to PATHOUT_TAR
824 # Usage: magicWriteVersion
825 # Version: 0.1.0
826 # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
827 # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
828 # Output: appends tar PATHOUT_TAR
829 # Depends: dateTimeShort, appendArgTar
830 local CONTENT_VERSION pubKeyIndex
831
832 # Set VERSION file name
833 FILEOUT_VERSION="$(dateTimeShort)..VERSION";
834
835 # Gather VERSION data in CONTENT_VERSION
836 CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
837 #CONTENT_VERSION="$CONTENT_VERSION""\\n";
838 CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
839 CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
840 CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
841 CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
842 CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
843 CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
844 ## Add list of recipient pubkeys
845 for pubkey in "${recPubKeysValid[@]}"; do
846 ((pubKeyIndex++))
847 CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
848 done
849 ## Process newline escapes
850 CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
851
852 # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
853 appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
854
855 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
856 magicGatherWriteBuffer() {
857 # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
858 # Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
859 # Inputs: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
860 # Depends: yell, try, vbm, appendArgTar, tar
861 local FN="${FUNCNAME[0]}";
862 wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
863 # Create buffer file with unique name
864 PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";
865 # Fill buffer
866 timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
867 timeBufferStart="$(dateTimeShort "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time
868 vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
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 "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
881 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
882 # DEBUG: check vars
883 vbm "STATUS:DIR_TMP :$DIR_TMP";
884 vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
885 vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
886 vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
887 vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
888
889
890 # Validate PATHOUT_TAR as tar.
891 checkMakeTar "$PATHOUT_TAR";
892 ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
893 if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi
894
895 # Write bufferBash to PATHOUT_TAR
896 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
897 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
898 appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
899
900 # Remove secured chunks from DIR_TMP
901 rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
902 vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
903 } # write buffer to disk
904
905 main() {
906 processArguments "$@" # Process arguments.
907
908 # Determine working directory
909 ## Set DIR_TMP_PARENT to user-specified value if specified
910 if [[ "$OPTION_TMPDIR" = "true" ]]; then
911 if [[ -d "$TMP_DIR_PRIORITY" ]]; then
912 DIR_TMP_PARENT="$OPTION_TMPDIR";
913 else
914 yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";
915 exit 1;
916 fi
917 fi
918
919 ## Set DIR_TMP_PARENT to default or fallback otherwise
920 if [[ -d "$DIR_TMP_DEFAULT" ]]; then
921 DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
922 elif [[ -d /tmp ]]; then
923 yell "WARNING:/dev/shm not available. Falling back to /tmp .";
924 DIR_TMP_PARENT="/tmp";
925 else
926 yell "ERROR:No valid working directory available. Exiting.";
927 exit 1;
928 fi
929
930 ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
931 DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
932
933 # Set output encryption and compression option strings
934 if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
935 if checkapp age; then # Check that age is available.
936 for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
937 vbm "DEBUG:Testing pubkey string:$pubkey";
938 if echo "butts" | age -a -r "$pubkey" 1>/dev/null; then
939 #### Form age recipient string
940 recipients="$recipients""-r '$pubkey' ";
941 vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
942 vbm "DEBUG:recipients:""$recipients";
943 #### Add validated pubkey to recPubKeysValid array
944 recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
945 else
946 yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
947 fi
948 done
949 vbm "DEBUG:Finished processing recPubKeys array";
950
951 ## Form age command string
952 CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
953 CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
954 else
955 yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
956 fi
957 else
958 CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
959 CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
960 vbm "DEBUG:Encryption not enabled."
961 fi
962 if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
963 if checkapp gzip; then # Check if gzip available
964 CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
965 CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
966 else
967 yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
968 fi
969 else
970 CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
971 CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
972 vbm "DEBUG:Compression not enabled.";
973 fi
974
975 # Check that critical apps and dirs are available, displag missing ones.
976 if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then
977 yell "ERROR:Critical components missing.";
978 displayMissing; yell "Exiting."; exit 1; fi
979
980 # Set script lifespan
981 setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")
982
983 # File name substring: encoded bufferTTL
984 bufferTTL_STR="$(timeDuration $BUFFER_TTL)";
985
986 # Init temp working dir
987 try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
988
989 # Initialize 'tar' archive
990 ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
991 PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
992 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
993 ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
994 checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
995 ## Append VERSION file to PATHOUT_TAR
996 magicWriteVersion;
997
998 # Define GPS conversion commands
999 CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
1000 CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
1001 CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
1002
1003 # MAIN LOOP:Record gps data until script lifespan ends
1004 while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
1005 magicGatherWriteBuffer &
1006 sleep "$BUFFER_TTL";
1007 done
1008
1009 # Cleanup
1010 ## Remove DIR_TMP
1011 try rm -r "$DIR_TMP";
1012
1013 vbm "STATUS:Main function finished.";
1014 } # Main function.
1015 #===END Declare local script functions===
1016 #==END Define script parameters==
1017
1018
1019 #==BEGIN Perform work and exit==
1020 main "$@" # Run main function.
1021 exit 0;
1022 #==END Perform work and exit==