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.4"; # 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.2
	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
	730	# Save function name
	731	local FN="${FUNCNAME[0]}";
	732	#yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
	733
	734	# Set file name
	735	if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
	736
	737	# Check tar path is a file
	738	if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
	739
	740	# Check temp dir arg
	741	if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
	742
	743	# Set command strings
	744	if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
	745	if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
	746	if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
	747	if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
	748
	749	# # Debug
	750	# yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
	751	# yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
	752	# yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
	753	# yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
	754	# yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
	755	# yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
	756	# yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
	757
	758	# Write to temporary working dir
	759	echo "$1" \| $CMD1 \| $CMD2 \| $CMD3 \| $CMD4 > "$TMP_DIR"/"$FILENAME";
	760
	761	# Append to tar
	762	try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
	763	#yell "DEBUG:STATUS:$FN:Finished appendArgTar()."
	764	} # Append Bash var to file appended to Tar archive
	765	appendFileTar(){
	766	# Desc: Processes first file and then appends to tar
	767	# Usage: appendFileTar [file path] [name of file to be inserted] [tar path] [temp dir] ([cmd1] [cmd2] [cmd3] [cmd4]...)
	768	# Version: 1.0.1
	769	# Input: arg1: path of file to be (processed and) written
	770	# arg2: name to use for file inserted into tar
	771	# arg3: tar archive path (must exist first)
	772	# arg4: temporary working dir
	773	# arg5+: command strings (ex: "gpsbabel -i nmea -f - -o kml -F - ")
	774	# Output: file written to disk
	775	# Example: decrypt multiple large files in parallel
	776	# appendFileTar /tmp/largefile1.gpg "largefile1" $HOME/archive.tar /tmp "gpg --decrypt" &
	777	# appendFileTar /tmp/largefile2.gpg "largefile2" $HOME/archive.tar /tmp "gpg --decrypt" &
	778	# appendFileTar /tmp/largefile3.gpg "largefile3" $HOME/archive.tar /tmp "gpg --decrypt" &
	779	# Depends: bash 5
	780
	781	# Save function name
	782	local FN="${FUNCNAME[0]}";
	783	#yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
	784
	785	# Set file name
	786	if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi
	787	# Check tar path is a file
	788	if [ -f "$3" ]; then TAR_PATH="$3"; else yell "ERROR:$FN:Tar archive arg not a file."; exit 1; fi
	789	# Check temp dir arg
	790	if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi
	791	# Set command strings
	792	if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1
	793	if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2
	794	if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3
	795	if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4
	796	# # Debug
	797	# yell "DEBUG:STATUS:$FN:CMD1:$CMD1"
	798	# yell "DEBUG:STATUS:$FN:CMD2:$CMD2"
	799	# yell "DEBUG:STATUS:$FN:CMD3:$CMD3"
	800	# yell "DEBUG:STATUS:$FN:CMD4:$CMD4"
	801	# yell "DEBUG:STATUS:$FN:FILENAME:$FILENAME"
	802	# yell "DEBUG:STATUS:$FN:TAR_PATH:$TAR_PATH"
	803	# yell "DEBUG:STATUS:$FN:TMP_DIR:$TMP_DIR"
	804
	805	# Write to temporary working dir
	806	cat "$1" \| $CMD1 \| $CMD2 \| $CMD3 \| $CMD4 > "$TMP_DIR"/"$FILENAME";
	807
	808	# Append to tar
	809	try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";
	810	#yell "DEBUG:STATUS:$FN:Finished appendFileTar()."
	811	} # Append file to Tar archive
	812	magicWriteVersion() {
	813	# Desc: Appends time-stamped VERSION to PATHOUT_TAR
	814	# Usage: magicWriteVersion
	815	# Version: 0.1.0
	816	# Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP
	817	# Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME
	818	# Output: appends tar PATHOUT_TAR
	819	# Depends: dateTimeShort, appendArgTar
	820	local CONTENT_VERSION pubKeyIndex
	821
	822	# Set VERSION file name
	823	FILEOUT_VERSION="$(dateTimeShort)..VERSION";
	824
	825	# Gather VERSION data in CONTENT_VERSION
	826	CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";
	827	#CONTENT_VERSION="$CONTENT_VERSION""\\n";
	828	CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";
	829	CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";
	830	CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";
	831	CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";
	832	CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";
	833	CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";
	834	## Add list of recipient pubkeys
	835	for pubkey in "${recPubKeysValid[@]}"; do
	836	((pubKeyIndex++))
	837	CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";
	838	done
	839	## Process newline escapes
	840	CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"
	841
	842	# Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR
	843	appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";
	844
	845	} # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()
	846	magicWriteBuffer() {
	847	# Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR
	848	# Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,
	849	# Inputs: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX
	850	# Depends: yell, try, vbm, appendArgTar, tar
	851	local FN="${FUNCNAME[0]}";
	852	wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )
	853
	854	timeBufferStart="$(dateTimeShort "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time#TODO subtract BUFFER_TTL from current time
	855	vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";
	856	# Determine file paths (time is start of buffer period)
	857	FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";
	858	## Files saved to DIR_TMP
	859	FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";
	860	FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";
	861	FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";
	862	PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";
	863	PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";
	864	PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";
	865	## Files saved to disk (DIR_OUT)
	866	### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")
	867	PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
	868	vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
	869	# DEBUG: check vars
	870	vbm "STATUS:DIR_TMP :$DIR_TMP";
	871	vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";
	872	vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";
	873	vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";
	874	vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";
	875
	876
	877	# Validate PATHOUT_TAR as tar.
	878	checkMakeTar "$PATHOUT_TAR";
	879	## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)
	880	if [[ $? -eq 1 ]] \|\| [[ $? -eq 2 ]]; then magicWriteVersion; fi
	881
	882	# Write bufferBash to PATHOUT_TAR
	883	appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data
	884	appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file
	885	appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file
	886
	887	# Remove secured chunks from DIR_TMP
	888	rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";
	889	vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";
	890	} # write buffer to disk
	891
	892	main() {
	893	processArguments "$@" # Process arguments.
	894
	895	# Determine working directory
	896	## Set DIR_TMP_PARENT to user-specified value if specified
	897	if [[ "$OPTION_TMPDIR" = "true" ]]; then
	898	if [[ -d "$TMP_DIR_PRIORITY" ]]; then
	899	DIR_TMP_PARENT="$OPTION_TMPDIR";
	900	else
	901	yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";
	902	exit 1;
	903	fi
	904	fi
	905
	906	## Set DIR_TMP_PARENT to default or fallback otherwise
	907	if [[ -d "$DIR_TMP_DEFAULT" ]]; then
	908	DIR_TMP_PARENT="$DIR_TMP_DEFAULT";
	909	elif [[ -d /tmp ]]; then
	910	yell "WARNING:/dev/shm not available. Falling back to /tmp .";
	911	DIR_TMP_PARENT="/tmp";
	912	else
	913	yell "ERROR:No valid working directory available. Exiting.";
	914	exit 1;
	915	fi
	916
	917	## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)
	918	DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().
	919
	920	# Set output encryption and compression option strings
	921	if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.
	922	if checkapp age; then # Check that age is available.
	923	for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message
	924	vbm "DEBUG:Testing pubkey string:$pubkey"
	925	if echo "butts" \| age -a -r "$pubkey" 1>/dev/null; then
	926	#### Form age recipient string
	927	recipients="$recipients""-r $pubkey ";
	928	vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";
	929	vbm "DEBUG:recipients:""$recipients";
	930	#### Add validated pubkey to recPubKeysValid array
	931	recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";
	932	else
	933	yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;
	934	fi
	935	done
	936	vbm "DEBUG:Finished processing recPubKeys array";
	937
	938	## Form age command string
	939	CMD_ENCRYPT="age ""$recipients ";
	940	CMD_ENCRYPT_SUFFIX=".age";
	941	else
	942	yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;
	943	fi
	944	else
	945	CMD_ENCRYPT="tee /dev/null ";
	946	CMD_ENCRYPT_SUFFIX="";
	947	vbm "DEBUG:Encryption not enabled."
	948	fi
	949	if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active
	950	if checkapp gzip; then # Check if gzip available
	951	CMD_COMPRESS="gzip ";
	952	CMD_COMPRESS_SUFFIX=".gz";
	953	else
	954	yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;
	955	fi
	956	else
	957	CMD_COMPRESS="tee /dev/null ";
	958	CMD_COMPRESS_SUFFIX="";
	959	vbm "DEBUG:Compression not enabled.";
	960	fi
	961
	962	# Check that critical apps and dirs are available, displag missing ones.
	963	if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then
	964	yell "ERROR:Critical components missing.";
	965	displayMissing; yell "Exiting."; exit 1; fi
	966
	967	# Set script lifespan
	968	setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")
	969
	970	# File name substring: encoded bufferTTL
	971	bufferTTL_STR="$(timeDuration $BUFFER_TTL)";
	972
	973	# Init temp working dir
	974	try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";
	975
	976	# Initialize 'tar' archive
	977	## Define output tar path (note: each day gets one tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))
	978	PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \
	979	vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";
	980	## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.
	981	checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";
	982	## Append VERSION file to PATHOUT_TAR
	983	magicWriteVersion;
	984
	985	# Define GPS conversion commands
	986	CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough
	987	CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX
	988	CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML
	989
	990	# MAIN LOOP:Record gps data until script lifespan ends
	991	declare debugCounter; debugCounter="0"; # set debug counter
	992	while [[ "$SECONDS" -lt "$scriptTTL" ]]; do
	993	# Create buffer file with unique name
	994	PATHOUT_BUFFER="$DIR_TMP/buffer$debugCounter++";
	995	# Fill Bash variable buffer
	996	timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;
	997	# Process bufferBash, save secured chunk set to DIR_TMP
	998	magicWriteBuffer &
	999	((debugCounter++));
	1000	done
	1001
	1002	# Cleanup
	1003	## Remove DIR_TMP
	1004	try rm -r "$DIR_TMP";
	1005
	1006	vbm "STATUS:Main function finished.";
	1007	} # Main function.
	1008	#===END Declare local script functions===
	1009	#==END Define script parameters==
	1010
	1011
	1012	#==BEGIN Perform work and exit==
	1013	main "$@" # Run main function.
	1014	exit 0;
	1015	#==END Perform work and exit==