#!/usr/bin/env python3 # vim: set tabstop=4 shiftwidth=4 noexpandtab filetype=python: """cppo: Copy/catalog files from a ProDOS/DOS 3.3/ShrinkIt image/archive. copy all files: cppo [options] imagefile target_directory copy one file : cppo [options] imagefile /extract/path target_path catalog image : cppo -cat [options] imagefile options: -shk: ShrinkIt archive as source (also auto-enabled by filename). -ad : Netatalk-compatible AppleDouble metadata files and resource forks. -e : Nulib2-compatible filenames with type/auxtype and resource forks. -uc : Copy GS/OS mixed case filenames as uppercase. -pro: Adapt DOS 3.3 names to ProDOS and remove addr/len from file data. /extract/path examples: /FULL/PRODOS/PATH (ProDOS image source) "MY FILENAME" (DOS 3.3 image source) Dir:SubDir:FileName (ShrinkIt archive source) + after a file name indicates a GS/OS or Mac OS extended (forked) file. Wildcard matching (*) is not supported and images are not validated. ShrinkIt support requires Nulib2. cppo requires Python 2.6+ or 3.0+.""" # cppo by Ivan X, ivan@ivanx.com, ivanx.com/appleii # Does anyone want to rewrite/refactor this? It works, but it's a mess. import sys import os import time import datetime import shutil import errno import uuid import subprocess import tempfile from binascii import a2b_hex, b2a_hex class Globals: pass g = Globals() g.image_data = b'' g.out_data = bytearray(b'') g.ex_data = None g.activeDirBlock = None g.activeFileName = None g.activeFileSize = None g.activeFileBytesCopied = 0 g.resourceFork = 0 g.shk_hasrf = False g.PDOSPATH = [] g.PDOSPATH_INDEX = 0 g.PDOSPATH_SEGMENT = None g.DIRPATH = "" g.target_name = None g.target_dir = "" g.appledouble_dir = None g.image_file = None g.extract_file = None # runtime options g.use_appledouble = False # -ad (AppleDouble headers + resource forks) g.use_extended = False # -e (extended filenames + resource forks) g.catalog_only = False # -cat (catalog only, no extract) g.casefold_upper = False # -uc (GS/OS mixed case filenames extract as uppercase) g.src_shk = False # -shk (ShrinkIt archive source) g.prodos_names = False # -pro (adapt DOS 3.3 names to ProDOS) g.afpsync_msg = True # -s (sets False to suppress afpsync message at end) g.extract_in_place = False # -n (don't create parent dir for SHK, extract files in place) g.dos33 = False # (DOS 3.3 image source, selected automatically) # 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 = to_dec(arg1[0:7]) + (1900 if year >= 1940 else 2000) month = to_dec(arg1[sli(7,4)]) day = to_dec(arg1[sli(11,5)]) hour = to_dec(arg1[sli(19,5)]) minute = to_dec(arg1[sli(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(unix_date): """ convert UNIX date to Apple epoch (2000-01-01) """ # 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 4 bytes adDate = (unix_date - 946684800) # $ date --date="2000-01-01 00:00:00 GMT" +%s # 946684800 # # Think: "UNIX dates have 30 years too many seconds to be Apple dates, # so we need to subtract 30 years' worth of seconds." if adDate < 0: adDate += 1<<32 # to get negative hex number return adDate.to_bytes(4, 'big') # cppo support functions: # arg1: directory block or [T,S] containing file entry, or shk file dir path # arg2: file index in overall directory (if applicable), or shk file name # returns byte position in disk image file def getStartPos(arg1, arg2): if g.dos33: return (ts(arg1) + (35 * (arg2 % 7)) + 11) else: # ProDOS return ( (arg1 * 512) + (39 * ((arg2 + (arg2 > 11)) % 13)) + (4 if arg2 > 11 else 43) ) def getStorageType(arg1, arg2): start = getStartPos(arg1, arg2) firstByte = g.image_data[start] return (int(firstByte != 255)*2 if g.dos33 else (firstByte//16)) def getFileName(arg1, arg2): start = getStartPos(arg1, arg2) if g.dos33: fileNameLo = bytearray() fileNameHi = g.image_data[sli(start+3, 30)] for b in fileNameHi: fileNameLo.append(b & 0x7f) fileName = bytes(fileNameLo).rstrip() else: # ProDOS firstByte = g.image_data[start] entryType = firstByte//16 nameLength = firstByte - entryType*16 fileName = g.image_data[sli(start+1, nameLength)] caseMask = getCaseMask(arg1, arg2) if caseMask and not g.casefold_upper: fileName = bytearray(fileName) for i in range(0, len(fileName)): if caseMask[i] == "1": fileName[i:i+1] = fileName[i:i+1].lower() fileName = bytes(fileName) return fileName def getCaseMask(arg1, arg2): start = getStartPos(arg1, arg2) caseMaskDec = int.from_bytes(g.image_data[sli(start+28,2)], 'little') if caseMaskDec < 32768: return None else: return to_bin(caseMaskDec - 32768, 15) def getFileType(arg1, arg2): if g.src_shk: return arg2.split('#')[1][0:2] start = getStartPos(arg1, arg2) if g.dos33: d33fileType = g.image_data[start+2] if (d33fileType & 127) == 4: return '06' # BIN elif (d33fileType & 127) == 1: return 'FA' # INT elif (d33fileType & 127) == 2: return 'FC' # BAS else: return '04' # TXT or other else: # ProDOS return b2a_hex(g.image_data[start+16:start+17]).decode() def getAuxType(arg1, arg2): if g.src_shk: return arg2.split('#')[1][2:6] start = getStartPos(arg1, arg2) if g.dos33: fileType = getFileType(arg1, arg2) if fileType == '06': # BIN (B) # file address is in first two bytes of file data fileTSlist = list(g.image_data[sli(start+0,2)]) fileStart = list(g.image_data[sli(ts(fileTSlist)+12,2)]) return (b2a_hex(g.image_data[sli(ts(fileStart)+1,1)]) + b2a_hex(g.image_data[sli(ts(fileStart),1)])).decode() elif fileType == 'FC': # BAS (A) return '0801' elif fileType == 'FA': # INT (I) return '9600' else: # TXT (T) or other return '0000' else: # ProDOS return (b2a_hex(g.image_data[sli(start+32,1)]) + b2a_hex(g.image_data[sli(start+31,1)])).decode() def getKeyPointer(arg1, arg2): start = getStartPos(arg1, arg2) if g.dos33: return list(g.image_data[sli(start,2)]) else: # ProDOS return int.from_bytes(g.image_data[sli(start+17,2)], 'little') def getFileLength(arg1, arg2): start = getStartPos(arg1, arg2) if g.dos33: fileType = getFileType(arg1, arg2) fileTSlist = list(g.image_data[sli(start,2)]) fileStart = list(g.image_data[sli(ts(fileTSlist)+12,2)]) if fileType == '06': # BIN (B) # file length is in second two bytes of file data return (int.from_bytes(g.image_data[ sli(ts(fileStart)+2, 2) ], 'little') + 4) elif fileType == 'FC' or fileType == 'FA': # BAS (A) or INT (I) # file length is in first two bytes of file data return (int.from_bytes(g.image_data[ sli(ts(fileStart), 2) ], 'little') + 2) else: # TXT (T) or other # sadly, we have to walk the whole file # length is determined by sectors in TSlist, minus wherever # anything after the first zero in the last sector fileSize = 0 lastTSpair = None prevTSpair = [0,0] nextTSlistSector = fileTSlist endFound = False while not endFound: pos = ts(nextTSlistSector) for tsPos in range(12, 256, 2): cur_ts_pair = list(g.image_data[sli(pos+tsPos,2)]) if ts(cur_ts_pair) != 0: fileSize += 256 prevTSpair = cur_ts_pair else: lastTSpair = prevTSpair endFound = True break if not lastTSpair: nextTSlistSector = list(g.image_data[sli(pos+1,2)]) if nextTSlistSector[0]+nextTSlistSector[1] == 0: lastTSpair = prevTSpair endFound = True break fileSize -= 256 pos = ts(prevTSpair) # now find out where the file really ends by finding the last 00 for offset in range(255, -1, -1): #print("pos: " + to_hex(pos)) if g.image_data[pos+offset] != 0: fileSize += (offset + 1) break return fileSize else: # ProDOS return int.from_bytes(g.image_data[sli(start+21,3)], 'little') def getCreationDate(arg1, arg2): #outputs prodos creation date/time as Unix time # (seconds since Jan 1 1970 GMT) #or None if there is none if g.src_shk: return None elif g.dos33: return None else: # ProDOS start = getStartPos(arg1, arg2) pdosDate = (to_bin(g.image_data[start+25],8)+ to_bin(g.image_data[start+24],8)+ to_bin(g.image_data[start+27],8)+ to_bin(g.image_data[start+26],8)) 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 if g.src_shk: modifiedDate = int(time.mktime(time.strptime(time.ctime( os.path.getmtime(os.path.join(arg1, arg2)))))) rVal = modifiedDate elif g.dos33: rVal = None else: # ProDOS start = getStartPos(arg1, arg2) pdosDate = (to_bin(g.image_data[start+34],8)+ to_bin(g.image_data[start+33],8)+ to_bin(g.image_data[start+36],8)+ to_bin(g.image_data[start+35],8)) try: rVal = pdosDateToUnixDate(pdosDate) except Exception: rVal = None return rVal def getVolumeName(): return getWorkingDirName(2) def getWorkingDirName(arg1, arg2=None): # arg1:block, arg2:casemask (optional) start = arg1 * 512 firstByte = g.image_data[start+4] entryType = firstByte//16 nameLength = firstByte - entryType*16 workingDirName = g.image_data[sli(start+5, nameLength)] if entryType == 15: # volume directory, get casemask from header caseMaskDec = int.from_bytes(g.image_data[sli(start+26,2)], 'little') if caseMaskDec < 32768: caseMask = None else: caseMask = to_bin(caseMaskDec - 32768,15) else: # subdirectory, get casemask from arg2 (not available in header) caseMask = arg2 if caseMask and not g.casefold_upper: workingDirName = bytearray(workingDirName) for i in range(0, len(workingDirName)): if caseMask[i] == "1": workingDirName[i:i+1] = workingDirName[i:i+1].lower() workingDirName = bytes(workingDirName) return workingDirName def getDirEntryCount(arg1): if g.dos33: entryCount = 0 nextSector = arg1 while True: top = ts(nextSector) pos = top+11 for e in range(0, 7): if g.image_data[pos] == 0: return entryCount # no more file entries else: if g.image_data[pos] != 255: entryCount += 1 # increment if not deleted file pos += 35 nextSector = list(g.image_data[sli(top+1,2)]) if nextSector == [0,0]: # no more catalog sectors return entryCount else: # ProDOS start = arg1 * 512 return int.from_bytes(g.image_data[sli(start+37,2)], 'little') def getDirNextChunkPointer(arg1): if g.dos33: start = ts(arg1) return list(g.image_data[sli(start+1,2)]) else: # ProDOS start = arg1 * 512 return int.from_bytes(g.image_data[sli(start+2,2)], 'little') def toProdosName(name): i=0 if name[0] == '.': # eliminate leading period name = name[1:] for c in name: if c != '.' and not c.isalnum(): name = name[:i] + '.' + name[i+1:] i+=1 name = name[:15] return name def ts(track, sector=None): # returns offset; track and sector can be dec, or hex-ustr # can also supply as [t,s] for convenience if sector == None: (track, sector) = track if isinstance(track, str): # hex-ustr track = int(track, 16) if isinstance(sector, str): # hex-ustr sector = int(sector, 16) return track*16*256 + sector*256 def sli(start, length=1, ext=None): """return a slice object from an offset and length""" return slice(start, start + length, ext) # --- main logic functions def copyFile(arg1, arg2): #arg1/arg2: # ProDOS : directory block / file index in overall directory # DOS 3.3 : [track, sector] / file index in overall VTOC # ShrinkIt: directory path / file name # copies file or dfork to g.out_data, rfork if any to g.ex_data g.activeFileBytesCopied = 0 if g.src_shk: with open(os.path.join(arg1, arg2), 'rb') as infile: g.out_data += infile.read() if g.shk_hasrf: print(" [data fork]") if g.use_extended or g.use_appledouble: print(" [resource fork]") if g.ex_data == None: g.ex_data = bytearray(b'') with open(os.path.join(arg1, (arg2 + "r")), 'rb') as infile: g.ex_data += infile.read() else: # ProDOS or DOS 3.3 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) if g.prodos_names: # remove address/length data from DOS 3.3 file data if ProDOS target if getFileType(arg1, arg2) == '06': g.out_data = g.out_data[4:] elif (getFileType(arg1, arg2) == 'FA' or getFileType(arg1, arg2) == 'FC'): g.out_data = g.out_data[2:] def copyBlock(arg1, arg2): #arg1: block number or [t,s] to copy #arg2: bytes to write (should be 256 (DOS 3.3) or 512 (ProDOS), # unless final block with less) #print(arg1 + " " + arg2 + " " + g.activeFileBytesCopied) if arg1 == 0: outBytes = bytes(arg2) else: outBytes = g.image_data[sli(ts(arg1) if g.dos33 else arg1*512, arg2)] if g.resourceFork > 0: if g.use_appledouble or g.use_extended: offset = (741 if g.use_appledouble else 0) if g.ex_data == None: g.ex_data = bytearray(b'') g.ex_data[ (g.activeFileBytesCopied + offset) : (g.activeFileBytesCopied + offset + arg2) ] = outBytes else: g.out_data[ g.activeFileBytesCopied : (g.activeFileBytesCopied + arg2) ] = outBytes g.activeFileBytesCopied += arg2 def processDir(arg1, arg2=None, arg3=None, arg4=None, arg5=None): # arg1: ProDOS directory block, or DOS 3.3 [track,sector] # for key block (with directory header): # arg2: casemask (optional), arg3:None, arg4:None, arg5:None # for secondary directory blocks (non-key block): # arg2/3/4/5: for non-key chunks: entryCount, entry#, # workingDirName, processedEntryCount entryCount = None e = None pe = None workingDirName = None if arg3: entryCount = arg2 e = arg3 workingDirName = arg4 pe = arg5 else: e = 0 pe = 0 entryCount = getDirEntryCount(arg1) if not g.dos33: workingDirName = getWorkingDirName(arg1, arg2).decode("L1") g.DIRPATH = (g.DIRPATH + "/" + workingDirName) if g.PDOSPATH_INDEX: if g.PDOSPATH_INDEX == 1: if ("/" + g.PDOSPATH_SEGMENT.lower()) != g.DIRPATH.lower(): print("ProDOS volume name does not match disk image.") quitNow(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: #print(pe, e, entryCount) processEntry(arg1, e) pe += 1 e += 1 if not (e + (0 if g.dos33 else (e>11)) ) % (7 if g.dos33 else 13): processDir(getDirNextChunkPointer(arg1), entryCount, e, workingDirName, pe) break def processEntry(arg1, arg2): # arg1=block number, [t,s] if g.dos33=True, or subdir name if g.src_shk=1 # arg2=index number of entry in directory, or file name if g.src_shk=1 #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)) eTargetName = None g.ex_data = None g.out_data = bytearray(b'') if g.src_shk: # ShrinkIt archive g.activeFileName = (arg2 if g.use_extended else arg2.split('#')[0]) if g.casefold_upper: g.activeFileName = g.activeFileName.upper() origFileName = g.activeFileName else: # ProDOS or DOS 3.3 image g.activeFileName = getFileName(arg1 ,arg2).decode("L1") origFileName = g.activeFileName if g.prodos_names: g.activeFileName = toProdosName(g.activeFileName) g.activeFileSize = getFileLength(arg1, arg2) if (not g.PDOSPATH_INDEX or g.activeFileName.upper() == g.PDOSPATH_SEGMENT.upper()): # if ProDOS directory, not file if not g.src_shk and getStorageType(arg1, arg2) == 13: if not g.PDOSPATH_INDEX: g.target_dir = g.target_dir + "/" + g.activeFileName g.appledouble_dir = g.target_dir + "/.AppleDouble" if not g.catalog_only or os.path.isdir(g.target_dir): makedirs(g.target_dir) if (not g.catalog_only and g.use_appledouble and not os.path.isdir(g.appledouble_dir)): makedirs(g.appledouble_dir) if g.PDOSPATH_SEGMENT: g.PDOSPATH_INDEX += 1 g.PDOSPATH_SEGMENT = g.PDOSPATH[g.PDOSPATH_INDEX] processDir(getKeyPointer(arg1, arg2), getCaseMask(arg1, arg2)) g.DIRPATH = g.DIRPATH.rsplit("/", 1)[0] if not g.PDOSPATH_INDEX: g.target_dir = g.target_dir.rsplit("/", 1)[0] g.appledouble_dir = (g.target_dir + "/.AppleDouble") else: # ProDOS or DOS 3.3 file either from image or ShrinkIt archive dirPrint = "" if g.DIRPATH: dirPrint = g.DIRPATH + "/" else: if g.src_shk: if "/".join(dirName.split('/')[3:]): dirPrint = ("/".join(dirName.split('/')[3:]) + "/") if (not g.extract_file or (os.path.basename(g.extract_file.lower()) == origFileName.split('#')[0].lower())): filePrint = g.activeFileName.split("#")[0] print(dirPrint + filePrint + ("+" if (g.shk_hasrf or (not g.src_shk and getStorageType(arg1, arg2) == 5)) else "") + ((" [" + origFileName + "] ") if (g.prodos_names and (origFileName != g.activeFileName)) else "")) if g.catalog_only: return if not g.target_name: g.target_name = g.activeFileName if g.use_extended: if g.src_shk: eTargetName = arg2 else: # ProDOS image eTargetName = (g.target_name + "#" + getFileType(arg1, arg2).lower() + getAuxType(arg1, arg2).lower()) # touch(g.target_dir + "/" + g.target_name) if g.use_appledouble: makeADfile() copyFile(arg1, arg2) saveName = (g.target_dir + "/" + (eTargetName if eTargetName else g.target_name)) save_file(saveName, g.out_data) creationDate = getCreationDate(arg1, arg2) modifiedDate = getModifiedDate(arg1, arg2) if modifiedDate and not creationDate: creationDate = modifiedDate elif creationDate and not modifiedDate: modifiedDate = creationDate elif not creationDate and not modifiedDate: creationDate = (datetime.datetime.today() - datetime.datetime(1970,1,1)).days*24*60*60 modifiedDate = creationDate if g.use_appledouble: # AppleDouble # set dates ADfile_path = g.appledouble_dir + "/" + g.target_name g.ex_data[637:641] = unixDateToADDate(creationDate) g.ex_data[641:645] = unixDateToADDate(modifiedDate) g.ex_data[645] = 0x80 g.ex_data[649] = 0x80 #set type/creator g.ex_data[653] = ord('p') g.ex_data[654:657] = bytes.fromhex( getFileType(arg1, arg2) + getAuxType(arg1, arg2)) g.ex_data[657:661] = b'pdos' save_file(ADfile_path, g.ex_data) touch(saveName, modifiedDate) if g.use_extended: # extended name from ProDOS image if g.ex_data: save_file((saveName + "r"), g.ex_data) touch((saveName + "r"), modifiedDate) if (g.PDOSPATH_SEGMENT or (g.extract_file and (g.extract_file.lower() == origFileName.lower()))): quitNow(0) g.target_name = None #else print(g.activeFileName + " doesn't match " + g.PDOSPATH_SEGMENT) def processForkedFile(arg1): # finder info except type/creator fInfoA_entryType = g.image_data[9] fInfoB_entryType = g.image_data[27] if fInfoA_entryType == 1: g.image_data[661:669], g.image_data[18:26] elif fInfoA_entryType == 2: g.image_data[669:685], g.image_data[10:26] if fInfoB_entryType == 1: g.image_data[661:669], g.image_data[36:44] elif fInfoB_entryType == 2: g.image_data[669:685], g.image_data[28:44] for f in (0, 256): g.resourceFork = f g.activeFileBytesCopied = 0 forkStart = arg1 * 512 # start of Forked File key block #print("--" + forkStart) forkStorageType = g.image_data[forkStart+f] forkKeyPointer = int.from_bytes(g.image_data[ sli(forkStart+f+1,2) ], 'little') forkFileLen = int.from_bytes(g.image_data[ sli(forkStart+f+5,3) ], 'little') g.activeFileSize = forkFileLen if g.resourceFork > 0: rsrcForkLen = int.from_bytes(g.image_data[ sli(forkStart + f + 5, 3)],'little') #print(">>>", rsrcForkLen) if g.use_appledouble or g.use_extended: print(" [resource fork]") if g.use_appledouble: g.ex_data[35:38] = rsrcForkLen.to_bytes(3, 'big') 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, or [t,s] of track/sector list #arg2: if True, it's a Master Index Block pos = 12 if g.dos33 else 0 bytesRemaining = g.activeFileSize while g.activeFileBytesCopied < g.activeFileSize: if g.dos33: targetTS = list(g.image_data[sli(ts(arg1)+pos,2)]) #print(to_hex(targetTS[0]),to_hex(targetTS[1])) bytesRemaining = (g.activeFileSize - g.activeFileBytesCopied) bs = (bytesRemaining if bytesRemaining < 256 else 256) copyBlock(targetTS, bs) pos += 2 if pos > 255: # continue with next T/S list sector processIndexBlock(list(g.image_data[sli(ts(arg1)+1,2)])) else: # ProDOS # Note these are not consecutive bytes targetBlock = (g.image_data[arg1*512+pos] + g.image_data[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.use_appledouble: return touch(g.appledouble_dir + "/" + g.target_name) g.ex_data = bytearray(741) # ADv2 header g.ex_data[sli(0x00,8)] = a2b_hex("0005160700020000") # number of entries g.ex_data[sli(0x18,2)] = a2b_hex("000D") # Resource Fork g.ex_data[sli(0x1a,12)] = a2b_hex("00000002000002E500000000") # Real Name g.ex_data[sli(0x26,12)] = a2b_hex("00000003000000B600000000") # Comment g.ex_data[sli(0x32,12)] = a2b_hex("00000004000001B500000000") # Dates Info g.ex_data[sli(0x3e,12)] = a2b_hex("000000080000027D00000010") # Finder Info g.ex_data[sli(0x4a,12)] = a2b_hex("000000090000028D00000020") # ProDOS file info g.ex_data[sli(0x56,12)] = a2b_hex("0000000B000002C100000008") # AFP short name g.ex_data[sli(0x62,12)] = a2b_hex("0000000D000002B500000000") # AFP File Info g.ex_data[sli(0x6e,12)] = a2b_hex("0000000E000002B100000004") # AFP Directory ID g.ex_data[sli(0x7a,12)] = a2b_hex("0000000F000002AD00000004") # dbd (second time) will create DEV, INO, SYN, SV~ def quitNow(exitcode=0): if (exitcode == 0 and g.afpsync_msg and g.use_appledouble 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.") if g.src_shk: # clean up for file in os.listdir('/tmp'): if file.startswith("cppo-"): shutil.rmtree('/tmp' + "/" + file) sys.exit(exitcode) def usage(exitcode=1): print(sys.modules[__name__].__doc__) quitNow(exitcode) def to_sys_name(name): if os.name == 'nt': if name[-1] == '.': name += '-' name = name.replace('./', '.-/') return name #---- IvanX general purpose functions ----# 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""" if isinstance(val, list): # [bin-ustr] val = int(val[0], 2) if isinstance(val, bytes): # bytes return b2a_hex(val).decode() elif isnumber(val): if val < 0: print ("val: " + str(val)) return b2a_hex(bytes([val])).decode() else: raise Exception("to_hex() requires bytes, int/long, or [bin-ustr]") 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, str): # hex-ustr return int(val, 16) elif isnumber(val): # int/long return val else: raise Exception("to_dec() requires bytes, hex-ustr or [bin-ustr]") def to_bin(val, fill = None): """convert bytes, hex-ustr, or int/long to bin-ustr""" if isinstance(val, bytes): # bytes b = bin(to_dec(to_hex(val)))[2:] elif isinstance(val, str): # hex-ustr b = bin(int(val, 16))[2:] elif isnumber(val): # int/long b = bin(val)[2:] else: raise Exception("to_bin() requires bytes, hex-ustr, or int/long") return b if not fill else b.zfill(fill) def to_bytes(val): """converts hex-ustr, int/long, or [bin-ustr] to bytes""" if isinstance(val, list): # [bin-ustr] val = to_hex(val[0]) if isnumber(val): # int/long if val < 256: return chr(val).encode() else: val = to_hex(val) if isinstance(val, str): # hex-ustr return a2b_hex(val.encode()) elif isinstance(val, bytes): return val else: raise Exception("to_bytes() requires hex-ustr, int/long, or [bin-ustr]") def touch(file_path, modTime=None): # http://stackoverflow.com/questions/1158076/implement-touch-using-python #print(file_path) with open(to_sys_name(file_path), "ab"): os.utime(file_path, None if modTime is None else (modTime, modTime)) def mkdir(dirPath): try: os.mkdir(to_sys_name(dirPath)) except FileExistsError: pass def makedirs(dirPath): try: os.makedirs(to_sys_name(dirPath)) except OSError as e: if e.errno != errno.EEXIST: raise def load_file(file_path): with open(to_sys_name(file_path), "rb") as imageHandle: return imageHandle.read() def save_file(file_path, fileData): with open(to_sys_name(file_path), "wb") as imageHandle: imageHandle.write(fileData) def dopo_swap(image_data): # for each track, # read each sector in the right sequence to make # valid ProDOS blocks (sector pairs) dopo = bytearray(143360) for t in range(0, 35): for s in range(16): src = ts(t,s) dst = ts(t,s if s in (0,15) else 15-s) dopo[dst:dst+256] = image_data[src:src+256] return bytes(dopo) 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 if __name__ == '__main__': args = sys.argv while True: # breaks when there are no more arguments starting with dash if len(args) == 1: usage() elif args[1][0] != '-': break elif args[1] == '-s': g.afpsync_msg = False args = args[1:] elif args[1] == '-n': g.extract_in_place = True args = args[1:] elif args[1] == '-uc': g.casefold_upper = True args = args[1:] elif args[1] == '-ad': g.use_appledouble = True g.prodos_names = True args = args[1:] elif args[1] == '-shk': g.src_shk = True args = args[1:] elif args[1] == '-pro': g.prodos_names = True args = args[1:] elif args[1] == '-e': g.use_extended = True g.prodos_names = True args = args[1:] elif args[1] == '-cat': g.catalog_only = True args = args[1:] else: usage() if g.use_appledouble and g.use_extended: usage() if g.catalog_only: if len(args) != 2: usage() else: if len(args) not in (3, 4): usage() g.image_file = args[1] if not os.path.isfile(g.image_file): print("Image/archive file \"" + g.image_file + "\" was not found.") quitNow(2) g.image_name = os.path.splitext(os.path.basename(g.image_file)) g.image_ext = g.image_name[1].lower() # automatically set ShrinkIt mode if extension suggests it if g.src_shk or g.image_ext in ('.shk', '.sdk', '.bxy'): if os.name == "nt": print("ShrinkIt archives cannot be extracted on Windows.") quitNow(2) else: try: with open(os.devnull, "w") as fnull: subprocess.call("nulib2", stdout = fnull, stderr = fnull) g.src_shk = True except Exception: print("Nulib2 is not available; not expanding ShrinkIt archive.") quitNow(2) if len(args) == 4: g.extract_file = args[2] if g.extract_file: targetPath = args[3] if os.path.isdir(targetPath): g.target_dir = targetPath elif targetPath.rsplit("/", 1) > 1: g.target_dir = targetPath.rsplit("/", 1)[0] g.target_name = targetPath.rsplit("/", 1)[1] if not os.path.isdir(g.target_dir): print("Target directory not found.") quitNow(2) else: if not g.catalog_only: if not os.path.isdir(args[2]): print("Target directory not found.") quitNow(2) if g.src_shk: g.prodos_names = False if not g.catalog_only: targetDir = (args[3] if g.extract_file else args[2]) unshkdir = ('/tmp' + "/cppo-" + str(uuid.uuid4())) makedirs(unshkdir) result = os.system("/bin/bash -c 'cd " + unshkdir + "; " + "result=$(nulib2 -xse " + os.path.abspath(g.image_file) + ((" " + args[2].replace('/', ':')) if g.extract_file else "") + " 2> /dev/null); " + "if [[ $result == \"Failed.\" ]]; then exit 3; " + "else if grep -q \"no records match\" <<< \"$result\"" + " > /dev/null; then exit 2; else exit 0; fi; fi'") if result == 512: print("File not found in ShrinkIt archive. Try cppo -cat to get the path,") print(" and omit any leading slash or colon.") quitNow(1) elif result != 0: print("ShrinkIt archive is invalid, or some other problem happened.") quitNow(1) if g.extract_file: g.extract_file = g.extract_file.replace(':', '/') extractPath = (unshkdir + "/" + g.extract_file) extractPathDir = os.path.dirname(extractPath) # move the extracted file to the root newunshkdir = ('/tmp' + "/cppo-" + str(uuid.uuid4())) makedirs(newunshkdir) for filename in os.listdir(extractPathDir): shutil.move(extractPathDir + "/" + filename, newunshkdir) shutil.rmtree(unshkdir) unshkdir = newunshkdir fileNames = [name for name in sorted(os.listdir(unshkdir)) if not name.startswith(".")] if g.extract_in_place: # extract in place from "-n" curDir = True elif (len(fileNames) == 1 and os.path.isdir(unshkdir + "/" + fileNames[0])): curDir = True # only one folder at top level, so extract in place volumeName = toProdosName(fileNames[0]) elif (len(fileNames) == 1 and # disk image, so extract in place fileNames[0][-1:] == "i"): curDir = True volumeName = toProdosName(fileNames[0].split("#")[0]) else: # extract in folder based on disk image name curDir = False volumeName = toProdosName(os.path.basename(g.image_file)) if volumeName[-4:].lower() in ('.shk', '.sdk', '.bxy'): volumeName = volumeName[:-4] if not g.catalog_only and not curDir and not g.extract_file: print("Extracting into " + volumeName) # recursively process unshrunk archive hierarchy for dirName, subdirList, fileList in os.walk(unshkdir): subdirList.sort() if not g.catalog_only: g.target_dir = (targetDir + ("" if curDir else ("/" + volumeName)) + ("/" if dirName.count('/') > 2 else "") + ("/".join(dirName.split('/')[3:]))) # chop tempdir if g.extract_file: # solo item, so don't put it in the tree g.target_dir = targetDir if g.casefold_upper: g.target_dir = g.target_dir.upper() g.appledouble_dir = (g.target_dir + "/.AppleDouble") makedirs(g.target_dir) if g.use_appledouble: makedirs(g.appledouble_dir) for fname in sorted(fileList): if fname[-1:] == "i": # disk image; rename to include suffix and correct # type/auxtype imagePath = os.path.join(dirName, fname).split("#")[0] new_name = (imagePath + ("" if os.path.splitext(imagePath.lower())[1] in ('.po', '.hdv') else ".PO") + "#e00005") os.rename(os.path.join(dirName, fname), new_name) fname = os.path.basename(new_name) g.shk_hasrf = False rfork = False if (fname[-1:] == "r" and os.path.isfile(os.path.join(dirName, fname[:-1]))): rfork = True elif (os.path.isfile(os.path.join(dirName, (fname + "r")))): g.shk_hasrf = True if not rfork: processEntry(dirName, fname) shutil.rmtree(unshkdir, True) quitNow(0) # end script if SHK g.image_data = load_file(g.image_file) # detect if image is 2mg and remove 64-byte header if so if g.image_ext in ('.2mg', '.2img'): g.image_data = g.image_data[64:] # handle 140K disk image if len(g.image_data) == 143360: #print("140K disk") prodos_disk = False fix_order = False # is it ProDOS? if g.image_data[sli(ts(0,0), 4)] == b'\x01\x38\xb0\x03': #print("detected ProDOS by boot block") if g.image_data[sli(ts(0,1)+3, 6)] == b'PRODOS': prodos_disk = True #print("order OK (PO)") elif g.image_data[sli(ts(0,14)+3, 6)] == b'PRODOS': #print("order needs fixing (DO)") prodos_disk = True fix_order = True # is it DOS 3.3? else: #print("it's not ProDOS") if g.image_data[ts(17,0)+3] == 3: (vtocT,vtocS) = g.image_data[sli(ts(17,0) + 1,2)] if vtocT<35 and vtocS<16: #print("it's DOS 3.3") g.dos33 = True # it's DOS 3.3; check sector order next if g.image_data[ts(17,14)+2] != 13: #print("order needs fixing (PO)") fix_order = True #else: print("order OK (DO)") # fall back on disk extension if weird boot block (e.g. AppleCommander) if not prodos_disk and not g.dos33: #print("format and ordering unknown, checking extension") if g.image_ext in ('.dsk', '.do'): fix_order = True #print("extension indicates DO, changing to PO") if fix_order: #print("fixing order") g.image_data = dopo_swap(g.image_data) #print("saving fixed order file as outfile.dsk") #save_file("outfile.dsk", g.image_data) #print("saved") if not prodos_disk and not g.dos33: print("Warning: Unable to determine disk format, assuming ProDOS.") # enforce leading slash if ProDOS if (not g.src_shk and not g.dos33 and g.extract_file and (args[2][0] not in ('/', ':'))): usage() if g.dos33: disk_name = (g.image_name[0] if g.image_ext in ('.dsk', '.do', '.po') else "".join(g.image_name)) if g.prodos_names: disk_name = toProdosName(disk_name) if not g.catalog_only: g.target_dir = (args[3] if g.extract_file else (args[2] + "/" + disk_name)) g.appledouble_dir = (g.target_dir + "/.AppleDouble") makedirs(g.target_dir) if g.use_appledouble: makedirs(g.appledouble_dir) if not g.extract_file: print("Extracting into " + disk_name) processDir(list(g.image_data[sli(ts(17,0)+1,2)])) if g.extract_file: print("ProDOS file not found within image file.") quitNow(0) # below: ProDOS g.activeDirBlock = 0 g.activeFileName = "" g.activeFileSize = 0 g.activeFileBytesCopied = 0 g.resourceFork = 0 g.PDOSPATH_INDEX = 0 g.prodos_names = False if g.extract_file: g.PDOSPATH = g.extract_file.replace(':', '/').split('/') g.extract_file = None if not g.PDOSPATH[0]: g.PDOSPATH_INDEX += 1 g.PDOSPATH_SEGMENT = g.PDOSPATH[g.PDOSPATH_INDEX] g.appledouble_dir = (g.target_dir + "/.AppleDouble") if g.use_appledouble and not os.path.isdir(g.appledouble_dir): mkdir(g.appledouble_dir) processDir(2) print("ProDOS file not found within image file.") quitNow(2) else: if not g.catalog_only: #print(args[0], args[1], args[2]) g.target_dir = (args[2] + "/" + getVolumeName().decode("L1")) g.appledouble_dir = (g.target_dir + "/.AppleDouble") if not os.path.isdir(g.target_dir): makedirs(g.target_dir) if g.use_appledouble and not os.path.isdir(g.appledouble_dir): makedirs(g.appledouble_dir) processDir(2) if not g.catalog_only: quitNow(0)