def stop(self, bp):
fr = gdb.selected_frame()
gb = fr.block().static_block
file = next(int(str(arg.value(fr))) for arg in gb if arg.name == "read_fd")
len_ = next(int(str(arg.value(fr))) for arg in fr.block() if arg.name == "buf_size")
ptr = next(int(arg.value(fr).address) for arg in gb if arg.name == "read_buf")
try:
if self.os_.isatty(file):
gdb.execute("set.var read_end = 0") # No reading for terminal
return
cur = self.os_.lseek(file, 0, self.os_.SEEK_CUR)
end = self.os_.lseek(file, 0, self.os_.SEEK_END)
available = end - cur
self.os_.lseek(file, cur, self.os_.SEEK_SET)
read_len = min(available, len_)
buf = self.os_.read(file, read_len)
gdb.selected_inferior().write_memory(ptr, buf, len(buf))
gdb.execute("set var read_end = {}".format(len(buf)))
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def stop(self, bp):
fr = gdb.selected_frame()
file = next(str(arg.value(fr).string()) for arg in fr.block() if arg.is_argument)
try:
st = self.os_.stat(file)
gdb.execute("set var st->st_dev = {}".format(st.st_dev))
gdb.execute("set var st->st_ino = {}".format(st.st_ino))
gdb.execute("set var st->st_mode = {}".format(map_file_mode(st.st_mode, stat, Flags)))
gdb.execute("set var st->st_nlink = {}".format(st.st_nlink))
gdb.execute("set var st->st_uid = {}".format(st.st_uid))
gdb.execute("set var st->st_gid = {}".format(st.st_gid))
gdb.execute("set var st->st_rdev = {}".format(st.st_rdev))
gdb.execute("set var st->st_size = {}".format(st.st_size))
gdb.execute("set var st->st_atime.tv_sec = {}".format(int(st.st_atime)))
gdb.execute("set var st->st_mtime.tv_sec = {}".format(int(st.st_mtime)))
gdb.execute("set var st->st_ctime.tv_sec = {}".format(int(st.st_ctime)))
gdb.execute("set var st->st_atime.tv_nsec = {}".format(st.st_atime_ns % 1000000000))
gdb.execute("set var st->st_mtime.tv_nsec = {}".format(st.st_mtime_ns % 1000000000))
gdb.execute("set var st->st_ctime.tv_nsec = {}".format(st.st_ctime_ns % 1000000000))
if hasattr(st, 'st_rdev'): gdb.execute("set var st->st_rdev = {}".format(getattr(st, 'st_rdev')))
if hasattr(st, 'st_blksize'): gdb.execute("set var st->st_blksize = {}".format(getattr(st, 'st_blksize')))
if hasattr(st, 'st_blocks'): gdb.execute("set var st->st_blocks = {}".format(getattr(st, 'st_blocks')))
gdb.execute("set var res = 0")
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def unlink(engine: Engine):
try:
name = engine.read_string()
os_.unlink(name)
engine.write_int(0)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def isatty(engine: Engine):
try:
fd = engine.read_int()
isatty_ = os_.isatty(fd)
engine.write_int(0)
engine.write_int(isatty_)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def stat_(engine: Engine):
try:
file = engine.read_string()
st = os_.stat(file)
engine.write_int(0)
write_stat(engine, st)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def fstat(engine: Engine):
try:
fd = engine.read_int()
st = os_.fstat(fd)
engine.write_int(0)
write_stat(engine, st)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def write_full(engine: Engine):
try:
fd = engine.read_int()
dt = engine.read_memory()
engine.write_int(os_.write(fd, dt))
except OSError as e:
engine.write_int(-1)
engine.write_int(map_errno(int(str(e)), errno, Flags))
def close_full(engine: Engine):
try:
fd = engine.read_int()
os_.close(fd)
engine.write_int(0)
except OSError as e:
engine.write_int(-1)
engine.write_int(map_errno(int(str(e)), errno, Flags))
def symlink(engine: Engine):
try:
existing = engine.read_string()
_new = engine.read_string()
os_.symlink(existing, _new)
engine.write_int(0)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def stop(self, bp):
fr = gdb.selected_frame()
fd = next(int(str(arg.value(fr))) for arg in fr.block() if arg.is_argument)
try:
gdb.execute("set var res = {}".format(1 if self.os_.isatty(fd) else 0))
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def stop(self, bp):
fr = gdb.selected_frame()
name = next(str(arg.value(fr).string()) for arg in fr.block() if arg.is_argument)
try:
gdb.execute("set var res = {}".format(self.os_.unlink(name)))
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def lseek(engine: Engine):
try:
file = engine.read_int()
ptr = engine.read_int()
dir_ = engine.read_int()
engine.write_int(os_.lseek(file, ptr, dir_))
except OSError as e:
engine.write_int(-1)
engine.write_int(map_errno(int(str(e)), errno, Flags))
def read_full(engine: Engine):
try:
fd = engine.read_int()
len_ = engine.read_int()
buf = os_.read(fd, len_)
engine.write_int(0)
engine.write_memory(buf)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def stop(self, bp):
fr = gdb.selected_frame()
file, ptr, dir_ = (arg.value(fr) for arg in fr.block() if arg.is_argument)
try:
gdb.execute("set var res = {}".format(self.os_.lseek(file, ptr, dir_)))
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def stop(self, bp):
fr = gdb.selected_frame()
[existing, new_] = [str(arg.value(fr).string()) for arg in fr.block() if arg.is_argument]
try:
self.os_.symlink(existing, new_)
gdb.execute("set var res = 0")
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def open_full(engine: Engine):
try:
file = engine.read_string()
flags = map_open_flags(engine.read_int(), Flags, os_)
mode = map_file_mode(engine.read_int(), Flags, os_)
engine.write_int(os_.open(file, flags, mode))
except OSError as e:
engine.write_int(-1)
engine.write_int(map_errno(int(str(e)), errno, Flags))
def stop(self, bp):
fr = gdb.selected_frame()
itr = (arg.value(fr) for arg in fr.block() if arg.is_argument)
file = str(next(itr).string())
flags = map_open_flags(int(str(next(itr))), Flags, self.os_)
mode = map_file_mode(int(str(next(itr))), Flags, self.os_)
try:
gdb.execute("set var res = {}".format(self.os_.open(file, flags, mode)))
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def stop(self, bp):
fr = gdb.selected_frame()
fd = next(int(str(arg.value(fr))) for arg in fr.block() if arg.is_argument)
try:
if fd == Flags.STDERR_FILENO or fd == Flags.STDOUT_FILENO or fd == Flags.STDIN_FILENO:
gdb.execute("set var err = {}".format(Flags.EACCES))
else:
self.os_.close(fd)
gdb.execute("set var res = 0")
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def stop(self, bp):
fr = gdb.selected_frame()
block = fr.block()
while block.function is None:
block = block.superblock
file, ptr, len_ = (arg.value(fr) for arg in block if arg.is_argument)
try:
buf = gdb.selected_inferior().read_memory(ptr, len_)
gdb.execute("set var res = {}".format(self.os_.write(file, buf.tobytes())))
gdb.execute("set var err = 0")
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
def read_buffered(engine: Engine):
try:
fd = engine.read_int()
len_ = engine.read_int()
cur = os_.lseek(fd, 0, os_.SEEK_CUR)
end = os_.lseek(fd, 0, os_.SEEK_END)
available = end - cur
read_len = min(available, len_)
buf = os_.read(fd, read_len)
engine.write_int(0)
engine.write_memory(buf)
except OSError as e:
engine.write_int(map_errno(int(str(e)), errno, Flags))
def stop(self, bp):
fr = gdb.selected_frame()
b = fr.block()
while b.function is None:
b = b.superblock
arg_values = (arg.value(fr) for arg in b if arg.is_argument)
file = int(str(next(arg_values)))
ptr = int(next(arg_values))
len_ = int(str(next(arg_values)))
try:
buf = self.os_.read(file, len_)
gdb.selected_inferior().write_memory(ptr, buf, len(buf))
gdb.execute("set var res = {}".format(len(buf)))
gdb.execute('set var err = 0')
except OSError as e:
gdb.execute("set var err = {}".format(map_errno(int(str(e)), errno, Flags)))
