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

1 #!/bin/bash

3 # Desc: Records gps data until midnight

4 # Author: Steven Baltakatei Sandoval; License: GPLv3+

5 # Usage: bkgpslog -o [output dir]

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

 SCRIPT_TIME_START=$(date +%Y%m%dT%H%M%S.%N);

 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.

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

29 ## Initialize variables

 OPTION_VERBOSE=""; OPTION_ENCRYPT=""; OPTION_COMPRESS=""; OPTION_TMPDIR="";

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"

43 #===Process Args===

     for arg in "$@"; do

45 #echo "DEBUG:processing arg:$arg"

         if command -v "$arg" 1>/dev/null 2>&1; then # Check if arg is a valid command

             appRollCall[$arg]="true";

48 #echo "DEBUG:appRollCall[$arg]:"${appRollCall[$arg]}

             if ! [ "$returnState" = "false" ]; then returnState="true"; fi

50 else

             appRollCall[$arg]="false"; returnState="false";

52 fi

53 done

55 #for key in "${!appRollCall[@]}"; do echo "DEBUG:$key => ${appRollCall[$key]}"; done

56 #echo "DEBUG:evaluating returnstate. returnState:"$returnState

58 #===Determine function return code===

     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

75 #===Process Args===

     for arg in "$@"; do

77 #echo "DEBUG:processing arg:$arg"

         if [ -f "$arg" ]; then

             fileRollCall["$arg"]="true";

80 #echo "DEBUG:fileRollCall[\"$arg\"]:"${fileRollCall["$arg"]}

             if ! [ "$returnState" = "false" ]; then returnState="true"; fi

82 else

             fileRollCall["$arg"]="false"; returnState="false";

84 fi

85 done

87 #for key in "${!fileRollCall[@]}"; do echo "DEBUG:fileRollCall key [$key] is:${fileRollCall[$key]}"; done

88 #echo "DEBUG:evaluating returnstate. returnState:"$returnState

90 #===Determine function return code===

     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===

     for arg in "$@"; do

109 #echo "DEBUG:processing arg:$arg"

         if [ -d "$arg" ]; then

             dirRollCall["$arg"]="true";

112 #echo "DEBUG:dirRollCall[\"$arg\"]:"${dirRollCall["$arg"]}

             if ! [ "$returnState" = "false" ]; then returnState="true"; fi

         elif [ "$arg" = "" ]; then

             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===

     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

 yell() { echo "$0: $*" >&2; }

 die() { yell "$*"; exit 111; }

138 try() { "$@" || die "cannot $*"; }

139

140 echoerr() {

     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"

     echoerr "            Specify time zone. (ex: \"America/New_York\")"

172 echoerr

173 echoerr " -t, --temp-dir"

174 echoerr " Specify parent directory for temporary working directory."

     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

     if [ "$OPTION_VERBOSE" = "true" ]; then

         FUNCTION_TIME=$(date --iso-8601=ns); # Save current time in nano seconds.

         echoerr "[$FUNCTION_TIME] ""$*"; # Display argument text.

203 fi

204

205 # End function

206 return 0; # Function finished.

207 } # Verbose message display function.

208 processArguments() {

     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:""$*"

         case "$1" in

             -h | --help) showUsage; exit 1;; # Display usage.

             --version) showVersion; exit 1;; # Show version

             -v | --verbose) OPTION_VERBOSE="true"; vbm "DEBUG:Verbose mode enabled.";; # Enable verbose mode.

             -o | --output) if [ -d "$2" ]; then DIR_OUT="$2"; vbm "DEBUG:DIR_OUT:$DIR_OUT"; shift; fi ;; # Define output directory.

             -e | --encrypt) OPTION_ENCRYPT="true"; vbm "DEBUG:Encrypted output mode enabled.";;

218 -r | --recipient) # Add 'age' recipient via public key string

                 recPubKeys+=("$2"); vbm "STATUS:pubkey added:""$2"; shift;;

             -c | --compress) OPTION_COMPRESS="true"; vbm "DEBUG:Compressed output mode enabled.";;

             -z | --time-zone) try setTimeZoneEV "$2"; shift;;

             -t | --temp-dir) OPTION_TMPDIR="true" && TMP_DIR_PRIORITY="$2"; shift;;

             *) 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

     if ! [[ $# -eq 1 ]]; then

242 yell "ERROR:Invalid argument count.";

243 return 1;

244 fi

245

246 # Read TZDIR env var if available

     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

     if ! [[ -f "$tzDir"/"$ARG1" ]]; then

255 yell "ERROR:Invalid time zone argument.";

256 return 2;

257 else

258 # Export ARG1 as TZ environment variable

         TZ="$ARG1" && export TZ && returnState="true";

260 fi

261

262 # Determine function return code

     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.

     TIME_NEXT_DAY="$(date -d "$TIME_CURRENT next day" --iso-8601=date)"; # Produce timestamp of beginning of tomorrow with resolution of 1 second.

     SECONDS_UNTIL_NEXT_DAY="$(( $(date +%s -d "$TIME_NEXT_DAY") - $(date +%s -d "$TIME_CURRENT") ))" ; # Calculate seconds until closest future midnight (res. 1 second).

     if [[ "$SECONDS_UNTIL_NEXT_DAY" -gt 0 ]]; then

282 returnState="true";

     elif [[ "$SECONDS_UNTIL_NEXT_DAY" -eq 0 ]]; then

284 returnState="warning_zero";

285 yell "WARNING:Reported time until next day exactly zero.";

     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

     try echo "$SECONDS_UNTIL_NEXT_DAY"; # Report

292

293 # Determine function return code

     if [[ "$returnState" = "true" ]]; then

295 return 0;

     elif [[ "$returnState" = "warning_zero" ]]; then

297 return 1;

     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.

     TIME_NEXT_HOUR="$(date -d "$TIME_CURRENT next hour" --iso-8601=hours)"; # Produce `date`-parsable current time stamp with resolution of 1 second.

     SECONDS_UNTIL_NEXT_HOUR="$(( $(date +%s -d "$TIME_NEXT_HOUR") - $(date +%s -d "$TIME_CURRENT") ))"; # Calculate seconds until next hour (res. 1 second).

     if [[ "$SECONDS_UNTIL_NEXT_HOUR" -gt 0 ]]; then

315 returnState="true";

     elif [[ "$SECONDS_UNTIL_NEXT_HOUR" -eq 0 ]]; then

317 returnState="warning_zero";

318 yell "WARNING:Reported time until next hour exactly zero.";

     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

     try echo "$SECONDS_UNTIL_NEXT_HOUR"; # Report

325

326 # Determine function return code

     if [[ "$returnState" = "true" ]]; then

328 return 0;

     elif [[ "$returnState" = "warning_zero" ]]; then

330 return 1;

     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

     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

     if [[ -z "$argTime" ]]; then

350 ## T: Time argument empty, use current time

         TIME_INPUT="$TIME_CURRENT";

352 else

353 ## F: Time argument exists, validate time

         if date --date="$argTime" 1>/dev/null 2>&1; then

355 ### T: Time argument is valid; use it

             TIME_INPUT="$argTime";

357 else

358 ### F: Time argument not valid; exit

             yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;

360 fi

361 fi

362 # Construct and deliver separator-les date string

     TIME_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%dT%H%M%S%z)";

     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

     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

     if [[ -z "$argTime" ]]; then

381 ## T: Time argument empty, use current time

         TIME_INPUT="$TIME_CURRENT";

383 else

384 ## F: Time argument exists, validate time

         if date --date="$argTime" 1>/dev/null 2>&1; then

386 ### T: Time argument is valid; use it

             TIME_INPUT="$argTime";

388 else

389 ### F: Time argument not valid; exit

             yell "ERROR:Invalid time argument supplied. Exiting."; exit 1;

391 fi

392 fi

393 # Construct and deliver separator-les date string

     DATE_CURRENT_SHORT="$(date -d "$TIME_INPUT" +%Y%m%d)"; # Produce separator-less current date with resolution 1 day.

     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

     argSeconds="$1"; # read arg1 (seconds)

     argPrecision="$2"; # read arg2 (precision)

418 precision=2; # set default precision

419

420 # Check that between one and two arguments is supplied

     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

     if [[ $# -ge 1 ]]; then

427 ## Check that argSeconds is a positive integer

         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

     if  [[ $# -eq 2 ]]; then

441 # Check that argPrecision is a positive integer

         if [[ "$argPrecision" =~ ^[[:digit:]]+$ ]] && [[ "$argPrecision" -gt 0 ]]; then

         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

     remainder="$argSeconds" ; # seconds

453 ## Calculate full years Y, update remainder

     fullYears=$(( remainder / (365*24*60*60) ));

     remainder=$(( remainder - (fullYears*365*24*60*60) ));

456 ## Calculate full months M, update remainder

     fullMonths=$(( remainder / (30*24*60*60) ));

     remainder=$(( remainder - (fullMonths*30*24*60*60) ));

459 ## Calculate full days D, update remainder

     fullDays=$(( remainder / (24*60*60) ));

     remainder=$(( remainder - (fullDays*24*60*60) ));

462 ## Calculate full hours H, update remainder

     fullHours=$(( remainder / (60*60) ));

     remainder=$(( remainder - (fullHours*60*60) ));

465 ## Calculate full minutes M, update remainder

     fullMinutes=$(( remainder / (60) ));

     remainder=$(( remainder - (fullMinutes*60) ));

468 ## Calculate full seconds S, update remainder

     fullSeconds=$(( remainder / (1) ));

     remainder=$(( remainder - (remainder*1) ));

471 ## Check which fields filled

     if [[ $fullYears -gt 0 ]]; then hasYears="true"; else hasYears="false"; fi

     if [[ $fullMonths -gt 0 ]]; then hasMonths="true"; else hasMonths="false"; fi

     if [[ $fullDays -gt 0 ]]; then hasDays="true"; else hasDays="false"; fi

     if [[ $fullHours -gt 0 ]]; then hasHours="true"; else hasHours="false"; fi

     if [[ $fullMinutes -gt 0 ]]; then hasMinutes="true"; else hasMinutes="false"; fi

     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

     if $hasYears && [[ $precision -gt 0 ]]; then

484 displayYears="true";

485 witherPrecision="true";

486 else

487 displayYears="false";

488 fi;

     if $witherPrecision; then ((precision--)); fi;

490

491 ### Months

     if $hasMonths && [[ $precision -gt 0 ]]; then

493 displayMonths="true";

494 witherPrecision="true";

495 else

496 displayMonths="false";

497 fi;

     if $witherPrecision && [[ $precision -gt 0 ]]; then

499 displayMonths="true";

500 fi;

     if $witherPrecision; then ((precision--)); fi;

502

503 ### Days

     if $hasDays && [[ $precision -gt 0 ]]; then

505 displayDays="true";

506 witherPrecision="true";

507 else

508 displayDays="false";

509 fi;

     if $witherPrecision && [[ $precision -gt 0 ]]; then

511 displayDays="true";

512 fi;

     if $witherPrecision; then ((precision--)); fi;

514

515 ### Hours

     if $hasHours && [[ $precision -gt 0 ]]; then

517 displayHours="true";

518 witherPrecision="true";

519 else

520 displayHours="false";

521 fi;

     if $witherPrecision && [[ $precision -gt 0 ]]; then

523 displayHours="true";

524 fi;

     if $witherPrecision; then ((precision--)); fi;

526

527 ### Minutes

     if $hasMinutes && [[ $precision -gt 0 ]]; then

529 displayMinutes="true";

530 witherPrecision="true";

531 else

532 displayMinutes="false";

533 fi;

     if $witherPrecision && [[ $precision -gt 0 ]]; then

535 displayMinutes="true";

536 fi;

     if $witherPrecision; then ((precision--)); fi;

538

539 ### Seconds

540

     if $hasSeconds && [[ $precision -gt 0 ]]; then

542 displaySeconds="true";

543 witherPrecision="true";

544 else

545 displaySeconds="false";

546 fi;

     if $witherPrecision && [[ $precision -gt 0 ]]; then

548 displaySeconds="true";

549 fi;

     if $witherPrecision; then ((precision--)); fi;

551

552 ## Determine whether or not the "T" separator is needed to separate date and time elements

     if ( $displayHours || $displayMinutes || $displaySeconds); then

         displayDateTime="true"; else displayDateTime="false"; fi

555

556 ## Construct duration output string

557 OUTPUT="P"

558 if $displayYears; then

         OUTPUT=$OUTPUT$fullYears"Y"; fi

560 if $displayMonths; then

         OUTPUT=$OUTPUT$fullMonths"M"; fi

562 if $displayDays; then

         OUTPUT=$OUTPUT$fullDays"D"; fi

564 if $displayDateTime; then

         OUTPUT=$OUTPUT"T"; fi

566 if $displayHours; then

         OUTPUT=$OUTPUT$fullHours"H"; fi

568 if $displayMinutes; then

         OUTPUT=$OUTPUT$fullMinutes"M"; fi

570 if $displaySeconds; then

         OUTPUT=$OUTPUT$fullSeconds"S"; fi

572

573 ## Output duration string to stdout

     echo "$OUTPUT" && returnState="true";

575

576 #===Determine function return code===

     if [ "$returnState" = "true" ]; then

578 return 0;

     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

     for key in "${!appRollCall[@]}"; do

598 value="${appRollCall[$key]}"

         if [ "$value" = "false" ]; then

600 #echo "DEBUG:Missing apps: $key => $value";

             missingApps="$missingApps""$key "

602 appMissing="true"

603 fi

604 done

     if [ "$appMissing" = "true" ]; then  # Only indicate if an app is missing.

         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

     for key in "${!fileRollCall[@]}"; do

614 value="${fileRollCall[$key]}"

         if [ "$value" = "false" ]; then

616 #echo "DEBUG:Missing files: $key => $value";

             missingFiles="$missingFiles""$key "

618 fileMissing="true"

619 fi

620 done

     if [ "$fileMissing" = "true" ]; then  # Only indicate if an app is missing.

         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

     for key in "${!dirRollCall[@]}"; do

630 value="${dirRollCall[$key]}"

         if [ "$value" = "false" ]; then

632 #echo "DEBUG:Missing dirs: $key => $value";

             missingDirs="$missingDirs""$key "

634 dirMissing="true"

635 fi

636 done

     if [ "$dirMissing" = "true" ]; then  # Only indicate if an dir is missing.

         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"

     if [[ "$ARG1" = "day" ]]; then

653 # Set script lifespan to end at start of next day

         if ! scriptTTL="$(timeUntilNextDay)"; then

             if [[ "$scriptTTL" -eq 0 ]]; then

656 ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.

657 else

             yell "ERROR: timeUntilNextDay exit code $?"; exit 1;

659 fi;

660 fi;

     elif [[ "$ARG1" = "hour" ]]; then

662 # Set script lifespan to end at start of next hour

         if ! scriptTTL="$(timeUntilNextHour)"; then

             if [[ "$scriptTTL" -eq 0 ]]; then

665 ((scriptTTL++)); # Add 1 because 0 would cause 'timeout' to never timeout.

666 else

                 yell "ERROR: timeUntilNextHour exit code $?"; exit 1;

668 fi;

669 fi;

670 else

         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

     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

         if [[ -f "$PATH_TAR" ]]; then

693 ### T: Rename file

             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

         try tar --create --file="$PATH_TAR" --files-from=/dev/null && \

702 returnFlag2="tar created";

703 fi

704

705 # Determine function return code

     if [[ "$returnFlag0" = "tar valid" ]]; then

707 return 0;

     elif [[ "$returnFlag2" = "tar created" ]] && ! [[ "$returnFlag1" = "tar moved" ]]; then

709 return 1; # tar missing so created

     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

     local FN="${FUNCNAME[0]}";

733 #yell "DEBUG:STATUS:$FN:Finished appendArgTar()."

734

735 # Set file name

     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi

737

738 # Check tar path is a file

     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

     if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi

743

744 # Set command strings

     if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1

     if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2

     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3

     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4

749

750 # Input command

     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

     eval "$CMD0"" | ""$CMD1"" | ""$CMD2"" | ""$CMD3"" | ""$CMD4" > "$TMP_DIR"/"$FILENAME";

765

766 # Append to tar

     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

     local FN="${FUNCNAME[0]}";

788 #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."

789

790 # Set file name

     if ! [ -z "$2" ]; then FILENAME="$2"; else yell "ERROR:$FN:Not enough arguments."; exit 1; fi

792 # Check tar path is a file

     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

     if ! [ -z "$4" ]; then TMP_DIR="$4"; else yell "ERROR:$FN:No temporary working dir set."; exit 1; fi

796 # Set command strings

     if ! [ -z "$5" ]; then CMD1="$5"; else CMD1="tee /dev/null "; fi # command string 1

     if ! [ -z "$6" ]; then CMD2="$6"; else CMD2="tee /dev/null "; fi # command string 2

     if ! [ -z "$7" ]; then CMD3="$7"; else CMD3="tee /dev/null "; fi # command string 3

     if ! [ -z "$8" ]; then CMD4="$8"; else CMD4="tee /dev/null "; fi # command string 4

801

802 # Input command string

     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

     eval "$CMD0 | $CMD1 | $CMD2 | $CMD3 | $CMD4" > "$TMP_DIR"/"$FILENAME";

817

818 # Append to tar

     try tar --append --directory="$TMP_DIR" --file="$TAR_PATH" "$FILENAME";

820 #yell "DEBUG:STATUS:$FN:Finished appendFileTar()."

821 } # Append file to Tar archive

822 magicWriteVersion() {

823 # Desc: Appends time-stamped VERSION to PATHOUT_TAR

824 # Usage: magicWriteVersion

825 # Version: 0.1.0

826 # Input: CONTENT_VERSION, FILEOUT_VERSION, PATHOUT_TAR, DIR_TMP

827 # Input: SCRIPT_VERSION, SCRIPT_URL, AGE_VERSION, AGE_URL, SCRIPT_HOSTNAME

828 # Output: appends tar PATHOUT_TAR

829 # Depends: dateTimeShort, appendArgTar

830 local CONTENT_VERSION pubKeyIndex

831

832 # Set VERSION file name

833 FILEOUT_VERSION="$(dateTimeShort)..VERSION";

834

835 # Gather VERSION data in CONTENT_VERSION

     CONTENT_VERSION="SCRIPT_VERSION=$SCRIPT_VERSION";

837 #CONTENT_VERSION="$CONTENT_VERSION""\\n";

     CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_NAME=$SCRIPT_NAME";

     CONTENT_VERSION="$CONTENT_VERSION""\\n""SCRIPT_URL=$SCRIPT_URL";

     CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_VERSION=$AGE_VERSION";

     CONTENT_VERSION="$CONTENT_VERSION""\\n""AGE_URL=$AGE_URL";

     CONTENT_VERSION="$CONTENT_VERSION""\\n""DATE=$(date --iso-8601=seconds)";

     CONTENT_VERSION="$CONTENT_VERSION""\\n""HOSTNAME=$SCRIPT_HOSTNAME";

844 ## Add list of recipient pubkeys

     for pubkey in "${recPubKeysValid[@]}"; do

846 ((pubKeyIndex++))

         CONTENT_VERSION="$CONTENT_VERSION""\\n""PUBKEY_$pubKeyIndex=$pubkey";

848 done

849 ## Process newline escapes

850 CONTENT_VERSION="$(echo -e "$CONTENT_VERSION")"

851

852 # Write CONTENT_VERSION as file FILEOUT_VERSION and write-append to PATHOUT_TAR

     appendArgTar "$CONTENT_VERSION" "$FILEOUT_VERSION" "$PATHOUT_TAR" "$DIR_TMP";

854

855 } # bkgpslog: write version data to PATHOUT_TAR via appendArgTar()

856 magicGatherWriteBuffer() {

857 # Desc: bkgpslog-specific meta function for writing data to DIR_TMP then appending each file to PATHOUT_TAR

858 # Inputs: PATHOUT_TAR FILEOUT_{NMEA,GPX,KML} CMD_CONV_{NMEA,GPX,KML} CMD_{COMPRESS,ENCRYPT} DIR_TMP,

859 # Inputs: BUFFER_TTL bufferTTL_STR SCRIPT_HOSTNAME CMD_COMPRESS_SUFFIX CMD_ENCRYPT_SUFFIX

860 # Depends: yell, try, vbm, appendArgTar, tar

     local FN="${FUNCNAME[0]}";

862 wait; # Wait to avoid collision with older magicWriteBuffer() instances (see https://www.tldp.org/LDP/abs/html/x9644.html )

863 # Create buffer file with unique name

     PATHOUT_BUFFER="$DIR_TMP/buffer$SECONDS";

865 # Fill buffer

     timeout "$BUFFER_TTL"s gpspipe -r -o "$PATHOUT_BUFFER" ;

     timeBufferStart="$(dateTimeShort  "$(date --date="$BUFFER_TTL seconds ago")")"; # Note start time

868 vbm "DEBUG:STATUS:$FN:Started magicWriteBuffer().";

869 # Determine file paths (time is start of buffer period)

     FILEOUT_BASENAME="$timeBufferStart""--""$bufferTTL_STR""..""$SCRIPT_HOSTNAME""_location" && vbm "STATUS:Set FILEOUT_BASENAME to:$FILEOUT_BASENAME";

871 ## Files saved to DIR_TMP

     FILEOUT_NMEA="$FILEOUT_BASENAME".nmea"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_NMEA to:$FILEOUT_NMEA";

     FILEOUT_GPX="$FILEOUT_BASENAME".gpx"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_GPX to:$FILEOUT_GPX";

     FILEOUT_KML="$FILEOUT_BASENAME".kml"$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX" && vbm "STATUS:Set FILEOUT_KML to:$FILEOUT_KML";

     PATHOUT_NMEA="$DIR_TMP"/"$FILEOUT_NMEA" && vbm "STATUS:Set PATHOUT_NMEA to:$PATHOUT_NMEA";

     PATHOUT_GPX="$DIR_TMP"/"$FILEOUT_GPX" && vbm "STATUS:Set PATHOUT_GPX to:$PATHOUT_GPX";

     PATHOUT_KML="$DIR_TMP"/"$FILEOUT_KML" && vbm "STATUS:Set PATHOUT_KML to:$PATHOUT_KML";

878 ## Files saved to disk (DIR_OUT)

879 ### one file per day (Ex: "20200731..hostname_location.[.gpx.gz].tar")

     PATHOUT_TAR="$DIR_OUT"/"$(dateShort "$(date --date="$BUFFER_TTL seconds ago")")".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \

881 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";

882 # DEBUG: check vars

883 vbm "STATUS:DIR_TMP :$DIR_TMP";

884 vbm "STATUS:PATHOUT_TAR :$PATHOUT_TAR";

885 vbm "STATUS:PATHOUT_NMEA:$PATHOUT_NMEA";

886 vbm "STATUS:PATHOUT_GPX:$PATHOUT_GPX";

887 vbm "STATUS:PATHOUT_KML:$PATHOUT_KML";

888

889

890 # Validate PATHOUT_TAR as tar.

891 checkMakeTar "$PATHOUT_TAR";

892 ## Add VERSION file if checkMakeTar had to create a tar (exited 1) or replace one (exited 2)

     if [[ $? -eq 1 ]] || [[ $? -eq 2 ]]; then magicWriteVersion; fi

894

895 # Write bufferBash to PATHOUT_TAR

     appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_NMEA" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_NMEA" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write NMEA data

     appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_GPX" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_GPX" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write GPX file

     appendFileTar "$PATHOUT_BUFFER" "$FILEOUT_KML" "$PATHOUT_TAR" "$DIR_TMP" "$CMD_CONV_KML" "$CMD_COMPRESS" "$CMD_ENCRYPT"; # Write KML file

899

900 # Remove secured chunks from DIR_TMP

     rm "$PATHOUT_BUFFER" "$PATHOUT_NMEA" "$PATHOUT_GPX" "$PATHOUT_KML";

902 vbm "DEBUG:STATUS:$FN:Finished magicWriteBuffer().";

903 } # write buffer to disk

904

905 main() {

906 processArguments "$@" # Process arguments.

907

908 # Determine working directory

909 ## Set DIR_TMP_PARENT to user-specified value if specified

     if [[ "$OPTION_TMPDIR" = "true" ]]; then

             if [[ -d "$TMP_DIR_PRIORITY" ]]; then

             DIR_TMP_PARENT="$OPTION_TMPDIR"; 

913 else

914 yell "WARNING:Specified temporary working directory not valid:$OPTION_TMPDIR";

915 exit 1;

916 fi

917 fi

918

919 ## Set DIR_TMP_PARENT to default or fallback otherwise

     if [[ -d "$DIR_TMP_DEFAULT" ]]; then

         DIR_TMP_PARENT="$DIR_TMP_DEFAULT";

     elif [[ -d /tmp ]]; then

923 yell "WARNING:/dev/shm not available. Falling back to /tmp .";

924 DIR_TMP_PARENT="/tmp";

925 else

926 yell "ERROR:No valid working directory available. Exiting.";

927 exit 1;

928 fi

929

930 ## Set DIR_TMP using DIR_TMP_PARENT and nonce (SCRIPT_TIME_START)

     DIR_TMP="$DIR_TMP_PARENT"/"$SCRIPT_TIME_START""..bkgpslog" && vbm "DEBUG:Set DIR_TMP to:$DIR_TMP"; # Note: removed at end of main().

932

933 # Set output encryption and compression option strings

     if [[ "$OPTION_ENCRYPT" = "true" ]]; then # Check if encryption option active.

935 if checkapp age; then # Check that age is available.

             for pubkey in "${recPubKeys[@]}"; do # Validate recipient pubkey strings by forming test message

937 vbm "DEBUG:Testing pubkey string:$pubkey";

                 if echo "butts" | age -a -r "$pubkey" 1>/dev/null; then

939 #### Form age recipient string

                     recipients="$recipients""-r '$pubkey' ";

                     vbm "STATUS:Added pubkey for forming age recipient string:""$pubkey";

                     vbm "DEBUG:recipients:""$recipients";

943 #### Add validated pubkey to recPubKeysValid array

                     recPubKeysValid+=("$pubkey") && vbm "DEBUG:recPubkeysValid:pubkey added:$pubkey";

945 else

                     yell "ERROR:Exit code ""$?"". Invalid recipient pubkey string. Exiting."; exit 1;

947 fi

948 done

949 vbm "DEBUG:Finished processing recPubKeys array";

950

951 ## Form age command string

             CMD_ENCRYPT="age ""$recipients " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";

             CMD_ENCRYPT_SUFFIX=".age" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";

954 else

             yell "ERROR:Encryption enabled but \"age\" not found. Exiting."; exit 1;

956 fi

957 else

         CMD_ENCRYPT="tee /dev/null " && vbm "CMD_ENCRYPT:$CMD_ENCRYPT";

         CMD_ENCRYPT_SUFFIX="" && vbm "CMD_ENCRYPT_SUFFIX:$CMD_ENCRYPT_SUFFIX";

960 vbm "DEBUG:Encryption not enabled."

961 fi

     if [[ "$OPTION_COMPRESS" = "true" ]]; then # Check if compression option active

         if checkapp gzip; then # Check if gzip available

             CMD_COMPRESS="gzip " && vbm "CMD_COMPRESS:$CMD_COMPRESS";

             CMD_COMPRESS_SUFFIX=".gz" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";

966 else

             yell "ERROR:Compression enabled but \"gzip\" not found. Exiting."; exit 1;

968 fi

969 else

         CMD_COMPRESS="tee /dev/null " && vbm "CMD_COMPRESS:$CMD_COMPRESS";

         CMD_COMPRESS_SUFFIX="" && vbm "CMD_COMPRESS_SUFFIX:$CMD_COMPRESS_SUFFIX";

972 vbm "DEBUG:Compression not enabled.";

973 fi

974

975 # Check that critical apps and dirs are available, displag missing ones.

     if ! checkapp gpspipe tar && ! checkdir "$DIR_OUT" "/dev/shm"; then

977 yell "ERROR:Critical components missing.";

         displayMissing; yell "Exiting."; exit 1; fi

979

980 # Set script lifespan

     setScriptTTL "$SCRIPT_TTL"; # seconds until next new SCRIPT_TTL (ex: "day" or "hour")

982

983 # File name substring: encoded bufferTTL

     bufferTTL_STR="$(timeDuration $BUFFER_TTL)";

985

986 # Init temp working dir

     try mkdir "$DIR_TMP" && vbm "DEBUG:Working dir creatd at:$DIR_TMP";

988

989 # Initialize 'tar' archive

990 ## Define output tar path (note: each day gets *one* tar file (Ex: "20200731..hostname_location.[.gpx.gz].tar"))

     PATHOUT_TAR="$DIR_OUT"/"$(dateShort)".."$SCRIPT_HOSTNAME""_location""$CMD_COMPRESS_SUFFIX""$CMD_ENCRYPT_SUFFIX".tar && \

992 vbm "STATUS:Set PATHOUT_TAR to:$PATHOUT_TAR";

993 ## Check that PATHOUT_TAR is a tar. Rename old and create empty one otherwise.

     checkMakeTar "$PATHOUT_TAR" && vbm "DEBUG:Confirmed or Created to be a tar:$PATHOUT_TAR";

995 ## Append VERSION file to PATHOUT_TAR

996 magicWriteVersion;

997

998 # Define GPS conversion commands

     CMD_CONV_NMEA="tee /dev/null " && vbm "STATUS:Set CMD_CONV_NMEA to:$CMD_CONV_NMEA"; # tee as passthrough

     CMD_CONV_GPX="gpsbabel -i nmea -f - -o gpx -F - " && vbm "STATUS:Set CMD_CONV_GPX to:$CMD_CONV_GPX"; # convert NMEA to GPX

     CMD_CONV_KML="gpsbabel -i nmea -f - -o kml -F - " && vbm "STATUS:Set CMD_CONV_KML to:$CMD_CONV_KML"; # convert NMEA to KML

1002

1003 # MAIN LOOP:Record gps data until script lifespan ends

     while [[ "$SECONDS" -lt "$scriptTTL" ]]; do

1005 magicGatherWriteBuffer &

         sleep "$BUFFER_TTL";

1007 done

1008

1009 # Cleanup

1010 ## Remove DIR_TMP

     try rm -r "$DIR_TMP";

1012

1013 vbm "STATUS:Main function finished.";

1014 } # Main function.

1015 #===END Declare local script functions===

1016 #==END Define script parameters==

1017

1018

1019 #==BEGIN Perform work and exit==

1020 main "$@" # Run main function.

1021 exit 0;

1022 #==END Perform work and exit==