mirror of
https://github.com/RasppleII/a2cloud.git
synced 2025-04-03 15:29:30 +00:00
Add cppo to archive
This commit is contained in:
T. Joseph Carter
parent
a47744dd07
commit
845425a3c5
761
docs/ivanx/setup/cppo-bash.txt
Normal file
761
docs/ivanx/setup/cppo-bash.txt
Normal file
@ -0,0 +1,761 @@
|
||||
#!/bin/bash
|
||||
|
||||
# need to test:
|
||||
# does both -e and -ad work as expected? what if you do both?
|
||||
|
||||
|
||||
#--ID-bashbyter routines
|
||||
|
||||
decToHex () {
|
||||
# converts single-byte decimal value to hexadecimal equivalent
|
||||
# arg: decimal value from 0-255
|
||||
# out: two-digit hex value from 00-FF
|
||||
#exit: 8=extraneous arg, 11=missing arg, 21=invalid arg
|
||||
[[ $1 ]] || return 11
|
||||
[[ $2 ]] && return 8
|
||||
[[ ( $(printf %d "$1" 2> /dev/null) == $1 ) \
|
||||
&& ( $1 -ge 0 ) && ( $1 -le 255 ) ]] || return 21
|
||||
# args are valid
|
||||
printf %02X "$1"
|
||||
}
|
||||
|
||||
hexToDec () {
|
||||
# converts single-byte hexadecimal value to decimal equivalent
|
||||
# arg: two-digit hex value from 00-FF
|
||||
# out: decimal value
|
||||
#exit: 8=extraneous arg, 11=missing arg, 21=invalid arg
|
||||
[[ $1 ]] || return 11
|
||||
[[ $2 ]] && return 8
|
||||
[[ ${#1} -eq 2 ]] || return 21
|
||||
[[ $(printf %02X "0x$1" 2> /dev/null) == \
|
||||
$(echo -n "$1" | tr [a-z] [A-Z]) ]] || return 21
|
||||
# args are valid
|
||||
printf %d "0x$1"
|
||||
}
|
||||
|
||||
hexToBin () {
|
||||
# converts single-byte hexadecimal value to binary string
|
||||
# arg: two-digit hex value from 00-FF
|
||||
# out: binary string value
|
||||
#exit: 8=extraneous arg, 11=missing arg, 21=invalid arg
|
||||
[[ $1 ]] || return 11
|
||||
[[ $2 ]] && return 8
|
||||
[[ ${#1} -eq 2 ]] || return 21
|
||||
[[ $(printf %02X "0x$1" 2> /dev/null) == \
|
||||
$(echo -n "$1" | tr [a-z] [A-Z]) ]] || return 21
|
||||
# args are valid
|
||||
for n in 0 1; do
|
||||
if [[ ${1:n:1} == "0" ]]; then b="0000"
|
||||
elif [[ ${1:n:1} == "1" ]]; then b="0001"
|
||||
elif [[ ${1:n:1} == "2" ]]; then b="0010"
|
||||
elif [[ ${1:n:1} == "3" ]]; then b="0011"
|
||||
elif [[ ${1:n:1} == "4" ]]; then b="0100"
|
||||
elif [[ ${1:n:1} == "5" ]]; then b="0101"
|
||||
elif [[ ${1:n:1} == "6" ]]; then b="0110"
|
||||
elif [[ ${1:n:1} == "7" ]]; then b="0111"
|
||||
elif [[ ${1:n:1} == "8" ]]; then b="1000"
|
||||
elif [[ ${1:n:1} == "9" ]]; then b="1001"
|
||||
elif [[ ${1:n:1} == "A" ]]; then b="1010"
|
||||
elif [[ ${1:n:1} == "B" ]]; then b="1011"
|
||||
elif [[ ${1:n:1} == "C" ]]; then b="1100"
|
||||
elif [[ ${1:n:1} == "D" ]]; then b="1101"
|
||||
elif [[ ${1:n:1} == "E" ]]; then b="1110"
|
||||
elif [[ ${1:n:1} == "F" ]]; then b="1111"
|
||||
fi
|
||||
echo -n $b
|
||||
done
|
||||
}
|
||||
|
||||
binToDec () {
|
||||
# converts single-byte binary string (8 bits) value to decimal
|
||||
# warning: no error checking
|
||||
# arg: binary string up to 8 bits
|
||||
# out: decimal value
|
||||
dec=0
|
||||
bits=$1
|
||||
while (( ${#bits} < 8 )); do
|
||||
bits="0$bits"
|
||||
done
|
||||
for n in {0..7}; do
|
||||
(( dec+=( ${bits:$n:1} * ( 2**(7-$n) ) ) ))
|
||||
done
|
||||
echo -n $dec
|
||||
}
|
||||
|
||||
binToHex () {
|
||||
# converts single-byte binary string (8 bits) value to hex
|
||||
# warning: no error checking
|
||||
# arg: binary string up to 8 bits
|
||||
# out: hex value
|
||||
echo $(decToHex $(binToDec $1))
|
||||
}
|
||||
|
||||
charToDec () {
|
||||
# converts single character to corresponding decimal value
|
||||
# stdin OR arg: one character
|
||||
# [arg overrides stdin; stdin is required for NUL (0) or LF (0x0A)]
|
||||
# out: decimal value from 0-255
|
||||
#exit: 8=extraneous arg, 9=invalid stdin,
|
||||
# 11=missing stdin/arg, 21=invalid arg
|
||||
[[ ( ! -t 0 ) && $1 ]] && { cat > /dev/null; return 8; }
|
||||
[[ ( -t 0 ) ]] && { [[ $2 ]] && return 8; [[ $1 ]] || return 11; }
|
||||
# arg/stdin is potentially valid (additional check below)
|
||||
charX="$1X"; [[ $1 ]] || charX="$(cat; echo -n 'X';)"
|
||||
[[ ${#charX} -le 2 ]] || return $(( $([[ $1 ]]; echo $?) ? 9 : 21 ))
|
||||
# above line verifies that arg/stdin is valid
|
||||
[[ ${#charX} -ne 2 ]] && { echo -n 0; return 0; }
|
||||
echo -n "${charX:0:1}" | od -t u1 | \
|
||||
head -1 | sed 's/[0\ ]*//' | tr -d ' \n'
|
||||
}
|
||||
|
||||
charToHex () {
|
||||
# converts single character to corresponding hexadecimal value
|
||||
# stdin OR arg: one character
|
||||
# [arg overrides stdin; stdin is required for NUL (0) or LF (0x0A)]
|
||||
# out: decimal value from 0-255
|
||||
#exit: 8=extraneous arg, 9=invalid stdin,
|
||||
# 11=missing stdin/arg, 21=invalid arg
|
||||
[[ ( ! -t 0 ) && $1 ]] && { cat > /dev/null; return 8; }
|
||||
[[ ( -t 0 ) ]] && { [[ $2 ]] && return 8; [[ $1 ]] || return 11; }
|
||||
# arg/stdin is potentially valid (additional check below)
|
||||
charX="$1X"; [[ $1 ]] || charX="$(cat; echo -n 'X';)"
|
||||
[[ ${#charX} -le 2 ]] || return $(( $([[ $1 ]]; echo $?) ? 9 : 21 ))
|
||||
# above line verifies that stdin/arg is valid
|
||||
[[ ${#charX} -ne 2 ]] && { echo -n "00"; return 0; }
|
||||
printf %02X $(echo -n "${charX:0:1}" | od -t u1 | \
|
||||
head -1 | sed 's/[0\ ]*//' | tr -d ' \n')
|
||||
}
|
||||
|
||||
decToChar () {
|
||||
# converts single-byte decimal value to equivalent character
|
||||
# arg: decimal number from 0-255
|
||||
# out: one character
|
||||
#exit: 8=extraneous arg, 11=missing arg, 21=invalid arg
|
||||
[[ $1 ]] || return 11
|
||||
[[ $2 ]] && return 8
|
||||
[[ ( $(printf %d "$1" 2> /dev/null ) == $1 ) \
|
||||
&& ( $1 -ge 0 ) && ( $1 -le 255 ) ]] || return 21
|
||||
# args are valid
|
||||
echo -n -e "\x$(printf %02X "$1")"
|
||||
}
|
||||
|
||||
hexToChar () {
|
||||
# converts single-byte hexadecimal value to corresponding character
|
||||
# arg: two-digit hexadecimal number from 00-FF
|
||||
# out: one character
|
||||
#exit: 8=extraneous arg, 11=missing arg, 21=invalid arg
|
||||
[[ $1 ]] || return 11
|
||||
[[ $2 ]] && return 8
|
||||
[[ ${#1} -eq 2 ]] || return 21
|
||||
[[ $(printf %02X "0x$1" 2> /dev/null) == \
|
||||
$(echo -n "$1" | tr [a-z] [A-Z]) ]] || return 21
|
||||
# args are valid
|
||||
echo -n -e "\x$1"
|
||||
}
|
||||
|
||||
readchars () {
|
||||
# read one or more characters from a file
|
||||
# arg1: filename
|
||||
# arg2: (optional) offset (# of bytes to skip before reading)
|
||||
# arg3: (optional) # of chars to read (default is until end of file)
|
||||
# out: sequence of characters
|
||||
# exit: 8=extraneous arg, 11=missing arg1,
|
||||
# 21=invalid arg1, 22=invalid arg2, 23=invalid arg3
|
||||
[[ $1 ]] || return 11
|
||||
[[ $4 ]] && return 8
|
||||
[[ -f $1 ]] || return 21
|
||||
[[ $2 ]] && { [[ ( $(printf %d "$2" 2> /dev/null) == $2 ) \
|
||||
&& ( $2 -ge 0 ) ]] || return 22; }
|
||||
[[ $3 ]] && { [[ ( $(printf %d "$3" 2> /dev/null) == $3 ) \
|
||||
&& ( $3 -ge 0 ) ]] || return 23; }
|
||||
# args are valid
|
||||
dd if="$1" bs=1 skip=$(($2)) $([[ $3 ]] && echo -n "count=$3") \
|
||||
2> /dev/null
|
||||
}
|
||||
|
||||
readcharDec () {
|
||||
# read one character from file & convert to equivalent decimal value
|
||||
# arg1: filename
|
||||
# arg2: (optional) offset (# of bytes to skip before reading)
|
||||
# out: decimal value from 0-255
|
||||
# exit: 8=extraneous arg, 11=missing arg1,
|
||||
# 21=invalid arg1, 22=invalid arg2
|
||||
[[ $1 ]] || return 11
|
||||
[[ $3 ]] && return 8
|
||||
[[ -f $1 ]] || return 21
|
||||
[[ $2 ]] && { [[ ( $(printf %d "$2" 2> /dev/null) == $2 ) \
|
||||
&& ( $2 -ge 0 ) ]] || return 22; }
|
||||
# args are valid
|
||||
charX="$(dd if="$1" bs=1 skip=$(($2)) \
|
||||
count=1 2> /dev/null; echo -n X)"
|
||||
[[ ${#charX} -gt 1 ]] || { echo -n 0; return 0; }
|
||||
echo -n "${charX:0:1}" | od -t u1 | \
|
||||
head -1 | sed 's/[0\ ]*//' | tr -d ' \n'
|
||||
}
|
||||
|
||||
readcharHex () {
|
||||
# read one character from file & convert to corresponding hex value
|
||||
# arg1: filename
|
||||
# arg2: (optional) offset (# of bytes to skip before reading)
|
||||
# out: two-digit hex value from 00-FF
|
||||
# exit: 8=extraneous arg, 11=missing arg1,
|
||||
# 21=invalid arg1, 22=invalid arg2
|
||||
[[ $1 ]] || return 11
|
||||
[[ $3 ]] && return 8
|
||||
[[ -f $1 ]] || return 21
|
||||
[[ $2 ]] && { [[ ( $(printf %d "$2" 2> /dev/null) == $2 ) \
|
||||
&& ( $2 -ge 0 ) ]] || return 22; }
|
||||
# args are valid
|
||||
charX="$(dd if="$1" bs=1 skip=$(($2)) \
|
||||
count=1 2> /dev/null; echo -n X)"
|
||||
[[ ${#charX} -gt 1 ]] || { echo -n "00"; return 0; }
|
||||
printf %02X $(echo -n "${charX:0:1}" | od -t u1 | \
|
||||
head -1 | sed 's/[0\ ]*//' | tr -d ' \n')
|
||||
}
|
||||
|
||||
### 2-15-11 above tested on OS X and Linux
|
||||
|
||||
writechars () {
|
||||
# write one or more characters (bytes) to file
|
||||
# arg1: filename
|
||||
# arg2: (optional) offset (# of bytes to skip before writing)
|
||||
# arg3 OR stdin: sequence of characters
|
||||
# [stdin required if writing NUL (0) or trailing LF (0x0A) chars]
|
||||
# out: nothing
|
||||
# exit: 8=extraneous arg, 11=missing arg1,
|
||||
# 13=missing stdin/arg3, 22=invalid arg2
|
||||
[[ $1 ]] || { [[ -t 0 ]] || cat > /dev/null; return 11; }
|
||||
[[ $2 ]] && { [[ ( $(printf %d "$2" 2> /dev/null) == $2 ) && \
|
||||
( $2 -ge 0 ) ]] || { [[ -t 0 ]] || cat > /dev/null; return 22; } }
|
||||
[[ ( ! -t 0 ) && $3 ]] && { cat > /dev/null; return 8; }
|
||||
[[ ( -t 0 ) ]] && { [[ $4 ]] && return 8; [[ $3 ]] || return 13; }
|
||||
# args are valid
|
||||
if [[ -t 0 ]]; then
|
||||
echo -n "$3" | \
|
||||
dd of="$1" bs=1 seek=$(($2)) conv=notrunc 2> /dev/null
|
||||
else
|
||||
dd of="$1" bs=1 seek=$(($2)) conv=notrunc 2> /dev/null
|
||||
fi
|
||||
}
|
||||
|
||||
writecharDec () {
|
||||
# write corresponding character of single-byte decimal value into file
|
||||
# arg1: filename
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: decimal number from 0-255
|
||||
# exit: 8=extraneous arg, 11=missing arg1, 12=missing arg2,
|
||||
# 13=missing arg3, 22=invalid arg2, 23=invalid arg3
|
||||
# out: nothing
|
||||
[[ $1 ]] || return 11; [[ $2 ]] || return 12; [[ $3 ]] || return 13
|
||||
[[ $4 ]] && return 8
|
||||
[[ ( $(printf %d "$2" 2> /dev/null) == $2 ) \
|
||||
&& ( $2 -ge 0 ) ]] || return 22
|
||||
[[ ( $(printf %d "$3" 2> /dev/null) == $3 ) \
|
||||
&& ( $3 -ge 0 ) && ( $3 -lt 255 ) ]] || return 23
|
||||
# args are valid
|
||||
echo -n -e "\x$(printf %02X "$3")" | \
|
||||
dd of="$1" bs=1 seek=$(($2)) conv=notrunc 2> /dev/null
|
||||
}
|
||||
|
||||
writecharHex () {
|
||||
# write corresponding character of single-byte hex value into file
|
||||
# arg1: filename
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: two-digit hexadecimal number from 00-FF
|
||||
# out: nothing
|
||||
# exit: 8=extraneous arg, 11=missing arg1, 12=missing arg2,
|
||||
# 13=missing arg3, 22=invalid arg2, 23=invalid arg3
|
||||
[[ $1 ]] || return 11; [[ $2 ]] || return 12; [[ $3 ]] || return 13
|
||||
[[ $4 ]] && return 8
|
||||
[[ ( $(printf %d "$2" 2> /dev/null) == $2 ) \
|
||||
&& ( $2 -ge 0 ) ]] || return 22
|
||||
[[ $(printf %02X "0x$3" 2> /dev/null) == \
|
||||
$(echo -n "$3" | tr [a-z] [A-Z]) ]] || return 23
|
||||
# args are valid
|
||||
echo -n -e "\x$3" | \
|
||||
dd of="$1" bs=1 seek=$2 conv=notrunc 2> /dev/null
|
||||
}
|
||||
|
||||
writecharsHex () {
|
||||
# write corresponding characters of hex values into file
|
||||
# arg1: filename
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: string of two-digit hexadecimal numbers from 00-FF, period delimited (not checked!)
|
||||
# out: nothing
|
||||
# exit: 8=extraneous arg, 11=missing arg1, 12=missing arg2,
|
||||
# 13=missing arg3, 22=invalid arg2, 23=invalid arg3
|
||||
[[ $1 ]] || return 11; [[ $2 ]] || return 12; [[ $3 ]] || return 13
|
||||
[[ $4 ]] && return 8
|
||||
[[ ( $(printf %d "$2" 2> /dev/null) == $2 ) \
|
||||
&& ( $2 -ge 0 ) ]] || return 22
|
||||
p=0
|
||||
offset=$2
|
||||
len=${#3}
|
||||
while (( p < len )); do
|
||||
outByte=${3:$p:2}
|
||||
[[ $(printf %02X "0x$outByte" 2> /dev/null) == \
|
||||
$(echo -n "$outByte" | tr [a-z] [A-Z]) ]] || return 23
|
||||
# args are valid
|
||||
echo -n -e "\x$outByte" | \
|
||||
dd of="$1" bs=1 seek=$offset conv=notrunc 2> /dev/null
|
||||
(( p += 3 ))
|
||||
(( offset++ ))
|
||||
done
|
||||
}
|
||||
|
||||
|
||||
# ---
|
||||
|
||||
pdosDateToUnixDate () {
|
||||
# input: ProDOS date/time bit sequence string in format:
|
||||
# yyyyyyymmmmddddd000hhhhh00mmmmmm
|
||||
# output: seconds since Unix epoch (1-Jan-1970), or current date/time if no ProDOS date
|
||||
year=$(( $(binToDec ${1:0:7}) + 1900 ))
|
||||
(( $year < 1940 )) && (( year+=100 ))
|
||||
month=$(binToDec ${1:7:4})
|
||||
day=$(binToDec ${1:11:5})
|
||||
hour=$(binToDec ${1:19:5})
|
||||
minute=$(binToDec ${1:26:6})
|
||||
date -d "$year-$month-$day $hour:$minute:00" "+%s" 2> /dev/null
|
||||
}
|
||||
|
||||
unixDateToADDate () {
|
||||
# input: seconds since Unix epoch (1-Jan-1970 00:00:00 GMT)
|
||||
# output: seconds since Netatalk epoch (1-Jan-2000 00:00:00 GMT),
|
||||
# in four period-delimited hex bytes (big endian)
|
||||
adDate=$(( $1 - 946684800 ));
|
||||
if (( $adDate < 0 )); then
|
||||
(( adDate+=4294967296 )) # to get negative hex number
|
||||
fi
|
||||
adDateHex=$(printf %08X $adDate)
|
||||
echo "${adDateHex:0:2}.${adDateHex:2:2}.${adDateHex:4:2}.${adDateHex:6:2}"
|
||||
}
|
||||
|
||||
# cppo support routines:
|
||||
# arg1: directory block
|
||||
# arg2: file index (if applicable)
|
||||
# arg3: directory chunk # (if applicable)
|
||||
|
||||
# returns byte position in disk image file
|
||||
getStartPos () {
|
||||
echo $(( ($1 * 512) + (39 * ( ($2 + ($2>11) ) % 13) ) + ( ($2>11) ? 4 : 43) ))
|
||||
}
|
||||
|
||||
getStorageType () {
|
||||
start=$(getStartPos $1 $2)
|
||||
firstByte=$(readcharDec "$image" $start)
|
||||
echo $(($firstByte/16))
|
||||
}
|
||||
|
||||
getFileName () {
|
||||
start=$(getStartPos $1 $2)
|
||||
firstByte=$(readcharDec "$image" $start)
|
||||
entryType=$(($firstByte/16))
|
||||
nameLength=$(($firstByte-$entryType*16))
|
||||
echo $(readchars "$image" $(($start+1)) $nameLength)
|
||||
}
|
||||
|
||||
getFileType () {
|
||||
start=$(getStartPos $1 $2)
|
||||
echo $(readcharHex "$image" $(($start+16)) )
|
||||
}
|
||||
|
||||
getKeyPointer () {
|
||||
start=$(getStartPos $1 $2)
|
||||
echo $(( $(readcharDec "$image" $(($start+17)) ) + \
|
||||
$(readcharDec "$image" $(($start+18)) ) * 256 ))
|
||||
}
|
||||
|
||||
getFileLength () {
|
||||
start=$(getStartPos $1 $2)
|
||||
echo $(( $(readcharDec "$image" $(($start+21)) ) + \
|
||||
$(readcharDec "$image" $(($start + 22)) ) * 256 + \
|
||||
$(readcharDec "$image" $(($start + 23)) ) * 65536 ))
|
||||
}
|
||||
|
||||
getAuxType () {
|
||||
start=$(getStartPos $1 $2)
|
||||
echo $(readcharHex "$image" $(($start+32)) ).$(readcharHex "$image" $(($start+31)) )
|
||||
}
|
||||
|
||||
getCreationDate () {
|
||||
#outputs prodos creation date/time as Unix time (seconds since Jan 1 1970 GMT)
|
||||
#or "NONE" if there is none
|
||||
start=$(getStartPos $1 $2)
|
||||
pdosDate=\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+25)) ) )\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+24)) ) )\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+27)) ) )\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+26)) ) )
|
||||
pdosDateToUnixDate $pdosDate || echo "NONE"
|
||||
}
|
||||
|
||||
getModifiedDate () {
|
||||
#outputs prodos modified date/time as Unix time (seconds since Jan 1 1970 GMT)
|
||||
start=$(getStartPos $1 $2)
|
||||
pdosDate=\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+34)) ) )\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+33)) ) )\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+36)) ) )\
|
||||
$( hexToBin $(readcharHex "$image" $(($start+35)) ) )
|
||||
pdosDateToUnixDate $pdosDate || echo "NONE"
|
||||
}
|
||||
|
||||
#isLocked () {
|
||||
# #returns 1 (meaning locked) if bit 7, 6, or 1 are clear; otherwise returns 0
|
||||
# start=$(getStartPos $1 $2)
|
||||
# access=$( $hexToBin $(readcharHex "$image" $(($start+30)) ) )
|
||||
# if [[ ${access:0:1} != "1" || ${access:1:1} != "1" || ${access:7:1} != "1" ]]; then
|
||||
# echo 1
|
||||
# else
|
||||
# echo 0
|
||||
# fi
|
||||
#}
|
||||
|
||||
getVolumeName () {
|
||||
echo $(getWorkingDirName 2)
|
||||
}
|
||||
|
||||
getWorkingDirName () {
|
||||
start=$(( $1 * 512 ))
|
||||
firstByte=$(readcharDec "$image" $(($start+4)) )
|
||||
entryType=$(($firstByte/16))
|
||||
nameLength=$(($firstByte-$entryType*16))
|
||||
echo $(readchars "$image" $(($start+5)) $nameLength)
|
||||
}
|
||||
|
||||
getDirEntryCount () {
|
||||
start=$(( $1 * 512 ))
|
||||
echo $(( $(readcharDec "$image" $(($start+37)) ) + \
|
||||
$(readcharDec "$image" $(($start+38)) ) * 256 ))
|
||||
}
|
||||
|
||||
getDirNextChunkPointer () {
|
||||
start=$(( $1 * 512 ))
|
||||
echo $(( $(readcharDec "$image" $(($start+2)) ) + \
|
||||
$(readcharDec "$image" $(($start+3)) ) * 256 ))
|
||||
}
|
||||
|
||||
# -- script begins in earnest here
|
||||
|
||||
copyFile () {
|
||||
activeFileBytesCopied=0
|
||||
storageType=$(getStorageType $1 $2)
|
||||
keyPointer=$(getKeyPointer $1 $2)
|
||||
fileLen=$(getFileLength $1 $2)
|
||||
if (( $storageType == 1 )); then #seedling
|
||||
copyBlock $keyPointer $fileLen
|
||||
elif (( $storageType == 2 )); then #sapling
|
||||
processIndexBlock $keyPointer
|
||||
elif (( $storageType == 3 )); then #tree
|
||||
processMasterIndexBlock $keyPointer
|
||||
elif (( $storageType == 5)); then #forked fileLen
|
||||
processForkedFile $keyPointer
|
||||
fi
|
||||
}
|
||||
|
||||
copyBlock () {
|
||||
#arg1: block to copy
|
||||
#arg2: bytes to write (should be 512, unless final block with less than 512 bytes)
|
||||
#echo $1 $2 $activeFileBytesCopied
|
||||
(( $1 == 0 )) && blockSource=/dev/zero || blockSource="$image"
|
||||
if (( $resourceFork > 0 )); then
|
||||
[[ $AD ]] && dd if="$blockSource" of="$ADdir/$targetName" bs=1 count=$2 skip=$(($1*512)) seek=$(($activeFileBytesCopied + 741)) 2> /dev/null
|
||||
[[ $EX ]] && dd if="$blockSource" of="$targetDir/${eTargetName}r" bs=1 count=$2 skip=$(($1*512)) seek=$activeFileBytesCopied 2> /dev/null
|
||||
else
|
||||
dd if="$blockSource" of="$targetDir/$targetName" bs=1 count=$2 skip=$(($1*512)) seek="$activeFileBytesCopied" 2> /dev/null
|
||||
fi
|
||||
activeFileBytesCopied=$(( $activeFileBytesCopied + $2 ))
|
||||
}
|
||||
|
||||
processDir () {
|
||||
# arg1: dirBlock
|
||||
# arg2/3/4/5: for non-key chunks: entryCount, entry#,
|
||||
# workingDirName, processedEntryCount
|
||||
|
||||
local entryCount
|
||||
local e
|
||||
local pe
|
||||
local workingDirName
|
||||
|
||||
if [[ $2 ]]; then
|
||||
entryCount=$2
|
||||
e=$3
|
||||
workingDirName=$4
|
||||
pe=$5
|
||||
else
|
||||
e=0
|
||||
pe=0
|
||||
entryCount=$(getDirEntryCount $1)
|
||||
workingDirName=$(getWorkingDirName $1)
|
||||
DIRPATH="$DIRPATH/$workingDirName"
|
||||
if [[ $PDOSPATH_INDEX ]]; then
|
||||
if (( $PDOSPATH_INDEX == 1 )); then
|
||||
if [[ "/$PDOSPATH_SEGMENT" != "$DIRPATH" ]]; then
|
||||
echo "ProDOS volume name does not match disk image."
|
||||
exit 2
|
||||
else
|
||||
(( PDOSPATH_INDEX++ ))
|
||||
PDOSPATH_SEGMENT=${PDOSPATH[PDOSPATH_INDEX]}
|
||||
fi
|
||||
fi
|
||||
else
|
||||
echo $DIRPATH
|
||||
fi
|
||||
fi
|
||||
while (( $pe < $entryCount )); do
|
||||
if (( $(getStorageType $1 $e) > 0 )); then
|
||||
processEntry $1 $e
|
||||
(( pe++ ))
|
||||
fi
|
||||
(( e++ ))
|
||||
(( ($e + ( $e>11 ) ) % 13 )) || { processDir $(getDirNextChunkPointer $1) $entryCount $e $workingDirName $pe; break; }
|
||||
done
|
||||
}
|
||||
|
||||
|
||||
processEntry () {
|
||||
#echo $(getFileName $1 $2) $(getStorageType $1 $2) $(getFileType $1 $2) $(getKeyPointer $1 $2) $(getFileLength $1 $2) $(getAuxType $1 $2) $(getCreationDate $1 $2) $(getModifiedDate $1 $2)
|
||||
activeFileName=$(getFileName $1 $2)
|
||||
activeFileSize=$(getFileLength $1 $2)
|
||||
[[ $PDOSPATH_INDEX ]] || echo " $activeFileName"
|
||||
|
||||
if [[ ( ! $PDOSPATH_INDEX ) || ( $activeFileName == $PDOSPATH_SEGMENT ) ]]; then
|
||||
|
||||
if (( $(getStorageType $1 $2) == 13 )); then
|
||||
[[ $PDOSPATH_INDEX ]] || targetDir="$targetDir/$activeFileName"
|
||||
ADdir="$targetDir/.AppleDouble"
|
||||
[[ $DIR || -d $targetDir ]] || mkdir -p $targetDir
|
||||
[[ $DIR || ! $AD || -d $ADdir ]] || mkdir -p $ADdir
|
||||
if [[ $PDOSPATH_SEGMENT ]]; then
|
||||
(( PDOSPATH_INDEX++ ))
|
||||
PDOSPATH_SEGMENT=${PDOSPATH[PDOSPATH_INDEX]}
|
||||
fi
|
||||
processDir $(getKeyPointer $1 $2)
|
||||
DIRPATH=${DIRPATH%/*}
|
||||
[[ $PDOSPATH_INDEX ]] || targetDir="$targetDir/.."
|
||||
ADdir="$targetDir/.AppleDouble"
|
||||
else
|
||||
[[ $DIR ]] && return
|
||||
[[ $targetName ]] || targetName=$activeFileName
|
||||
[[ $EX ]] && eTargetName="$targetName#$(getFileType $1 $2 | tr [:upper:] [:lower:])$(getAuxType $1 $2 | sed 's/\.//' | tr [:upper:] [:lower:])"
|
||||
touch "$targetDir/$targetName"
|
||||
makeADfile
|
||||
copyFile $1 $2
|
||||
creationDate=$(getCreationDate $1 $2);
|
||||
modifiedDate=$(getModifiedDate $1 $2);
|
||||
if [[ $creationDate == "NONE" && $modifiedDate != "NONE" ]]; then
|
||||
creationDate=$modifiedDate
|
||||
elif [[ $creationDate != "NONE" && $modifiedDate == "NONE" ]]; then
|
||||
modifiedDate=$creationDate
|
||||
elif [[ $creationDate == "NONE" && $modifiedDate == "NONE" ]]; then
|
||||
creationDate=$(date "+%s")
|
||||
modifiedDate=$creationDate
|
||||
fi
|
||||
if [[ $AD ]]; then # AppleDouble
|
||||
# set dates
|
||||
ADfilePath="$ADdir/$targetName"
|
||||
writecharsHex "$ADfilePath" 637 $(unixDateToADDate $creationDate).$(unixDateToADDate $modifiedDate)
|
||||
writecharHex "$ADfilePath" 645 80
|
||||
writecharHex "$ADfilePath" 649 80
|
||||
#set type/creator
|
||||
writechars "$ADfilePath" 653 "p"
|
||||
writecharsHex "$ADfilePath" 654 "$(getFileType $1 $2).$(getAuxType $1 $2)"
|
||||
writechars "$ADfilePath" 657 "pdos"
|
||||
fi
|
||||
touch -d @$modifiedDate "$targetDir/$targetName"
|
||||
if [[ $EX ]]; then # extended name
|
||||
mv "$targetDir/$targetName" "$targetDir/$eTargetName"
|
||||
[[ -f $targetDir/${eTargetName}r ]] && touch -d @$modifiedDate "$targetDir/${eTargetName}r"
|
||||
fi
|
||||
[[ $PDOSPATH_SEGMENT ]] && syncExit
|
||||
targetName=
|
||||
fi
|
||||
|
||||
#else
|
||||
#echo "$activeFileName doesn't match $PDOSPATH_SEGMENT"
|
||||
fi
|
||||
}
|
||||
|
||||
processForkedFile () {
|
||||
# finder info except type/creator
|
||||
fInfoA_entryType=$(readcharDec "$image" 9)
|
||||
fInfoB_entryType=$(readcharDec "$image" 27)
|
||||
if (( $fInfoA_entryType==1 )); then
|
||||
readchars "$image" 18 8 | writechars "$image" 661
|
||||
elif (( $fInfoA_entryType==2 )); then
|
||||
readchars "$image" 10 16 | writechars "$image" 669
|
||||
fi
|
||||
if (( $fInfoB_entryType==1 )); then
|
||||
readchars "$image" 36 8 | writechars "$image" 661
|
||||
elif (( $fInfoB_entryType==2 )); then
|
||||
readchars "$image" 28 16 | writechars "$image" 669
|
||||
fi
|
||||
|
||||
for f in 0 256; do
|
||||
resourceFork=$f
|
||||
activeFileBytesCopied=0
|
||||
forkStart=$(( ($1 * 512) )) # start of Forked File key block
|
||||
# echo --$forkStart
|
||||
forkStorageType=$(readcharDec "$image" $(($forkStart+$f+0)) )
|
||||
forkKeyPointer=$(( $(readcharDec "$image" $(($forkStart+$f+1)) ) + \
|
||||
$(readcharDec "$image" $(($forkStart+$f+2)) ) * 256 ))
|
||||
forkFileLen=$(( $(readcharDec "$image" $(($forkStart+$f+5)) ) + \
|
||||
$(readcharDec "$image" $(($forkStart+$f+6)) ) * 256 + \
|
||||
$(readcharDec "$image" $(($forkStart+$f+7)) ) * 65536 ))
|
||||
activeFileSize=$forkFileLen
|
||||
if (( $resourceFork > 0 )); then
|
||||
rsrcForkLenHex=$(readcharHex "$image" $(($forkStart+$f+7)) ).\
|
||||
$(readcharHex "$image" $(($forkStart+$f+6)) ).\
|
||||
$(readcharHex "$image" $(($forkStart+$f+5)) )
|
||||
# echo ">>>$rsrcForkLenHex"
|
||||
echo " [resource fork]"
|
||||
[[ $AD ]] && writecharsHex "$ADdir/$targetName" 35 "$rsrcForkLenHex"
|
||||
else
|
||||
echo " [data fork]"
|
||||
fi
|
||||
if (( $forkStorageType == 1 )); then #seedling
|
||||
copyBlock $forkKeyPointer $forkFileLen
|
||||
elif (( $forkStorageType == 2 )); then #sapling
|
||||
processIndexBlock $forkKeyPointer
|
||||
elif (( $forkStorageType == 3 )); then #tree
|
||||
processMasterIndexBlock $forkKeyPointer
|
||||
fi
|
||||
done
|
||||
# echo
|
||||
resourceFork=0
|
||||
}
|
||||
|
||||
processMasterIndexBlock() {
|
||||
processIndexBlock $1 1
|
||||
}
|
||||
|
||||
processIndexBlock () {
|
||||
#arg1: indexBlock
|
||||
#arg2: if set, it's a Master Index Block
|
||||
local pos=0
|
||||
local bytesRemaining
|
||||
while (( $activeFileBytesCopied < $activeFileSize )); do
|
||||
targetBlock=$(( $(readcharDec $image $(($1*512+$pos)) ) + $(readcharDec $image $(($1*512+($pos+256) )) )*256 ))
|
||||
if [[ $2 ]]; then
|
||||
processIndexBlock $targetBlock
|
||||
else
|
||||
bytesRemaining=$(($activeFileSize - $activeFileBytesCopied))
|
||||
bs=$(( $bytesRemaining<512 ? $bytesRemaining : 512 ))
|
||||
copyBlock $targetBlock $bs
|
||||
fi
|
||||
(( pos++ ))
|
||||
(( $pos > 255 )) && break # go to next entry in Master Index Block (tree)
|
||||
done
|
||||
}
|
||||
|
||||
makeADfile () {
|
||||
ADfilePath="$ADdir/$targetName"
|
||||
[[ ! $AD ]] && return
|
||||
dd if=/dev/zero of="$ADfilePath" bs=741 count=1 2> /dev/null
|
||||
writecharsHex "$ADfilePath" $(hexToDec 00) "00.05.16.07.00.02.00.00" # ADv2 header
|
||||
writecharsHex "$ADfilePath" $(hexToDec 18) "00.0D" # number of entries
|
||||
writecharsHex "$ADfilePath" $(hexToDec 1A) "00.00.00.02.00.00.02.E5.00.00.00.00" # Resource Fork
|
||||
writecharsHex "$ADfilePath" $(hexToDec 26) "00.00.00.03.00.00.00.B6.00.00.00.00" # Real Name
|
||||
writecharsHex "$ADfilePath" $(hexToDec 32) "00.00.00.04.00.00.01.B5.00.00.00.00" # Comment
|
||||
writecharsHex "$ADfilePath" $(hexToDec 3E) "00.00.00.08.00.00.02.7D.00.00.00.10" # Dates Info
|
||||
writecharsHex "$ADfilePath" $(hexToDec 4A) "00.00.00.09.00.00.02.8D.00.00.00.20" # Finder Info
|
||||
writecharsHex "$ADfilePath" $(hexToDec 56) "00.00.00.0B.00.00.02.C1.00.00.00.08" # ProDOS file info
|
||||
writecharsHex "$ADfilePath" $(hexToDec 62) "00.00.00.0D.00.00.02.B5.00.00.00.00" # AFP short name
|
||||
writecharsHex "$ADfilePath" $(hexToDec 6E) "00.00.00.0E.00.00.02.B1.00.00.00.04" # AFP File Info
|
||||
writecharsHex "$ADfilePath" $(hexToDec 7A) "00.00.00.0F.00.00.02.AD.00.00.00.04" # AFP Directory ID
|
||||
# dbd (second time) will create DEV, INO, SYN, SV~
|
||||
}
|
||||
|
||||
syncExit () {
|
||||
if [[ -d /usr/local/etc/netatalk && $AD ]]; then
|
||||
echo "File(s) have been copied to the target directory. If the directory" 1>&2
|
||||
echo "is shared by Netatalk, please use 'afpsync' now." 1>&2
|
||||
fi
|
||||
exit 0
|
||||
}
|
||||
|
||||
usage () {
|
||||
echo "usage:"
|
||||
echo "copy all files: cppo [-ad|-e] imagefile targetDirectory"
|
||||
echo "copy one file : cppo [-ad|-e] imagefile /FULL/PRODOS/FILE/PATH targetPath"
|
||||
echo "catalog image : cppo -cat imagefile"
|
||||
echo
|
||||
echo "cppo copies either one file or all files from a ProDOS raw disk image"
|
||||
echo "to a folder shared by Netatalk. -cat displays all files on the image."
|
||||
echo "No verification or validation of the disk image is performed."
|
||||
echo
|
||||
echo "-ad enables creating AppleDouble header files and copying resource forks."
|
||||
echo "-e appends the ProDOS type and auxtype to filenames, and copies resource"
|
||||
echo " forks, so they can be preserved when added to ShrinkIt archives by"
|
||||
echo " nulib2 (using its -e option)."
|
||||
echo
|
||||
echo "Wildcard matching (*) is not supported."
|
||||
exit 1
|
||||
}
|
||||
|
||||
# --- start
|
||||
|
||||
if [[ $1 == "-ad" ]]; then
|
||||
AD=1
|
||||
shift
|
||||
fi
|
||||
if [[ $1 == "-e" ]]; then
|
||||
[[ $AD ]] && usage
|
||||
EX=1
|
||||
shift
|
||||
fi
|
||||
|
||||
if [[ $1 == "-cat" ]]; then
|
||||
DIR=1
|
||||
shift
|
||||
fi
|
||||
|
||||
[[ ( $DIR && $1 ) || ( $1 && $2 ) ]] || usage
|
||||
[[ $3 && ( ${2:0:1} != "/" ) && ( ${2:0:1} != ":" ) ]] && usage
|
||||
|
||||
image="$1"
|
||||
[[ -f "$image" ]] || { echo "Source image not found."; exit 2; }
|
||||
if [[ $3 ]]; then
|
||||
pdospath=$(echo $2 | tr [:lower:] [:upper:])
|
||||
targetPath=$3
|
||||
if [[ -d $targetPath ]]; then
|
||||
targetDir=$targetPath
|
||||
else
|
||||
targetDir="${targetPath%/*}"
|
||||
targetName="${targetPath##*/}"
|
||||
fi
|
||||
[[ -d $targetDir ]] || { echo "Target directory not found."; exit 2; }
|
||||
else
|
||||
if [[ ! $DIR ]]; then
|
||||
[[ -d "$2" ]] || { echo "Target directory not found."; exit 2; }
|
||||
fi
|
||||
fi
|
||||
|
||||
activeDirBlock=0
|
||||
activeFileName=""
|
||||
activeFileSize=0
|
||||
activeFileBytesCopied=0
|
||||
resourceFork=0
|
||||
|
||||
if [[ $3 ]]; then
|
||||
IFS='/:'
|
||||
PDOSPATH=($pdospath)
|
||||
unset IFS
|
||||
[[ ! ${PDOSPATH[0]} ]] && (( PDOSPATH_INDEX++ ))
|
||||
PDOSPATH_SEGMENT=${PDOSPATH[PDOSPATH_INDEX]}
|
||||
ADdir="$targetDir/.AppleDouble"
|
||||
[[ ! $AD || -d $ADdir ]] || mkdir $ADdir
|
||||
processDir 2
|
||||
echo "ProDOS file not found within image file."
|
||||
exit 2
|
||||
else
|
||||
if [[ ! $DIR ]]; then
|
||||
targetDir="$2/$(getVolumeName)"
|
||||
ADdir="$targetDir/.AppleDouble"
|
||||
[[ -d $targetDir ]] || mkdir -p $targetDir
|
||||
[[ ! $AD || -d $ADdir ]] || mkdir -p $ADdir
|
||||
fi
|
||||
processDir 2
|
||||
[[ $DIR ]] || syncExit
|
||||
fi
|
||||
882
docs/ivanx/setup/cppo.txt
Normal file
882
docs/ivanx/setup/cppo.txt
Normal file
@ -0,0 +1,882 @@
|
||||
#!/usr/bin/env python
|
||||
"""cppo: Copy or catalog one or all files from a ProDOS raw disk image.
|
||||
|
||||
copy all files:
|
||||
cppo [-ad|-e] imagefile target_directory
|
||||
copy one file:
|
||||
cppo [-ad|-e] imagefile /FULL/PRODOS/FILE/PATH target_path
|
||||
catalog image:
|
||||
cppo -cat imagefile
|
||||
|
||||
-ad : Create AppleDouble header files and preserve resource forks.
|
||||
-e : Append ProDOS type and auxtype to filenames, and copy resource
|
||||
forks, for adding to ShrinkIt archives with Nulib2
|
||||
using its -e option.
|
||||
|
||||
Wildcard matching/globbing (*) is not supported.
|
||||
No verification or validation of the disk image is performed.
|
||||
|
||||
(Compatible with Python 2.6 and later, including 3.x.)
|
||||
"""
|
||||
|
||||
# cppo by Ivan X, ivan@ivanx.com, ivanx.com/appleii
|
||||
|
||||
# If anyone's looking at this, and feels it's not sufficiently Pythonic,
|
||||
# I know that. It's pretty much a line-for-line conversion of the original
|
||||
# Bash script. I did start a beautiful from-the-ground-up object-oriented
|
||||
# version, then realized it would be faster to translate it ugly and quick.
|
||||
|
||||
# imports for python 3 code compatibility
|
||||
from __future__ import print_function
|
||||
from __future__ import unicode_literals
|
||||
from __future__ import absolute_import
|
||||
from __future__ import division
|
||||
|
||||
import sys
|
||||
import os
|
||||
import time
|
||||
import datetime
|
||||
|
||||
# Intentially fails on pre-2.6 so user can see what's wrong
|
||||
b'ERROR: cppo requires Python 2.6 or later, including 3.x.'
|
||||
|
||||
class Globals(object):
|
||||
pass
|
||||
|
||||
g = Globals()
|
||||
|
||||
g.imageData = b''
|
||||
g.outFileData = bytearray(b'')
|
||||
g.adFileData = bytearray(b'')
|
||||
g.exFileData = bytearray(b'')
|
||||
|
||||
g.activeDirBlock = None
|
||||
g.activeFileName = None
|
||||
g.activeFileSize = None
|
||||
g.activeFileBytesCopied = 0
|
||||
g.resourceFork = 0
|
||||
|
||||
g.PDOSPATH = []
|
||||
g.PDOSPATH_INDEX = 0
|
||||
g.PDOSPATH_SEGMENT = None
|
||||
g.DIRPATH = ""
|
||||
|
||||
g.targetName = None
|
||||
g.targetDir = ""
|
||||
g.ADdir = None
|
||||
g.imageFile = None
|
||||
|
||||
g.AD = 0
|
||||
g.EX = 0
|
||||
g.DIR = 0
|
||||
g.silent = 0
|
||||
|
||||
# functions
|
||||
|
||||
def pdosDateToUnixDate(arg1):
|
||||
# input: ProDOS date/time bit sequence string in format:
|
||||
# "yyyyyyymmmmddddd000hhhhh00mmmmmm" (ustr)
|
||||
# output: seconds since Unix epoch (1-Jan-1970),
|
||||
# or current date/time if no ProDOS date
|
||||
year = (binToDec(slyce(arg1,0,7)) + 1900)
|
||||
if (year < 1940): year += 100
|
||||
month = binToDec(slyce(arg1,7,4))
|
||||
day = binToDec(slyce(arg1,11,5))
|
||||
hour = binToDec(slyce(arg1,19,5))
|
||||
minute = binToDec(slyce(arg1,26,6))
|
||||
# print(year, month, day, hour, minute)
|
||||
td = (datetime.datetime(year, month, day, hour, minute) -
|
||||
datetime.datetime(1970,1,1))
|
||||
unixDate_naive = (td.days*24*60*60 + td.seconds)
|
||||
td2 = (datetime.datetime.fromtimestamp(unixDate_naive) -
|
||||
datetime.datetime.utcfromtimestamp(unixDate_naive))
|
||||
utcoffset = (td2.days*24*60*60 + td2.seconds)
|
||||
# print(unixDate_naive - utcoffset)
|
||||
return (unixDate_naive - utcoffset) # local time zone with DST
|
||||
|
||||
def unixDateToADDate(arg1):
|
||||
# input: seconds since Unix epoch (1-Jan-1970 00:00:00 GMT)
|
||||
# output: seconds since Netatalk epoch (1-Jan-2000 00:00:00 GMT),
|
||||
# in hex-ustr (big endian)
|
||||
adDate = (arg1 - 946684800)
|
||||
if (adDate < 0 ):
|
||||
adDate += 4294967296 # to get negative hex number
|
||||
adDateHex = to_hex(adDate).zfill(8).upper()
|
||||
# print(arg1, adDate, adDateHex)
|
||||
return adDateHex
|
||||
|
||||
# cppo support routines:
|
||||
# arg1: directory block
|
||||
# arg2: file index (if applicable)
|
||||
# arg3: directory chunk # (if applicable)
|
||||
|
||||
#most of these not tested yet in Python
|
||||
# returns byte position in disk image file
|
||||
def getStartPos(arg1, arg2):
|
||||
return ( (arg1 * 512) +
|
||||
(39 * ((arg2 + (arg2 > 11)) % 13)) +
|
||||
(4 if (arg2 > 11) else 43) )
|
||||
|
||||
def getStorageType(arg1, arg2):
|
||||
start = getStartPos(arg1, arg2)
|
||||
firstByte = readcharDec(g.imageData, start)
|
||||
return (firstByte//16)
|
||||
|
||||
def getFileName(arg1, arg2):
|
||||
start = getStartPos(arg1, arg2)
|
||||
firstByte = readcharDec(g.imageData, start)
|
||||
entryType = (firstByte//16)
|
||||
nameLength = (firstByte - entryType*16)
|
||||
return readchars(g.imageData, start+1, nameLength)
|
||||
|
||||
def getFileType(arg1, arg2):
|
||||
start = getStartPos(arg1, arg2)
|
||||
return readcharHex(g.imageData, start+16)
|
||||
|
||||
def getKeyPointer(arg1, arg2):
|
||||
start = getStartPos(arg1, arg2)
|
||||
return (readcharDec(g.imageData, start+17) +
|
||||
readcharDec(g.imageData, start+18)*256)
|
||||
|
||||
def getFileLength(arg1, arg2):
|
||||
start = getStartPos(arg1, arg2)
|
||||
return (readcharDec(g.imageData, start+21) +
|
||||
readcharDec(g.imageData, start+22)*256 +
|
||||
readcharDec(g.imageData, start+23)*65536)
|
||||
|
||||
def getAuxType(arg1, arg2):
|
||||
start = getStartPos(arg1, arg2)
|
||||
return (readcharHex(g.imageData, start+32) +
|
||||
readcharHex(g.imageData, start+31))
|
||||
|
||||
def getCreationDate(arg1, arg2):
|
||||
#outputs prodos creation date/time as Unix time
|
||||
# (seconds since Jan 1 1970 GMT)
|
||||
#or None if there is none
|
||||
start = getStartPos(arg1, arg2)
|
||||
pdosDate = (hexToBin(readcharHex(g.imageData, start+25)) +
|
||||
hexToBin(readcharHex(g.imageData, start+24)) +
|
||||
hexToBin(readcharHex(g.imageData, start+27)) +
|
||||
hexToBin(readcharHex(g.imageData, start+26)))
|
||||
try:
|
||||
rVal = pdosDateToUnixDate(pdosDate)
|
||||
except Exception:
|
||||
rVal = None
|
||||
return rVal
|
||||
|
||||
def getModifiedDate(arg1, arg2):
|
||||
#outputs prodos modified date/time as Unix time
|
||||
# (seconds since Jan 1 1970 GMT)
|
||||
#or None if there is none
|
||||
start = getStartPos(arg1, arg2)
|
||||
pdosDate = (hexToBin(readcharHex(g.imageData, start+34)) +
|
||||
hexToBin(readcharHex(g.imageData, start+33)) +
|
||||
hexToBin(readcharHex(g.imageData, start+36)) +
|
||||
hexToBin(readcharHex(g.imageData, start+35)))
|
||||
try:
|
||||
rVal = pdosDateToUnixDate(pdosDate)
|
||||
except Exception:
|
||||
rVal = None
|
||||
return rVal
|
||||
|
||||
def getVolumeName():
|
||||
return getWorkingDirName(2)
|
||||
|
||||
def getWorkingDirName(arg1):
|
||||
start = ( arg1 * 512 )
|
||||
firstByte = readcharDec(g.imageData, start+4)
|
||||
entryType = (firstByte//16)
|
||||
nameLength = (firstByte - entryType*16)
|
||||
return readchars(g.imageData, start+5, nameLength)
|
||||
|
||||
def getDirEntryCount(arg1):
|
||||
start = ( arg1 * 512 )
|
||||
return (readcharDec(g.imageData, start+37) +
|
||||
readcharDec(g.imageData, start+38)*256)
|
||||
|
||||
def getDirNextChunkPointer(arg1):
|
||||
start = ( arg1 * 512 )
|
||||
return (readcharDec(g.imageData, start+2) +
|
||||
readcharDec(g.imageData, start+3)*256)
|
||||
|
||||
# -- script begins in earnest here
|
||||
|
||||
def copyFile(arg1, arg2):
|
||||
g.outFileData = bytearray(b'')
|
||||
g.exFileData = bytearray(b'')
|
||||
g.activeFileBytesCopied = 0
|
||||
storageType = getStorageType(arg1, arg2)
|
||||
keyPointer = getKeyPointer(arg1, arg2)
|
||||
fileLen = getFileLength(arg1, arg2)
|
||||
if (storageType == 1): #seedling
|
||||
copyBlock(keyPointer, fileLen)
|
||||
elif (storageType == 2): #sapling
|
||||
processIndexBlock(keyPointer)
|
||||
elif (storageType == 3): #tree
|
||||
processMasterIndexBlock(keyPointer)
|
||||
elif (storageType == 5): #extended (forked)
|
||||
processForkedFile(keyPointer)
|
||||
|
||||
def copyBlock(arg1, arg2):
|
||||
#arg1: block to copy
|
||||
#arg2: bytes to write (should be 512,
|
||||
# unless final block with less than 512 bytes)
|
||||
#print(arg1 + " " + arg2 + " " + g.activeFileBytesCopied)
|
||||
if (arg1 == 0):
|
||||
outBytes = (b'\x00' * arg2)
|
||||
else:
|
||||
outBytes = slyce(g.imageData, arg1*512, arg2)
|
||||
if (g.resourceFork > 0):
|
||||
if g.AD:
|
||||
g.adFileData[g.activeFileBytesCopied+741:
|
||||
(g.activeFileBytesCopied+741 + arg2)] = outBytes
|
||||
if g.EX:
|
||||
g.exFileData[g.activeFileBytesCopied:
|
||||
(g.activeFileBytesCopied + arg2)] = outBytes
|
||||
else:
|
||||
g.outFileData[g.activeFileBytesCopied:
|
||||
(g.activeFileBytesCopied + arg2)] = outBytes
|
||||
g.activeFileBytesCopied += arg2
|
||||
|
||||
def processDir(arg1, arg2=None, arg3=None, arg4=None, arg5=None):
|
||||
# arg1: dirBlock
|
||||
# arg2/3/4/5: for non-key chunks: entryCount, entry#,
|
||||
# workingDirName, processedEntryCount
|
||||
|
||||
entryCount = None
|
||||
e = None
|
||||
pe = None
|
||||
workingDirName = None
|
||||
|
||||
if arg2:
|
||||
entryCount = arg2
|
||||
e = arg3
|
||||
workingDirName = arg4
|
||||
pe = arg5
|
||||
else:
|
||||
e = 0
|
||||
pe = 0
|
||||
entryCount = getDirEntryCount(arg1)
|
||||
workingDirName = getWorkingDirName(arg1).decode("L1")
|
||||
g.DIRPATH = (g.DIRPATH + "/" + workingDirName)
|
||||
if g.PDOSPATH_INDEX:
|
||||
if (g.PDOSPATH_INDEX == 1):
|
||||
if (("/" + g.PDOSPATH_SEGMENT) != g.DIRPATH):
|
||||
print("ProDOS volume name does not match disk image.")
|
||||
sys.exit(2)
|
||||
else:
|
||||
g.PDOSPATH_INDEX += 1
|
||||
g.PDOSPATH_SEGMENT = g.PDOSPATH[g.PDOSPATH_INDEX]
|
||||
else:
|
||||
print(g.DIRPATH)
|
||||
while (pe < entryCount):
|
||||
if (getStorageType(arg1, e) > 0):
|
||||
processEntry(arg1, e)
|
||||
pe += 1
|
||||
e += 1
|
||||
if not ((e + ( e>11 ) ) % 13):
|
||||
processDir(getDirNextChunkPointer(arg1),
|
||||
entryCount,
|
||||
e,
|
||||
workingDirName,
|
||||
pe)
|
||||
break
|
||||
|
||||
def processEntry(arg1, arg2):
|
||||
'''
|
||||
print(getFileName(arg1, arg2), getStorageType(arg1, arg2),
|
||||
getFileType(arg1, arg2), getKeyPointer(arg1, arg2),
|
||||
getFileLength(arg1, arg2), getAuxType(arg1, arg2),
|
||||
getCreationDate(arg1, arg2), getModifiedDate(arg1, arg2))
|
||||
'''
|
||||
g.activeFileName = getFileName(arg1 ,arg2).decode("L1")
|
||||
g.activeFileSize = getFileLength(arg1, arg2)
|
||||
|
||||
if ((not g.PDOSPATH_INDEX) or (g.activeFileName == g.PDOSPATH_SEGMENT)):
|
||||
|
||||
if (getStorageType(arg1, arg2) == 13): # if ProDOS directory
|
||||
if not g.PDOSPATH_INDEX:
|
||||
g.targetDir = (g.targetDir + "/" + g.activeFileName)
|
||||
g.ADdir = (g.targetDir + "/.AppleDouble")
|
||||
if not (g.DIR or os.path.isdir(g.targetDir)):
|
||||
makedirs(g.targetDir)
|
||||
if not (g.DIR or (not g.AD) or os.path.isdir(g.ADdir)):
|
||||
makedirs(g.ADdir)
|
||||
if g.PDOSPATH_SEGMENT:
|
||||
g.PDOSPATH_INDEX += 1
|
||||
g.PDOSPATH_SEGMENT = g.PDOSPATH[g.PDOSPATH_INDEX]
|
||||
processDir(getKeyPointer(arg1, arg2))
|
||||
g.DIRPATH = g.DIRPATH.rsplit("/", 1)[0]
|
||||
if not g.PDOSPATH_INDEX:
|
||||
g.targetDir = g.targetDir.rsplit("/", 1)[0]
|
||||
g.ADdir = (g.targetDir + "/.AppleDouble")
|
||||
else: # if ProDOS file
|
||||
if not g.PDOSPATH_INDEX:
|
||||
print(" " + g.activeFileName)
|
||||
if g.DIR:
|
||||
return
|
||||
if not g.targetName:
|
||||
g.targetName = g.activeFileName
|
||||
if g.EX:
|
||||
eTargetName = (g.targetName + "#" +
|
||||
getFileType(arg1, arg2).lower() +
|
||||
getAuxType(arg1, arg2).lower())
|
||||
touch(g.targetDir + "/" + g.targetName)
|
||||
if g.AD: makeADfile()
|
||||
copyFile(arg1, arg2)
|
||||
saveFile((g.targetDir + "/" + g.targetName), g.outFileData)
|
||||
creationDate = getCreationDate(arg1, arg2)
|
||||
modifiedDate = getModifiedDate(arg1, arg2)
|
||||
if (creationDate is None and modifiedDate is not None):
|
||||
creationDate = modifiedDate
|
||||
elif (creationDate is not None and modifiedDate is None):
|
||||
modifiedDate = creationDate
|
||||
elif (creationDate is None and modifiedDate is None):
|
||||
creationDate = (datetime.datetime.today() -
|
||||
datetime.datetime(1970,1,1)).days*24*60*60
|
||||
modifiedDate = creationDate
|
||||
if g.AD: # AppleDouble
|
||||
# set dates
|
||||
ADfilePath = (g.ADdir + "/" + g.targetName)
|
||||
writecharsHex(g.adFileData,
|
||||
637,
|
||||
(unixDateToADDate(creationDate) +
|
||||
unixDateToADDate(modifiedDate)))
|
||||
writecharHex(g.adFileData, 645, "80")
|
||||
writecharHex(g.adFileData, 649, "80")
|
||||
#set type/creator
|
||||
writechars(g.adFileData, 653, b'p')
|
||||
writecharsHex(g.adFileData,
|
||||
654,
|
||||
(getFileType(arg1, arg2) +
|
||||
getAuxType(arg1, arg2)))
|
||||
writechars(g.adFileData, 657, b'pdos')
|
||||
saveFile(ADfilePath, g.adFileData)
|
||||
touch((g.targetDir + "/" + g.targetName), modifiedDate)
|
||||
if g.EX: # extended name
|
||||
os.rename((g.targetDir + "/" + g.targetName),
|
||||
(g.targetDir + "/" + eTargetName))
|
||||
if (len(g.exFileData) > 0):
|
||||
saveFile((g.targetDir + "/" + eTargetName + "r"),
|
||||
g.exFileData)
|
||||
touch((g.targetDir + "/" + eTargetName + "r"),
|
||||
modifiedDate)
|
||||
if g.PDOSPATH_SEGMENT:
|
||||
syncExit()
|
||||
g.targetName = None
|
||||
|
||||
#else:
|
||||
#print(g.activeFileName + " doesn't match " + g.PDOSPATH_SEGMENT)
|
||||
|
||||
def processForkedFile(arg1):
|
||||
# finder info except type/creator
|
||||
fInfoA_entryType = readcharDec(g.imageData, 9)
|
||||
fInfoB_entryType = readcharDec(g.imageData, 27)
|
||||
if (fInfoA_entryType == 1):
|
||||
writechars(g.imageData, 661, readchars(g.imageData, 18, 8))
|
||||
elif (fInfoA_entryType == 2):
|
||||
writechars(g.imageData, 669, readchars(g.imageData, 10, 16))
|
||||
if (fInfoB_entryType == 1):
|
||||
writechars(g.imageData, 661, readchars(g.imageData, 36, 8))
|
||||
elif (fInfoB_entryType == 2):
|
||||
writechars(g.imageData, 669, readchars(g.imageData, 28, 16))
|
||||
|
||||
for f in [0, 256]:
|
||||
g.resourceFork = f
|
||||
g.activeFileBytesCopied = 0
|
||||
forkStart = (arg1 * 512) # start of Forked File key block
|
||||
# print("--" + forkStart)
|
||||
forkStorageType = readcharDec(g.imageData, forkStart+f+0)
|
||||
forkKeyPointer = (readcharDec(g.imageData, forkStart+f+1) +
|
||||
readcharDec(g.imageData, forkStart+f+2)*256)
|
||||
forkFileLen = (readcharDec(g.imageData, forkStart+f+5) +
|
||||
readcharDec(g.imageData, forkStart+f+6)*256 +
|
||||
readcharDec(g.imageData, forkStart+f+7)*256*256)
|
||||
g.activeFileSize = forkFileLen
|
||||
if (g.resourceFork > 0):
|
||||
rsrcForkLenHex = (readcharHex(g.imageData, forkStart+f+7) +
|
||||
readcharHex(g.imageData, forkStart+f+6) +
|
||||
readcharHex(g.imageData, forkStart+f+5))
|
||||
# print(">>>" + rsrcForkLenHex)
|
||||
print(" [resource fork]")
|
||||
if g.AD:
|
||||
writecharsHex(g.adFileData, 35, rsrcForkLenHex)
|
||||
else:
|
||||
print(" [data fork]")
|
||||
if (forkStorageType == 1): #seedling
|
||||
copyBlock(forkKeyPointer, forkFileLen)
|
||||
elif (forkStorageType == 2): #sapling
|
||||
processIndexBlock(forkKeyPointer)
|
||||
elif (forkStorageType == 3): #tree
|
||||
processMasterIndexBlock(forkKeyPointer)
|
||||
# print()
|
||||
g.resourceFork = 0
|
||||
|
||||
def processMasterIndexBlock(arg1):
|
||||
processIndexBlock(arg1, True)
|
||||
|
||||
def processIndexBlock(arg1, arg2=False):
|
||||
#arg1: indexBlock
|
||||
#arg2: if True, it's a Master Index Block
|
||||
pos = 0
|
||||
bytesRemaining = g.activeFileSize
|
||||
while (g.activeFileBytesCopied < g.activeFileSize):
|
||||
targetBlock = (readcharDec(g.imageData, arg1*512+pos) +
|
||||
readcharDec(g.imageData, arg1*512+(pos+256))*256)
|
||||
if arg2:
|
||||
processIndexBlock(targetBlock)
|
||||
else:
|
||||
bytesRemaining = (g.activeFileSize - g.activeFileBytesCopied)
|
||||
bs = (bytesRemaining if (bytesRemaining < 512) else 512)
|
||||
copyBlock(targetBlock, bs)
|
||||
pos += 1
|
||||
if (pos > 255):
|
||||
break # go to next entry in Master Index Block (tree)
|
||||
|
||||
def makeADfile():
|
||||
if not g.AD: return
|
||||
touch(g.ADdir + "/" + g.targetName)
|
||||
g.adFileData = bytearray(b'\x00' * 741)
|
||||
# ADv2 header
|
||||
writecharsHex(g.adFileData, hexToDec("00"), "0005160700020000")
|
||||
# number of entries
|
||||
writecharsHex(g.adFileData, hexToDec("18"), "000D")
|
||||
# Resource Fork
|
||||
writecharsHex(g.adFileData, hexToDec("1A"), "00000002000002E500000000")
|
||||
# Real Name
|
||||
writecharsHex(g.adFileData, hexToDec("26"), "00000003000000B600000000")
|
||||
# Comment
|
||||
writecharsHex(g.adFileData, hexToDec("32"), "00000004000001B500000000")
|
||||
# Dates Info
|
||||
writecharsHex(g.adFileData, hexToDec("3E"), "000000080000027D00000010")
|
||||
# Finder Info
|
||||
writecharsHex(g.adFileData, hexToDec("4A"), "000000090000028D00000020")
|
||||
# ProDOS file info
|
||||
writecharsHex(g.adFileData, hexToDec("56"), "0000000B000002C100000008")
|
||||
# AFP short name
|
||||
writecharsHex(g.adFileData, hexToDec("62"), "0000000D000002B500000000")
|
||||
# AFP File Info
|
||||
writecharsHex(g.adFileData, hexToDec("6E"), "0000000E000002B100000004")
|
||||
# AFP Directory ID
|
||||
writecharsHex(g.adFileData, hexToDec("7A"), "0000000F000002AD00000004")
|
||||
# dbd (second time) will create DEV, INO, SYN, SV~
|
||||
|
||||
def syncExit():
|
||||
if (not g.silent and g.AD and os.path.isdir("/usr/local/etc/netatalk")):
|
||||
print("File(s) have been copied to the target directory. " +
|
||||
"If the directory")
|
||||
print("is shared by Netatalk, please type 'afpsync' now.")
|
||||
# saveFile(g.imageFile, g.imageData)
|
||||
sys.exit(0)
|
||||
|
||||
def usage():
|
||||
print(sys.modules[__name__].__doc__)
|
||||
sys.exit(1)
|
||||
|
||||
# --- ID bashbyter functions (adapted)
|
||||
|
||||
def decToHex(arg1):
|
||||
# converts single-byte decimal value to hexadecimal equivalent
|
||||
# arg: decimal value from 0-255
|
||||
# out: two-digit hex string from 00-FF
|
||||
#exit: 21=invalid arg
|
||||
if (arg1<0 or arg1>255): sys.exit(21)
|
||||
return to_hex(arg1).upper()
|
||||
|
||||
def hexToDec(arg1):
|
||||
# converts single-byte hexadecimal value to decimal equivalent
|
||||
# arg: two-digit hex value from 00-FF
|
||||
# out: decimal value
|
||||
#exit: 21=invalid arg
|
||||
if (len(arg1) != 2): return 21
|
||||
return to_dec(arg1)
|
||||
|
||||
def hexToBin(arg1):
|
||||
# converts single-byte hexadecimal value to binary string
|
||||
# arg: two-digit hex value from 00-FF
|
||||
# out: binary string value
|
||||
#exit: 21=invalid arg
|
||||
if (len(arg1) != 2): return 21
|
||||
return to_bin(arg1).zfill(8)
|
||||
|
||||
def binToDec(arg1):
|
||||
# converts single-byte binary string (8 bits) value to decimal
|
||||
# warning: no error checking
|
||||
# arg: binary string up to 8 bits
|
||||
# out: decimal value
|
||||
return to_dec([arg1])
|
||||
|
||||
def binToHex(arg1):
|
||||
# converts single-byte binary string (8 bits) value to hex
|
||||
# warning: no error checking
|
||||
# arg: binary string up to 8 bits
|
||||
# out: hex value
|
||||
return to_hex(arg1).upper()
|
||||
|
||||
def charToDec(arg1):
|
||||
# converts single char (of type bytes) to corresponding decimal value
|
||||
# arg: one char (of type bytes)
|
||||
# out: decimal value from 0-255
|
||||
#exit: 21=invalid arg
|
||||
if (len(arg1) != 1): return 21
|
||||
return to_dec(arg1)
|
||||
|
||||
def charToHex(arg1):
|
||||
# converts single char (of type bytes) to corresponding hex value
|
||||
# arg: one char (of type bytes)
|
||||
# out: hexadecimal value from 00-FF
|
||||
#exit: 21=invalid arg
|
||||
if (len(arg1) != 1): return 21
|
||||
return to_hex(arg1).upper()
|
||||
|
||||
def decToChar(arg1):
|
||||
# converts single-byte decimal value to equivalent char (of type bytes)
|
||||
# arg: decimal number from 0-255
|
||||
# out: one character
|
||||
#exit: 21=invalid arg
|
||||
if (arg1<0 or arg1>255): sys.exit(21)
|
||||
return to_bytes(arg1)
|
||||
|
||||
def hexToChar(arg1):
|
||||
# converts single-byte hex value to corresponding char (of type bytes)
|
||||
# arg: two-digit hexadecimal number from 00-FF
|
||||
# out: one character
|
||||
#exit: 21=invalid arg
|
||||
if (len(arg1) != 2): return 21
|
||||
return to_bytes(arg1)
|
||||
|
||||
def readchars(arg1, arg2=0, arg3=0):
|
||||
# read one or more characters from a bytes variable
|
||||
# arg1: bytes or bytearray variable
|
||||
# arg2: (optional) offset (# of bytes to skip before reading)
|
||||
# arg3: (optional) # of chars to read (default is to end of bytes var)
|
||||
# out: sequence of characters (bytes or bytearray)
|
||||
# exit: 21=invalid arg1, 22=invalid arg2, 23=invalid arg3
|
||||
if not (isinstance(arg1, bytes) or isinstance(arg1, bytearray)):
|
||||
sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
if (arg3<0): sys.exit(23)
|
||||
if (arg3 == 0):
|
||||
arg3 = len(arg1)
|
||||
return slyce(arg1, arg2, arg3)
|
||||
|
||||
def readcharDec(arg1, arg2=0):
|
||||
# read one character from bytes var & convert to equivalent dec value
|
||||
# arg1: bytes var
|
||||
# arg2: (optional) offset (# of bytes to skip before reading)
|
||||
# out: decimal value from 0-255
|
||||
# exit: 21=invalid arg1, 22=invalid arg2
|
||||
if not (isinstance(arg1, bytes) or isinstance(arg1, bytearray)):
|
||||
sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
return to_dec(slyce(arg1, arg2, 1))
|
||||
|
||||
def readcharHex(arg1, arg2=0):
|
||||
# read one character from bytes var & convert to corresponding hex value
|
||||
# arg1: bytes var
|
||||
# arg2: (optional) offset (# of bytes to skip before reading)
|
||||
# out: two-digit hex value from 00-FF
|
||||
# exit: 21=invalid arg1, 22=invalid arg2
|
||||
if not (isinstance(arg1, bytes) or isinstance(arg1, bytearray)):
|
||||
sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
return to_hex(slyce(arg1, arg2, 1))
|
||||
|
||||
def writechars(arg1, arg2, arg3):
|
||||
# write one or more characters (bytes) to bytearray
|
||||
# arg1: bytearray variable
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: sequence of bytes (or bytearray)
|
||||
# out: nothing
|
||||
# exit: 21=invalid arg1, 22=invalid arg2, 23=invalid arg3
|
||||
if not isinstance(arg1, bytearray): sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
if not (isinstance(arg3, bytes) or isinstance(arg3, bytearray)):
|
||||
sys.exit(23)
|
||||
arg1[arg2:arg2+len(arg3)] = arg3
|
||||
|
||||
def writecharDec(arg1, arg2, arg3):
|
||||
# write corresponding char of single-byte decimal value into bytearray
|
||||
# arg1: bytearray
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: decimal number from 0-255
|
||||
# exit: 21=invalid arg1, 22=invalid arg2, 23=invalid arg3
|
||||
# out: nothing
|
||||
if not isinstance(arg1, bytearray): sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
if not isnumber(arg3): sys.exit(23)
|
||||
arg1[arg2:arg2+1] = to_bytes(arg3)
|
||||
|
||||
def writecharHex(arg1, arg2, arg3):
|
||||
# write corresponding character of single-byte hex value into bytearray
|
||||
# arg1: bytearray
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: two-digit hexadecimal number from 00-FF
|
||||
# out: nothing
|
||||
# exit: 21=invalid arg1, 22=invalid arg2, 23=invalid arg3
|
||||
if not isinstance(arg1, bytearray): sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
if not isinstance(arg3, type("".encode().decode())): sys.exit(23)
|
||||
arg1[arg2:arg2+1] = to_bytes(arg3)
|
||||
|
||||
def writecharsHex(arg1, arg2, arg3):
|
||||
# write corresponding characters of hex values into bytearray
|
||||
# arg1: bytearray
|
||||
# arg2: offset (# of bytes to skip before writing)
|
||||
# arg3: string of two-digit hexadecimal numbers from 00-FF
|
||||
# out: nothing
|
||||
# exit: 21=invalid arg1, 22=invalid arg2, 23=invalid arg3
|
||||
if not isinstance(arg1, bytearray): sys.exit(21)
|
||||
if (arg2<0): sys.exit(22)
|
||||
if not isinstance(arg3, type("".encode().decode())): sys.exit(23)
|
||||
arg1[arg2:arg2+len(to_bytes(arg3))] = to_bytes(arg3)
|
||||
|
||||
#---- IvanX general purpose functions ----#
|
||||
|
||||
def slyce(val, start_pos=0, length=1, reverse=False):
|
||||
"""returns slice of object (but not a slice object)
|
||||
allows specifying length, and 3.x "bytes" consistency"""
|
||||
the_slyce = val[start_pos:start_pos+length]
|
||||
return (the_slyce[::-1] if reverse else the_slyce)
|
||||
|
||||
def to_hex(val):
|
||||
"""convert bytes, decimal number, or [bin-ustr] to two-digit hex values
|
||||
unlike hex(), accepts bytes; has no leading 0x or trailing L"""
|
||||
from binascii import b2a_hex
|
||||
if isinstance(val, list): # [bin-ustr]
|
||||
val = int(val[0], 2)
|
||||
if isinstance(val, bytes): # bytes
|
||||
return b2a_hex(val).decode("L1")
|
||||
elif isnumber(val):
|
||||
# .encode().decode() always returns unicode in both P2 and P3
|
||||
return (hex(val)[2:].split("L")[0]).encode("L1").decode("L1")
|
||||
else:
|
||||
raise Exception("to_hex() requires bytes, int/long, or [bin-ustr]")
|
||||
|
||||
def hex_slyce(val, start_pos=0, length=1, little_endian=False):
|
||||
"""returns bytes slyce as hex-ustr"""
|
||||
return to_hex(slyce(val, start_pos, length, little_endian))
|
||||
|
||||
def dec_slyce(val, start_pos=0, length=1, little_endian=False):
|
||||
"""returns bytes slyce converted to decimal int/long"""
|
||||
return to_dec(hex_slyce(val, start_pos, length, little_endian))
|
||||
|
||||
def bin_slyce(val, start_pos=0, length=1, little_endian=False):
|
||||
"""returns bytes slyce converted to bin-ustr"""
|
||||
return to_bin(hex_slyce(val, start_pos, length, little_endian))
|
||||
|
||||
def to_dec(val):
|
||||
"""convert bytes, hex-ustr or [bin-ustr] to decimal int/long"""
|
||||
if isinstance(val, list): # [bin-ustr]
|
||||
return int(val[0], 2)
|
||||
elif isinstance(val, bytes): # bytes
|
||||
return int(to_hex(val), 16)
|
||||
elif isinstance(val, type("".encode().decode())): # hex-ustr
|
||||
return int(val, 16)
|
||||
else:
|
||||
raise Exception("to_dec() requires bytes, hex-ustr or [bin-ustr]")
|
||||
|
||||
def to_bin(val):
|
||||
"""convert bytes, hex-ustr, or int/long to bin-ustr"""
|
||||
if isinstance(val, bytes): # bytes
|
||||
return (bin(to_dec(to_hex(val))))[2:].encode("L1").decode("L1")
|
||||
elif isinstance(val, type("".encode().decode())): # hex-ustr
|
||||
return (bin(int(val, 16)))[2:].encode("L1").decode("L1")
|
||||
elif isnumber(val): # int/long
|
||||
return (bin(val))[2:].encode("L1").decode("L1")
|
||||
else:
|
||||
raise Exception("to_bin() requires bytes, hex-ustr, or int/long")
|
||||
|
||||
def to_bytes(val):
|
||||
"""converts hex-ustr, int/long, or [bin-ustr] to bytes"""
|
||||
from binascii import a2b_hex
|
||||
if isinstance(val, list): # [bin-ustr]
|
||||
val = to_hex(val[0])
|
||||
if isnumber(val): # int/long
|
||||
val = to_hex(val)
|
||||
if isinstance(val, type("".encode().decode())): # hex-ustr
|
||||
return a2b_hex(bytes(val.encode("L1"))) # works on both P2 and P3
|
||||
else:
|
||||
raise Exception(
|
||||
"to_bytes() requires hex-ustr, int/long, or [bin-ustr]")
|
||||
|
||||
def shift(items):
|
||||
"""Shift list items to left, losing the first item.
|
||||
|
||||
in : list
|
||||
out: list
|
||||
"""
|
||||
for i in range(0, (len(items)-1)):
|
||||
items[i] = items[i+1]
|
||||
del items[-1]
|
||||
return items
|
||||
|
||||
def s(string):
|
||||
"""Perform local variable substution, e.g. 'total: {num} items'"""
|
||||
# http://stackoverflow.com/questions/2960772/
|
||||
# putting-a-variable-inside-a-string-python
|
||||
# http://stackoverflow.com/questions/6618795/
|
||||
# get-locals-from-calling-namespace-in-python
|
||||
import inspect
|
||||
frame = inspect.currentframe()
|
||||
try:
|
||||
rVal = string.format(**frame.f_back.f_locals)
|
||||
finally:
|
||||
del frame
|
||||
return rVal
|
||||
|
||||
def get_object_names(cls, include_subclasses=True):
|
||||
object_names = []
|
||||
for (this_object_name, this_object_id) in list(globals().items()):
|
||||
if include_subclasses:
|
||||
if isinstance(this_object_id, cls):
|
||||
object_names.append(this_object_name)
|
||||
else:
|
||||
if type(this_object_id) is cls:
|
||||
object_names.append(this_object_name)
|
||||
return object_names
|
||||
|
||||
def touch(filePath, modTime=None):
|
||||
# http://stackoverflow.com/questions/1158076/implement-touch-using-python
|
||||
import os
|
||||
if (os.name == "nt"):
|
||||
if filePath[-1] == ".": filePath += "-"
|
||||
filePath = filePath.replace("./", ".-/")
|
||||
with open(filePath, "ab"):
|
||||
os.utime(filePath, (None if (modTime is None) else (modTime, modTime)))
|
||||
|
||||
def mkdir(dirPath):
|
||||
import os
|
||||
if (os.name == "nt"):
|
||||
if dirPath[-1] == ".": dirPath += "-"
|
||||
dirPath = dirPath.replace("./", ".-/")
|
||||
try:
|
||||
os.mkdir(dirPath)
|
||||
except FileExistsError:
|
||||
pass
|
||||
|
||||
def makedirs(dirPath):
|
||||
import os
|
||||
if (os.name == "nt"):
|
||||
if dirPath[-1] == ".": dirPath += "-"
|
||||
dirPath = dirPath.replace("./", ".-/")
|
||||
try:
|
||||
os.makedirs(dirPath)
|
||||
except FileExistsError:
|
||||
pass
|
||||
|
||||
def loadFile(filePath):
|
||||
import os
|
||||
if (os.name == "nt"):
|
||||
if filePath[-1] == ".": filePath += "-"
|
||||
filePath = filePath.replace("./", ".-/")
|
||||
with open(filePath, "rb") as imageHandle:
|
||||
return imageHandle.read()
|
||||
|
||||
def saveFile(filePath, fileData):
|
||||
import os
|
||||
if (os.name == "nt"):
|
||||
if filePath[-1] == ".": filePath += "-"
|
||||
filePath = filePath.replace("./", ".-/")
|
||||
with open(filePath, "wb") as imageHandle:
|
||||
imageHandle.write(fileData)
|
||||
|
||||
def isnumber(number):
|
||||
try: # make sure it's not a string
|
||||
len(number)
|
||||
return False
|
||||
except TypeError:
|
||||
pass
|
||||
try:
|
||||
int(number)
|
||||
except ValueError:
|
||||
return False
|
||||
return True
|
||||
|
||||
#---- end IvanX general purpose functions ----#
|
||||
|
||||
|
||||
# --- start
|
||||
|
||||
args = sys.argv
|
||||
if (len(args) == 1):
|
||||
usage()
|
||||
|
||||
if (args[1] == "-s"):
|
||||
g.silent=1
|
||||
args = args[1:] #shift
|
||||
|
||||
if (args[1] == "-ad"):
|
||||
g.AD = 1
|
||||
args = args[1:] #shift
|
||||
|
||||
if (args[1] == "-e"):
|
||||
if g.AD: usage()
|
||||
g.EX = 1
|
||||
args = args[1:] #shift
|
||||
|
||||
if (args[1] == "-cat"):
|
||||
g.DIR = 1
|
||||
args = args[1:]
|
||||
|
||||
if not ((g.DIR and len(args) >= 2) or (len(args) >= 3)):
|
||||
usage()
|
||||
if ((len(args) == 4) and
|
||||
(slyce(args[2],0,1) != "/") and
|
||||
(slyce(args[2],0,1) != ":")):
|
||||
usage()
|
||||
|
||||
g.imageFile = args[1]
|
||||
if not os.path.isfile(g.imageFile):
|
||||
print("Source " + g.imageFile + " was not found.")
|
||||
sys.exit(2)
|
||||
g.imageData = loadFile(g.imageFile)
|
||||
|
||||
if (len(args) == 4):
|
||||
g.PDOSPATH = args[2].upper()
|
||||
targetPath = args[3]
|
||||
if os.path.isdir(targetPath):
|
||||
g.targetDir = targetPath
|
||||
else:
|
||||
g.targetDir = targetPath.rsplit("/", 1)[0]
|
||||
g.targetName = targetPath.rsplit("/", 1)[1]
|
||||
if not os.path.isdir(g.targetDir):
|
||||
print("Target directory not found.")
|
||||
sys.exit(2)
|
||||
else:
|
||||
if not g.DIR:
|
||||
if not os.path.isdir(args[2]):
|
||||
print("Target directory not found.")
|
||||
sys.exit(2)
|
||||
|
||||
g.activeDirBlock = 0
|
||||
g.activeFileName = ""
|
||||
g.activeFileSize = 0
|
||||
g.activeFileBytesCopied = 0
|
||||
g.resourceFork = 0
|
||||
g.PDOSPATH_INDEX = 0
|
||||
|
||||
if (len(args) == 4):
|
||||
g.PDOSPATH = g.PDOSPATH.replace(':', '/').split('/')
|
||||
if not g.PDOSPATH[0]:
|
||||
g.PDOSPATH_INDEX += 1
|
||||
g.PDOSPATH_SEGMENT = g.PDOSPATH[g.PDOSPATH_INDEX]
|
||||
g.ADdir = (g.targetDir + "/.AppleDouble")
|
||||
if not ((not g.AD) or os.path.isdir(g.ADdir)):
|
||||
mkdir(g.ADdir)
|
||||
processDir(2)
|
||||
print("ProDOS file not found within image file.")
|
||||
sys.exit(2)
|
||||
else:
|
||||
if not g.DIR:
|
||||
# print(args[0], args[1], args[2])
|
||||
g.targetDir = (args[2] + "/" + getVolumeName().decode("L1"))
|
||||
g.ADdir = (g.targetDir + "/.AppleDouble")
|
||||
if not os.path.isdir(g.targetDir):
|
||||
makedirs(g.targetDir)
|
||||
if not ((not g.AD) or os.path.isdir(g.ADdir)):
|
||||
makedirs(g.ADdir)
|
||||
processDir(2)
|
||||
if not g.DIR:
|
||||
syncExit()
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user