--- /dev/null
+import binascii
+import serial
+from stat import S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IXGRP, S_IROTH, S_IXOTH, S_IFDIR, S_IFREG
+import struct
+
+from AESession import AESession
+import AEMultipart
+
+
+###################################
+#
+# All paths are without leading /
+# All paths are in Amiga charset.
+#
+###################################
+
+
+# Command 0x01
+# Cancel a running operation.
+#
+def cancel(session):
+ session.sendMsg(1, b'')
+
+
+
+# Command 0x64
+# List a directory.
+#
+def dir_list(session, path):
+ print("AECmds.dir_list: " + path)
+
+ session.sendMsg(0x64, path + b'\x00\x01')
+
+ dirlist = AEMultipart.recv(session)
+ # TODO: Check for None returned, meaning that the path doesn't exist.
+ # Actually, what can we return then?
+ # None is not iterable, and [] indicates an empty directory.
+ close(session)
+
+
+ # Parse dirlist
+
+ (numents,) = struct.unpack('!L', dirlist[0:4])
+ dirlist = dirlist[4:]
+
+ kids = {}
+ #kids['.'] = (dict(st_mode=(S_IFDIR | 0o755), st_nlink=2), {})
+ #kids['..'] = (dict(st_mode=(S_IFDIR | 0o755), st_nlink=2), {})
+
+ while numents > 0:
+ assert len(dirlist) > 29
+ (entlen, size, used, type, attrs, mdays, mmins, mticks, type2) = struct.unpack('!LLLHHLLLB', dirlist[0:29])
+ # entlen - Size of this entry in the list, in bytes
+ # size - Size of file.
+ # For drives, total space.
+ # used - 0 for files and folders.
+ # For drives, space used.
+ # type - ?
+ # attrs - Amiga attributes
+ # mdays - Last modification in days since 1978-01-01
+ # mmins - Last modification in minutes since mdays
+ # mticks - Last modification in ticks (1/50 sec) since mmins
+ # type2 - 0: Volume
+ # - 1: Volume
+ # - 2: Directory
+ # - 3: File
+ # - 4: ROM
+ # - 5: ADF
+ # - 6: HDF
+ assert entlen <= len(dirlist)
+
+ name = dirlist[29:entlen].split(b'\x00')[0].decode(encoding="iso8859-1")
+
+ dirlist = dirlist[entlen:]
+ numents -= 1
+
+ st = {}
+ st = {}
+ st['st_mode'] = 0
+ #if attrs & 0x40: st['st_mode'] |= Script
+ #if attrs & 0x20: st['st_mode'] |= Pure
+ #if attrs & 0x10: st['st_mode'] |= Archive
+ if not attrs & 0x08: st['st_mode'] |= S_IRUSR | S_IRGRP | S_IROTH # Read
+ if not attrs & 0x04: st['st_mode'] |= S_IWUSR # Write
+ if not attrs & 0x02: st['st_mode'] |= S_IXUSR | S_IXGRP | S_IXOTH # Execute
+ #if not attrs & 0x01: st['st_mode'] |= Delete
+
+ # Check for directory
+ if type & 0x8000:
+ st['st_mode'] |= S_IFDIR
+ else:
+ st['st_mode'] |= S_IFREG
+ st['st_nlink'] = 1
+
+ st['st_size'] = size
+
+ st['st_mtime'] = (2922*24*60*60) # Amiga epoch starts 1978-01-01
+ st['st_mtime'] += (mdays*24*60*60) # Days since 1978-01-01
+ st['st_mtime'] += (mmins*60) # Minutes
+ st['st_mtime'] += (mticks/50) # Ticks of 1/50 sec
+
+ st['st_blksize'] = session.packetsize - 4
+
+ # TODO: Convert time zone.
+ # Amiga time seems to be local time, we currently treat it as UTC.
+
+ kids[name] = (st, None)
+
+ return kids
+
+
+
+# Command 0x65
+# Read a file.
+#
+def file_read_start(session, path):
+ print("AECmds.file_read_start: " + path)
+
+ # Request file
+ session.sendMsg(0x65, path + b'\x00')
+
+ # Get file response header
+ (filelen, pktsize) = AEMultipart.recvHeader(session)
+
+ # TODO: Check for None returned, meaning that the path doesn't exist.
+ # This may not be necessary in case FUSE always issues a getattr()
+ # beforehand.
+
+ return filelen
+
+
+def file_read_next(session):
+ (blockOffset, blockData) = AEMultipart.recvBlock(session)
+
+ if (blockData == None):
+ blen = None
+ else:
+ blen = len(blockData)
+
+ print("AECmds.file_read_next: " + str(blen) + ' @ ' + str(blockOffset))
+
+ return (blockOffset, blockData)
+
+
+
+# Command 0x66
+# Write a complete file and set its attributes and time.
+#
+def file_write(session, path, amigaattrs, unixtime, filebody):
+ print('AECmds.file_write: ' + path + ' -- ' + str(len(filebody)))
+
+ filelen = len(filebody)
+
+ _utime = unixtime - (2922*24*60*60) # Amiga epoch starts 1978-01-01
+ mdays = int(_utime / (24*60*60)) # Days since 1978-01-01
+ _utime -= mdays * (24*60*60)
+ mmins = int(_utime / 60) # Minutes
+ _utime -= mmins * 60
+ mticks = _utime * 50 # Ticks of 1/50 sec
+
+ filetype = 3 # Regular file
+
+ data = struct.pack('!LLLLLLLB',
+ 29 + len(path) + 6, # Length of this message, really
+ filelen,
+ 0,
+ amigaattrs,
+ mdays,
+ mmins,
+ mticks,
+ filetype)
+ data += path
+ data += b'\0\0\0\0\0\0' # No idea what this is for
+ session.sendMsg(0x66, data)
+
+ # TODO: Handle target FS full
+ # TODO: Handle permission denied on target FS
+
+ AEMultipart.send(session, filebody)
+ close(session)
+
+
+
+# Command 0x67
+# Delete a path.
+# Can be a file or folder, and will be deleted recursively.
+#
+def delete(session, path):
+ print("AECmds.delete: " + path)
+
+ session.sendMsg(0x67, path + b'\x00')
+
+ (type, _) = session.recvMsg()
+
+ close(session)
+
+ # type == 0 means the file was deleted successfully
+ return (type == 0)
+
+
+
+# Command 0x68
+# Rename a file, leaving it in the same folder.
+#
+def rename(session, path, new_name):
+ print("AECmds.rename: " + path + ' - ' + new_name)
+ session.sendMsg(0x68, path + b'\x00' + new_name + b'\x00')
+ (type, _) = session.recvMsg()
+
+ if type != 0:
+ print("AECmds.rename: Response type " + str(type))
+
+ close(session)
+
+ # Assume that type == 0 means the file was renamed successfully
+ return (type == 0)
+
+
+
+# Command 0x69
+# Move a file from a folder to a different one, keeping its name.
+#
+def move(session, path, new_parent):
+ print("AECmds.move: " + path + ' - ' + new_parent)
+ session.sendMsg(0x69, path + b'\x00' + new_parent + b'\x00\xc9')
+ (type, _) = session.recvMsg()
+
+ if type != 0:
+ print("AECmds.move: Response type " + str(type))
+
+ close(session)
+
+ # Assume that type == 0 means the file was moved successfully
+ return (type == 0)
+
+
+
+# Command 0x6a
+# Copy a file.
+#
+def copy(session, path, new_parent):
+ print("AECmds.copy: " + path + ' - ' + new_parent)
+ session.sendMsg(0x6a, path + b'\x00' + new_parent + b'\x00\xc9')
+ (type, _) = session.recvMsg()
+
+ if type != 0:
+ print("AECmds.copy: Response type " + str(type))
+
+ close(session)
+
+ # Assume that type == 0 means the file was copied successfully
+ return (type == 0)
+
+
+
+# Command 0x6b
+# Set attributes and comment.
+#
+def setattr(session, amigaattrs, path, comment):
+ print("AECmds.setattr: " + str(amigaattrs) + ' - ' + path + ' - ' + comment)
+
+ data = struct.pack('!L', amigaattrs)
+ data += path + b'\x00'
+ data += comment + b'\x00'
+ data += struct.pack('!L', 0)
+
+ session.sendMsg(0x6b, data)
+ (type, _) = session.recvMsg()
+
+ if type != 0:
+ print("AECmds.setattr: Response type " + str(type))
+
+ close(session)
+
+ # Assume that type == 0 means the file was copied successfully
+ return (type == 0)
+
+
+
+# Command 0x6c
+# Request (?)
+#
+
+
+
+# Command 0x6d
+# Finish a running operation.
+#
+def close(session):
+ print('AECmds.close')
+
+ session.sendMsg(0x6d, b'')
+
+ (type, data) = session.recvMsg()
+ assert type == 0x0a
+ if data != b'\0\0\0\0\0':
+ print('AECmds.close: data == ' + binascii.hexlify(data))
+ # Format of data returned:
+ # Byte 0: ?
+ # Byte 1: ?
+ # Byte 2: ?
+ # Byte 3: 00 - No error
+ # 06 - File no longer exists
+ # 1c - Timed out waiting for host to request next read block
+ # Byte 4: Path in case of error 06.
+ # Empty (null-terminated) otherwise?
+ # Null-terminated string.
+ #assert data == b'\0\0\0\0\0'
+
+
+
+# Command 0x6e
+# Format a disk.
+#
+
+
+
+# Command 0x6f
+# Create a new folder and matching .info file.
+# This folder will be named "Unnamed1".
+#
--- /dev/null
+import binascii
+from errno import ENOENT, EINVAL, EIO, EROFS
+from fusepy import FUSE, FuseOSError, Operations
+from stat import S_IRUSR, S_IWUSR, S_IXUSR, S_IRGRP, S_IROTH, S_IXGRP, S_IXOTH, S_IFDIR, S_IFREG
+import struct
+import sys
+from time import time
+
+from AELink import AELinkSerial
+from AESession import AESession
+import AEMultipart
+import AECmds
+from FuseCache import FuseCache
+import FusePatches
+
+
+amiga_charset = 'iso8859-1'
+
+
+
+
+
+
+
+
+class AEFuse(Operations):
+ def __init__(self, session):
+ self.session = session
+
+ self.cache = FuseCache()
+
+ self.readpath = None
+ self.readbuf = None
+ self.readmax = None # Total size of the file being read
+
+ self.writepath = None
+ self.writebuf = None
+ self.writemtime = None
+ self.writeattrs = None
+
+
+ def getattr(self, path, fh=None):
+ print('AEFuse.getattr: ' + path)
+
+ dirpath = path[0:path.rfind('/')] # Without the trailing slash
+ name = path[path.rfind('/') + 1:] # Without a leading slash
+
+ st = self.cache.getattr(path)
+
+ if not st:
+ # If we have a cache miss, see if we've cached its parent
+ # directory.
+ #
+ # If not, then try to read the parent directory.
+ #
+ # Note that accessing a deep path will cause Linux to stat its
+ # parents recursively, which in turn will cause self.getattr()
+ # to call self.readdir() on them, filling all cache levels in
+ # between.
+ #
+ # https://sourceforge.net/p/fuse/mailman/message/19717106/
+ #
+ if self.cache.getkids(dirpath) == None:
+ # We haven't read the directory yet
+ if name in self.readdir(dirpath, fh):
+ # If the dirlist succeeded, try again.
+ #
+ # Note that we're never asking the host for a deep path
+ # that doesn't exist, since Linux will stat all parents,
+ # thus listing directories at every level until the first
+ # one that doesn't exist (see above).
+ #
+ # As a bonus, this automatically updates the cache if the
+ # path now exists.
+ return self.getattr(path, fh)
+
+ # Okay, the path doesn't exist.
+ # That means our file can't exist.
+ print('getaddr ENOENT: ' + path)
+ raise FuseOSError(ENOENT)
+
+ return st
+
+
+ def readdir(self, path, fh):
+ print("AEFuse.readdir: " + path)
+
+ self._cancel_read()
+ self._flush_write()
+
+ # Request directory listing
+ kids = AECmds.dir_list(self.session, path[1:].encode(amiga_charset))
+
+ # Update cache
+ self.cache.setkids(path, kids)
+
+ #return [(name, self.cache[name], 0) for name in self.cache.keys()]
+ return kids.keys()
+
+
+ def read(self, path, size, offset, fh):
+ print("AEFuse.read: " + path + ' -- ' + str(size) + ' @ ' + str(offset))
+
+ # Avoid inconsistency.
+ # If we don't do this, then reading the file while it's open
+ # returns something different from what is in the write buffer.
+ self._flush_write()
+
+ if self.readpath != path:
+ if self.readpath != None:
+ self._cancel_read()
+
+ self.readpath = path
+ self.readbuf = b''
+
+ # Request file
+ self.readmax = AECmds.file_read_start(self.session, path[1:].encode(amiga_charset))
+
+ # TODO: Check for None returned, meaning that the path doesn't exist.
+
+ if (offset + size > len(self.readbuf)) \
+ and (offset < self.readmax) \
+ and (len(self.readbuf) < self.readmax):
+ # Get further file contents if we need it.
+ while len(self.readbuf) < min(offset + size, self.readmax):
+ (blockOffset, blockData) = AECmds.file_read_next(self.session)
+
+ if blockData == None:
+ # Since we only enter this loop if there should be data
+ # left to read, a None returned means an unexpected EOF
+ # or more probably, the connection timed out.
+ #
+ # We operate under the illusion that we can keep the last
+ # accessed file open wherever we were at, however after a
+ # few seconds the host will close the file without us
+ # knowing. In case that happens, let's reload the file.
+ print('Unexpected error while reading next file block.')
+ print('Re-requesting file.')
+
+ # If we cancel the transfer ourselves, then the reply to
+ # sendClose() will be 0x00 0x00 0x00 0x1c 0x00.
+ #
+ # Strange: If we cancel in the same situation, but without
+ # having received the type 1 cancel message from the host,
+ # the reply to sendClose() is normal zeroes.
+ self._cancel_read()
+ return self.read(path, size, offset, fh)
+
+ assert blockOffset == len(self.readbuf)
+ self.readbuf += blockData
+
+ # When done transferring a whole file, the Amiga side insists on
+ # sending its end-of-file type 4 message. So let's request it.
+ if len(self.readbuf) == self.readmax:
+ (blockOffset, blockData) = AECmds.file_read_next(self.session)
+ assert blockData == None
+
+ print("read: " + path + ' -- finished with len(self.readbuf) == ' + str(len(self.readbuf)))
+ return self.readbuf[offset:offset + size]
+
+
+ def _cancel_read(self):
+ # Cancel current read operation
+ if self.readpath != None:
+ if (len(self.readbuf) < self.readmax):
+ print('_cancel_read: Cancelling.')
+ AECmds.cancel(self.session)
+
+ AECmds.close(self.session)
+
+ self.readbuf = None
+ self.readpath = None
+
+
+ def open(self, path, flags):
+ print("AEFuse.open: " + path)
+
+ # Dummy function to allow file access.
+
+ return 0
+
+
+ def _prep_write(self, path, trunclen):
+ # We can't write in the virtual top level directory
+ if len(path) < 4:
+ raise FuseOSError(ENOENT)
+
+ self._cancel_read()
+
+ if self.writepath != path:
+ self._flush_write()
+
+ # If the file already exists, read its previous contents.
+ # Check cache, since FUSE/VFS will have filled it.
+ st = self.cache.getattr(path)
+ if st != None and st['st_size'] > 0:
+ if trunclen != None:
+ if trunclen > 0:
+ self.writebuf = self.read(path, trunclen, 0, None)
+ else:
+ self.writebuf = self.read(path, st['st_size'], 0, None)
+ self._cancel_read()
+
+ self.writepath = path
+ self.writeattrs = 0
+ if self.writebuf == None:
+ self.writebuf = b''
+
+
+ def create(self, path, mode, fi=None):
+ print("AEFuse.create: " + path)
+
+ # We can't write in the virtual top level directory
+ if len(path) < 4:
+ raise FuseOSError(ENOENT)
+
+ # We can't create a file over an existing one.
+ # By now, the system will have primed our cache, so we won't ask
+ # the big fuseop self.getattr(). That wouldn't work anyway, since
+ # it raises a FuseOSError rather than returning None.
+ assert self.cache.getattr(path) == None
+ if self.writepath != None:
+ assert path != self.writepath
+
+ # Create a dummy file, so the path exists
+ AECmds.file_write(self.session, path[1:].encode(amiga_charset), 0, time(), b'')
+
+ # Refresh cache so a subsequent getattr() succeeds
+ dirpath = path[0:path.rfind('/')]
+ self.readdir(dirpath, None)
+
+ return 0
+
+
+ def truncate(self, path, length, fh=None):
+ print("AEFuse.truncate: " + path + ' -- ' + str(length))
+
+ self._prep_write(path, length)
+
+ self.writebuf = self.writebuf[:length]
+ if length > len(self.writebuf):
+ # Fill up
+ self.writebuf = self.writebuf[:len(self.writebuf)] + (b'\0' * (length - len(self.writebuf)))
+
+ self.writemtime = time()
+
+ return 0
+
+
+
+ # WARNING: Due to buffering, we will NOT be able to report
+ # a full disk as a response to the write call!
+ def write(self, path, data, offset, fh):
+ print("AEFuse.write: " + path + ' -- ' + str(len(data)) + ' @ ' + str(offset))
+
+ self._prep_write(path, None)
+
+ if offset > len(self.writebuf):
+ # Fill up
+ self.writebuf = self.writebuf[:len(self.writebuf)] + (b'\0' * (offset - len(self.writebuf)))
+
+ self.writebuf = self.writebuf[:offset] + data + self.writebuf[offset+len(data):]
+ self.writemtime = time()
+
+ # WARNING!
+ # We cannot check for a full disk here, so we're
+ # just assuming that buffering is fine.
+ return len(data)
+
+
+ def utimens(self, path, (atime, mtime)):
+ print("AEFuse.utimens: " + path + ' -- ' + str(mtime))
+
+ # We can only set the time when sending a complete file.
+ if self.writepath == path:
+ self.writemtime = mtime
+ else:
+ raise FuseOSError(EROFS)
+
+
+ def _flush_write(self):
+ if self.writepath == None:
+ return
+
+ # If this fails, there is nothing we can do.
+ # Except returning an error on close().
+ # But honestly, who checks for that?
+ AECmds.file_write(self.session,
+ self.writepath[1:].encode(amiga_charset), self.writeattrs,
+ self.writemtime, self.writebuf)
+
+ # Extract dirpath before we throw away self.writepath
+ dirpath = self.writepath[0:self.writepath.rfind('/')]
+
+ # Throw away the write buffer once done, so we don't cache full files.
+ self.writepath = None
+ self.writebuf = None
+ self.writemtime = None
+ self.writeattrs = None
+
+ # Refresh cache so subsequent accesses are correct
+ self.readdir(dirpath, None)
+
+
+ # Called on close()
+ def flush(self, path, fh):
+ print("AEFuse.flush: " + path)
+
+ # Flush any remaining write buffer
+ self._flush_write()
+
+ print("AEFuse.flush: finished: " + path)
+
+
+ def unlink(self, path):
+ print("AEFuse.unlink: " + path)
+
+ # TODO: Handle file that is currently open for reading/writing
+
+ self.session.sendMsg(0x67, path[1:].encode(amiga_charset) + b'\x00')
+
+ (type, _) = self.session.recvMsg()
+
+ self.session.sendClose()
+
+ # Refresh cache so a subsequent getattr() is up to date.
+ # We refresh even in case the delete failed, because it
+ # indicates our cache being out of date.
+ dirpath = path[0:path.rfind('/')]
+ self.readdir(dirpath, None)
+
+ if type == 0:
+ return 0 # File deleted successfully
+ else:
+ raise FuseOSError(EIO)
+
+
+ def rmdir(self, path):
+ # TODO: Refuse if the directory is not empty
+ return self.unlink(path)
+
+
+ def ae_mkdir(self, path):
+ self._cancel_read()
+
+ amigaattrs = 0
+
+ _utime = time() - (2922*24*60*60) # Amiga epoch starts 1978-01-01
+ mdays = int(_utime / (24*60*60)) # Days since 1978-01-01
+ _utime -= mdays * (24*60*60)
+ mmins = int(_utime / 60) # Minutes
+ _utime -= mmins * 60
+ mticks = _utime * 50 # Ticks of 1/50 sec
+
+ filetype = 2 # Folder
+
+ data = struct.pack('!LLLLLLLB',
+ 29 + len(path) + 6, # Length of this message, really
+ 0,
+ 0,
+ amigaattrs,
+ mdays,
+ mmins,
+ mticks,
+ filetype)
+ data += path.encode(amiga_charset)
+ data += b'\0\0\0\0\0\0' # No idea what this is for
+ self.session.sendMsg(0x66, data)
+
+ # TODO: Handle target FS full
+ # TODO: Handle permission denied on target FS
+
+ self.session.sendClose()
+
+
+ def mkdir(self, path, mode):
+ print('AEFuse.mkdir: ' + path)
+
+ self.ae_mkdir(path[1:].encode(amiga_charset))
+
+ # Refresh cache so a subsequent getattr() succeeds
+ dirpath = path[0:path.rfind('/')]
+ self.readdir(dirpath, None)
+
+
+ def rename(self, old, new):
+ print('AEFuse.rename: ' + old + ' - ' + new)
+ dirpath_old = old[0:old.rfind('/')]
+ dirpath_new = new[0:new.rfind('/')]
+ filename_old = old[old.rfind('/') + 1:]
+ filename_new = new[new.rfind('/') + 1:]
+
+ # If the file already exists, delete it.
+ # Check cache, since FUSE/VFS will have filled it.
+ st = self.cache.getattr(new)
+ if st != None:
+ self.unlink(new)
+
+ if dirpath_new == dirpath_old:
+ AECmds.rename(self.session,
+ old[1:].encode(amiga_charset),
+ filename_new.encode(amiga_charset))
+ else:
+ # Move in 3 steps:
+ # 1. Rename file to a temporary name
+ # (NOTE: We hope it doesn't exist!)
+ # 2. Move the file to the new folder
+ # 3. Rename the file to the target file name
+ # The reason for this is that the old file name may exist in
+ # the new directory, and the new file name may exist in the
+ # old directory. Thus, if we were to do only one renaming,
+ # either order of rename+move or move+rename could be
+ # problematic.
+
+ assert (self.cache.getattr(dirpath_old + '/_fatemp_') == None)
+ assert (self.cache.getattr(dirpath_new + '/_fatemp_') == None)
+
+ AECmds.rename(self.session,
+ old[1:].encode(amiga_charset),
+ '_fatemp_'.encode(amiga_charset))
+ AECmds.move(self.session,
+ (dirpath_old + '/_fatemp_')[1:].encode(amiga_charset),
+ dirpath_new[1:].encode(amiga_charset))
+ AECmds.rename(self.session,
+ (dirpath_new + '/_fatemp_')[1:].encode(amiga_charset),
+ filename_new.encode(amiga_charset))
+
+ # Refresh cache so a subsequent getattr() succeeds
+ self.readdir(dirpath_old, None)
+ self.readdir(dirpath_new, None)
+
+
+ def chmod(self, path, mode):
+ print("AEFuse.chmod: " + path + ' -- ' + str(mode))
+
+ amigaattrs = 0
+ # Apparently we don't have to worry about directory flags
+ if not mode & S_IRUSR: amigaattrs |= 0x08
+ if not mode & S_IWUSR: amigaattrs |= 0x04
+ if not mode & S_IXUSR: amigaattrs |= 0x02
+
+ AECmds.setattr(self.session,
+ amigaattrs,
+ path[1:].encode(amiga_charset),
+ '')
+
+
+ def chown(self, path, uid, gid):
+ # AmigaOS does not know users/groups.
+ raise FuseOSError(EROFS)
+
+
+ # Called on umount
+ def destroy(self, path):
+ print('AEFuse.destroy: ' + path)
+
+ # Flush any remaining write buffer
+ self._cancel_read()
+ self._flush_write()
--- /dev/null
+import binascii
+import serial
+import struct
+import traceback
+
+
+class AELink:
+ def __init__(self):
+ return
+
+
+
+
+
+class AELinkSerial(AELink):
+ def __init__(self, path, speed):
+ self.ser = serial.Serial(path, speed, timeout=5, rtscts=1)
+ assert self.ser.name == path
+
+ AELink.__init__(self)
+
+ def recv(self, rxlen):
+ assert self.ser.is_open
+ buf = self.ser.read(rxlen)
+ #print("Received: " + binascii.hexlify(buf))
+ return buf
+
+ def send(self, data):
+ assert self.ser.is_open
+ #print("Sending: " + binascii.hexlify(data))
+ #traceback.print_stack()
+ return self.ser.write(data)
+
+ def close(self):
+ assert self.ser.is_open
+ self.ser.close()
--- /dev/null
+import struct
+
+
+
+def recvHeader(session):
+ (type, data) = session.recvMsg()
+ # TODO: Check for type 1, as that means an error.
+ # For example, a directory can't be listed because it doesn't exist.
+ assert type == 3
+ assert len(data) == 8
+
+ (datalen, pktsize) = struct.unpack('!LL', data)
+
+ return (datalen, pktsize)
+
+
+def recvBlock(session):
+ # Send empty type 0 message to request next block
+ session.sendMsg(0, b'')
+
+ (type, data) = session.recvMsg()
+
+ if type == 1:
+ print('recvMultipartBlock: Host cancelled transfer.')
+ # Maybe TODO: Raise an exception
+ return (None, None)
+
+ if type == 4:
+ # Last block
+ assert len(data) == 0
+ return (None, None)
+
+ # Expect a data block
+ assert type == 5
+
+ # Any data block has the offset prepended,
+ # followed by up to PACKETSIZE-4 bytes of payload.
+ assert len(data) >= 4
+
+ (offset,) = struct.unpack('!L', data[0:4])
+
+ return (offset, data[4:])
+
+
+def recv(session):
+ fullData = b''
+
+ (datalen, pktsize) = recvHeader(session)
+
+ offset = 0
+ data = b''
+ while data != None:
+ assert offset == len(fullData)
+ fullData += data
+
+ (offset, data) = recvBlock(session)
+
+ return fullData
+
+
+def send(session, fullData):
+ # Wait for Amiga to request first block with type 0
+ (type, _) = session.recvMsg()
+
+ # TODO: Handle transfer abort (type 1)
+ # TODO: What happens when sending an ADF != 901120 bytes?
+ assert (type == 0) or (type == 8)
+
+ if type == 8:
+ # Does this confirm that we want to overwrite?
+ session.sendMsg(0, b'')
+
+ # Send length and block size
+ session.sendMsg(3, struct.pack('!LL', len(fullData), session.packetsize))
+
+ bytesSent = 0
+ while bytesSent < len(fullData):
+ # Wait for Amiga to request block with type 0
+ (type, _) = session.recvMsg()
+ assert type == 0
+
+ print("AEMultipart.send: " + str(bytesSent))
+
+ txlen = min(session.packetsize - 4, len(fullData) - bytesSent)
+ session.sendMsg(5, struct.pack('!L', bytesSent) + fullData[bytesSent : bytesSent+txlen])
+
+ bytesSent += txlen
+
+ # Wait for Amiga's type 0
+ (type, _) = session.recvMsg()
+ assert type == 0
+
+ # Finish transfer
+ session.sendMsg(4, b'')
--- /dev/null
+import binascii
+import serial
+import struct
+
+
+class AESession:
+ def __init__(self, link):
+ self.link = link
+ self.seq = 1
+ self.sendInit()
+ self.packetsize = 512
+
+
+ def recvMsg(self):
+ rawHeader = self.link.recv(12)
+ if len(rawHeader) != 12:
+ print('recvMsg: len(rawHeader) == ' + str(len(rawHeader)) + ' data: ' + binascii.hexlify(rawHeader))
+ #assert len(rawHeader) == 12
+
+ (type, datalen, seq, crc) = struct.unpack('!HHLL', rawHeader)
+ assert crc == (binascii.crc32(rawHeader[0:8]) & 0xffffffff)
+ # TODO: Send PkRs if CRC mismatches
+
+ data = b''
+
+ if datalen > 0:
+ data = self.link.recv(datalen)
+ assert len(data) == datalen
+
+ # Note: Python calculates signed CRCs.
+ # Thus, we parse the incoming CRC as signed.
+ datacrc = self.link.recv(4)
+ assert len(datacrc) == 4
+ (datacrc,) = struct.unpack('!L', datacrc)
+
+ assert datacrc == (binascii.crc32(data) & 0xffffffff)
+ # TODO: Send PkRs if CRC mismatches
+
+ self.link.send(b'PkOk')
+
+ # seq is currently ignored when receiving
+ return (type, data)
+
+
+ def sendMsg(self, type, data):
+ stream = struct.pack('!HHL', type, len(data), self.seq)
+ stream += struct.pack('!L', binascii.crc32(stream) & 0xffffffff)
+
+ if len(data) > 0:
+ stream += data
+ stream += struct.pack('!L', binascii.crc32(data) & 0xffffffff)
+
+ self.link.send(stream)
+
+ # TODO: Re-send on 'PkRs'
+ assert self.link.recv(4) == b'PkOk'
+
+ self.seq += 1;
+
+
+
+ def sendInit(self):
+ self.sendMsg(2, b'Cloanto(r)')
+ # TBD: Password support.
+ # It is CRC32'd and the CRC is appended to the string above.
+
+ # TODO: Recover from desynced state
+ #if not self.isAcked():
+ # self.sendAck()
+ # return self.sendInit()
+
+ (type, data) = self.recvMsg()
+ assert type == 2
+ assert data.startswith(b'Cloanto')
+
+
+ def sendClose(self):
+ print('sendClose')
+
+ self.sendMsg(0x6d, b'')
+
+ (type, data) = self.recvMsg()
+ assert type == 0x0a
+ if data != b'\0\0\0\0\0':
+ print('sendClose: data == ' + binascii.hexlify(data))
+ # Format of data returned:
+ # Byte 0: ?
+ # Byte 1: ?
+ # Byte 2: ?
+ # Byte 3: 00 - No error
+ # 06 - File no longer exists
+ # 1c - Timed out waiting for host to request next read block
+ # Byte 4: Path in case of error 06.
+ # Empty (null-terminated) otherwise?
+ # Null-terminated string.
+ #assert data == b'\0\0\0\0\0'
--- /dev/null
+from stat import S_IFDIR
+
+
+class FuseCache():
+ def __init__(self):
+ # Initialize virtual root
+ self.cache = {}
+
+ # Cache tuple:
+ # (dict of attrs, dict of children in folder)
+
+
+ def getattr(self, path):
+ paths = [p for p in path.split('/') if len(p) > 0]
+ #print(paths)
+
+ # Virtual root
+ st = dict(st_mode=(S_IFDIR | 0o755), st_nlink=2)
+
+ c = self.cache
+ for p in paths:
+ if c == None:
+ return None
+
+ if p not in c:
+ return None
+
+ (st, c) = c[p]
+
+ return st
+
+
+ def getkids(self, path):
+ paths = [p for p in path.split('/') if len(p) > 0]
+
+ c = self.cache
+ for p in paths:
+ if c == None:
+ return None
+
+ if p not in c:
+ return None
+
+ (_, c) = c[p]
+
+ return c
+
+
+ # Set a cache node's children and their attributes.
+ # This implicitly purges any prvious children from the cache.
+ # Thus, those directories will be re-scanned next time.
+ def setkids(self, path, children):
+ paths = [p for p in path.split('/') if len(p) > 0]
+
+ c = self.cache
+ for p in paths:
+ # We expect to be able to walk the path, because we can't get
+ # there without Linux' VFS stat'ing all directories leading up.
+ parent = c
+ (_, c) = c[p]
+
+ if (c == self.cache):
+ self.cache = children
+ else:
+ (st, _) = parent[p]
+ parent[p] = (st, children)
--- /dev/null
+# Ugly patches for fusepy to accommodate inflexible userspace applications.
+#
+
+from ctypes import c_uint, cast, POINTER, Structure
+from fusepy import FUSE
+
+
+class fuse_conn_info(Structure):
+ _fields_ = [
+ ('proto_major', c_uint),
+ ('proto_minor', c_uint),
+ ('async_read', c_uint),
+ ('max_write', c_uint),
+ ('max_readahead', c_uint),
+ ('capable', c_uint),
+ ('want', c_uint),
+ ('max_background', c_uint),
+ ('congestion_threshold', c_uint)
+ ]
+
+
+# Ugly patch for fusepy to allow changing max_readahead.
+#
+# This is necessary for FUSE filesystems which need to avoid unnecessary
+# data transfers.
+#
+# Example:
+# If a GIO (as in GLib/GNOME's GIO) based file manager (e.g. XFCE's Thunar)
+# tries to determine each file's type by inspecting its header (GLib 2.50
+# reads up to 4 KB of each file), this results in a lot of traffic. If the
+# kernel increases this to 16 KB as part of its buffered I/O's readahead,
+# things become very slow on exotically slow links or host media.
+# In fact, this patch has been written with a 2 KByte/s link in mind.
+#
+# Why not turn off this header-sniffing feature in userspace?
+# Because... Neither Thunar nor GLib/GIO have this option, and exotic FUSE
+# filesystems still need to work on them until they have a mechanism to turn
+# this off. Preferably with a hint in stat() or statfs().
+#
+# NOTE:
+# The kernel will impose a lower bound on max_readahead.
+# As of 4.9 on x86-64, this is 4096 bytes.
+# (still a lot on a 2 KB/s link, but Thunar won't be *completely* useless)
+#
+def patch_max_readahead(max_readahead):
+ old_init = FUSE.init
+
+ def _new_fuse_init(self, conn):
+ conn2 = cast(conn, POINTER(fuse_conn_info))
+ conn2.contents.max_readahead = max_readahead
+ return old_init(self, conn)
+
+ FUSE.init = _new_fuse_init
--- /dev/null
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
--- /dev/null
+fuse-aexplorer
+===============
+
+A crude re-implementation of the Amiga Explorer protocol, for Linux/FUSE.
+
+All knowledge of the protocol is either based on Mark Street's lxamiga or
+[lxamiga.pl](https://github.com/marksmanuk/lxamiga) or gained by
+monitoring communication between the original Windows version of
+Amiga Explorer and the Amiga side.
+
+This software is highly experimental and use is fully AT YOUR OWN RISK.
+Please don't blame me or Cloanto or anyone if anything breaks.
+
+If you experience any issues (and that's almost guaranteed), please use
+[Cloanto's official Windows software](https://www.amigaforever.com/ae/)
+instead. It's a great, stable software package.
+
+
+Usage:
+-------
+
+./fuse-aexplorer /mnt/amiga /dev/ttyUSB0 19200
+
+cp -a myfile "/mnt/amiga/RAM\:Ram\ Disk/"
+
+
+
+
+DATA LOSS WARNING
+==================
+
+Comments and attributes without an equivalence in Linux are lost
+whenever a write operation (including changing attributes) is
+performed on a file.
+
+I'm sure there's more, but I've forgotten about it.
+
+
+
+Things that are broken
+=======================
+
+A lot. The Amiga Explorer protocol really isn't meant to be used as
+a "network file system".
+
+Examples:
+
+ - Reading only a part of a file isn't possible.
+ There is a hack to only read the start of it, thus making Thunar
+ and other GIO programs not get stuck completely.
+
+ - Changing a part of a file or appending data isn't possible - it
+ has to be rewritten from scratch.
+ We're buffering a file and send it when flush() is called.
+
+ - Setting a file's modification date can only be done when
+ writing it from scratch.
+ Use 'cp -a' to copy your files.
+
+ - Files and folders being deleted on the Amiga while we know that they
+ exist (i.e. their attributes are cached) causes undefined behavior.
+
+ - And many more hacks!
+ Really, go use the original software instead!
+
+
+
+TODO
+=====
+
+Search the code for TODO and NOTE.
+
+:-)
+
+
+
+Thanks
+=======
+
+Cloanto for Amiga Explorer. Great stuff and a life saver.
+
+Mark Street for lxamiga and
+[lxamiga.pl](https://github.com/marksmanuk/lxamiga) - this gave me a
+head start in understanding the protocol.
+
+
+
+License
+========
+
+GNU General Public License v2 only.
--- /dev/null
+Message types
+==============
+
+ Msg ID | Sending side | Description
+ --------|--------------|----------------------------------
+ 00 | Ami/PC | Ask for next block
+ 01 | Ami/PC | Transfer cancelled
+ 02 | Ami/PC | Initialisation / Init response
+ 03 | Ami/? | Multipart header
+ 04 | Amiga | EOF (no payload)
+ 05 | Amiga | Next data block
+
+ 08 | Amiga | File already exists (when trying to write with 0x66)
+ 09 | Amiga | Size ? (response to 0x6c)
+ 0a | Amiga | Close response
+ 0b | Amiga | Format response?
+
+ 64 | PC | List directory
+ 65 | PC | File read
+ 66 | PC | File/folder write
+ 67 | PC | File/folder delete (recursively)
+ 68 | PC | File rename (name changes) (works on drives, too?)
+ 69 | PC | File move (path changes)
+ 6a | PC | File copy
+ 6b | PC | Set attributes and comment
+ 6c | PC | Request size on disk (?)
+ 6d | PC | Close file
+ 6e | PC | Format disk (needs Kickstart 2.0 or newer)
+ 6f | PC | New folder
+
+
+
+
+Request details
+================
+
+64 - List a directory
+----------------------
+
+### TODO ###
+
+
+65 - Read a file
+-----------------
+
+### TODO ###
+
+
+66 - Write a file
+------------------
+
+### TODO ###
+
+
+67 - Delete file/folder
+------------------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ n | Path
+ 1 | 0x00
+
+Then, read type 0 for confirmation.
+Then, sendClose() (0xa response: 5x 00).
+
+If Path is a folder, it will be deleted together with its contents.
+
+
+68 - Rename file/folder
+------------------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ n | Path (including old file name)
+ 1 | 0x00
+ n | New file name (without path)
+ 1 | 0x00
+
+Then, read type 0 for confirmation.
+Then, sendClose() (0xa response: 5x 00).
+
+
+69 - Move file/folder
+----------------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ n | Path (including old file name)
+ 1 | 0x00
+ n | New path to contain file (folder without trailing slash or file name)
+ 1 | 0x00
+ 1 | 0xc9 (?)
+
+Then, read type 0 for confirmation.
+Then, sendClose() (0xa response: 5x 00).
+
+If Path is a folder, it will be moved together with its contents.
+This command appears to work across devices.
+
+
+6a - Copy file/folder
+----------------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ n | Path (including old file name)
+ 1 | 0x00
+ n | New path to contain file (folder without trailing slash or file name)
+ 1 | 0x00
+ 1 | 0xc9 (?)
+
+Then, read type 0 for confirmation.
+Then, sendClose() (0xa response: 5x 00).
+
+If Path is a folder, it will be moved together with its contents.
+This command appears to work across devices.
+
+
+6b - Set attributes and comment
+--------------------------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ 4 | Attributes
+ n | Path
+ 1 | 0x00
+ n | Comment
+ 1 | 0x00
+ 4 | Checksum? (seems to be 0x00000000 if comment empty)
+
+Then, read type 0 for confirmation.
+Then, sendClose() (0xa response: 5x 00).
+
+
+6c - Request size on disk (?)
+------------------------------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ n | Path
+ 1 | 0x00
+
+Then, read type 0 for confirmation.
+Then, read type 9 for 12 bytes of payload (### TODO ###).
+Then, send type 0 to request more data (no payload).
+Then, read type 9 for 12 bytes of payload (### TODO ###).
+Then, send type 0 to request more data (no payload).
+Then, read type 0 signaling end of attributes (no payload).
+Then, sendClose() (0xa response: 5x 00).
+
+OR
+
+Then, read type 0 for confirmation.
+Then, read type 0 signaling end of attributes (no payload).
+Then, sendClose() (0xa response: 5x 00).
+
+
+
+6d - Close file
+----------------
+
+No payload.
+
+Then, read type 0x0a for confirmation (typical payload: 5 bytes of 0x00).
+
+This is used to finish an operation, such as a directory listing
+or renaming a file.
+
+
+6e - Format disk
+-----------------
+
+### TODO ###
+
+
+6f - New folder
+----------------
+
+Payload:
+
+ Bytes | Content
+ -------|--------------------
+ n | Parent path
+ 1 | 0x00
+
+Then, read type 0 for confirmation.
+Then, sendClose() (0xa response: 5x 00).
+
+The host will create a new folder in the given path, together with a
+matching .info file.
+The folder name cannot be chosen, and will be something like "Unnamed1".
+
+To create a folder with a specific name, use 0x66.
+Note that 0x66'ing a folder does not seem to set its time.
--- /dev/null
+#!/usr/bin/env python
+#
+# A FUSE filesystem to access an Amiga's files via Cloanto's Amiga Explorer.
+#
+# Known limitations:
+# See README.
+#
+# SPDX-License-Identifier: GPL-2.0
+#
+
+
+from fusepy import FUSE
+import sys
+
+from AEpy.AELink import AELinkSerial
+from AEpy.AESession import AESession
+from AEpy.AEFuse import AEFuse
+from AEpy import FusePatches
+
+
+
+
+
+if __name__ == '__main__':
+ # Monkey patch fusepy
+ FusePatches.patch_max_readahead(512)
+
+ serspeed = 19200
+
+ if len(sys.argv) - 1 < 2:
+ print('Only ' + str(len(sys.argv) - 1) + ' arguments given.')
+ print('Usage: ' + sys.argv[0] + ' <mount point> <serial device> [serial speed]')
+
+ sys.exit(-1)
+
+ if len(sys.argv) - 1 > 2:
+ serspeed = int(sys.argv[3])
+
+ link = AELinkSerial(sys.argv[2], serspeed)
+ session = AESession(link)
+ fuse = AEFuse(session)
+ FUSE(fuse, sys.argv[1], nothreads=True, foreground=True)
projects / fuse-aexplorer.git / commitdiff