#! /usr/bin/env python # vim: set tabstop=4 shiftwidth=4 expandtab filetype=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()