def UnGetC(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
val = ctx.cpu.r_reg(REG_D2)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
ch = fh.ungetc(val)
log_dos.info("UnGetC(%s, %d) -> ch=%c (%d)" % (fh, val, ch, ch))
return ch
def FPutC(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
val = ctx.cpu.r_reg(REG_D2)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
log_dos.info("FPutC(%s, '%c' (%d))" % (fh, val, val))
self.file_mgr.write(fh, chr(val))
return val
def DupLock(self, lib, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
dup_lock = self.lock_mgr.create_lock(lock.ami_path, False)
log_dos.info("DupLock: %s -> %s", lock, dup_lock)
self.io_err = NO_ERROR
return dup_lock.b_addr
def DateToStr(self, ctx):
dt_ptr = ctx.cpu.r_reg(REG_D1)
dt = AccessStruct(ctx.mem, DateTimeDef, struct_addr=dt_ptr)
ds_day = dt.r_s("dat_Stamp.ds_Days")
ds_min = dt.r_s("dat_Stamp.ds_Minute")
ds_tick = dt.r_s("dat_Stamp.ds_Tick")
format = dt.r_s("dat_Format")
flags = dt.r_s("dat_Flags")
str_day_ptr = dt.r_s("dat_StrDay")
str_date_ptr = dt.r_s("dat_StrDate")
str_time_ptr = dt.r_s("dat_StrTime")
at = AmiTime(ds_day, ds_min, ds_tick)
st = at.to_sys_time()
log_dos.info("DateToStr: ptr=%06x format=%x flags=%x day_ptr=%06x date_ptr=%06x time_ptr=%06x %s => sys_time=%d", \
dt_ptr, format, flags, str_day_ptr, str_date_ptr, str_time_ptr, at, st)
t = time.gmtime(st)
day_str = time.strftime("%A", t)
date_str = time.strftime("%d-%m-%y", t)
time_str = time.strftime("%H:%M:%S", t)
log_dos.info("DateToStr: result day='%s' date='%s' time='%s'", day_str,
date_str, time_str)
if str_day_ptr != 0:
ctx.mem.access.w_cstr(str_day_ptr, day_str)
if str_date_ptr != 0:
ctx.mem.access.w_cstr(str_date_ptr, date_str)
if str_time_ptr != 0:
ctx.mem.access.w_cstr(str_time_ptr, time_str)
return self.DOSTRUE
def DateToStr(self, ctx):
dt_ptr = ctx.cpu.r_reg(REG_D1)
dt = AccessStruct(ctx.mem,DateTimeDef,struct_addr=dt_ptr)
ds_day = dt.r_s("dat_Stamp.ds_Days")
ds_min = dt.r_s("dat_Stamp.ds_Minute")
ds_tick = dt.r_s("dat_Stamp.ds_Tick")
format = dt.r_s("dat_Format")
flags = dt.r_s("dat_Flags")
str_day_ptr = dt.r_s("dat_StrDay")
str_date_ptr = dt.r_s("dat_StrDate")
str_time_ptr = dt.r_s("dat_StrTime")
at = AmiTime(ds_day, ds_min, ds_tick)
st = at.to_sys_time()
log_dos.info("DateToStr: ptr=%06x format=%x flags=%x day_ptr=%06x date_ptr=%06x time_ptr=%06x %s => sys_time=%d", \
dt_ptr, format, flags, str_day_ptr, str_date_ptr, str_time_ptr, at, st)
t = time.gmtime(st)
day_str = time.strftime("%A", t)
date_str = time.strftime("%d-%m-%y", t)
time_str = time.strftime("%H:%M:%S", t)
log_dos.info("DateToStr: result day='%s' date='%s' time='%s'", day_str, date_str, time_str)
if str_day_ptr != 0:
ctx.mem.access.w_cstr(str_day_ptr, day_str)
if str_date_ptr != 0:
ctx.mem.access.w_cstr(str_date_ptr, date_str)
if str_time_ptr != 0:
ctx.mem.access.w_cstr(str_time_ptr, time_str)
return self.DOSTRUE
def FPutC(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
val = ctx.cpu.r_reg(REG_D2)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
log_dos.info("FPutC(%s, '%c' (%d))" % (fh, val, val))
fh.write(chr(val))
return val
def setup_lib(self, ctx):
AmigaLibrary.setup_lib(self, ctx)
log_dos.info("open dos.library V%d", self.version)
# init own state
self.io_err = 0
self.cur_dir_lock = None
self.ctx = ctx
self.mem_allocs = {}
self.seg_lists = {}
self.matches = {}
self.rdargs = {}
self.dos_objs = {}
# setup RootNode
self.root_struct = ctx.alloc.alloc_struct("RootNode",RootNodeDef)
self.access.w_s("dl_Root",self.root_struct.addr)
# setup DosInfo
self.dos_info = ctx.alloc.alloc_struct("DosInfo",DosInfoDef)
self.root_struct.access.w_s("rn_Info",self.dos_info.addr)
# setup dos list
self.dos_list = DosList(ctx.alloc)
baddr = self.dos_list.build_list(ctx.path_mgr)
# create lock manager
self.lock_mgr = LockManager(ctx.path_mgr, self.dos_list, ctx.alloc)
# create file manager
self.file_mgr = FileManager(ctx.path_mgr, ctx.alloc, ctx.mem)
# currently we use a single fake port for all devices
self.fs_handler_port = ctx.exec_lib.port_mgr.create_port("FakeFSPort",self.file_mgr)
log_dos.info("dos fs handler port: %06x" % self.fs_handler_port)
self.file_mgr.setup(self.fs_handler_port)
def UnGetC(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
val = ctx.cpu.r_reg(REG_D2)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
ch = self.file_mgr.ungetc(fh, val)
log_dos.info("UnGetC(%s, %d) -> ch=%c (%d)" % (fh, val, ch, ch))
return ch
def Open(self, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
mode = ctx.cpu.r_reg(REG_D2)
# decode mode
if mode == 1006:
mode_name = "new"
f_mode = "wb+"
elif mode == 1005:
mode_name = "old"
f_mode = "rb+"
elif mode == 1004:
mode_name = "r/w"
f_mode = "rb+"
else:
mode_name = "?"
fh = self.file_mgr.open(name, f_mode)
log_dos.info("Open: name='%s' (%s/%d/%s) -> %s" % (name, mode_name, mode, f_mode, fh))
if fh == None:
self.io_err = ERROR_OBJECT_NOT_FOUND
return 0
else:
return fh.b_addr
def Open(self, lib, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
mode = ctx.cpu.r_reg(REG_D2)
# decode mode
if mode == 1006:
mode_name = "new"
f_mode = "wb"
elif mode == 1005:
mode_name = "old"
f_mode = "rb+"
elif mode == 1004:
mode_name = "r/w"
f_mode = "rb+"
else:
mode_name = "?"
fh = self.file_mgr.open(name, f_mode)
log_dos.info("Open: name='%s' (%s/%d/%s) -> %s" %
(name, mode_name, mode, f_mode, fh))
if fh == None:
self.io_err = ERROR_OBJECT_NOT_FOUND
return 0
else:
return fh.b_addr
def DupLock(self, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
dup_lock = self.lock_mgr.create_lock(lock.ami_path, False)
log_dos.info("DupLock: %s -> %s",lock, dup_lock)
self.io_err = NO_ERROR
return dup_lock.b_addr
def setup_lib(self, ctx):
AmigaLibrary.setup_lib(self, ctx)
log_dos.info("open dos.library V%d", self.version)
# init own state
self.io_err = 0
self.cur_dir_lock = None
self.ctx = ctx
self.mem_allocs = {}
self.seg_lists = {}
self.matches = {}
self.rdargs = {}
self.dos_objs = {}
# setup RootNode
self.root_struct = ctx.alloc.alloc_struct("RootNode", RootNodeDef)
self.access.w_s("dl_Root", self.root_struct.addr)
# setup DosInfo
self.dos_info = ctx.alloc.alloc_struct("DosInfo", DosInfoDef)
self.root_struct.access.w_s("rn_Info", self.dos_info.addr)
# setup dos list
self.dos_list = DosList(ctx.alloc)
baddr = self.dos_list.build_list(ctx.path_mgr)
# create lock manager
self.lock_mgr = LockManager(ctx.path_mgr, self.dos_list, ctx.alloc)
# create file manager
self.file_mgr = FileManager(ctx.path_mgr, ctx.alloc, ctx.mem)
# currently we use a single fake port for all devices
self.fs_handler_port = ctx.exec_lib.port_mgr.create_port(
"FakeFSPort", self.file_mgr)
log_dos.info("dos fs handler port: %06x" % self.fs_handler_port)
self.file_mgr.setup(self.fs_handler_port)
def VFWritef(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
fmt_ptr = ctx.cpu.r_reg(REG_D2)
args_ptr = ctx.cpu.r_reg(REG_D3)
fmt = ctx.mem.access.r_cstr(fmt_ptr)
log_dos.info("VFWritef: fh=%s format='%s' args_ptr=%06x" %
(fh, fmt, args_ptr))
out = ''
pos = 0
state = ''
while pos < len(fmt):
ch = fmt[pos]
pos = pos + 1
if state[0:0] == 'x':
n = ord(ch.ascii_uppercase)
if n >= ord('0') and n <= ord('9'):
n = n - ord('0')
elif n >= ord('A') and n <= ord('Z'):
n = (n - ord('A')) + 10
else:
n = 0
ch = state[1]
if ch == 'T':
out = out + ("%*s" % (n, ctx.mem.access.r_cstr(val)))
elif ch == 'O':
out = out + ("%*O" % (n, val))
elif ch == 'X':
out = out + ("%*X" % (n, val))
elif ch == 'I':
out = out + ("%*ld" % (n, ctypes.c_long(val).value))
elif ch == 'U':
out = out + ("%*lu" % (n, ctypes.c_ulong(val).value))
else:
out = out + '%' + state[1] + state[0]
state = ''
elif state == '%':
if ch == 'S':
out = out + ctx.mem.access.r_cstr(val)
elif ch == 'C':
out = out + chr(val & 0xff)
elif ch == 'N':
out = out + ("%ld", ctypes.c_long(val).value)
elif ch == '$':
pass
elif ch == 'T' or ch == 'O' or ch == 'X' or ch == 'I' or ch == 'U':
state = 'x' + ch
else:
state = ''
out = out + '%' + ch
else:
if ch == '%':
state = '%'
val = ctx.mem.access.r32(args_ptr)
args_ptr = args_ptr + 4
else:
out = out + ch
fh.write(out)
return len(out)
def PutStr(self, lib, ctx):
str_ptr = ctx.cpu.r_reg(REG_D1)
str_dat = ctx.mem.access.r_cstr(str_ptr)
# write to stdout
fh = self.file_mgr.get_output()
ok = self.file_mgr.write(fh, str_dat)
log_dos.info("PutStr: '%s'", str_dat)
return 0 # ok
def Close(self, lib, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
self.file_mgr.close(fh)
log_dos.info("Close: %s" % fh)
return self.DOSTRUE
def Close(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
self.file_mgr.close(fh)
log_dos.info("Close: %s" % fh)
return self.DOSTRUE
def UnLock(self, lib, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
if lock_b_addr == 0:
log_dos.info("UnLock: NULL")
else:
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
log_dos.info("UnLock: %s" % (lock))
self.lock_mgr.release_lock(lock)
def PutStr(self, ctx):
str_ptr = ctx.cpu.r_reg(REG_D1)
str_dat = ctx.mem.access.r_cstr(str_ptr)
# write to stdout
fh = self.file_mgr.get_output()
ok = self.file_mgr.write(fh, str_dat)
log_dos.info("PutStr: '%s'", str_dat)
return 0 # ok
def UnLock(self, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
if lock_b_addr == 0:
log_dos.info("UnLock: NULL")
else:
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
log_dos.info("UnLock: %s" % (lock))
self.lock_mgr.release_lock(lock)
def VFWritef(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
fmt_ptr = ctx.cpu.r_reg(REG_D2)
args_ptr = ctx.cpu.r_reg(REG_D3)
fmt = ctx.mem.access.r_cstr(fmt_ptr)
log_dos.info("VFWritef: fh=%s format='%s' args_ptr=%06x" % (fh, fmt, args_ptr))
out = ""
pos = 0
state = ""
while pos < len(fmt):
ch = fmt[pos]
pos = pos + 1
if state[0:0] == "x":
n = ord(ch.ascii_uppercase)
if n >= ord("0") and n <= ord("9"):
n = n - ord("0")
elif n >= ord("A") and n <= ord("Z"):
n = (n - ord("A")) + 10
else:
n = 0
ch = state[1]
if ch == "T":
out = out + ("%*s" % (n, ctx.mem.access.r_cstr(val)))
elif ch == "O":
out = out + ("%*O" % (n, val))
elif ch == "X":
out = out + ("%*X" % (n, val))
elif ch == "I":
out = out + ("%*ld" % (n, ctypes.c_long(val).value))
elif ch == "U":
out = out + ("%*lu" % (n, ctypes.c_ulong(val).value))
else:
out = out + "%" + state[1] + state[0]
state = ""
elif state == "%":
if ch == "S":
out = out + ctx.mem.access.r_cstr(val)
elif ch == "C":
out = out + chr(val & 0xFF)
elif ch == "N":
out = out + ("%ld", ctypes.c_long(val).value)
elif ch == "$":
pass
elif ch == "T" or ch == "O" or ch == "X" or ch == "I" or ch == "U":
state = "x" + ch
else:
state = ""
out = out + "%" + ch
else:
if ch == "%":
state = "%"
val = ctx.mem.access.r32(args_ptr)
args_ptr = args_ptr + 4
else:
out = out + ch
fh.write(out)
return len(out)
def VFWritef(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
fmt_ptr = ctx.cpu.r_reg(REG_D2)
args_ptr = ctx.cpu.r_reg(REG_D3)
fmt = ctx.mem.access.r_cstr(fmt_ptr)
log_dos.info("VFWritef: fh=%s format='%s' args_ptr=%06x" % (fh, fmt, args_ptr))
out = ''
pos = 0
state = ''
while pos < len(fmt):
ch = fmt[pos]
pos = pos + 1
if state[0:0] == 'x':
n = ord(ch.ascii_uppercase)
if n >= ord('0') and n <= ord('9'):
n = n - ord('0')
elif n >= ord('A') and n <= ord('Z'):
n = (n - ord('A')) + 10
else:
n = 0
ch = state[1]
if ch == 'T':
out = out + ("%*s" % (n, ctx.mem.access.r_cstr(val)))
elif ch == 'O':
out = out + ("%*O" % (n, val))
elif ch == 'X':
out = out + ("%*X" % (n, val))
elif ch == 'I':
out = out + ("%*ld" % (n, ctypes.c_long(val).value))
elif ch == 'U':
out = out + ("%*lu" % (n, ctypes.c_ulong(val).value))
else:
out = out + '%' + state[1] + state[0]
state = ''
elif state == '%':
if ch == 'S':
out = out + ctx.mem.access.r_cstr(val)
elif ch == 'C':
out = out + chr(val & 0xff)
elif ch == 'N':
out = out + ("%ld", ctypes.c_long(val).value)
elif ch == '$':
pass
elif ch == 'T' or ch == 'O' or ch == 'X' or ch == 'I' or ch == 'U':
state = 'x' + ch
else:
state = ''
out = out + '%' + ch
else:
if ch == '%':
state = '%'
val = ctx.mem.access.r32(args_ptr)
args_ptr = args_ptr + 4
else:
out = out + ch
self.file_mgr.write(fh, out)
return len(out)
def DeleteFile(self, lib, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
self.io_err = self.file_mgr.delete(name)
log_dos.info("DeleteFile: '%s': err=%s" % (name, self.io_err))
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def ParentDir(self, lib, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
parent_lock = self.lock_mgr.create_parent_lock(lock)
log_dos.info("ParentDir: %s -> %s" % (lock, parent_lock))
if parent_lock != None:
return parent_lock.b_addr
else:
return 0
def PathPart(self, ctx):
addr = ctx.cpu.r_reg(REG_D1)
path = ctx.mem.access.r_cstr(addr)
pos = dos.PathPart.path_part(path)
if pos < len(path):
log_dos.info("PathPart: path='%s' -> result='%s'", path, path[pos:])
else:
log_dos.info("PathPart: path='%s' -> pos=NULL", path)
return addr + pos
def IsInteractive(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
res = self.file_mgr.is_interactive(fh)
log_dos.info("IsInteractive(%s): %s" % (fh, res))
if res:
return self.DOSTRUE
else:
return self.DOSFALSE
def DeleteFile(self, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
self.io_err = self.file_mgr.delete(name)
log_dos.info("DeleteFile: '%s': err=%s" % (name, self.io_err))
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def IsInteractive(self, lib, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
res = self.file_mgr.is_interactive(fh)
log_dos.info("IsInteractive(%s): %s" % (fh, res))
if res:
return self.DOSTRUE
else:
return self.DOSFALSE
def IsFileSystem(self, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
res = self.file_mgr.is_file_system(name)
log_dos.info("IsFileSystem('%s'): %s" % (name, res))
if res:
return self.DOSTRUE
else:
return self.DOSFALSE
def IsFileSystem(self, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
res = self.file_mgr.is_file_system(name)
log_dos.info("IsFileSystem('%s'): %s" % (name, res))
if res:
return self.DOSTRUE
else:
return self.DOSFALSE
def ParentDir(self, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
parent_lock = self.lock_mgr.create_parent_lock(lock)
log_dos.info("ParentDir: %s -> %s" % (lock, parent_lock))
if parent_lock != None:
return parent_lock.b_addr
else:
return 0
def FGetC(self, lib, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
# TODO: use buffered I/O
ch = self.file_mgr.read(fh, 1)
log_dos.info("FGetC(%s) -> ch=%s" % (fh, ch))
if ch == None or ch == "":
return -1
else:
return ord(ch)
def FGetC(self, lib, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
# TODO: use buffered I/O
ch = self.file_mgr.read(fh, 1)
log_dos.info("FGetC(%s) -> ch=%s" % (fh, ch))
if ch == None or ch == "":
return -1
else:
return ord(ch)
def DateStamp(self, ctx):
ds_ptr = ctx.cpu.r_reg(REG_D1)
ds = AccessStruct(ctx.mem,DateStampDef,struct_addr=ds_ptr)
t = time.time()
at = sys_to_ami_time(t)
log_dos.info("DateStamp: ptr=%06x sys_time=%d time=%s", ds_ptr, t, at)
ds.w_s("ds_Days",at.tday)
ds.w_s("ds_Minute",at.tmin)
ds.w_s("ds_Tick",at.tick)
return ds_ptr
def set_managers(self, path_mgr, lock_mgr, file_mgr, port_mgr, seg_loader):
self.path_mgr = path_mgr
self.lock_mgr = lock_mgr
self.file_mgr = file_mgr
self.port_mgr = port_mgr
self.seg_loader = seg_loader
# create fs handler port
self.fs_handler_port = port_mgr.add_int_port(self)
log_dos.info("dos fs handler port: %06x" % self.fs_handler_port)
file_mgr.set_fs_handler_port(self.fs_handler_port)
def MatchEnd(self, lib, ctx):
anchor_ptr = ctx.cpu.r_reg(REG_D1)
log_dos.info("MatchEnd: anchor=%06x " % (anchor_ptr))
# retrieve match
if not self.matches.has_key(anchor_ptr):
raise VamosInternalError("No matcher found for %06x" % anchor_ptr)
mfn = self.matches[anchor_ptr]
del self.matches[anchor_ptr]
if mfn != None:
mfn.end(ctx)
def set_managers(self, path_mgr, lock_mgr, file_mgr, port_mgr, seg_loader):
self.path_mgr = path_mgr
self.lock_mgr = lock_mgr
self.file_mgr = file_mgr
self.port_mgr = port_mgr
self.seg_loader = seg_loader;
# create fs handler port
self.fs_handler_port = port_mgr.add_int_port(self)
log_dos.info("dos fs handler port: %06x" % self.fs_handler_port)
file_mgr.set_fs_handler_port(self.fs_handler_port)
def PathPart(self, ctx):
addr = ctx.cpu.r_reg(REG_D1)
path = ctx.mem.access.r_cstr(addr)
pos = dos.PathPart.path_part(path)
if pos < len(path):
log_dos.info("PathPart: path='%s' -> result='%s'", path,
path[pos:])
else:
log_dos.info("PathPart: path='%s' -> pos=NULL", path)
return addr + pos
def DateStamp(self, lib, ctx):
ds_ptr = ctx.cpu.r_reg(REG_D1)
ds = AccessStruct(ctx.mem, DateStampDef, struct_addr=ds_ptr)
t = time.time()
at = sys_to_ami_time(t)
log_dos.info("DateStamp: ptr=%06x time=%s" % (ds_ptr, at))
ds.w_s("ds_Days", at.tday)
ds.w_s("ds_Minute", at.tmin)
ds.w_s("ds_Tick", at.tick)
return ds_ptr
def SetProtection(self, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
mask = ctx.cpu.r_reg(REG_D2)
self.io_err = self.file_mgr.set_protection(name, mask)
log_dos.info("SetProtection: '%s' mask=%04x: err=%s", name, mask, self.io_err)
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def MatchEnd(self, ctx):
anchor_ptr = ctx.cpu.r_reg(REG_D1)
log_dos.info("MatchEnd: anchor=%06x " % (anchor_ptr))
# retrieve match
if not self.matches.has_key(anchor_ptr):
raise VamosInternalError("MatchEnd: No matcher found for %06x" % anchor_ptr)
mfn = self.matches[anchor_ptr]
del self.matches[anchor_ptr]
if mfn != None:
mfn.end(ctx)
def Read(self, lib, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
buf_ptr = ctx.cpu.r_reg(REG_D2)
size = ctx.cpu.r_reg(REG_D3)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
data = self.file_mgr.read(fh, size)
ctx.mem.access.w_data(buf_ptr, data)
got = len(data)
log_dos.info("Read(%s, %06x, %d) -> %d" % (fh, buf_ptr, size, got))
return got
def Examine(self, lib, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
fib_ptr = ctx.cpu.r_reg(REG_D2)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
log_dos.info("Examine: %s fib=%06x" % (lock, fib_ptr))
fib = AccessStruct(ctx.mem, FileInfoBlockDef, struct_addr=fib_ptr)
self.io_err = self.lock_mgr.examine_lock(lock, fib)
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def Rename(self, ctx):
old_name_ptr = ctx.cpu.r_reg(REG_D1)
old_name = ctx.mem.access.r_cstr(old_name_ptr)
new_name_ptr = ctx.cpu.r_reg(REG_D2)
new_name = ctx.mem.access.r_cstr(new_name_ptr)
self.io_err = self.file_mgr.rename(old_name, new_name)
log_dos.info("Rename: '%s' -> '%s': err=%s" % (old_name, new_name, self.io_err))
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def Write(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
buf_ptr = ctx.cpu.r_reg(REG_D2)
size = ctx.cpu.r_reg(REG_D3)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
data = ctx.mem.access.r_data(buf_ptr,size)
self.file_mgr.write(fh, data)
got = len(data)
log_dos.info("Write(%s, %06x, %d) -> %d" % (fh, buf_ptr, size, got))
return size
def Read(self, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
buf_ptr = ctx.cpu.r_reg(REG_D2)
size = ctx.cpu.r_reg(REG_D3)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
data = self.file_mgr.read(fh, size)
ctx.mem.access.w_data(buf_ptr, data)
got = len(data)
log_dos.info("Read(%s, %06x, %d) -> %d" % (fh, buf_ptr, size, got))
return got
def Write(self, lib, ctx):
fh_b_addr = ctx.cpu.r_reg(REG_D1)
buf_ptr = ctx.cpu.r_reg(REG_D2)
size = ctx.cpu.r_reg(REG_D3)
fh = self.file_mgr.get_by_b_addr(fh_b_addr)
data = ctx.mem.access.r_data(buf_ptr, size)
self.file_mgr.write(fh, data)
got = len(data)
log_dos.info("Write(%s, %06x, %d) -> %d" % (fh, buf_ptr, size, got))
return size
def SetProtection(self, lib, ctx):
name_ptr = ctx.cpu.r_reg(REG_D1)
name = ctx.mem.access.r_cstr(name_ptr)
mask = ctx.cpu.r_reg(REG_D2)
self.io_err = self.file_mgr.set_protection(name, mask)
log_dos.info("SetProtection: '%s' mask=%04x: err=%s", name, mask,
self.io_err)
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def MatchPattern(self, ctx, ignore_case=False):
pat_ptr = ctx.cpu.r_reg(REG_D1)
txt_ptr = ctx.cpu.r_reg(REG_D2)
pat = ctx.mem.access.r_cstr(pat_ptr)
txt = ctx.mem.access.r_cstr(txt_ptr)
match = pattern_match(pat, txt)
log_dos.info("MatchPattern: pat=%s txt=%s ignore_case=%s -> match=%s", pat, txt, ignore_case, match)
if match:
return -1
else:
return 0
def ExNext(self, ctx):
lock_b_addr = ctx.cpu.r_reg(REG_D1)
fib_ptr = ctx.cpu.r_reg(REG_D2)
lock = self.lock_mgr.get_by_b_addr(lock_b_addr)
log_dos.info("ExNext: %s fib=%06x" % (lock, fib_ptr))
fib = AccessStruct(ctx.mem,FileInfoBlockDef,struct_addr=fib_ptr)
self.io_err = self.lock_mgr.examine_next(lock, fib)
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def Rename(self, lib, ctx):
old_name_ptr = ctx.cpu.r_reg(REG_D1)
old_name = ctx.mem.access.r_cstr(old_name_ptr)
new_name_ptr = ctx.cpu.r_reg(REG_D2)
new_name = ctx.mem.access.r_cstr(new_name_ptr)
self.io_err = self.file_mgr.rename(old_name, new_name)
log_dos.info("Rename: '%s' -> '%s': err=%s" %
(old_name, new_name, self.io_err))
if self.io_err == NO_ERROR:
return self.DOSTRUE
else:
return self.DOSFALSE
def MatchPattern(self, lib, ctx, ignore_case=False):
pat_ptr = ctx.cpu.r_reg(REG_D1)
txt_ptr = ctx.cpu.r_reg(REG_D2)
pat = ctx.mem.access.r_cstr(pat_ptr)
txt = ctx.mem.access.r_cstr(txt_ptr)
match = pattern_match(pat, txt)
log_dos.info("MatchPattern: pat=%s txt=%s ignore_case=%s -> match=%s",
pat, txt, ignore_case, match)
if match:
return -1
else:
return 0
def FreeArgs(self, lib, ctx):
rdargs_ptr = ctx.cpu.r_reg(REG_D1)
log_dos.info("FreeArgs: %06x" % rdargs_ptr)
# find rdargs
if not self.rdargs.has_key(rdargs_ptr):
raise VamosInternalError("Can't find RDArgs: %06x" % rdargs_ptr)
rdargs = self.rdargs[rdargs_ptr]
del self.rdargs[rdargs_ptr]
# clean up rdargs
addr = rdargs.access.r_s('RDA_Buffer')
self._free_mem(addr)
self.alloc.free_struct(rdargs)
def FreeArgs(self, lib, ctx):
rdargs_ptr = ctx.cpu.r_reg(REG_D1)
log_dos.info("FreeArgs: %06x" % rdargs_ptr)
# find rdargs
if not self.rdargs.has_key(rdargs_ptr):
raise VamosInternalError("Can't find RDArgs: %06x" % rdargs_ptr)
rdargs = self.rdargs[rdargs_ptr]
del self.rdargs[rdargs_ptr]
# clean up rdargs
addr = rdargs.access.r_s('RDA_Buffer')
self._free_mem(addr)
self.alloc.free_struct(rdargs)
def AddPart(self, ctx):
dn_addr = ctx.cpu.r_reg(REG_D1)
fn_addr = ctx.cpu.r_reg(REG_D2)
size = ctx.cpu.r_reg(REG_D3)
dn = ctx.mem.access.r_cstr(dn_addr)
fn = ctx.mem.access.r_cstr(fn_addr)
np = dos.PathPart.add_part(dn,fn,size)
log_dos.info("AddPart: dn='%s' fn='%s' size=%d -> np='%s'", dn, fn, size, np)
if np != None:
ctx.mem.access.w_cstr(dn_addr, np)
return self.DOSTRUE
else:
return self.DOSFALSE
def SystemTagList(self, ctx):
cmd_ptr = ctx.cpu.r_reg(REG_D1)
tagitem_ptr = ctx.cpu.r_reg(REG_D2)
cmd = ctx.mem.access.r_cstr(cmd_ptr)
tag_list = taglist_parse_tagitem_ptr(ctx.mem, tagitem_ptr, DosTags)
log_dos.info("SystemTagList: cmd='%s' tags=%s", cmd, tag_list)
# parse "command line"
cl = CommandLine()
if not cl.parse_string(cmd):
log_dos.info("SystemTagList: error parsing command: '%s'", cmd)
return 10 # RETURN_ERROR
args = cl.args
if len(args) == 0:
log_dos.info("SystemTagList: error parsing command: '%s'", cmd)
return 10 # RETURN_ERROR
bin = args[0]
args = args[1:]
# TODO: redirs
log_dos.info("SystemTagList: bin='%s' args=%s", bin, args)
# create a process and run it...
proc = Process(ctx, bin, args)
if not proc.ok:
log_dos.warn("SystemTagList: can't create process for '%s' args=%s", bin, args)
return 0xffffffff
ctx.start_sub_process(proc)
def MatchFirst(self, ctx):
pat_ptr = ctx.cpu.r_reg(REG_D1)
pat = ctx.mem.access.r_cstr(pat_ptr)
anchor_ptr = ctx.cpu.r_reg(REG_D2)
anchor = AccessStruct(self.ctx.mem,AnchorPathDef,struct_addr=anchor_ptr)
# create MatchFirstNext instance
mfn = MatchFirstNext(self.path_mgr, self.lock_mgr, pat, anchor)
log_dos.info("MatchFirst: pat='%s' anchor=%06x strlen=%d flags=%02x-> ok=%s" \
% (pat, anchor_ptr, mfn.str_len, mfn.flags, mfn.ok))
if not mfn.ok:
self.io_err = ERROR_BAD_TEMPLATE
return self.io_err
log_dos.debug("MatchFirst: %s" % mfn.matcher)
# try first match
self.io_err = mfn.first(ctx)
if self.io_err == NO_ERROR:
log_dos.info("MatchFirst: found name='%s' path='%s' -> parent lock %s, io_err=%d", mfn.name, mfn.path, mfn.dir_lock, self.io_err)
self.matches[anchor_ptr] = mfn
# no entry found or error
elif self.io_err == ERROR_OBJECT_NOT_FOUND:
log_dos.info("MatchFirst: none found")
self.matches[anchor_ptr] = mfn
else:
log_dos.info("MatchFirst: error: %d", self.io_err)
return self.io_err
def SystemTagList(self, lib, ctx):
cmd_ptr = ctx.cpu.r_reg(REG_D1)
tagitem_ptr = ctx.cpu.r_reg(REG_D2)
cmd = ctx.mem.access.r_cstr(cmd_ptr)
tag_list = taglist_parse_tagitem_ptr(ctx.mem, tagitem_ptr, DosTags)
log_dos.info("SystemTagList: cmd='%s' tags=%s", cmd, tag_list)
# parse "command line"
cl = CommandLine()
if not cl.parse_string(cmd):
log_dos.info("SystemTagList: error parsing command: '%s'", cmd)
return 10 # RETURN_ERROR
args = cl.args
if len(args) == 0:
log_dos.info("SystemTagList: error parsing command: '%s'", cmd)
return 10 # RETURN_ERROR
bin = args[0]
args = args[1:]
# TODO: redirs
log_dos.info("SystemTagList: bin='%s' args=%s", bin, args)
# create a process and run it...
proc = Process(ctx, bin, args)
if not proc.ok:
log_dos.warn(
"SystemTagList: can't create process for '%s' args=%s", bin,
args)
return 0xffffffff
ctx.start_sub_process(proc)
def MatchFirst(self, ctx):
pat_ptr = ctx.cpu.r_reg(REG_D1)
pat = ctx.mem.access.r_cstr(pat_ptr)
anchor_ptr = ctx.cpu.r_reg(REG_D2)
anchor = AccessStruct(self.ctx.mem,
AnchorPathDef,
struct_addr=anchor_ptr)
# create MatchFirstNext instance
mfn = MatchFirstNext(ctx.path_mgr, self.lock_mgr, pat, anchor)
log_dos.info("MatchFirst: pat='%s' anchor=%06x strlen=%d flags=%02x-> ok=%s" \
% (pat, anchor_ptr, mfn.str_len, mfn.flags, mfn.ok))
if not mfn.ok:
self.io_err = ERROR_BAD_TEMPLATE
return self.io_err
log_dos.debug("MatchFirst: %s" % mfn.matcher)
# try first match
self.io_err = mfn.first(ctx)
if self.io_err == NO_ERROR:
log_dos.info(
"MatchFirst: found name='%s' path='%s' -> parent lock %s, io_err=%d",
mfn.name, mfn.path, mfn.dir_lock, self.io_err)
self.matches[anchor_ptr] = mfn
# no entry found or error
elif self.io_err == ERROR_OBJECT_NOT_FOUND:
log_dos.info("MatchFirst: none found")
self.matches[anchor_ptr] = mfn
else:
log_dos.info("MatchFirst: error: %d", self.io_err)
return self.io_err
def AddPart(self, ctx):
dn_addr = ctx.cpu.r_reg(REG_D1)
fn_addr = ctx.cpu.r_reg(REG_D2)
size = ctx.cpu.r_reg(REG_D3)
dn = ctx.mem.access.r_cstr(dn_addr)
fn = ctx.mem.access.r_cstr(fn_addr)
np = dos.PathPart.add_part(dn, fn, size)
log_dos.info("AddPart: dn='%s' fn='%s' size=%d -> np='%s'", dn, fn,
size, np)
if np != None:
ctx.mem.access.w_cstr(dn_addr, np)
return self.DOSTRUE
else:
return self.DOSFALSE
def VPrintf(self, lib, ctx):
format_ptr = ctx.cpu.r_reg(REG_D1)
argv_ptr = ctx.cpu.r_reg(REG_D2)
format = ctx.mem.access.r_cstr(format_ptr)
# write on output
fh = self.file_mgr.get_output()
log_dos.info("VPrintf: format='%s' argv=%06x" % (format, argv_ptr))
# now decode printf
ps = dos.Printf.printf_parse_string(format)
dos.Printf.printf_read_data(ps, ctx.mem.access, argv_ptr)
log_dos.debug("VPrintf: parsed format: %s", ps)
result = dos.Printf.printf_generate_output(ps)
# write result
self.file_mgr.write(fh, result)
return len(result)
