def to_bytes(self) -> bytes: struct = ffi.new('struct siginfo*') struct.si_code = self.code struct.si_pid = self.pid struct.si_uid = self.uid struct.si_status = self.status return bytes(ffi.buffer(struct))
def to_bytes(self) -> bytes: output = [0] * 16 for val in self: idx = val // 64 bit = val % 64 output[idx] |= 1 << bit return bytes(ffi.buffer(ffi.new('cpu_set_t const*', (output, ))))
def to_bytes(self) -> bytes: return bytes(ffi.buffer(ffi.new('struct file_clone_range const*', { "src_fd": self.src_fd, "src_offset": self.src_offset, "src_length": self.src_length, "dest_offset": self.dest_offset, })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new('struct fuse_getattr_in*', { 'getattr_flags': self.getattr_flags, 'fh': self.fh, })))
def to_bytes(self) -> bytes: data = self.data + "\0" return bytes( ffi.buffer( ffi.new('struct fuse_getxattr_in*', { 'size': len(data), })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new('struct fuse_flush_in*', { 'fh': self.fh, 'lock_owner': self.lock_owner, })))
def __get__(self, instance, owner) -> str: data = bytes(ffi.buffer(getattr(instance.cffi, self.name))) try: valid_data = data[:data.index(b'\0')] except ValueError: valid_data = data return valid_data.decode()
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new('struct fuse_open_out*', { 'fh': self.fh, 'open_flags': self.open_flags, })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new('struct fuse_open_in*', { 'flags': self.flags, 'unused': 0, })))
def to_bytes(self) -> bytes: # We can't just create a struct sockaddr_storage and turn the whole thing to bytes, # because that will pad the actually valid data with a bunch of trailing null bytes. # And we can't do that because the length of the valid data is semantically # meaningful for some socket addresses, such as sockaddr_un. return bytes(ffi.buffer(ffi.new('sa_family_t*', self.family))) + self.data
def to_bytes(self) -> bytes: ret = b"" for ptr in self: ret += bytes(ffi.buffer(ffi.new('struct iovec const*', { "iov_base": ffi.cast('void*', int(ptr.near)), "iov_len": ptr.size(), }))) return ret
def to_bytes(self) -> bytes: struct = ffi.new( 'struct robust_list_head*', { 'list': (ffi.cast('struct robust_list*', int(self.first.near)), ), 'futex_offset': ffi.offsetof('struct futex_node', 'futex'), 'list_op_pending': ffi.NULL, }) return bytes(ffi.buffer(struct))
async def batch_read(self, ops: t.List[Pointer]) -> t.List[bytes]: ret: t.List[bytes] = [] for src in ops: if src.mapping.task.address_space != self.local_task.address_space: raise Exception("trying to read from pointer", src, "not in local address space") buf = ffi.buffer(ffi.cast('void*', int(src.near)), src.size()) ret.append(bytes(buf)) return ret
def to_bytes(self) -> bytes: struct = ffi.new('struct __user_cap_data_struct[2]') capset_names = ['effective', 'permitted', 'inheritable'] for name in capset_names: capset = getattr(self, name) one, two = to_uint32s(capset) setattr(struct[0], name, one) setattr(struct[1], name, two) return bytes(ffi.buffer(struct))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct fuse_release_in*', { 'fh': self.fh, 'flags': self.flags, 'release_flags': self.release_flags, })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct fuse_attr_out*', { 'attr_valid': self.attr_valid.sec, 'attr_valid_nsec': self.attr_valid.nsec, 'attr': self.attr._to_cffi_dict(), })))
def to_bytes(self) -> bytes: namebytes = self.name.encode() + b'\0' length = ffi.sizeof('struct fuse_dirent') + len(namebytes) padding = align(length, 8) - length namebytes = namebytes + bytes(padding) return bytes( ffi.buffer( ffi.new('struct fuse_dirent*', self._to_cffi_dict(namebytes)))) + namebytes
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct rsyscall_syscall const*', { "sys": self.number, "args": (self.arg1, self.arg2, self.arg3, self.arg4, self.arg5, self.arg6), })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct fuse_init_in*', { 'major': self.major, 'minor': self.minor, 'max_readahead': self.max_readahead, 'flags': self.flags, })))
def to_bytes(self) -> bytes: return bytes(ffi.buffer(ffi.new('struct msghdr*', { "msg_name": ffi.cast('void*', int(self.name.near)) if self.name else ffi.NULL, "msg_namelen": self.name.size() if self.name else 0, "msg_iov": ffi.cast('void*', int(self.iov.near)), "msg_iovlen": len(self.iov.value), "msg_control": ffi.cast('void*', int(self.control.near)) if self.control else ffi.NULL, "msg_controllen": self.control.size() if self.control else 0, "msg_flags": 0, })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct fuse_read_in*', { 'fh': self.fh, 'offset': self.offset, 'size': self.size, 'read_flags': self.read_flags, 'flags': self.flags, })))
def record(reclen: int) -> bytes: record = ffi.new('struct linux_dirent64*', { "d_ino": self.inode, "d_off": self.offset, "d_reclen": reclen, "d_type": self.type, "d_name": self.name.encode(), }) data = bytes(ffi.buffer(record)) # pad to real length return data + bytes(8 - (len(data) % 8))
def to_bytes(self, val: T_cmsg) -> bytes: if not isinstance(val, self.cls): raise Exception("Serializer for", self.cls, "had to_bytes called on different type", val) data = val.to_data() header = bytes(ffi.buffer(ffi.new('struct cmsghdr*', { "cmsg_len": ffi.sizeof('struct cmsghdr') + len(data), "cmsg_level": val.level(), "cmsg_type": val.type(), }))) return header + data
def to_bytes(self) -> bytes: msg_data = self.msg_to_bytes() return bytes( ffi.buffer( ffi.new( 'struct fuse_out_header*', { 'len': ffi.sizeof('struct fuse_out_header') + len(msg_data), 'error': self.hdr.error, 'unique': self.hdr.unique, }))) + msg_data
def to_bytes(self) -> bytes: namebytes = self.dirent.name.encode() + b'\0' length = ffi.sizeof('struct fuse_direntplus') + len(namebytes) padding = align(length, 8) - length namebytes = namebytes + bytes(padding) return bytes( ffi.buffer( ffi.new( 'struct fuse_direntplus*', { "entry_out": self.entry_out._to_cffi_dict(), "dirent": self.dirent._to_cffi_dict(namebytes), }))) + namebytes
def to_bytes(self) -> bytes: if self.name is not None: name = self.name.encode() name_len = len(name) else: name = b"" name_len = 0 return bytes(ffi.buffer(ffi.new('struct inotify_event*', { "wd": self.wd, "mask": self.mask, "cookie": self.cookie, "len": name_len, "name": name, })))
def to_bytes(self) -> bytes: struct = ffi.new( 'struct futex_node*', { # technically we're supposed to have a pointer to the first node in the robust list to # indicate the end. but that's tricky to do. so instead let's just use a NULL pointer; # the kernel will EFAULT when it hits the end. make sure not to map 0, or we'll # break. https://imgflip.com/i/2zwysg 'list': (ffi.cast('struct robust_list*', int(self.next.near)) if self.next else ffi.NULL, ), 'futex': self.futex, }) return bytes(ffi.buffer(struct))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct kernel_sigaction const*', { "ksa_handler": ffi.cast('sighandler_t', int(self.handler)), "ksa_flags": self.flags, "ksa_restorer": ffi.cast('sigrestore_t', int(self.restorer or 0)), "ksa_mask": self.mask.to_cffi()[0], })))
def to_bytes(self) -> bytes: return bytes( ffi.buffer( ffi.new( 'struct fuse_init_out*', { 'major': self.major, 'minor': self.minor, 'max_readahead': self.max_readahead, 'flags': self.flags, 'max_background': self.max_background, 'congestion_threshold': self.congestion_threshold, 'max_write': self.max_write, 'time_gran': self.time_gran, })))
def to_bytes(self) -> bytes: msg_data = self.msg_to_bytes() return bytes( ffi.buffer( ffi.new( 'struct fuse_in_header*', { 'len': FuseInHeader.sizeof() + len(msg_data), 'opcode': self.opcode, 'unique': self.hdr.unique, 'nodeid': self.hdr.nodeid, 'uid': self.hdr.uid, 'gid': self.hdr.gid, 'pid': self.hdr.pid, }))) + msg_data