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