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.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 / (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	validateInput() {
	823	# Desc: Validates Input
	824	# Usage: validateInput [str input] [str input type]
	825	# Version: 0.2.1
	826	# Input: arg1: string to validate
	827	# arg2: string specifying input type (ex:"ssh_pubkey")
	828	# Output: return code 0: if input string matched specified string type
	829	# Depends: bash 5, yell
	830
	831	# Save function name
	832	local FN="${FUNCNAME[0]}";
	833
	834	# Process arguments
	835	argInput="$1";
	836	argType="$2";
	837	if [[ $# -gt 2 ]]; then yell "ERROR:$0:$FN:Too many arguments."; exit 1; fi;
	838
	839	# Check for blank
	840	if [[ -z "$argInput" ]]; then return 1; fi
	841
	842	# Define input types
	843	## ssh_pubkey
	844	### Check for alnum/dash base64 (ex: "ssh-rsa AAAAB3NzaC1yc2EAAA")
	845	if [[ "$argType" = "ssh_pubkey" ]]; then
	846	if [[ "$argInput" =~ ^[[:alnum:]-][\ ][[:alnum:]+/=]*$ ]]; then
	847	return 0; fi; fi;
	848
	849	## age_pubkey
	850	### Check for age1[:bech32:]
	851	if [[ "$argType" = "age_pubkey" ]]; then
	852	if [[ "$argInput" =~ ^age1[qpzry9x8gf2tvdw0s3jn54khce6mua7l]*$ ]]; then
	853	return 0; fi; fi
	854
	855	# Return error if no condition matched.
	856	return 1;
	857	} # Validates strings
	858	magicWriteVersion() {
	859	# Desc: Appends time-stamped VERSION to PATHOUT_TAR
	860	# Usage: magicWriteVersion
	861	# Version: 0.1.0
	862	# Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
	863	# Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
	864	# Output: appends tar PATHOUT_TAR
	865	# Depends: dateTimeShort, appendArgTar
	866	local CONTENT_VERSION pubKeyIndex
	867
	868	# Set VERSION file name
	869	FILEOUT_VERSION="$(dateTimeShort)..VERSION";
	870
	871	# Gather VERSION data in CONTENT_VERSION
	872	CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
	873	#CONTENT_VERSION="$CONTENT_VERSION""\\n";
	874	CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
	875	CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
	876	CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
	877	CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
	878	CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
	879	CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
	880	## Add list of recipient pubkeys
	881	for pubkey in "${recPubKeysValid[@]}"; do
	882	((pubKeyIndex++))
	883	CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
	884	done
	885	## Process newline escapes
	886	CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
	887
	888	# Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
	889	appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
	890
	891	} # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
	892	magicGatherWriteBuffer() {
	893	# Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
	894	# Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
	895	# Inputs: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
	896	# Depends: yell, try, vbm, appendArgTar, tar
	897	local FN="${FUNCNAME[0]}";
	898	wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
	899	# Create buffer file with unique name
	900	PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";
	901	# Fill buffer
	902	timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
	903	timeBufferStart="$(dateTimeShort "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time
	904	vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
	905	# Determine file paths (time is start of buffer period)
	906	FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
	907	## Files saved to DIR_TMP
	908	FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
	909	FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
	910	FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
	911	PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
	912	PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
	913	PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
	914	## Files saved to disk (DIR_OUT)
	915	### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
	916	PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
	917	vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
	918	# DEBUG: check vars
	919	vbm "STATUS:DIR_TMP :$DIR_TMP";
	920	vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
	921	vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
	922	vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
	923	vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
	924
	925
	926	# Validate PATHOUT_TAR as tar.
	927	checkMakeTar "$PATHOUT_TAR";
	928	## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
	929	if [[ $? -eq 1 ]] \|\| [[ $? -eq 2 ]]; then magicWriteVersion; fi
	930
	931	# Write bufferBash to PATHOUT_TAR
	932	appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
	933	appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
	934	appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
	935
	936	# Remove secured chunks from DIR_TMP
	937	rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
	938	vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
	939	} # write buffer to disk
	940
	941	main() {
	942	processArguments "$@" # Process arguments.
	943
	944	# Determine working directory
	945	## Set DIR_TMP_PARENT to user-specified value if specified
	946	if [[ "$OPTION_TMPDIR" = "true" ]]; then
	947	if [[ -d "$TMP_DIR_PRIORITY" ]]; then
	948	DIR_TMP_PARENT="$OPTION_TMPDIR";
	949	else
	950	yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";
	951	exit 1;
	952	fi
	953	fi
	954
	955	## Set DIR_TMP_PARENT to default or fallback otherwise
	956	if [[ -d "$DIR_TMP_DEFAULT" ]]; then
	957	DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
	958	elif [[ -d /tmp ]]; then
	959	yell "WARNING:/dev/shm not available. Falling back to /tmp .";
	960	DIR_TMP_PARENT="/tmp";
	961	else
	962	yell "ERROR:No valid working directory available. Exiting.";
	963	exit 1;
	964	fi
	965
	966	## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
	967	DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
	968
	969	# Set output encryption and compression option strings
	970	if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
	971	if checkapp age; then # Check that age is available.
	972	for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
	973	vbm "DEBUG:Testing pubkey string:$pubkey";
	974	if echo "butts" \| age -a -r "$pubkey" 1>/dev/null &&
	975	( validateInput "$pubkey" "ssh_pubkey" \|\| validateInput "$pubkey" "age_pubkey"); then
	976	#### Form age recipient string
	977	recipients="$recipients""-r '$pubkey' ";
	978	vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
	979	vbm "DEBUG:recipients:""$recipients";
	980	#### Add validated pubkey to recPubKeysValid array
	981	recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
	982	else
	983	yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
	984	fi
	985	done
	986	vbm "DEBUG:Finished processing recPubKeys array";
	987
	988	## Form age command string
	989	CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
	990	CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
	991	else
	992	yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
	993	fi
	994	else
	995	CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";
	996	CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";
	997	vbm "DEBUG:Encryption not enabled."
	998	fi
	999	if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
	1000	if checkapp gzip; then # Check if gzip available
	1001	CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
	1002	CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
	1003	else
	1004	yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
	1005	fi
	1006	else
	1007	CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";
	1008	CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";
	1009	vbm "DEBUG:Compression not enabled.";
	1010	fi
	1011
	1012	# Check that critical apps and dirs are available, displag missing ones.
	1013	if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then
	1014	yell "ERROR:Critical components missing.";
	1015	displayMissing; yell "Exiting."; exit 1; fi
	1016
	1017	# Set script lifespan
	1018	setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")
	1019
	1020	# File name substring: encoded bufferTTL
	1021	bufferTTL_STR="$(timeDuration $BUFFER_TTL)";
	1022
	1023	# Init temp working dir
	1024	try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
	1025
	1026	# Initialize 'tar' archive
	1027	## Define output tar path (note: each day gets one tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
	1028	PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
	1029	vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
	1030	## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
	1031	checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
	1032	## Append VERSION file to PATHOUT_TAR
	1033	magicWriteVersion;
	1034
	1035	# Define GPS conversion commands
	1036	CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
	1037	CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
	1038	CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
	1039
	1040	# MAIN LOOP:Record gps data until script lifespan ends
	1041	while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
	1042	magicGatherWriteBuffer &
	1043	sleep "$BUFFER_TTL";
	1044	done
	1045
	1046	# Cleanup
	1047	## Remove DIR_TMP
	1048	try rm -r "$DIR_TMP";
	1049
	1050	vbm "STATUS:Main function finished.";
	1051	} # Main function.
	1052	#===END Declare local script functions===
	1053	#==END Define script parameters==
	1054
	1055
	1056	#==BEGIN Perform work and exit==
	1057	main "$@" # Run main function.
	1058	exit 0;
	1059	#==END Perform work and exit==