hrx

#!/bin/sh
set -eu
case $1 in -x) set -x; shift; esac

# Warning: problematic for binary files,
# shell scripts can not have null char $'\0' in vairables

o=${0##*["${PATHSEP:-/}"]}

log() {
	printf %s\\n >&2 "$o: $1"
}
die() {
	log "$1"
	exit "${2-2}"
}


case $# in 0) die "use --help for usage"; esac


case $1 in --help)
printf %s\\n \
"Usage: $o c|x|t [-f HRXFILE] [-b BOUNDARY] [OPTION]... [FILE]..." \
"" \
"Create, extract, or list files from a hrx file" \
"" \
"(soon                         )	c	Create" \
"(ok, bugs:eof-nl,mparents     )	x	Extract" \
"(in progress - mostly done    )	t	List" \
"(ok                           )	-f FILE	Name of HRXFILE ('-' for stdin/out)" \
"(consider                     )	-C DIR	Change to DIR before operation" \
"(soon                         )	-v	Verbose" \
"(soon                         )	-O	Extract to stdout" \
"(consider extension           )	-m	Don't restore mtime" \
"(consider extension           )	-o	Don't restore user:group" \
"(consider/soon exists check   )	-k	Don't replace existing files" \
"(won't add                    )	-Z	(De)compress using compress" \
"(won't add                    )	-z	(De)compress using gzip" \
"(won't add                    )	-J	(De)compress using xz" \
"(won't add                    )	-j	(De)compress using bzip2" \
"(won't add                    )	--lzma	(De)compress using lzma" \
"(won't add/consider           )	-a	(De)compress based on extension" \
"(consider extension           )	-h	Follow symlinks    ( consider extension to hrx -> .hrx+unix whene boundary have permissions and allows symlinks )" \
"(consider glob                )	-T FILE	File with names to include" \
"(consider glob                )	-X FILE	File with glob patterns to exclude" \
"(consider glob                )	--exclude PATTERN	Glob pattern to exclude" \
"(consider/soon exists check   )	--overwrite		Replace existing files" \
"(nothing done                 )	--strip-components NUM	NUM of leading components to strip" \
"(nothing done                 )	--no-recursion		Don't descend in directories" \
"(consider extension           )	--numeric-owner		Use numeric user:group" \
"(consider extension           )	--no-same-permissions	Don't restore access permissions" \
"" \
"GNU tar:" \
"(consider/soon exists check   )	--skip-old-files	don't replace existing files when extracting, silently skip over them" \
;
exit; esac

# (todo) errors to consider:
#tar: This does not look like a tar archive
#tar: adoestna: Not found in archive
#tar: Exiting with failure status due to previous errors


case $1 in [!-]*)  set -- -"$@"; esac # first argument is always an option

OPTIND=1;
unset opt_c opt_x opt_t opt_f opt_f_val opt_b opt_b_val
while getopts cxtvOf:b: i; do
	case $i in
		c) opt_c='';;
		x) opt_x='';;
		t) opt_t='';;
		v) opt_v='';;
		O) opt_O='';;
		f) opt_f=''; opt_f_val=$OPTARG;;
		b) opt_b=''; opt_b_val=$OPTARG;;
		?) exit;
	esac
done
shift $((OPTIND - 1))



case ${opt_c+c}${opt_x+x}${opt_t+t} in
	'')  die "specify one of -c, -x or -t option";;
	??*) die "specify only one of -c, -x or -t option";;
esac


case ${opt_b+b} in b)
	case $opt_b_val in
		0|'<>'|'') die "0 boundary '<>' is not allowed";;
		"${opt_b_val#*[!0-9]*}") # when it is a num (note: including 0, and not including negative nums in -*)
			_i=$opt_b_val
			boundary='<'
			while case $_i in *[!0-9]*) log "ERROR 5"; false;; 0) false; esac; do
				boundary=$boundary'='
				: $(( _i = _i - 1 )) || exit
			done
			boundary=$boundary'>'
			;;
		'<'*'='*'>') # bad: lazy check
			boundary=$opt_b_val
			;;
		=|=*=) # bad: lazy check
			boundary='<'$opt_b_val'>'
			;;
	esac
esac

# path-character ::= any character other than
# U+0000 through U+001F
#  00 	NUL #  no need to/can't detect, shell scripts does no support it. native shell eror may be printed (if the shell has implemented it)
#  01 	SOH
#  02 	STX
#  03 	ETX
#  04 	EOT
#  05 	ENQ
#  06 	ACK
#  07 	BEL
#  08 	BS
#  09 	TAB
#  0A 	LF
#  0B 	VT
#  0C 	FF
#  0D 	CR
#  0E 	SO
#  0F 	SI
#  10 	DLE
#  11 	DC1
#  12 	DC2
#  13 	DC3
#  14 	DC4
#  15 	NAK
#  16 	SYN
#  17 	ETB
#  18 	CAN
#  19 	EM
#  1A 	SUB
#  1B 	ESC
#  1C 	FS
#  1D 	GS
#  1E 	RS
#  1F 	US
# ,
# DEL U+007F DELETE,
# '/' U+002F SOLIDUS, # used as path separator (wont detect)
# ':' U+003A COLON or
# '\' U+005C REVERSE SOLIDUS
path_chars_blacklist=$(
printf \
\\x01\
\\x02\
\\x03\
\\x04\
\\x05\
\\x06\
\\x07\
\\x08\
\\x09\
\\x0A\
\\x0B\
\\x0C\
\\x0D\
\\x0E\
\\x0F\
\\x10\
\\x11\
\\x12\
\\x13\
\\x14\
\\x15\
\\x16\
\\x17\
\\x18\
\\x19\
\\x1A\
\\x1B\
\\x1C\
\\x1D\
\\x1E\
\\x1F\
\
\\x3A\
\\x5C\
;
)


# fns:


# comment:
case ${opt_v+v} in # consider: using option to get only the comments?
v)
	hrx_parse_begin_comment() { _hrx_parse__begin_matched=''; }
	hrx_parse_comment() { printf %s\\n >&2 "comment: $line"; }
	hrx_parse_end_comment() { :; }
	;;
*)
	hrx_parse_begin_comment() {
		:
		###_hrx_parse__begin_matched=''
	}
	###hrx_parse_comment() { :; }
	###hrx_parse_end_comment() { :; }
esac


# invalid:
hrx_parse_begin_x_invalid() {
	count_invalid=$(( invalid + 1 ))
	###_hrx_parse__begin_matched
}
###hrx_parse_x_invalid() { :; }
###hrx_parse_end_x_invalid() { :; }


# unused ends:
###hrx_parse_end_dir() { :; }
hrx_parse_end_file() { :; } # TODO: WHEN '-c' opt specified CREASING ? DOES THIS LINE HAVE TO BE HERE???


case ${opt_c+c}${opt_x+x}${opt_t+t} in
x|t)
	# fns for parsing:

	in_line() {
		printf %s "${1-, }in line $line_num: '$line'"
	}

	parsing_err() {
		die "parsing error($1)$(in_line)" "${2-4}"
	}
	error() {
		die "ERROR $1$(in_line)" "${2-4}"
	}

	hrx_is_boundary() {
		case $1 in
			"$boundary"|"$boundary "*) return 0;;
			*)                         return 1;;
		esac
	}


	hrx_parse_boundary_fn1() { # might be needed when `-c` option  to auto parese boundary in all files 
		case $1 in
			\<=*\>*) ;;
			*) return 1;;
		esac

		_i=${line#?}
		_i=${_i%%\>*}

		case ${_i} in
			''|*[!=]*) return 1;;
			*) boundary=${_i%%\>*}\>
		esac

		_i=\<${_i}\>
		case $line in
			"$_i"*) boundary=$_i;; # found first boundary
			*) error 1;;
		esac
	}

	hrx_parse_boundary_fn2() {
		case ${boundary+b} in
		b) # note: if boundary var present, then we find the first line that matches that boundary (skiping start)
			#hrx_parse_boundary_fn1
			while :; do
				case $line in "$boundary "*) break; esac
				#log "ignoring begining line ${line_num}: ${line}"
				read -r line || break # seems like empty archive
			done
			;;
		*)
			hrx_parse_boundary_fn1 "$line" || { # sets 'boundary'
				die "mallformed entry, can not parse boundary$(in_line)"
			}
			;;
		esac
	}


esac

case ${opt_c+c}${opt_x+x}${opt_t+t} in
x)

	_match_path() {
		case $# in
		0)
			return 1
			;;
		*)
			for _i; do
				case $path in "$_i"|"$_i"/*) # TODO:! args might be in '*/' todo: iterate over args and trim all end '/'
					return 1
				esac
			done
		esac
		return 0
	}



	# -O option in tar combined with -t or with -xv seems to behave the same way, also filenames got printed to stdout after file content
	# (I don't see a point of copying this behaviour, this implementation will print the file to begining of the entry - before the file content)...

	# `entry_type` should always be in (dir|file|comment|x_invalid)

	# -t & -x dir:
	hrx_parse_begin_dir() {
		count_explisit_dirs=$(( explisit_dirs + 1 ))
		if _match_path "$@"; then
			case ${opt_t+t}${opt_v+v} in ?*)
				printf %s\\n "$path"
			esac
			case ${opt_O+O}:${opt_x+x} in :x)
				mkdir -p -- "$path" || {
					count_err=$(( count_err + 1 ))
					log "note: failed to create dir: '$path'"
				}
			esac
		fi
		# case ${opt_v+v} in v) # TODO
		# log "todo: what sohuld -tv options do?"
		# esac

		###_hrx_parse__begin_matched=''
	}
	###hrx_parse_dir() {
	###	case $line in ?*)
	###		log "todo: dir body should not have content? or allow empty lines? (path=$path$(in_line))" # TODO
	###	esac
	###}

	# -t & -x file:
	hrx_parse_begin_file() {
		unset _hrx_parse__begin_matched

		if ! _match_path "$@"; then
			return
		fi

		case ${opt_t+t}${opt_v+v} in ?*)
			printf %s\\n "$path"
		esac
		case ${opt_O+O}:${opt_x+x} in :x)
			path_basedir=${path%/[!/]*}
			case $path_basedir in ''|"$path") ;; *)
				if [ ! -d "$path_basedir" ]; then
					mkdir -p -- "$path_basedir" || {
						log "failed to create path_basedir directory (expect create/reset file content to fail): '$path_basedir', for file: $path"
					}
				fi
			esac
			##unset path_basedir
			:> "$path" || { # (unshure comment) consider stopping hrx_parse_file
				count_err=$(( count_err + 1 ))
				log "failed to create/reset content of file: $path"
				return
			}
		esac

		_hrx_parse__begin_matched=''
		count_files=$(( files + 1 ))
		_hrx_parse_file__write_err_lines=0
	}
	hrx_parse_file() {

		case ${opt_O+O}:${opt_x+x} in
		O:*)
			printf %s\\n "$line"
			;;
		:x)
			printf %s\\n "$line" >> "$path" || { # note: $line var can not have null char $'\0'
				# do not spam for every line
				_hrx_parse_file__write_err_lines=$(( _hrx_parse_file__write_err_lines + 1 ))
			}
			;;
		esac
	}
	hrx_parse_end_file() {

		case $_hrx_parse_file__write_err_lines in 0);; *)
			count_err=$(( count_err + 1 ))
			log "failed to write $_hrx_parse_file__write_err_lines lines to file: $path"
		esac
	}




	hrx_get_entry_type() {

		# first time needs to get boundary, after this redefine fn
		hrx_parse_boundary_fn2

		hrx_get_entry_type() {

			unset path
			case $line in
				"$boundary") entry_type=comment;;
				"$boundary "*/) entry_type=dir;;
				"$boundary "?*) entry_type=file;;
				"$boundary ")
					log "warning: comment with space before new line / seems like empty path? $(in_line '')"
					entry_type=comment
				;;
				*) parsing_err 2 1;;
			esac

			case $entry_type in dir|file) # parsing+validate var `path`
				path=${line#"$boundary "}
				case $line in "$boundary $path") ;; *)
					error 3
				esac

				while case $path in /*) ;; *) false; esac; do
					log "note: triming absolute path$(in_line)"
					path=${path#/}
				done

				case $path in
				'../'*|*'/../'*|*'/..'|'..')
					log "relative paths contaning '..' are not allowed, path='$path', SKIPING"
					entry_type=x_invalid
					;;

				'') # expected when trimming '/'|'///'
					log "empty path, path='$path'$(in_line)"
					entry_type=x_invalid
					;;
				*["$path_chars_blacklist"]*)
					log "note: found disawolled char, path='$path'. (allowing it anyway)"
					;;
				esac

			esac

			case $entry_type in
				dir|file) _needs_args='';;
				comment|x_invalid) unset _needs_args;;
				*) unset _needs_args;;
			esac

		}
		hrx_get_entry_type "$@"
	}

	hrx_extract() {
		line_num=0
		unset ended
		unset _needs_args # slightly improve performance for large amount of arguments
		while read -r line; do
			line_num=$(( line_num + 1 ))

			case ${entry_type-} in '') ;; *)
				! hrx_is_boundary "$line" || {
					${_hrx_parse__begin_matched+hrx_parse_end_"$entry_type"}
					entry_type=''
				}
			esac

			
			case ${entry_type-} in '')
				hrx_get_entry_type "$line"
				unset _hrx_parse__begin_matched
				hrx_parse_begin_"$entry_type" ${_needs_args+"$@"}
				continue
			esac

			# NOTE: `entry_type` should always be in (dir|file|comment|x_invalid)
			hrx_parse_"$entry_type"

		done

		ended=''

		case ${entry_type-} in
			'')
				if hrx_get_entry_type "$line"; then
					unset _hrx_parse__begin_matched
					hrx_parse_begin_"$entry_type" ${_needs_args+"$@"}
					${_hrx_parse__begin_matched+hrx_parse_end_"$entry_type"}
				else
					log "empty archive"
				fi
				
				return
		esac

		${_hrx_parse__begin_matched+hrx_parse_end_"$entry_type"}
	}


	;;
c)
	# fns for creating
	# consider in thsi is decided: comments wont be allowed
	# if no boundary option provided, then will scan all files for conflicting boundary-like lines

	# note, same as tar behaiviour -O option is ignore here


	# specs say:
	# > When a HRX file is extracted, the extraction process should (by default) create a directory named after the HRX file, with the extension ".hrx" removed
	# however this implementation of hrx is sticking to what `tar` command does:
	# extract files as path in PWD
	# (todo) if -C opt specified changes PWD to that dir



	case ${opt_b+b} in '')
		# for now require to be provided
		#die "(todo add auto boundary chooser) for now --boundary option is required when creating archive"
		# die "(todo add auto boundary chooser) for now -b (boundary) option is required when creating archive"

		# default boundary as specs:
		boundary='<===>'
	esac

	# src: /^/\ https://github.com/denisde4ev/sh/blob/56e23b438756f3fc70b5bda83e9423224df640b7/cat.sh
	cat() { # because why not
		case $# in 0) ;; *)
			case $1 in --) shift; esac
			case $1 in -) ;; *)
				cat < "$1"
				return
			esac
		esac

		while read -r line; do # note: $line var can not have null char $'\0'
			printf %s\\n "$line"
		done
		printf %s "$line"
	}

	hrx_create() {
		for file; do
			file_type=''
			if
			[ -L "$file" ]; then file_type=link; elif
			[ -f "$file" ]; then file_type=file; elif
			[ -d "$file" ]; then file_type=dir; elif
			[ -e "$file" ]; then file_type=exists; elif
			true; then :; fi

			# NOTE: here unexplicitly calling fn-s `hrx_create_link|hrx_create_file|hrx_create_dir|hrx_create_exists`
			hrx_create_"$file_type"1 "$file"
		done
	}

	hrx_create_link1() {
		printf %s\\n "$boundary $1 (Symlink)"
		readlink -- "$1"
	}

	## todo: something here # case ${opt_1+1} in
		
	hrx_create_dir1() {
		printf %s\\n "$boundary $1/"

		# recurse inside of directory here:
		set -- "$1"/*
		if [ -e "$1" ] || [ -L "$1" ]; then
			hrx_create "$@"
		#else
		#	set --
		fi
	}
	hrx_create_exists1() {
		die "unrecognized file type for: file='${1}'" # TODO:! test this / ask ai what could happen
	}
	hrx_create_file1() {
		case "$1" in "${opt_f_val:?}") log "warning: skiping archive output itself: file='$1'"; return; esac

		printf %s\\n "$boundary $1"
		cat "$1"
	}

	;;
t)
#example:
#F 2
#L bb -> aa
#D dir/
#F dir/123
	hrx_test() {
		#case ${1+x} in x)
		case $# in [1-9]*) die "not expected to get extra arguments: \$1='$1'";
# todo
esac
		echo NOT DONE! >&2; exit 123;
		while IFS='' read -r line; do
			exit 123
		done < "${opt_f_val:?}"
	}
	;;
esac




IFS='' # do not trim `read -r line`


case ${opt_b+b} in
	b) boundary=$opt_b_val;;
	*) unset boundary;;
esac

count_files=''
count_explisit_dirs=''
count_invalid=''
count_err=0
main() {
	unset -f main

	case ${opt_c+c}${opt_x+x}${opt_t+t} in
	t)
		: log "NOTE: 'hrx -t' is in progress"

		hrx_test "$@"
		;;
	x)
		log 'hrx -x : NOT TESTED'
		hrx_extract "$@"
		;;
	c)
		[ ! -e "${opt_f_val:?}" ] || die "arhive file already exists" # TODO: consider further implement appending to file
		hrx_create "$@"  >> "${opt_f_val:?}"
		;;
	esac
}

case ${opt_f_val-} in -) unset opt_f; esac # if its '-' then same as missing -> read from stdin
# and do not add test for if the stdin is the tty, hrx is human readable and *typeable*

case ${opt_f+f} in
	f) main "$@" < "$opt_f_val";;
	*) main "$@";;
esac