zdv2.bktei.com Git - EVA-2020-02.git/blame_incremental

... / ...

Commit	Line	Data
	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.7"; # 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 / (3652460*60) ));
	455	remainder=$(( remainder - (fullYears365246060) ));
	456	## Calculate full months M, update remainder
	457	fullMonths=$(( remainder / (302460*60) ));
	458	remainder=$(( remainder - (fullMonths30246060) ));
	459	## Calculate full days D, update remainder
	460	fullDays=$(( remainder / (246060) ));
	461	remainder=$(( remainder - (fullDays2460*60) ));
	462	## Calculate full hours H, update remainder
	463	fullHours=$(( remainder / (60*60) ));
	464	remainder=$(( remainder - (fullHours6060) ));
	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==