class LibWwqParseCFFI(LibWwqLyParseBase): def __init__(self): super(LibWwqParseCFFI, self).__init__() from cffi import FFI self.ffi = FFI() self.lib = self.ffi.dlopen(self.lib_path) self.ffi.cdef(""" char * get_uuid(); char * get_name(); int parse(char * c,int length,char **result,int *result_length); int free_str(char * c); """) self.lib.__class__.__repr__ = lambda s: "<%s object at 0x%016X>" % (s.__class__.__name__, id(s)) logging.debug("successful load lib %s" % self.lib) weakref.finalize(self, lambda: logging.debug("%s released" % self.lib) if self.ffi.dlclose(self.lib) or 1 else None) def get_uuid(self) -> bytes: return self.ffi.string(self.lib.get_uuid()) def get_name(self) -> bytes: return self.ffi.string(self.lib.get_name()) def lib_parse(self, byte_str: bytes) -> bytes: length = self.ffi.cast("int", len(byte_str)) result_length = self.ffi.new("int *") result_p = self.ffi.new("char **") # p = self.ffi.new("char []", byte_str) p = self.ffi.from_buffer(byte_str) self.lib.parse(p, length, result_p, result_length) result = self.ffi.unpack(result_p[0], result_length[0]) self.lib.free_str(result_p[0]) return result
class PythonLib: def load(self, filterpath): self.ffi = FFI() self.ffi.cdef(""" void *pythonGetData(const char *); const char *pythonGetType(const char *); const char *pythonGetCast(const char *); const char *pythonGetDims(const char *); """) self.filterlib = self.ffi.dlopen(filterpath) def getData(self, name): name = self.ffi.new("char[]", name.encode("utf-8")) cast = self.filterlib.pythonGetCast(name) data = self.filterlib.pythonGetData(name) ctype = self.ffi.string(cast).decode("utf-8") return self.ffi.cast(ctype, data) def getType(self, name): name = self.ffi.new("char[]", name.encode("utf-8")) return self.ffi.string(self.filterlib.pythonGetType(name)) def getDims(self, name): name = self.ffi.new("char[]", name.encode("utf-8")) dims = self.filterlib.pythonGetDims(name) dims = self.ffi.string(dims).decode("utf-8") return tuple([int(dim) for dim in dims.split("x")])
def test_char16_t(self): ffi = FFI() x = ffi.new("char16_t[]", 5) assert len(x) == 5 and ffi.sizeof(x) == 10 x[2] = u + '\u1324' assert x[2] == u + '\u1324' y = ffi.new("char16_t[]", u + '\u1234\u5678') assert len(y) == 3 assert list(y) == [u + '\u1234', u + '\u5678', u + '\x00'] assert ffi.string(y) == u + '\u1234\u5678' z = ffi.new("char16_t[]", u + '\U00012345') assert len(z) == 3 assert list(z) == [u + '\ud808', u + '\udf45', u + '\x00'] assert ffi.string(z) == u + '\U00012345'
def test_char16_t(self): ffi = FFI() x = ffi.new("char16_t[]", 5) assert len(x) == 5 and ffi.sizeof(x) == 10 x[2] = u+'\u1324' assert x[2] == u+'\u1324' y = ffi.new("char16_t[]", u+'\u1234\u5678') assert len(y) == 3 assert list(y) == [u+'\u1234', u+'\u5678', u+'\x00'] assert ffi.string(y) == u+'\u1234\u5678' z = ffi.new("char16_t[]", u+'\U00012345') assert len(z) == 3 assert list(z) == [u+'\ud808', u+'\udf45', u+'\x00'] assert ffi.string(z) == u+'\U00012345'
def test_variable_of_unknown_size(): ffi = FFI() ffi.cdef(""" typedef ... opaque_t; opaque_t globvar; """) lib = verify( ffi, 'test_constant_of_unknown_size', """ typedef char opaque_t[6]; opaque_t globvar = "hello"; """) # can't read or write it at all e = py.test.raises(TypeError, getattr, lib, 'globvar') assert str(e.value) in [ "cdata 'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet" ] #pypy e = py.test.raises(TypeError, setattr, lib, 'globvar', []) assert str(e.value) in [ "'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet" ] #pypy # but we can get its address p = ffi.addressof(lib, 'globvar') assert ffi.typeof(p) == ffi.typeof('opaque_t *') assert ffi.string(ffi.cast("char *", p), 8) == b"hello"
def load_ffi_interface(): ''' Load and return the FFI library instance, and DLL interface to the avmu DLL. return value is a 2-tuple (ffi_lib, dll_handle) ''' # We have to use globals or some sort of persistent state here, because if # we load the DLL twice, it'll create two typedef classes for all the DLL objects, # which will then fail to interoperate. global STATIC_FFI global STATIC_LIB if STATIC_FFI is not None and STATIC_LIB is not None: return STATIC_FFI, STATIC_LIB dll_path = find_dll() from . import load_header from cffi import FFI ffi = FFI() headers = load_header.load() ffi.cdef(headers) lib = ffi.dlopen(dll_path) print("Loaded library version: ", ffi.string(lib.versionString()).decode("utf-8")) STATIC_FFI = ffi STATIC_LIB = lib return ffi, lib
class QmixError(object): """ Qmix SDK error messages. """ def __init__(self, error_number): dll_dir = config.read_config().get('qmix_dll_dir', None) dll_filename = 'usl.dll' dll_path = find_dll(dll_dir=dll_dir, dll_filename=dll_filename) if dll_path is None: msg = 'Could not find the Qmix SDK DLL %s.' % dll_filename raise RuntimeError(msg) else: self.dll_path = dll_path self._ffi = FFI() self._ffi.cdef(ERROR_HEADER) self._dll = self._ffi.dlopen(self.dll_path) self.error_number = error_number self._error_code = self._ffi.new('TErrCode *') @property def error_code(self): self._error_code = hex(abs(self.error_number)) return self._error_code @property def error_string(self): e = self.error_code s = self._dll.ErrorToString(int(e, 16)) return self._ffi.string(s).decode('utf8')
def test_strchr(self): ffi = FFI(backend=self.Backend()) ffi.cdef(""" char *strchr(const char *s, int c); """) ffi.C = ffi.dlopen(None) p = ffi.new("char[]", b"hello world!") q = ffi.C.strchr(p, ord('w')) assert ffi.string(q) == b"world!"
def test_strchr(self): ffi = FFI(backend=self.Backend()) ffi.cdef(""" char *strchr(const char *s, int c); """) ffi.C = ffi.dlopen(None) p = ffi.new("char[]", b"hello world!") q = ffi.C.strchr(p, ord('w')) assert ffi.string(q) == b"world!"
class BGPDump: def __init__(self, filename): self.filename = str(filename) if isinstance(filename, unicode) else filename self.ffi = None self.libc = None self.libbgpdump = None self.handle = None def __enter__(self): self.ffi = FFI() libdir = resource_filename('bgpdumpy', 'lib') or '' self.libc = self.ffi.dlopen(None) self.libbgpdump = self.ffi.dlopen(os.path.join(libdir, 'libbgpdump.so')) self.ffi.cdef(CTypes) self.handle = self.libbgpdump.bgpdump_open_dump(self.filename) return self def __exit__(self, exc_type, exc_val, exc_tb): self.libbgpdump.bgpdump_close_dump(self.handle) del self.libbgpdump self.libbgpdump = None del self.libc self.libc = None del self.ffi self.ffi = None def __iter__(self): while True: if self.handle.eof == 1: break currentEntry = self.libbgpdump.bgpdump_read_next(self.handle) if currentEntry == self.ffi.NULL: continue # sometimes we get NULL back for no apparent reason try: yield BGPEntry(self, currentEntry) finally: self.libbgpdump.bgpdump_free_mem(currentEntry) @property def version(self): return self.ffi.string(self.libbgpdump.bgpdump_version())
class BGPDump: def __init__(self, filename): self.filename = str(filename) if isinstance( filename, unicode ) else filename self.ffi = None self.libc = None self.libbgpdump = None self.handle = None def __enter__(self): self.ffi = FFI() libdir = resource_filename( 'bgpdumpy', 'lib' ) or '' self.libc = self.ffi.dlopen(None) self.libbgpdump = self.ffi.dlopen( os.path.join( libdir, 'libbgpdump.so' ) ) self.ffi.cdef(CTypes) self.handle = self.libbgpdump.bgpdump_open_dump(self.filename) return self def __exit__(self, exc_type, exc_val, exc_tb): self.libbgpdump.bgpdump_close_dump(self.handle) del self.libbgpdump self.libbgpdump = None del self.libc self.libc = None del self.ffi self.ffi = None def __iter__(self): while True: if self.handle.eof == 1: break currentEntry = self.libbgpdump.bgpdump_read_next(self.handle) if currentEntry == self.ffi.NULL: continue # sometimes we get NULL back for no apparent reason try: yield BGPEntry(self, currentEntry) finally: self.libbgpdump.bgpdump_free_mem(currentEntry) @property def version(self): return self.ffi.string(self.libbgpdump.bgpdump_version())
class KaldiGmmDecoder(KaldiDecoderBase): """docstring for KaldiGmmDecoder""" def __init__(self, graph_dir=None, words_file=None, graph_file=None, model_conf_file=None): super(KaldiGmmDecoder, self).__init__() self._ffi = FFI() self._ffi.cdef(""" void* init_gmm(float beam, int32_t max_active, int32_t min_active, float lattice_beam, char* word_syms_filename_cp, char* fst_in_str_cp, char* config_cp); bool decode_gmm(void* model_vp, float samp_freq, int32_t num_frames, float* frames, bool finalize); bool get_output_gmm(void* model_vp, char* output, int32_t output_length, double* likelihood_p); """) self._lib = self._ffi.dlopen(self._library_binary) if words_file is None and graph_dir is not None: words_file = graph_dir + r"graph\words.txt" if graph_file is None and graph_dir is not None: graph_file = graph_dir + r"graph\HCLG.fst" self.words_file = os.path.normpath(words_file) self.graph_file = os.path.normpath(graph_file) self.model_conf_file = os.path.normpath(model_conf_file) self._model = self._lib.init_gmm(7.0, 7000, 200, 8.0, words_file, graph_file, model_conf_file) self.sample_rate = 16000 def decode(self, frames, finalize, grammars_activity=None): if not isinstance(frames, np.ndarray): frames = np.frombuffer(frames, np.int16) frames = frames.astype(np.float32) frames_char = self._ffi.from_buffer(frames) frames_float = self._ffi.cast('float *', frames_char) self._start_decode_time(len(frames)) result = self._lib.decode_gmm(self._model, self.sample_rate, len(frames), frames_float, finalize) self._stop_decode_time(finalize) if not result: raise RuntimeError("decoding error") return finalize def get_output(self, output_max_length=4 * 1024): output_p = self._ffi.new('char[]', output_max_length) likelihood_p = self._ffi.new('double *') result = self._lib.get_output_gmm(self._model, output_p, output_max_length, likelihood_p) output_str = self._ffi.string(output_p) likelihood = likelihood_p[0] return output_str, likelihood
def test_cffi_asprintf(): from cffi import FFI ffi = FFI() ffi.cdef( """int asprintf(char** buf, const char *format, ...); // copy-pasted from the man page""" ) C = ffi.dlopen(None) # loads the entire C namespace buf = ffi.new("char**") arg1 = ffi.new("char[]", b"wo") arg2 = ffi.new("char[]", b"ld") C.asprintf(buf, b"hello %sr%s", arg1, arg2) assert ffi.string(buf[0]).decode() == "hello world"
class RangeLib: def __init__(self, config_file): self.ffi = FFI() self.ffi.cdef(""" typedef void easy_lr ; // avoid exposing the struct internals, fake it as void easy_lr* range_easy_create(const char* config_file); const char ** range_easy_expand(easy_lr* elr, const char * c_range); const char * range_easy_eval(easy_lr* elr, const char * c_range); char * range_easy_compress(easy_lr* elr, const char ** c_nodes); int range_easy_destroy(easy_lr* elr); """) self.rangelib_ffi = self.ffi.dlopen("libcrange.so") self.elr = self.rangelib_ffi.range_easy_create(self.ffi.new("char[]", config_file)) def __charpp_to_native(self, arg): i = 0 arr = [] while arg[i] != self.ffi.NULL: arr.append(self.ffi.string(arg[i])) i = i + 1 return arr def expand(self, c_range): ret = self.rangelib_ffi.range_easy_expand(self.elr, self.ffi.new("char[]", c_range)) return self.__charpp_to_native(ret) def compress(self, nodes): char_arg = map(lambda x: self.ffi.new("char[]", x), nodes) char_arg.append(self.ffi.NULL) ret = self.rangelib_ffi.range_easy_compress(self.elr, self.ffi.new("char*[]", char_arg)) return self.ffi.string(ret) def eval(self, c_range): ret = self.rangelib_ffi.range_easy_eval(self.elr, self.ffi.new("char[]", c_range)) return self.ffi.string(ret) def __del__(self): self.rangelib_ffi.range_easy_destroy(self.elr)
def c_string_as_py_string(ffi: FFI, ptr: CffiData) -> str: """Convert if possible a cffi pointer to an ANSI C string <char*> to a python string. Args: ffi (FFI): FFI instance wrapping the native compilation module owning the native memory ptr (CffiData): cffi pointer (FFI.CData) Raises: RuntimeError: conversion is not supported Returns: str: converted string """ return as_string(ffi.string(ptr))
def test_function_with_struct_argument(self): if sys.platform == 'win32': py.test.skip("no 'inet_ntoa'") if (self.Backend is CTypesBackend and '__pypy__' in sys.builtin_module_names): py.test.skip("ctypes limitation on pypy") ffi = FFI(backend=self.Backend()) ffi.cdef(""" struct in_addr { unsigned int s_addr; }; char *inet_ntoa(struct in_addr in); """) ffi.C = ffi.dlopen(None) ina = ffi.new("struct in_addr *", [0x04040404]) a = ffi.C.inet_ntoa(ina[0]) assert ffi.string(a) == b'4.4.4.4'
def test_function_with_struct_argument(self): if sys.platform == 'win32': py.test.skip("no 'inet_ntoa'") if (self.Backend is CTypesBackend and '__pypy__' in sys.builtin_module_names): py.test.skip("ctypes limitation on pypy") ffi = FFI(backend=self.Backend()) ffi.cdef(""" struct in_addr { unsigned int s_addr; }; char *inet_ntoa(struct in_addr in); """) ffi.C = ffi.dlopen(None) ina = ffi.new("struct in_addr *", [0x04040404]) a = ffi.C.inet_ntoa(ina[0]) assert ffi.string(a) == b'4.4.4.4'
def test_char32_t(self): ffi = FFI() x = ffi.new("char32_t[]", 5) assert len(x) == 5 and ffi.sizeof(x) == 20 x[3] = u+'\U00013245' assert x[3] == u+'\U00013245' y = ffi.new("char32_t[]", u+'\u1234\u5678') assert len(y) == 3 assert list(y) == [u+'\u1234', u+'\u5678', u+'\x00'] py_uni = u+'\U00012345' z = ffi.new("char32_t[]", py_uni) assert len(z) == 2 assert list(z) == [py_uni, u+'\x00'] # maybe a 2-unichars string assert ffi.string(z) == py_uni if len(py_uni) == 1: # 4-bytes unicodes in Python s = ffi.new("char32_t[]", u+'\ud808\udf00') assert len(s) == 3 assert list(s) == [u+'\ud808', u+'\udf00', u+'\x00']
def test_char32_t(self): ffi = FFI() x = ffi.new("char32_t[]", 5) assert len(x) == 5 and ffi.sizeof(x) == 20 x[3] = u + '\U00013245' assert x[3] == u + '\U00013245' y = ffi.new("char32_t[]", u + '\u1234\u5678') assert len(y) == 3 assert list(y) == [u + '\u1234', u + '\u5678', u + '\x00'] py_uni = u + '\U00012345' z = ffi.new("char32_t[]", py_uni) assert len(z) == 2 assert list(z) == [py_uni, u + '\x00'] # maybe a 2-unichars string assert ffi.string(z) == py_uni if len(py_uni) == 1: # 4-bytes unicodes in Python s = ffi.new("char32_t[]", u + '\ud808\udf00') assert len(s) == 3 assert list(s) == [u + '\ud808', u + '\udf00', u + '\x00']
def symbols(headers): ffi = FFI() ffi.cdef(headers) nanomsg = ffi.dlopen("nanomsg") lines = [] for i in range(1024): val = ffi.new("int*") name = nanomsg.nn_symbol(i, val) if name == ffi.NULL: break name = ffi.string(name).decode() name = name[3:] if name.startswith("NN_") else name lines.append("%s = %s" % (name, val[0])) return "\n".join(lines) + "\n"
def symbols(headers): ffi = FFI() ffi.cdef(headers) nanomsg = ffi.dlopen('nanomsg') lines = [] for i in range(1024): val = ffi.new('int*') name = nanomsg.nn_symbol(i, val) if name == ffi.NULL: break name = ffi.string(name).decode() name = name[3:] if name.startswith('NN_') else name lines.append('%s = %s' % (name, val[0])) return '\n'.join(lines) + '\n'
def symbols(headers): ffi = FFI() ffi.cdef(headers) nanomsg = ffi.dlopen('nanomsg') lines = [] for i in range(1024): val = ffi.new('int*') name = nanomsg.nn_symbol(i, val) if name == ffi.NULL: break name = ffi.string(name).decode() name = name[3:] if name.startswith('NN_') else name lines.append('%s = %s' % (name, val[0])) return '\n'.join(lines) + '\n'
def c_charptrptr_as_string_list(ffi: FFI, ptr: CffiData, size: int) -> List[str]: """Convert if possible a cffi pointer to a C data array char** , into a list of python strings. Args: ffi (FFI): FFI instance wrapping the native compilation module owning the native memory ptr (CffiData): cffi pointer (FFI.CData) size (int): number of character strings in the char** pointer Raises: RuntimeError: conversion is not supported Returns: List[str]: converted data """ # TODO check type strings = ffi.cast('char*[%d]' % (size, ), ptr) res = [as_string(ffi.string(strings[i])) for i in range(size)] return res
def test_variable_of_unknown_size(): ffi = FFI() ffi.cdef(""" typedef ... opaque_t; opaque_t globvar; """) lib = verify(ffi, 'test_variable_of_unknown_size', """ typedef char opaque_t[6]; opaque_t globvar = "hello"; """) # can't read or write it at all e = py.test.raises(TypeError, getattr, lib, 'globvar') assert str(e.value) in ["cdata 'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet"] #pypy e = py.test.raises(TypeError, setattr, lib, 'globvar', []) assert str(e.value) in ["'opaque_t' is opaque", "'opaque_t' is opaque or not completed yet"] #pypy # but we can get its address p = ffi.addressof(lib, 'globvar') assert ffi.typeof(p) == ffi.typeof('opaque_t *') assert ffi.string(ffi.cast("char *", p), 8) == b"hello"
rc = ngspice_shared.ngSpice_Command('bg_run') print 'ngSpice_Command returned', rc time.sleep(.1) # required before to test if the simulation is running while (ngspice_shared.ngSpice_running()): time.sleep(.1) print "Simulation is done" all_plots = ngspice_shared.ngSpice_AllPlots() i = 0 while (True): if all_plots[i] == ffi.NULL: break else: print ffi.string(all_plots[i]) i += 1 plot_name = 'tran1' all_vectors = ngspice_shared.ngSpice_AllVecs(plot_name) i = 0 while (True): if all_vectors[i] == ffi.NULL: break else: vector_name = ffi.string(all_vectors[i]) vector_info = ngspice_shared.ngGet_Vec_Info('.'.join((plot_name, vector_name))) length = vector_info.v_length print "vector[{}] {} type {} flags {} length {}".format(i, vector_name, vector_info.v_type,
class DTrace: ## /usr/src/sys/cddl/contrib/opensolaris/uts/common/sys/dtrace.h DTRACE_PROBESPEC_NONE = -1 DTRACE_PROBESPEC_PROVIDER = 0 DTRACE_PROBESPEC_MOD = 1 DTRACE_PROBESPEC_FUNC = 2 DTRACE_PROBESPEC_NAME = 3 def __init__(self): self._DTRACE_VERSION = 3 self._ffi = FFI() self._C = self._ffi.dlopen(None) # print "X"*10, self._C.stdout self._dtrace = get_dtrace(self._ffi) self._dtp = None self._fd = None def get_error(self): if self._dtp: err_no = self._dtrace.dtrace_errno(self._dtp) err_msg_c = self._dtrace.dtrace_errmsg(self._dtp, err_no) err_msg = self._ffi.string(err_msg_c).decode("utf8") return err_no, err_msg else: return 0, None def open(self): error = self._ffi.new("int*") self._dtp = self._dtrace.dtrace_open(self._DTRACE_VERSION, 0, error) if self._dtp == self._ffi.NULL: err_msg_c = self._dtrace.dtrace_errmsg(self._dtp, error) err_msg = self._ffi.string(err_msg_c).decode("utf8") raise Exception(err_msg) def set_option(self, key, value): if self._dtp: res = self._dtrace.dtrace_setopt(self._dtp, key.encode("utf8"), value.encode("utf8")) if res == -1: err_no, err_msg = self.get_error() raise Exception("could not set DTrace option '{}' to '{}' - {}".format(key, value, err_msg)) def compile(self, program): prog = self._dtrace.dtrace_program_strcompile( self._dtp, program.encode("utf8"), self._dtrace.DTRACE_PROBESPEC_NAME, 0, 0, self._ffi.NULL ) if prog == self._ffi.NULL: err_no, err_msg = self.get_error() raise Exception("could not compile D program - {}".format(err_msg)) return DTraceProgram(self, prog) def go(self, fd=None): if self._dtp: fd = fd or sys.stdout self._fd = self._ffi.cast("FILE*", fd) self._chew = self._ffi.callback( "int (const dtrace_probedata_t*, const dtrace_recdesc_t*, void*)", self.chew ) res = self._dtrace.dtrace_go(self._dtp) if res != 0: err_no, err_msg = self.get_error() raise Exception("could not start instrumentation: {}".format(e)) else: print ("instrumentation started") def work(self): if self._dtp: res = self._dtrace.dtrace_work(self._dtp, self._fd, self._ffi.NULL, self._chew, self._ffi.NULL) print ("work result: {}".format(res)) def sleep(self): if self._dtp: res = self._dtrace.dtrace_sleep(self._dtp) print ("woke up") def stop(self): if self._dtp: res = self._dtrace.dtrace_stop(self._dtp) if res == -1: err_no, err_msg = self.get_error() raise Exception("could not stop instrumentation: {}".format(err_msg)) else: print ("instrumentation stopped") def close(self): if self._dtp: self._dtrace.dtrace_close(self._dtp) self._dtp = None def chew(self, data, rec, arg): print ("chew!", data, rec, arg) # A NULL rec indicates that we've processed the last record. if rec == self._ffi.NULL: return self._dtrace.DTRACE_CONSUME_NEXT return self._dtrace.DTRACE_CONSUME_THIS
class NFLOG(object): _instance = None def __new__(cls): if not cls._instance: cls._instance = super(NFLOG, cls).__new__(cls) return cls._instance def __init__(self): global _cdef, _clibs_includes, _clibs_link self.ffi = FFI() self.ffi.cdef(_cdef) self.libnflog = self.ffi.verify(_clibs_includes, libraries=list(_clibs_link)) self.libnflog_cache = dict() _cdef = _clibs_includes = _clibs_link = None def _ffi_call( self, func, args, no_check=False, check_gt0=False, check_notnull=False ): '''Call libnflog function through cffi, checking return value and raising error, if necessary. Checks if return is >0 by default.''' res = func(*args) if no_check\ or (check_gt0 and res > 0)\ or (check_notnull and res)\ or res >= 0: return res errno_ = self.ffi.errno raise NFLogError(errno_, os.strerror(errno_)) def __getattr__(self, k): if not (k.startswith('nflog_') or k.startswith('c_')): return super(NFLOG, self).__getattr__(k) if k.startswith('c_'): k = k[2:] if k not in self.libnflog_cache: func = getattr(self.libnflog, k) self.libnflog_cache[k] = lambda *a,**kw: self._ffi_call(func, a, **kw) return self.libnflog_cache[k] def generator( self, qids, pf=(socket.AF_INET, socket.AF_INET6), qthresh=None, timeout=None, nlbufsiz=None, buff_size=None, extra_attrs=None, handle_overflows=True ): '''Generator that yields: - on first iteration - netlink fd that can be poll'ed or integrated into some event loop (twisted, gevent, ...). Also, that is the point where uid/gid/caps can be dropped. - on all subsequent iterations it does recv() on that fd, returning either None (if no packet can be assembled yet) or captured packet payload. qids: nflog group ids to bind to (nflog_bind_group) Keywords: pf: address families to pass to nflog_bind_pf extra_attrs: metadata to extract from captured packets, returned in a list after packet payload, in the same order nlbufsiz (bytes): set size of netlink socket buffer for the created queues qthresh (packets): set the maximum amount of logs in buffer for each group timeout (seconds): set the maximum time to push log buffer for this group buff_size (bytes): size of the batch to fetch from libnflog to process in python (default: min(nlbufsiz, 1 MiB)) handle_overflows: supress ENOBUFS NFLogError on queue overflows (but do log warnings, default: True)''' handle = self.nflog_open(check_notnull=True) for pf in (pf if not isinstance(pf, int) else [pf]): self.nflog_unbind_pf(handle, pf) self.nflog_bind_pf(handle, pf) if isinstance(extra_attrs, bytes): extra_attrs = [extra_attrs] cb_results = list() @self.ffi.callback('nflog_callback') def recv_callback( qh, nfmsg, nfad, data, extra_attrs=extra_attrs, ts_slot=self.ffi.new('struct timeval *'), pkt_slot=self.ffi.new('char **'), ts_err_mask=frozenset([0, errno.EAGAIN]), result=None ): try: pkt_len = self.nflog_get_payload(nfad, pkt_slot) result = self.ffi.buffer(pkt_slot[0], pkt_len)[:] if extra_attrs: result = [result] for attr in extra_attrs: if attr == 'len': result.append(pkt_len) elif attr == 'ts': # Fails quite often (EAGAIN, SUCCESS, ...), not sure why try: self.nflog_get_timestamp(nfad, ts_slot) except NFLogError as err: if err.errno not in ts_err_mask: raise result.append(None) else: result.append(ts_slot.tv_sec + ts_slot.tv_usec * 1e-6) elif attr == 'prefix': result.append(self.ffi.string(self.nflog_get_prefix(nfad)) or None) else: raise NotImplementedError('Unknown nflog attribute: {}'.format(attr)) cb_results.append(result) except: cb_results.append(StopIteration) # breaks the generator raise return 0 for qid in (qids if not isinstance(qids, int) else [qids]): qh = self.nflog_bind_group(handle, qid, check_notnull=True) self.nflog_set_mode(qh, self.libnflog.NFULNL_COPY_PACKET, 0xffff) if qthresh: self.nflog_set_qthresh(qh, qthresh) if timeout: self.nflog_set_timeout(qh, int(timeout * 100)) if nlbufsiz: self.nflog_set_nlbufsiz(qh, nlbufsiz) self.nflog_callback_register(qh, recv_callback, self.ffi.NULL) fd = self.nflog_fd(handle) if not buff_size: if nlbufsiz: buff_size = min(nlbufsiz, 1*2**20) else: buff_size = 1*2**20 buff = self.ffi.new('char[]', buff_size) peek = yield fd # yield fd for poll() on first iteration while True: if peek: peek = yield NFWouldBlock # poll/recv is required continue # Receive/process netlink data, which may contain multiple packets try: nlpkt_size = self.c_recv(fd, buff, buff_size, 0) except NFLogError as err: if handle_overflows and err.errno == errno.ENOBUFS: log.warn( 'nlbufsiz seem' ' to be insufficient to hold unprocessed packets,' ' consider raising it via corresponding function keyword' ) continue raise self.nflog_handle_packet(handle, buff, nlpkt_size, no_check=True) # yield individual L3 packets for result in cb_results: if result is StopIteration: raise result peek = yield result cb_results = list()
class LibWwqParseCFFI(LibWwqLyParseBase): def __init__(self): super(LibWwqParseCFFI, self).__init__() from cffi import FFI self.ffi = FFI() self.lib = self.ffi.dlopen(self.lib_path) self.ffi.cdef(""" char * get_uuid(); char * get_name(); int parse(char * c,int length,char **result,int *result_length); int free_str(char * c); void* atomic_int64_init(); int atomic_int64_destroy(void* ptr); int64_t atomic_int64_get(void* ptr); int64_t atomic_int64_set(void* ptr, int64_t val); int64_t atomic_int64_add(void* ptr, int64_t val); int64_t atomic_int64_sub(void* ptr, int64_t val); int64_t atomic_int64_and(void* ptr, int64_t val); int64_t atomic_int64_or(void* ptr, int64_t val); int64_t atomic_int64_xor(void* ptr, int64_t val); typedef union epoll_data { void* ptr; int fd; uint32_t u32; uint64_t u64; uintptr_t sock; /* Windows specific */ void* hnd; /* Windows specific */ } epoll_data_t; typedef struct { uint32_t events; /* Epoll events and flags */ epoll_data_t data; /* User data variable */ } epoll_event ; void* epoll_create(int size); void* epoll_create1(int flags); int epoll_close(void* ephnd); int epoll_ctl(void* ephnd, int op, uintptr_t sock, epoll_event* event); int epoll_wait(void* ephnd, epoll_event* events, int maxevents, int timeout); """) self.lib.__class__.__repr__ = lambda s: "<%s object at 0x%016X>" % (s.__class__.__name__, id(s)) logging.debug("successful load lib %s" % self.lib) weakref.finalize(self, lambda: logging.debug("%s released" % self.lib) if self.ffi.dlclose(self.lib) or 1 else None) def get_uuid(self) -> bytes: return self.ffi.string(self.lib.get_uuid()) def get_name(self) -> bytes: return self.ffi.string(self.lib.get_name()) def lib_parse(self, byte_str: bytes) -> bytes: length = self.ffi.cast("int", len(byte_str)) result_length = self.ffi.new("int *") result_p = self.ffi.new("char **") # p = self.ffi.new("char []", byte_str) p = self.ffi.from_buffer(byte_str) self.lib.parse(p, length, result_p, result_length) result = self.ffi.unpack(result_p[0], result_length[0]) self.lib.free_str(result_p[0]) return result
def test_shm(): shmstep0() shmstep1() shmstep2() def setup_function(function): print("setting up %s" % function) if __name__ == "__main__": global shm import sys shmstep0() print shm.fd, shm.size, ffi.string(shm.name) c = sys.stdin.readline() print "readlins is return", c if c[:4] == "open": print "into openex test process 2" shmstep1x() print "copy 7 bytes " caddr = ffi.cast("void*", shm.addr) C.memcpy(caddr, "welcome", 7) sys.stdin.readline() print "copy %d bytes" % (4096 * 2 + 1) C.memcpy(caddr, "welcome" * 2000, 4096 * 2 + 1) sys.stdin.readline() shmstep2() elif c[:5] == "close": pass
from cffi import FFI ffi = FFI() ffi.cdef(""" // some declarations from the man page struct passwd { char *pw_shell; ...; }; struct passwd *getpwuid(int uid); """) C = ffi.verify(""" // passed to the real C compiler #include <sys/types.h> #include <pwd.h> """, libraries=[]) # or a list of libraries to link with p = C.getpwuid(0) print ffi.string(p.pw_shell)
class Sunlink: ''' Wraper for sunlink c lib ''' def __init__(self, header="include/sunlink.h"): self.ffi = FFI() self.ffi.cdef(self.headerFromFile(header)) self.sunlink = self.ffi.dlopen("lib/libsunlink.so") def headerFromFile(self, file): header = None with open(file) as conf: header = conf.read() return header def cli_sndrcv(self, nodeid, head, reqdata, reqfiles, timeout=60): ret, arg_ip, arg_port = self.getaddr(nodeid) if ret != 0: sys.exit("Can't get address(ip, port)") arg_head = self.ffi.new("TAPIHEAD *", head) arg_reqdata = self.ffi.new("char [1024]", reqdata) arg_reqfiles = self.ffi.new("char [1024]", reqfiles) arg_ansdta = self.ffi.new("char [1024]") arg_resfiles = self.ffi.new("char [1024]") ret = self.sunlink.cli_sndrcv(arg_ip, arg_port[0], arg_head, arg_reqdata, arg_reqfiles, arg_ansdta, arg_resfiles, timeout) if ret != 0: sys.exit("Send data fail.") return tuple(map(self.ffi.string, (arg_ansdta, arg_resfiles))) def svr_snd(self, head, ansdata, resfiles, timeout=60): ret = 0 arg_head = self.ffi.new("TAPIHEAD *", head) arg_ansdta = self.ffi.new("char [1024]", ansdata) arg_resfiles = self.ffi.new("char [1024]", resfiles) ret = self.sunlink.svr_snd(arg_head, arg_ansdta, arg_resfiles, timeout) return ret def svr_rcv(self, timeout=60): ret = 0 arg_head = self.ffi.new("TAPIHEAD *") arg_reqdata = self.ffi.new("char [1024]") arg_reqfiles = self.ffi.new("char [1024]") ret = self.sunlink.svr_rcv(arg_head, arg_reqdata, arg_reqfiles, timeout) return (ret, self.ffi.string(arg_reqdata), self.ffi.string(arg_reqfiles)) def svrend(self): ret = self.sunlink.tapi_svrend() return ret def getaddr(self, nodeid): ret = 0 arg_svrname = self.ffi.new("char [16]", nodeid) arg_ip = self.ffi.new("char [16]") arg_port = self.ffi.new("int *") ret = self.sunlink.tapi_getaddr(arg_svrname, arg_ip, arg_port) return (ret, arg_ip, arg_port[0])
def record(): global disable_native_grab signal.signal(signal.SIGINT, exit_gracefully) signal.signal(signal.SIGTERM, exit_gracefully) time.sleep(5) state = State.WAITING recordPath = '.' if (disable_native_grab == False): ffi = FFI() mscLib = ffi.dlopen('msc_x64.dll') ffi.cdef(''' int init(); void close(); int get_capture_width(); int get_capture_height(); int get_bytes_per_pixel(); int capture_frame(uint8_t* buffer); const char* get_last_error(); ''') ret = mscLib.init() print(ret) print(ffi.string(mscLib.get_last_error())) else: sct = mss() # if not os.path.exists(os.path.dirname(recordPath)): # try: # os.makedirs(os.path.dirname(recordPath)) # except OSError as exc: # Guard against race condition # if exc.errno != errno.EEXIST: # print('Recording name already exists. Please use another one') # raise # else: # print('Recording name already exists. Please use another one') # exit(1) try: counter = 0 id = 0 prevSec = datetime.now().time().second while True: # Excplicit update call because I'm lazy telemetry.update() speed = telemetry.get_telemetry_value('m_speed') * 3.6 laptime = telemetry.get_telemetry_value('m_lapTime') g_lat = telemetry.get_telemetry_value('m_gforce_lat') g_lon = telemetry.get_telemetry_value('m_gforce_lon') if (laptime > 0 and state == State.WAITING): print('Driving started') counter = 0 state = State.DRIVING recordPath = get_record_path() try: os.makedirs(os.path.dirname(recordPath)) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: print('Recording name already exists. Please use another one') raise with open(recordPath + 'meta.json', 'w') as f: f.write( '{"inputs":[' '"cam/image_array",' '"telemetry/speed",' '"user/throttle",' '"user/angle",' '"user/brake",' '"user/mode"],' '"types":[' '"image_array",' '"float",' '"float",' '"float",' '"float",' '"str"]}') # print(laptime) elif (laptime == 0 and state != State.WAITING): print('New lap starting') state = State.WAITING elif (state == State.WAITING): print('Waiting for start') if (g_lat > 6 or g_lon > 6): # state = State.CRASHED print('Crashed', g_lon, g_lat) if (state == State.DRIVING): # print(speed, g_lon, g_lat) captureJoystick(counter, recordPath, speed) if (disable_native_grab): capture_screen_py(sct, counter, recordPath) else: capture_screen(ffi, mscLib, counter, recordPath) id = id + 1 counter = counter + 1 currSec = datetime.now().time().second if currSec is not prevSec: print('Change', id, 'fps') id = 0 prevSec = currSec # sleep(0.1) except Exception as e: print('\a') time.sleep(1) print('\a') time.sleep(1) print('\a') quit()
from cffi import FFI ffi = FFI() ffi.cdef(""" // some declarations from the man page struct passwd { char *pw_name; ...; }; struct passwd *getpwuid(int uid); double addch(double x, double y); """) C = ffi.verify(""" // passed to the real C compiler #include <sys/types.h> #include <pwd.h> double addch(double x, double y) { return x + 10.0 * y; } """, libraries=[]) # or a list of libraries to link with p = C.getpwuid(0) print 'hello1' assert ffi.string(p.pw_name) == 'root' # on Python 3: b'root' print 'hello2' print C.addch(1.0,2.0)
def invoke(func, *args): retcode = func(*args) if retcode != 0: ret = lib.SpcGetErrMsg(retcode) print ret raise invoke(lib.SpcInitEnvEx) invoke(lib.SpcVerifyPIN,ffi.new("char[]","88888888"),8) userName = ffi.new("char[250]") lenUserName = ffi.new("unsigned int*") lenUserName[0] = 250 invoke(lib.SpcGetCardUserInfo,userName, lenUserName) print "Actual len:",len(userName)," ret len: ",lenUserName[0] print ffi.string(userName) cert = ffi.new("uint8_t[4096]") lenCert = ffi.new("unsigned int*") lenCert[0] = 4096 invoke(lib.SpcGetEnvCert,cert, lenCert) print "Cert Len:",lenCert[0] print bytes(ffi.buffer(cert,lenCert[0])) lib.SpcClearEnv()
class _PcapFfi(object): ''' This class represents the low-level interface to the libpcap library. It encapsulates all the cffi calls and C/Python conversions, as well as translation of errors and error codes to PcapExceptions. It is intended to be used as a singleton class through the PcapDumper and PcapLiveDevice classes, below. ''' _instance = None __slots__ = ['_ffi', '_libpcap', '_interfaces', '_windoze'] def __init__(self): ''' Assumption: this class is instantiated once in the main thread before any other threads have a chance to try instantiating it. ''' if _PcapFfi._instance: raise Exception("Can't initialize this class more than once!") _PcapFfi._instance = self self._windoze = False self._ffi = FFI() self._ffi.cdef(''' struct pcap; typedef struct pcap pcap_t; struct pcap_dumper; typedef struct pcap_dumper pcap_dumper_t; struct pcap_addr { struct pcap_addr *next; struct sockaddr *addr; struct sockaddr *netmask; struct sockaddr *broadaddr; struct sockaddr *dstaddr; }; typedef struct pcap_addr pcap_addr_t; struct pcap_if { struct pcap_if *next; char *name; char *description; pcap_addr_t *addresses; int flags; }; typedef struct pcap_if pcap_if_t; int pcap_findalldevs(pcap_if_t **, char *); void pcap_freealldevs(pcap_if_t *); struct pcap_pkthdr { long tv_sec; long tv_usec; unsigned int caplen; unsigned int len; }; struct pcap_stat { unsigned int recv; unsigned int drop; unsigned int ifdrop; }; typedef void (*pcap_handler)(unsigned char *, const struct pcap_pkthdr *, const unsigned char *); pcap_t *pcap_open_dead(int, int); pcap_dumper_t *pcap_dump_open(pcap_t *, const char *); void pcap_dump_close(pcap_dumper_t *); void pcap_dump(pcap_dumper_t *, struct pcap_pkthdr *, unsigned char *); // live capture pcap_t *pcap_create(const char *, char *); pcap_t *pcap_open_live(const char *, int, int, int, char *); pcap_t *pcap_open_offline(const char *fname, char *errbuf); int pcap_set_snaplen(pcap_t *, int); int pcap_snapshot(pcap_t *); int pcap_set_promisc(pcap_t *, int); int pcap_set_timeout(pcap_t *, int); int pcap_set_buffer_size(pcap_t *, int); int pcap_set_tstamp_precision(pcap_t *, int); int pcap_get_tstamp_precision(pcap_t *); int pcap_set_tstamp_type(pcap_t *, int); int pcap_list_tstamp_types(pcap_t *, int **); void pcap_free_tstamp_types(int *); int pcap_setdirection(pcap_t *, int); int pcap_datalink(pcap_t *); int pcap_setnonblock(pcap_t *, int, char *); int pcap_getnonblock(pcap_t *, char *); int pcap_set_immediate_mode(pcap_t *, int); int pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const unsigned char **); int pcap_dispatch(pcap_t *, int, pcap_handler, unsigned char *); int pcap_loop(pcap_t *, int, pcap_handler, unsigned char *); void pcap_breakloop(pcap_t *); int pcap_activate(pcap_t *); void pcap_close(pcap_t *); int pcap_get_selectable_fd(pcap_t *); int pcap_sendpacket(pcap_t *, const unsigned char *, int); char *pcap_geterr(pcap_t *); char *pcap_lib_version(); int pcap_stats(pcap_t *, struct pcap_stat *); struct bpf_insn; struct bpf_program { unsigned int bf_len; struct bpf_insn *bf_insns; }; int pcap_setfilter(pcap_t *, struct bpf_program *); int pcap_compile(pcap_t *, struct bpf_program *, const char *, int, unsigned int); void pcap_freecode(struct bpf_program *); ''') if sys.platform == 'darwin': libname = 'libpcap.dylib' elif sys.platform == 'win32': libname = 'wpcap.dll' # winpcap self._windoze = True else: # if not macOS (darwin) or windows, assume we're on # some unix-based system and try for libpcap.so libname = 'libpcap.so' try: self._libpcap = self._ffi.dlopen(libname) except Exception as e: raise PcapException("Error opening libpcap: {}".format(e)) self._interfaces = [] self.discoverdevs() @staticmethod def instance(): if not _PcapFfi._instance: _PcapFfi._instance = _PcapFfi() return _PcapFfi._instance @property def version(self): return self._ffi.string(self._libpcap.pcap_lib_version()) def discoverdevs(self): ''' Find all the pcap-eligible devices on the local system. ''' if len(self._interfaces): raise PcapException("Device discovery should only be done once.") ppintf = self._ffi.new("pcap_if_t * *") errbuf = self._ffi.new("char []", 128) rv = self._libpcap.pcap_findalldevs(ppintf, errbuf) if rv: raise PcapException("pcap_findalldevs returned failure: {}".format( self._ffi.string(errbuf))) pintf = ppintf[0] tmp = pintf pindex = 0 while tmp != self._ffi.NULL: xname = self._ffi.string( tmp.name) # "internal name"; still stored as bytes object xname = xname.decode('ascii', 'ignore') if self._windoze: ext_name = "port{}".format(pindex) else: ext_name = xname pindex += 1 if tmp.description == self._ffi.NULL: xdesc = ext_name else: xdesc = self._ffi.string(tmp.description) xdesc = xdesc.decode('ascii', 'ignore') # NB: on WinPcap, only loop flag is set isloop = (tmp.flags & 0x1) == 0x1 isup = (tmp.flags & 0x2) == 0x2 isrunning = (tmp.flags & 0x4) == 0x4 # JS: I've observed that the isup and isrunning flags # are patently false on some systems. As a result, we # blindly include all interfaces, regardless of their # reported status (though we still include status flags # in the interface object). # if isup and isrunning: xif = PcapInterface(ext_name, xname, xdesc, isloop, isup, isrunning) self._interfaces.append(xif) tmp = tmp.next self._libpcap.pcap_freealldevs(pintf) @property def devices(self): return self._interfaces @property def lib(self): return self._libpcap @property def ffi(self): return self._ffi def _recv_packet(self, xdev): phdr = self._ffi.new("struct pcap_pkthdr **") pdata = self._ffi.new("unsigned char **") rv = self._libpcap.pcap_next_ex(xdev, phdr, pdata) if rv == 1: rawpkt = bytes(self._ffi.buffer(pdata[0], phdr[0].caplen)) #dt = datetime.fromtimestamp(phdr[0].tv_sec) usec = int(xffi.cast("int", phdr[0].tv_usec)) #ts = dt.replace(microsecond=usec) ts = float("{:d}.{:06d}".format(phdr[0].tv_sec, usec)) return PcapPacket(ts, phdr[0].caplen, phdr[0].len, rawpkt) elif rv == 0: # timeout; nothing to return return None elif rv == -1: # error on receive; raise an exception s = self._ffi.string(self._libpcap.pcap_geterr(xpcap)) raise PcapException("Error receiving packet: {}".format(s)) elif rv == -2: # reading from savefile, but none left return None def _set_filter(self, xdev, filterstr): bpf = self._ffi.new("struct bpf_program *") cfilter = self._ffi.new("char []", bytes(filterstr, 'ascii')) compile_result = self._libpcap.pcap_compile(xdev, bpf, cfilter, 0, 0xffffffff) if compile_result < 0: # get error, raise exception s = self._ffi.string(self._libpcap.pcap_geterr(xdev)) raise PcapException( "Error compiling filter expression: {}".format(s)) sf_result = self._libpcap.pcap_setfilter(xdev, bpf) if sf_result < 0: # get error, raise exception s = self._ffi.string(self._libpcap.pcap_geterr(xdev)) raise PcapException( "Error setting filter on pcap handle: {}".format(s)) self._libpcap.pcap_freecode(bpf)
from cffi import FFI ffi = FFI() ffi.cdef(""" // some declarations from the man page struct passwd { char *pw_name; ...; }; struct passwd *getpwuid(int uid); """) C = ffi.verify(""" // passed to the real C compiler #include <sys/types.h> #include <pwd.h> """) print ffi.string(C.getpwuid(0).pw_name)
the case in validation functions), or throw exceptions. :raises: :class:`OATHError` containing error message on non-OK return value. """ if retval != c.OATH_OK and (not positive_ok or retval < 0): errno = _ffi.cast('oath_rc', retval) err_str = _ffi.string(c.oath_strerror(errno)) err = OATHError(err_str) err.code = errno raise err _handle_retval(c.oath_init()) atexit.register(c.oath_done) library_version = _ffi.string(c.oath_check_version(b'0')) def check_library_version(version): """ Determine whether the library version is greater than or equal to the specified version. :param bytes version: The dotted version number to check :rtype: :func:`bool` """ return c.oath_check_version(to_bytes(version)) != _ffi.NULL def base32_decode(data): """
:param bool positive_ok: Whether positive integers are acceptable (as is the case in validation functions), or throw exceptions. :raises: :class:`OATHError` containing error message on non-OK return value. """ if retval != c.OATH_OK and (not positive_ok or retval < 0): errno = _ffi.cast('oath_rc', retval) err_str = _ffi.string(c.oath_strerror(errno)) err = OATHError(err_str) err.code = errno raise err _handle_retval(c.oath_init()) atexit.register(c.oath_done) library_version = _ffi.string(c.oath_check_version(b'0')) def check_library_version(version): """ Determine whether the library version is greater than or equal to the specified version. :param bytes version: The dotted version number to check :rtype: :func:`bool` """ return c.oath_check_version(to_bytes(version)) != _ffi.NULL def base32_decode(data): """
class _PcapFfi(object): """ This class represents the low-level interface to the libpcap library. It encapsulates all the cffi calls and C/Python conversions, as well as translation of errors and error codes to PcapExceptions. It is intended to be used as a singleton class through the PcapDumper and PcapLiveDevice classes, below. """ _instance = None __slots__ = ["_ffi", "_libpcap", "_interfaces", "_windoze"] def __init__(self): """ Assumption: this class is instantiated once in the main thread before any other threads have a chance to try instantiating it. """ if _PcapFfi._instance: raise Exception("Can't initialize this class more than once!") _PcapFfi._instance = self self._windoze = False self._ffi = FFI() self._ffi.cdef( """ struct pcap; typedef struct pcap pcap_t; struct pcap_dumper; typedef struct pcap_dumper pcap_dumper_t; struct pcap_addr { struct pcap_addr *next; struct sockaddr *addr; struct sockaddr *netmask; struct sockaddr *broadaddr; struct sockaddr *dstaddr; }; typedef struct pcap_addr pcap_addr_t; struct pcap_if { struct pcap_if *next; char *name; char *description; pcap_addr_t *addresses; int flags; }; typedef struct pcap_if pcap_if_t; int pcap_findalldevs(pcap_if_t **, char *); void pcap_freealldevs(pcap_if_t *); struct pcap_pkthdr { unsigned long tv_sec; unsigned long tv_usec; unsigned int caplen; unsigned int len; }; struct pcap_stat { unsigned int recv; unsigned int drop; unsigned int ifdrop; }; pcap_t *pcap_open_dead(int, int); pcap_dumper_t *pcap_dump_open(pcap_t *, const char *); void pcap_dump_close(pcap_dumper_t *); void pcap_dump(pcap_dumper_t *, struct pcap_pkthdr *, unsigned char *); // live capture pcap_t *pcap_create(const char *, char *); // source, errbuf pcap_t *pcap_open_live(const char *, int, int, int, char *); pcap_t *pcap_open_offline(const char *fname, char *errbuf); int pcap_set_snaplen(pcap_t *, int); // 0 on success int pcap_snapshot(pcap_t *); int pcap_set_promisc(pcap_t *, int); // 0 on success int pcap_set_buffer_size(pcap_t *, int); // 0 on success int pcap_datalink(pcap_t *); int pcap_setnonblock(pcap_t *, int, char *); // 0 on success int pcap_getnonblock(pcap_t *, char *); int pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const unsigned char **); int pcap_activate(pcap_t *); void pcap_close(pcap_t *); int pcap_get_selectable_fd(pcap_t *); int pcap_sendpacket(pcap_t *, const unsigned char *, int); char *pcap_geterr(pcap_t *); char *pcap_lib_version(); int pcap_stats(pcap_t *, struct pcap_stat *); struct bpf_insn; struct bpf_program { unsigned int bf_len; struct bpf_insn *bf_insns; }; int pcap_setfilter(pcap_t *, struct bpf_program *); int pcap_compile(pcap_t *, struct bpf_program *, const char *, int, unsigned int); void pcap_freecode(struct bpf_program *); """ ) if sys.platform == "darwin": self._libpcap = self._ffi.dlopen("libpcap.dylib") # standard libpcap elif sys.platform == "linux": self._libpcap = self._ffi.dlopen("libpcap.so") # standard libpcap elif sys.platform == "win32": self._libpcap = self._ffi.dlopen("wpcap.dll") # winpcap self._windoze = True else: raise PcapException("Don't know how to locate libpcap on this platform: {}".format(sys.platform)) self._interfaces = [] self.discoverdevs() @staticmethod def instance(): if not _PcapFfi._instance: _PcapFfi._instance = _PcapFfi() return _PcapFfi._instance @property def version(self): return self._ffi.string(self._libpcap.pcap_lib_version()) def discoverdevs(self): """ Find all the pcap-eligible devices on the local system. """ if len(self._interfaces): raise PcapException("Device discovery should only be done once.") ppintf = self._ffi.new("pcap_if_t * *") errbuf = self._ffi.new("char []", 128) rv = self._libpcap.pcap_findalldevs(ppintf, errbuf) if rv: raise PcapException("pcap_findalldevs returned failure: {}".format(self._ffi.string(errbuf))) pintf = ppintf[0] tmp = pintf pindex = 0 while tmp != self._ffi.NULL: xname = self._ffi.string(tmp.name) # "internal name"; still stored as bytes object xname = xname.decode("ascii", "ignore") if self._windoze: ext_name = "port{}".format(pindex) else: ext_name = xname pindex += 1 if tmp.description == self._ffi.NULL: xdesc = ext_name else: xdesc = self._ffi.string(tmp.description) xdesc = xdesc.decode("ascii", "ignore") # NB: on WinPcap, only loop flag is set isloop = (tmp.flags & 0x1) == 0x1 isup = (tmp.flags & 0x2) == 0x2 isrunning = (tmp.flags & 0x4) == 0x4 xif = Interface(ext_name, xname, xdesc, isloop, isup, isrunning) self._interfaces.append(xif) tmp = tmp.next self._libpcap.pcap_freealldevs(pintf) @property def devices(self): return self._interfaces def open_dumper(self, outfile, dltype=Dlt.DLT_EN10MB, snaplen=65535): pcap = self._libpcap.pcap_open_dead(dltype.value, snaplen) xoutfile = self._ffi.new("char []", bytes(outfile, "ascii")) pcapdump = self._libpcap.pcap_dump_open(pcap, xoutfile) dl = self._libpcap.pcap_datalink(pcap) snaplen = self._libpcap.pcap_snapshot(pcap) return PcapDev(Dlt(dl), 0, snaplen, self.version, pcapdump) def close_dumper(self, pcapdump): self._libpcap.pcap_dump_close(pcapdump) def write_packet(self, dumper, pkt, ts=None): pkthdr = self._ffi.new("struct pcap_pkthdr *") if not ts: ts = time() pkthdr.tv_sec = int(ts) pkthdr.tv_usec = int(1000000 * (ts - int(ts))) pkthdr.caplen = len(pkt) pkthdr.len = len(pkt) xpkt = self._ffi.new("char []", pkt) self._libpcap.pcap_dump(dumper, pkthdr, xpkt) def open_pcap_file(self, filename): errbuf = self._ffi.new("char []", 128) pcap = self._libpcap.pcap_open_offline(bytes(filename, "ascii"), errbuf) if pcap == self._ffi.NULL: raise PcapException( "Failed to open pcap file for reading: {}: {}".format(filename, self._ffi.string(errbuf)) ) dl = self._libpcap.pcap_datalink(pcap) try: dl = Dlt(dl) except ValueError as e: raise PcapException("Don't know how to handle datalink type {}".format(dl)) return PcapDev(dl, 0, 0, self.version, pcap) def open_live(self, device, snaplen=65535, promisc=1, to_ms=100, nonblock=True): errbuf = self._ffi.new("char []", 128) internal_name = None for dev in self._interfaces: if dev.name == device: internal_name = dev.internal_name break if internal_name is None: raise Exception("No such device {} exists.".format(device)) pcap = self._libpcap.pcap_open_live(bytes(internal_name, "ascii"), snaplen, promisc, to_ms, errbuf) if pcap == self._ffi.NULL: raise PcapException("Failed to open live device {}: {}".format(internal_name, self._ffi.string(errbuf))) if nonblock: rv = self._libpcap.pcap_setnonblock(pcap, 1, errbuf) if rv != 0: raise PcapException( "Error setting pcap device in nonblocking state: {}".format(self._ffi.string(errbuf)) ) # gather what happened nblock = self._libpcap.pcap_getnonblock(pcap, errbuf) snaplen = self._libpcap.pcap_snapshot(pcap) dl = self._libpcap.pcap_datalink(pcap) try: dl = Dlt(dl) except ValueError as e: raise PcapException("Don't know how to handle datalink type {}".format(dl)) return PcapDev(dl, nblock, snaplen, self.version, pcap) def close_live(self, pcap): self._libpcap.pcap_close(pcap) def get_select_fd(self, xpcap): try: return self._libpcap.pcap_get_selectable_fd(xpcap) except: return -1 def send_packet(self, xpcap, xbuffer): if not isinstance(xbuffer, bytes): raise PcapException("Packets to be sent via libpcap must be serialized as a bytes object") xlen = len(xbuffer) rv = self._libpcap.pcap_sendpacket(xpcap, xbuffer, xlen) if rv == 0: return True s = self._ffi.string(self._libpcap.pcap_geterr(xpcap)) raise PcapException("Error sending packet: {}".format(s)) def recv_packet(self, xpcap): phdr = self._ffi.new("struct pcap_pkthdr **") pdata = self._ffi.new("unsigned char **") rv = self._libpcap.pcap_next_ex(xpcap, phdr, pdata) if rv == 1: rawpkt = bytes(self._ffi.buffer(pdata[0], phdr[0].caplen)) ts = float("{}.{}".format(phdr[0].tv_sec, phdr[0].tv_usec)) return PcapPacket(ts, phdr[0].caplen, phdr[0].len, rawpkt) elif rv == 0: # timeout; nothing to return return None elif rv == -1: # error on receive; raise an exception s = self._ffi.string(self._libpcap.pcap_geterr(xpcap)) raise PcapException("Error receiving packet: {}".format(s)) elif rv == -2: # reading from savefile, but none left return None def set_filter(self, xpcap, filterstr): bpf = self._ffi.new("struct bpf_program *") cfilter = self._ffi.new("char []", bytes(filterstr, "ascii")) compile_result = self._libpcap.pcap_compile(xpcap.pcap, bpf, cfilter, 0, 0xFFFFFFFF) if compile_result < 0: # get error, raise exception s = self._ffi.string(self._libpcap.pcap_geterr(xpcap.pcap)) raise PcapException("Error compiling filter expression: {}".format(s)) sf_result = self._libpcap.pcap_setfilter(xpcap.pcap, bpf) if sf_result < 0: # get error, raise exception s = self._ffi.string(self._libpcap.pcap_geterr(xpcap.pcap)) raise PcapException("Error setting filter on pcap handle: {}".format(s)) self._libpcap.pcap_freecode(bpf) def stats(self, xpcap): pstat = self._ffi.new("struct pcap_stat *") rv = self._libpcap.pcap_stats(xpcap, pstat) if rv == 0: return PcapStats(pstat.recv, pstat.drop, pstat.ifdrop) else: s = self._ffi.string(self._libpcap.pcap_geterr(xpcap)) raise PcapException("Error getting stats: {}".format(s))
# Strings are a bit harder. Go's strings are stored in a struct {char*, int}, # so we have to do conversion. This is further complicated by CFFI's ownership # semantics - we have to ensure that the char* lives as long as the struct, # otherwise the string will be garbage. We'll use a global weakref dictionary # to track that. import weakref global_weakrefs = weakref.WeakKeyDictionary() def toGoString(string): """Converts a Python string into the equivalent Go string and ensures the memory for the string lives as long as the struct reference.""" string_p = ffi.new('char[]', string) v = ffi.new('GoString*', { 'p': string_p, 'n': len(string) })[0] global_weakrefs[v] = (string_p,) return v # Now we can call the ReturnString function # Note that Go strings are passed by value and not by pointer, but toGoString # is required by CFFI to make a GoString*. We can use [0] to deference it to # a value. print ffi.string(dnslib.ReturnString(toGoString("golang.org")))
from cffi import FFI ffi = FFI() ffi.cdef(""" // some declarations from the man page struct passwd { char *pw_name; ...; }; struct passwd *getpwuid(int uid); """) C = ffi.verify(""" // passed to the real C compiler #include <sys/types.h> #include <pwd.h> """, libraries=[]) # or a list of libraries to link with p = C.getpwuid(0) print(p) print(ffi.string(p.pw_name)) assert ffi.string(p.pw_name) == b'root' # on Python 3: b'root'
#!/usr/bin/env python3 from cffi import FFI import os ffi = FFI() ffi.set_source("_vosk", None) ffi.cdef(os.popen("cpp ../../src/vosk_api.h").read()) ffi.compile() C = ffi.dlopen("libvosk.so") model = C.vosk_model_new("model".encode('utf-8')) rec = C.vosk_recognizer_new(model, 16000) with open("test.wav", "rb") as wf: while True: data = wf.read(8000) if len(data) == 0: break if C.vosk_recognizer_accept_waveform(rec, data, len(data)): print(ffi.string(C.vosk_recognizer_result(rec)).decode('utf-8')) else: print( ffi.string( C.vosk_recognizer_partial_result(rec)).decode('utf-8')) print(ffi.string(C.vosk_recognizer_final_result(rec)).decode('utf-8')) C.vosk_recognizer_free(rec) C.vosk_model_free(model)
callback = ffi.callback("sr_datafeed_callback_t", callback_imp) assert sigrok.sr_init(ctx) == sigrok.SR_OK try: dlist = sigrok.sr_driver_list() i = 0 while True: driver = dlist[i] i += 1 if driver == ffi.NULL: break assert sigrok.sr_driver_init(ctx[0], driver) == sigrok.SR_OK res = sigrok.sr_driver_scan(driver, ffi.NULL) if res != ffi.NULL: name = ffi.string(driver[0].name) print(name) if name == "fx2lafw": sdi = ffi.cast("struct sr_dev_inst*", res.data) print (ffi.string(sdi.vendor)) assert sigrok.sr_dev_open(sdi) == sigrok.SR_OK j = 0 for idx in range(sigrok.g_slist_length(sdi.probes)): probe = ffi.cast('struct sr_probe*',sdi.probes[idx].data) print (ffi.string(probe.name)) session = sigrok.sr_session_new() assert sigrok.sr_session_dev_add(sdi) == sigrok.SR_OK sigrok.sr_session_datafeed_callback_add(callback, ffi.NULL) assert sigrok.sr_session_start() == sigrok.SR_OK def stop():
class _PcapFfi(object): ''' This class represents the low-level interface to the libpcap library. It encapsulates all the cffi calls and C/Python conversions, as well as translation of errors and error codes to PcapExceptions. It is intended to be used as a singleton class through the PcapDumper and PcapLiveDevice classes, below. ''' _instance = None __slots__ = ['_ffi', '_libpcap','_interfaces','_windoze'] def __init__(self): ''' Assumption: this class is instantiated once in the main thread before any other threads have a chance to try instantiating it. ''' if _PcapFfi._instance: raise Exception("Can't initialize this class more than once!") _PcapFfi._instance = self self._windoze = False self._ffi = FFI() self._ffi.cdef(''' struct pcap; typedef struct pcap pcap_t; struct pcap_dumper; typedef struct pcap_dumper pcap_dumper_t; struct pcap_addr { struct pcap_addr *next; struct sockaddr *addr; struct sockaddr *netmask; struct sockaddr *broadaddr; struct sockaddr *dstaddr; }; typedef struct pcap_addr pcap_addr_t; struct pcap_if { struct pcap_if *next; char *name; char *description; pcap_addr_t *addresses; int flags; }; typedef struct pcap_if pcap_if_t; int pcap_findalldevs(pcap_if_t **, char *); void pcap_freealldevs(pcap_if_t *); struct pcap_pkthdr { long tv_sec; long tv_usec; unsigned int caplen; unsigned int len; }; struct pcap_stat { unsigned int recv; unsigned int drop; unsigned int ifdrop; }; typedef void (*pcap_handler)(unsigned char *, const struct pcap_pkthdr *, const unsigned char *); pcap_t *pcap_open_dead(int, int); pcap_dumper_t *pcap_dump_open(pcap_t *, const char *); void pcap_dump_close(pcap_dumper_t *); void pcap_dump(pcap_dumper_t *, struct pcap_pkthdr *, unsigned char *); // live capture pcap_t *pcap_create(const char *, char *); pcap_t *pcap_open_live(const char *, int, int, int, char *); pcap_t *pcap_open_offline(const char *fname, char *errbuf); int pcap_set_snaplen(pcap_t *, int); int pcap_snapshot(pcap_t *); int pcap_set_promisc(pcap_t *, int); int pcap_set_timeout(pcap_t *, int); int pcap_set_buffer_size(pcap_t *, int); int pcap_set_tstamp_precision(pcap_t *, int); int pcap_get_tstamp_precision(pcap_t *); int pcap_set_tstamp_type(pcap_t *, int); int pcap_list_tstamp_types(pcap_t *, int **); void pcap_free_tstamp_types(int *); int pcap_setdirection(pcap_t *, int); int pcap_datalink(pcap_t *); int pcap_setnonblock(pcap_t *, int, char *); int pcap_getnonblock(pcap_t *, char *); int pcap_set_immediate_mode(pcap_t *, int); int pcap_next_ex(pcap_t *, struct pcap_pkthdr **, const unsigned char **); int pcap_dispatch(pcap_t *, int, pcap_handler, unsigned char *); int pcap_loop(pcap_t *, int, pcap_handler, unsigned char *); void pcap_breakloop(pcap_t *); int pcap_activate(pcap_t *); void pcap_close(pcap_t *); int pcap_get_selectable_fd(pcap_t *); int pcap_sendpacket(pcap_t *, const unsigned char *, int); char *pcap_geterr(pcap_t *); char *pcap_lib_version(); int pcap_stats(pcap_t *, struct pcap_stat *); struct bpf_insn; struct bpf_program { unsigned int bf_len; struct bpf_insn *bf_insns; }; int pcap_setfilter(pcap_t *, struct bpf_program *); int pcap_compile(pcap_t *, struct bpf_program *, const char *, int, unsigned int); void pcap_freecode(struct bpf_program *); ''') if sys.platform == 'darwin': libname = 'libpcap.dylib' elif sys.platform == 'win32': libname = 'wpcap.dll' # winpcap self._windoze = True else: # if not macOS (darwin) or windows, assume we're on # some unix-based system and try for libpcap.so libname = 'libpcap.so' try: self._libpcap = self._ffi.dlopen(libname) except Exception as e: raise PcapException("Error opening libpcap: {}".format(e)) self._interfaces = [] self.discoverdevs() @staticmethod def instance(): if not _PcapFfi._instance: _PcapFfi._instance = _PcapFfi() return _PcapFfi._instance @property def version(self): return self._ffi.string(self._libpcap.pcap_lib_version()) def discoverdevs(self): ''' Find all the pcap-eligible devices on the local system. ''' if len(self._interfaces): raise PcapException("Device discovery should only be done once.") ppintf = self._ffi.new("pcap_if_t * *") errbuf = self._ffi.new("char []", 128) rv = self._libpcap.pcap_findalldevs(ppintf, errbuf) if rv: raise PcapException("pcap_findalldevs returned failure: {}".format(self._ffi.string(errbuf))) pintf = ppintf[0] tmp = pintf pindex = 0 while tmp != self._ffi.NULL: xname = self._ffi.string(tmp.name) # "internal name"; still stored as bytes object xname = xname.decode('ascii', 'ignore') if self._windoze: ext_name = "port{}".format(pindex) else: ext_name = xname pindex += 1 if tmp.description == self._ffi.NULL: xdesc = ext_name else: xdesc = self._ffi.string(tmp.description) xdesc = xdesc.decode('ascii', 'ignore') # NB: on WinPcap, only loop flag is set isloop = (tmp.flags & 0x1) == 0x1 isup = (tmp.flags & 0x2) == 0x2 isrunning = (tmp.flags & 0x4) == 0x4 # JS: I've observed that the isup and isrunning flags # are patently false on some systems. As a result, we # blindly include all interfaces, regardless of their # reported status (though we still include status flags # in the interface object). # if isup and isrunning: xif = PcapInterface(ext_name, xname, xdesc, isloop, isup, isrunning) self._interfaces.append(xif) tmp = tmp.next self._libpcap.pcap_freealldevs(pintf) @property def devices(self): return self._interfaces @property def lib(self): return self._libpcap @property def ffi(self): return self._ffi def _recv_packet(self, xdev): phdr = self._ffi.new("struct pcap_pkthdr **") pdata = self._ffi.new("unsigned char **") rv = self._libpcap.pcap_next_ex(xdev, phdr, pdata) if rv == 1: rawpkt = bytes(self._ffi.buffer(pdata[0], phdr[0].caplen)) #dt = datetime.fromtimestamp(phdr[0].tv_sec) usec = int(xffi.cast("int", phdr[0].tv_usec)) #ts = dt.replace(microsecond=usec) ts = float("{:d}.{:06d}".format(phdr[0].tv_sec, usec)) return PcapPacket(ts, phdr[0].caplen, phdr[0].len, rawpkt) elif rv == 0: # timeout; nothing to return return None elif rv == -1: # error on receive; raise an exception s = self._ffi.string(self._libpcap.pcap_geterr(xpcap)) raise PcapException("Error receiving packet: {}".format(s)) elif rv == -2: # reading from savefile, but none left return None def _set_filter(self, xdev, filterstr): bpf = self._ffi.new("struct bpf_program *") cfilter = self._ffi.new("char []", bytes(filterstr, 'ascii')) compile_result = self._libpcap.pcap_compile(xdev, bpf, cfilter, 0, 0xffffffff) if compile_result < 0: # get error, raise exception s = self._ffi.string(self._libpcap.pcap_geterr(xdev)) raise PcapException("Error compiling filter expression: {}".format(s)) sf_result = self._libpcap.pcap_setfilter(xdev, bpf) if sf_result < 0: # get error, raise exception s = self._ffi.string(self._libpcap.pcap_geterr(xdev)) raise PcapException("Error setting filter on pcap handle: {}".format(s)) self._libpcap.pcap_freecode(bpf)
class _PcapFfi(object): """ This class represents the low-level interface to the libpcap library. It encapsulates all the cffi calls and C/Python conversions, as well as translation of errors and error codes to PcapExceptions. It is intended to be used as a singleton class through the PcapDumper and PcapLiveDevice classes, below. """ _instance = None __slots__ = ['_ffi', '_libpcap', '_interfaces', '_windows'] def __init__(self): """ Assumption: this class is instantiated once in the main thread before any other threads have a chance to try instantiating it. """ if _PcapFfi._instance: raise Exception("Can't initialize this class more than once!") _PcapFfi._instance = self self._windows = False self._ffi = FFI() self._ffi.cdef(cc, override=True) self._ffi.cdef(cc_packed, override=True, packed=1) if sys.platform == 'darwin': libname = 'libpcap.dylib' elif "win" in sys.platform[:3]: libname = 'wpcap.dll' # winpcap self._windows = True else: # if not macOS (darwin) or windows, assume we're on # some unix-based system and try for libpcap.so libname = 'libpcap.so' try: self._libpcap = self._ffi.dlopen(libname) except Exception as e: raise PcapException("Error opening libpcap: {}".format(e)) self._interfaces = [] self.discoverdevs() @staticmethod def instance(): if not _PcapFfi._instance: _PcapFfi._instance = _PcapFfi() return _PcapFfi._instance @property def version(self): return self._ffi.string(self._libpcap.pcap_lib_version()) def discoverdevs(self): """ Find all the pcap-eligible devices on the local system. """ if len(self._interfaces): raise PcapException("Device discovery should only be done once.") ppintf = self._ffi.new("pcap_if_t * *") errbuf = self._ffi.new("char []", 128) rv = self._libpcap.pcap_findalldevs(ppintf, errbuf) if rv: raise PcapException("pcap_findalldevs returned failure: {}".format( self._ffi.string(errbuf))) pintf = ppintf[0] tmp = pintf pindex = 0 while tmp != self._ffi.NULL: xname = self._ffi.string( tmp.name) # "internal name"; still stored as bytes object xname = xname.decode('ascii', 'ignore') if self._windows: ext_name = "port{}".format(pindex) else: ext_name = xname pindex += 1 if tmp.description == self._ffi.NULL: xdesc = ext_name else: xdesc = self._ffi.string(tmp.description) xdesc = xdesc.decode('ascii', 'ignore') # NB: on WinPcap, only loop flag is set isloop = (tmp.flags & 0x1) == 0x1 isup = (tmp.flags & 0x2) == 0x2 isrunning = (tmp.flags & 0x4) == 0x4 xif = PcapInterface(ext_name, xname, xdesc, isloop, isup, isrunning) self._interfaces.append(xif) tmp = tmp.next self._libpcap.pcap_freealldevs(pintf) @property def devices(self): return self._interfaces @property def lib(self): return self._libpcap @property def ffi(self): return self._ffi def _process_packet(self, xdev, header, packet, nroots): # MPLS header mpls = self._ffi.new("union mpls *") # IP header iph = self._ffi.new("struct nfstream_iphdr *") # IPv6 header iph6 = self._ffi.new("struct nfstream_ipv6hdr *") # lengths and offsets eth_offset = 0 radio_len = 0 fc = 0 type = 0 wifi_len = 0 pyld_eth_len = 0 check = 0 ip_offset = 0 ip_len = 0 frag_off = 0 vlan_id = 0 proto = 0 time = 0 time = (header.tv_sec * TICK_RESOLUTION) + (header.tv_usec / (1000000 / TICK_RESOLUTION)) datalink_type = self._libpcap.pcap_datalink(xdev) datalink_check = True while datalink_check: datalink_check = False if Dlt(datalink_type) == Dlt.DLT_NULL: tmp_dlt_null = self._ffi.cast('struct pp_32 *', packet + eth_offset) if int(ntohs(tmp_dlt_null.value)) == 2: type = 0x0800 else: type = 0x86dd ip_offset = 4 + eth_offset elif Dlt( datalink_type ) == Dlt.DLT_PPP_SERIAL: # Cisco PPP in HDLC - like framing - 50 chdlc = self._ffi.cast('struct nfstream_chdlc *', packet + eth_offset) ip_offset = self._ffi.sizeof( 'struct nfstream_chdlc') # CHDLC_OFF = 4 type = ntohs(chdlc.proto_code) elif (Dlt(datalink_type) == Dlt.DLT_C_HDLC) or ( Dlt(datalink_type) == Dlt.DLT_PPP): # Cisco PPP - 9 or 104 chdlc = self._ffi.cast('struct nfstream_chdlc *', packet + eth_offset) # CHDLC_OFF = 4 ip_offset = self._ffi.sizeof( 'struct nfstream_chdlc') # CHDLC_OFF = 4 type = ntohs(chdlc.proto_code) elif Dlt(datalink_type ) == Dlt.DLT_EN10MB: # IEEE 802.3 Ethernet - 1 */ ethernet = self._ffi.cast('struct nfstream_ethhdr *', packet + eth_offset) ip_offset = self._ffi.sizeof( 'struct nfstream_ethhdr') + eth_offset check = ntohs(ethernet.h_proto) if check <= 1500: pyld_eth_len = check elif check >= 1536: type = check if pyld_eth_len != 0: llc = self._ffi.cast('struct nfstream_llc_header_snap *', packet + ip_offset) if (llc.dsap == 0xaa) or ( llc.ssap == 0xaa): # check for LLC layer with SNAP ext type = llc.snap.proto_ID ip_offset += 8 elif (llc.dsap == 0x42) or (llc.ssap == 0x42): # No SNAP ext return None elif Dlt(datalink_type ) == Dlt.DLT_LINUX_SLL: # Linux Cooked Capture - 113 type = (packet[eth_offset + 14] << 8) + packet[eth_offset + 15] ip_offset = 16 + eth_offset elif Dlt( datalink_type ) == Dlt.DLT_IEEE802_11_RADIO: # Radiotap link - layer - 127 radiotap = self._ffi.cast('struct nfstream_radiotap_header *', packet + eth_offset) radio_len = radiotap.len if (radiotap.flags & 0x50) == 0x50: # Check Bad FCS presence return None # Calculate 802.11 header length(variable) wifi = self._ffi.cast('struct nfstream_wifi_header *', packet + (eth_offset + radio_len)) fc = wifi.fc # Check wifi data presence if fcf_type(fc) == 0x2: if (fcf_to_ds(fc) and fcf_from_ds(fc) == 0x0) or ( fcf_to_ds(fc) == 0x0 and fcf_from_ds(fc)): wifi_len = 26 # + 4 byte fcs else: pass # Check ether_type from LLC llc = self._ffi.cast( 'struct nfstream_llc_header_snap *', packet + (eth_offset + wifi_len + radio_len)) if llc.dsap == 0xaa: type = ntohs(llc.snap.proto_ID) # Set IP header offset ip_offset = wifi_len + radio_len + self._ffi.sizeof( 'struct nfstream_llc_header_snap') + eth_offset elif Dlt(datalink_type) == Dlt.DLT_RAW: ip_offset = 0 eth_offset = 0 else: return None ether_type_check = True while ether_type_check: ether_type_check = False if type == 0x8100: vlan_id = ((packet[ip_offset] << 8) + packet[ip_offset + 1]) & 0xFFF type = (packet[ip_offset + 2] << 8) + packet[ip_offset + 3] ip_offset += 4 while type == 0x8100 and ip_offset < header.caplen: # Double tagging for 802.1Q vlan_id = ((packet[ip_offset] << 8) + packet[ip_offset + 1]) & 0xFFF type = ( packet[ip_offset + 2] << 8) + packet[ip_offset + 3] ip_offset += 4 ether_type_check = True elif (type == 0x8847) or (type == 0x8848): tmp_u32 = self._ffi.cast('struct pp_32 *', packet + ip_offset) mpls.u32 = int(ntohl(tmp_u32.value)) type = 0x0800 ip_offset += 4 while not mpls.mpls.s: tmp_u32_loop = self._ffi.cast('struct pp_32 *', packet + ip_offset) mpls.u32 = int(ntohl(tmp_u32_loop.value)) ip_offset += 4 ether_type_check = True elif type == 0x8864: type = 0x0800 ip_offset += 8 ether_type_check = True else: pass ip_check = True while ip_check: ip_check = False # Check and set IP header size and total packet length iph = self._ffi.cast('struct nfstream_iphdr *', packet + ip_offset) # Just work on Ethernet packets that contain IP if (type == 0x0800) and (header.caplen >= ip_offset): frag_off = ntohs(iph.frag_off) if header.caplen < header.len: pass if iph.version == 4: ip_len = iph.ihl * 4 iph6 = self._ffi.NULL if iph.protocol == 41: # IPPROTO_IPV6 ip_offset += ip_len ip_check = True if (frag_off & 0x1FFF) != 0: return None elif iph.version == 6: iph6 = self._ffi.cast('struct nfstream_ipv6hdr *', packet + ip_offset) ip_len = self._ffi.sizeof('struct nfstream_ipv6hdr') if iph6.ip6_hdr.ip6_un1_nxt == 60: # IPv6 destination option options = self._ffi.cast('uint8_t *', packet + (ip_offset + ip_len)) ip_len += 8 * (options[1] + 1) iph = self._ffi.NULL else: return None l4_offset = 0 ipsize = 0 src_addr = 0 dst_addr = 0 l4_packet_len = 0 version = 0 nfstream_hash = 0 if iph6 == self._ffi.NULL: version = 4 l4_packet_len = ntohs(iph.tot_len) - (iph.ihl * 4) ipsize = header.caplen - ip_offset proto = iph.protocol src_addr = ntohl(iph.saddr) dst_addr = ntohl(iph.daddr) nfstream_hash += iph.saddr + iph.daddr + proto + vlan_id else: version = 6 src_addr = ntohl(iph6.ip6_src.u6_addr.u6_addr32[0]) << 96 | ntohl( iph6.ip6_src.u6_addr.u6_addr32[1]) << 64 | ntohl( iph6.ip6_src.u6_addr.u6_addr32[2]) << 32 | ntohl( iph6.ip6_src.u6_addr.u6_addr32[3]) dst_addr = ntohl(iph6.ip6_dst.u6_addr.u6_addr32[0]) << 96 | ntohl( iph6.ip6_dst.u6_addr.u6_addr32[1]) << 64 | ntohl( iph6.ip6_dst.u6_addr.u6_addr32[2]) << 32 | ntohl( iph6.ip6_dst.u6_addr.u6_addr32[3]) proto = iph6.ip6_hdr.ip6_un1_nxt if proto == 60: options = self._ffi.cast( 'uint8_t *', iph6) + self._ffi.sizeof('struct nfstream_ipv6hdr') proto = options[0] l4_packet_len = ntohs(iph6.ip6_hdr.ip6_un1_plen) nfstream_hash += ( iph6.ip6_src.u6_addr.u6_addr32[2] + iph6.ip6_src.u6_addr.u6_addr32[3]) + ( iph6.ip6_dst.u6_addr.u6_addr32[2] + iph6.ip6_dst.u6_addr.u6_addr32[3]) + proto + vlan_id if version == 4: if ipsize < 20: return None if ((iph.ihl * 4) > ipsize) or (ipsize < ntohs(iph.tot_len)): return None l4_offset = iph.ihl * 4 l3 = self._ffi.cast('uint8_t *', iph) else: l4_offset = self._ffi.sizeof('struct nfstream_ipv6hdr') l3 = self._ffi.cast('uint8_t *', iph6) l4 = self._ffi.cast('uint8_t *', l3) + l4_offset syn, cwr, ece, urg, ack, psh, rst, fin = 0, 0, 0, 0, 0, 0, 0, 0 if (proto == 6 ) and l4_packet_len >= self._ffi.sizeof('struct nfstream_tcphdr'): tcph = self._ffi.cast('struct nfstream_tcphdr *', l4) sport = int(ntohs(tcph.source)) dport = int(ntohs(tcph.dest)) syn = int(tcph.syn) cwr = int(tcph.cwr) ece = int(tcph.ece) urg = int(tcph.urg) ack = int(tcph.ack) psh = int(tcph.psh) rst = int(tcph.rst) fin = int(tcph.fin) elif (proto == 17) and l4_packet_len >= self._ffi.sizeof( 'struct nfstream_udphdr'): udph = self._ffi.cast('struct nfstream_udphdr *', l4) sport = int(ntohs(udph.source)) dport = int(ntohs(udph.dest)) else: sport = 0 dport = 0 nfstream_hash += sport + dport if version == 4: return NFPacket(time=int(time), capture_length=header.caplen, length=header.len, nfhash=nfstream_hash, ip_src=src_addr, ip_dst=dst_addr, src_port=sport, dst_port=dport, protocol=proto, vlan_id=vlan_id, version=version, tcpflags=tcpflags(syn=syn, cwr=cwr, ece=ece, urg=urg, ack=ack, psh=psh, rst=rst, fin=fin), raw=bytes(xffi.buffer(iph, ipsize)), root_idx=nfstream_hash % nroots) else: return NFPacket(time=int(time), capture_length=header.caplen, length=header.len, nfhash=nfstream_hash, ip_src=src_addr, ip_dst=dst_addr, src_port=sport, dst_port=dport, protocol=proto, vlan_id=vlan_id, version=version, tcpflags=tcpflags(syn=syn, cwr=cwr, ece=ece, urg=urg, ack=ack, psh=psh, rst=rst, fin=fin), raw=bytes(xffi.buffer(iph6, header.len - ip_offset)), root_idx=nfstream_hash % nroots) def _recv_packet(self, xdev, nroots=1): phdr = self._ffi.new("struct pcap_pkthdr **") pdata = self._ffi.new("unsigned char **") rv = self._libpcap.pcap_next_ex(xdev, phdr, pdata) if rv == 1: return self._process_packet(xdev, phdr[0], pdata[0], nroots) elif rv == 0: # timeout; nothing to return return 0 elif rv == -1: # error on receive; raise an exception s = self._ffi.string(self._libpcap.pcap_geterr(xdev)) raise PcapException("Error receiving packet: {}".format(s)) elif rv == -2: # reading from savefile, but none left return -2
from cffi import FFI ffi = FFI() ffi.cdef(open('hello.h').read()) lib = ffi.dlopen('./libhello.so') #lib = ffi.verify("#include <hello.h>", include_dirs=["."]) a = ffi.string(lib.hello()) print a
void Add(const char *host); void Remove(const char *host); const char *Hash(const char *key); void SetReplica(GoInt replica); void Cfree(void *p); """) lib = ffi.dlopen("./consistent.so") print lib.Add, lib.Remove, lib.Hash, lib.Cfree host1 = ffi.new("char[]", "host1") lib.Add(host1) key = ffi.new("char[]", "test_key") host = lib.Hash(key) print ffi.string(host) lib.Cfree(host) # print("awesome.Add(12,99) = %d" % lib.Add(12,99)) # print("awesome.Cosine(1) = %f" % lib.Cosine(1)) # # data = ffi.new("GoInt[]", [74,4,122,9,12]) # nums = ffi.new("GoSlice*", {'data':data, 'len':5, 'cap':5}) # lib.Sort(nums[0]) # print("awesome.Sort(74,4,122,9,12) = %s" % [ # ffi.cast("GoInt*", nums.data)[i] # for i in range(nums.len)]) # # data = ffi.new("char[]", b"Hello Python!") # msg = ffi.new("GoString*", {'data':data, 'len':13}) # print("log id %d" % lib.Log(msg[0]))
'libressl_version', 'libressl_version_info', 'version', 'version_info', ] libcrypto_path = _backend_config().get('libcrypto_path') if libcrypto_path is None: libcrypto_path = find_library('crypto') if not libcrypto_path: raise LibraryNotFoundError('The library libcrypto could not be found') try: vffi = FFI() vffi.cdef("const char *SSLeay_version(int type);") version_string = vffi.string( vffi.dlopen(libcrypto_path).SSLeay_version(0)).decode('utf-8') except (AttributeError): vffi = FFI() vffi.cdef("const char *OpenSSL_version(int type);") version_string = vffi.string( vffi.dlopen(libcrypto_path).OpenSSL_version(0)).decode('utf-8') is_libressl = 'LibreSSL' in version_string version_match = re.search('\\b(\\d\\.\\d\\.\\d[a-z]*)\\b', version_string) if not version_match: version_match = re.search('(?<=LibreSSL )(\\d\\.\\d(\\.\\d)?)\\b', version_string) if not version_match: raise LibraryNotFoundError('Error detecting the version of libcrypto') version = version_match.group(1)
class FC_Solve: # TEST:$num_befs_weights=5; NUM_BEFS_WEIGHTS = 5 FCS_STATE_SUSPEND_PROCESS = 5 def __init__(self): self.ffi = FFI() self.lib = self.ffi.dlopen( "../libfreecell-solver." + ("dll" if (platform.system() == 'Windows') else "so")) self.ffi.cdef(''' void * freecell_solver_user_alloc(); typedef struct{ char s[20];}fcs_move_t; int freecell_solver_user_get_moves_left (void * user); int freecell_solver_user_get_next_move (void * user, fcs_move_t * move); void freecell_solver_user_free(void * instance); double fc_solve_user_INTERNAL_get_befs_weight(void * user, int idx); typedef char * freecell_solver_str_t; typedef int (*freecell_solver_user_cmd_line_known_commands_callback_t)( void *instance, int argc, freecell_solver_str_t argv[], int arg_index, int *num_to_skip, int *ret, void *context); int freecell_solver_user_cmd_line_parse_args_with_file_nesting_count( void *instance, int argc, freecell_solver_str_t argv[], int start_arg, freecell_solver_str_t *known_parameters, freecell_solver_user_cmd_line_known_commands_callback_t callback, void *callback_context, char **error_string, int *last_arg, int file_nesting_count, freecell_solver_str_t opened_files_dir); int freecell_solver_user_set_flares_plan(void * instance, char * s); int freecell_solver_user_INTERNAL_compile_all_flares_plans(void * instance, char * * s); int fc_solve_user_INTERNAL_get_flares_plan_num_items(void * i); char * fc_solve_user_INTERNAL_get_flares_plan_item_type(void * i, int item_idx); int fc_solve_user_INTERNAL_get_flares_plan_item_flare_idx(void * i, int item_idx); int fc_solve_user_INTERNAL_get_flares_plan_item_iters_count(void * i, int item_idx); int fc_solve_user_INTERNAL_compile_all_flares_plans(void * i, char **error_string); int fc_solve_user_INTERNAL_get_num_by_depth_tests_order( void * api_instance); int fc_solve_user_INTERNAL_get_by_depth_tests_max_depth( void * api_instance, int depth_idx); long freecell_solver_user_get_num_times_long(void * user); long freecell_solver_user_get_num_states_in_collection_long(void * user); void freecell_solver_user_limit_iterations_long( void * api_instance, const long max_iters); int freecell_solver_user_solve_board(void *api_instance, const char *const state_as_string); int freecell_solver_user_resume_solution(void * user); void freecell_solver_user_recycle(void *api_instance); ''') self.user = self.lib.freecell_solver_user_alloc() def is_SUSPEND(self, ret_code): """docstring for is_SUSPEND""" return ret_code == self.FCS_STATE_SUSPEND_PROCESS def get_next_move(self): move = self.ffi.new('fcs_move_t *') num_moves = self.lib.freecell_solver_user_get_moves_left(self.user) if not num_moves: return None ret = self.lib.freecell_solver_user_get_next_move(self.user, move) SUCCESS = 0 return (move if ret == SUCCESS else None) def input_cmd_line__generic(self, cmd_line_args): last_arg = self.ffi.new('int *') error_string = self.ffi.new('char * *') known_params = self.ffi.new('char * *') opened_files_dir = self.ffi.new('char [32001]') prefix = 'freecell_solver_user_cmd_line' func = 'parse_args_with_file_nesting_count' getattr(self.lib, prefix + '_' + func)( self.user, # instance len(cmd_line_args), # argc [self.ffi.new('char[]', bytes(s, 'UTF-8')) \ for s in cmd_line_args], # argv 0, # start_arg known_params, # known_params self.ffi.NULL, # callback self.ffi.NULL, # callback_context error_string, # error_string last_arg, # last_arg -1, # file_nesting_count opened_files_dir ) return (last_arg[0], len(cmd_line_args)) # TEST:$set_befs=0; def _set_befs_weights(self, name, weights_s): # TEST:$set_befs=$set_befs+$input_cmd_line; self.input_cmd_line(name, ["-asw", weights_s]) def __destroy__(self): self.ffi.freecell_solver_user_free(self.user) def _get_plan_type(self, item_idx): return self.ffi.string( self.lib.fc_solve_user_INTERNAL_get_flares_plan_item_type( self.user, item_idx)) def solve_board(self, board): return self.lib.freecell_solver_user_solve_board( self.user, bytes(board, 'UTF-8') ) def resume_solution(self): return self.lib.freecell_solver_user_resume_solution(self.user) def limit_iterations(self, max_iters): self.lib.freecell_solver_user_limit_iterations_long( self.user, max_iters ) def get_num_times(self): return self.lib.freecell_solver_user_get_num_times_long( self.user) def get_num_states_in_col(self): return self.lib.freecell_solver_user_get_num_states_in_collection_long( self.user) def recycle(self): self.lib.freecell_solver_user_recycle(self.user)
""") try: _lib = _ffi.dlopen( os.path.join( os.path.dirname(os.path.abspath(__file__)), "libcadical.so" ) ) except OSError as err: raise RuntimeError( "libcadical.so not found, run build_libcadical.sh" ) from err version = _ffi.string(_lib.ccadical_signature()) _status_to_bool = {0: None, 10: True, 20: False} _value_to_bool = {1: True, 0: None, -1: False} class Solver: def __init__(self): self.__solver = _lib.ccadical_init() self.__exception = None def __del__(self): _lib.ccadical_release(self.__solver) def add(self, lit): _lib.ccadical_add(self.__solver, lit)
class AbiInlineDeviceReader(CffiDeviceReader): def __init__(self, library: CffiDeviceReader.Library): super().__init__() self.ffi = FFI() self.ffi.cdef(""" char* get_cell(char *device, int row, int column); void free_resource(char *resource); """) library_name = library.get_library_name() self.lib = self.ffi.dlopen( os.path.join(os.path.dirname(__file__), library_name)) def get_cell(self, device: bytes, row: int, col: int): """ Returns the requested cell value of the specified device Parameters ---------- device bytes The device you want to retrieve the cell value on row int The table row of the value you want to retrieve col int The table column of the value you want to retrieve Returns ------- The pointer to the byte array containing the value of the cell **NOTE:** call free_resource() or free_resources() to free the allocated memory """ self.allocated_resources.append(self.lib.get_cell(device, row, col)) return self.allocated_resources[-1] def to_string(self, c_char_ptr) -> str: return self.ffi.string(c_char_ptr) def free_resource(self, resource) -> None: """Releases the resource previously allocated when calling get_cell Parameters ---------- resource: c_void_p The pointer to the byte array previously allocated by get_cell() Returns ------- None When the resource has been successfully released Raises ------ ResourceNotAllocated If the resource was not previously allocated """ if resource in self.allocated_resources: self.allocated_resources.remove(resource) self.lib.free_resource(resource) else: raise self.ResourceNotAllocated def free_resources(self): """Release all previously allocated resources""" for resource in reversed(self.allocated_resources): self.free_resource(resource) def num_allocated_resources(self) -> int: """Return the number of allocated resources Returns int The number of allocated resources """ return len(self.allocated_resources)
class CStrACL(object): _lazy = None @classmethod def lazy_instance(cls): if not cls._lazy: cls._lazy = cls() return cls._lazy def __init__(self): self.ffi = FFI() cdef = ''' struct __acl_ext; typedef struct __acl_ext *acl_t; typedef unsigned int acl_type_t; typedef unsigned int mode_t; static const acl_type_t ACL_TYPE_ACCESS; static const acl_type_t ACL_TYPE_DEFAULT; static const int TEXT_ABBREVIATE; static const int TEXT_NUMERIC_IDS; static const int TEXT_SOME_EFFECTIVE; static const int TEXT_ALL_EFFECTIVE; static const int TEXT_SMART_INDENT; acl_t acl_init(int count); acl_t acl_get_file(const char *path_p, acl_type_t type); acl_t acl_from_mode(mode_t mode); acl_t acl_from_text(const char *buf_p); char *acl_to_any_text( acl_t acl, const char *prefix, char separator, int options ); int acl_calc_mask(acl_t *acl_p); int acl_set_file(const char *path_p, acl_type_t type, acl_t acl); int acl_set_fd(int fd, acl_t acl); int acl_free(void *obj_p); ''' self.ffi.cdef(cdef) self.libacl = self.ffi.verify(''' #include <sys/types.h> #include <sys/acl.h> #include <acl/libacl.h> ''', libraries=['acl']) self._flag_cache = dict() for k, pre, alias in re.findall(r'\b((ACL_TYPE|TEXT)_([A-Z_]+))\b', cdef): v = getattr(self.libacl, k) setattr(self, k, v) if alias not in self._flag_cache: self._flag_cache[alias] = v else: self._flag_cache[alias] = None def _flag(self, k): if isinstance(k, (int, long)): return k elif not isinstance(k, types.StringTypes): return reduce(op.or_, it.imap(self._flag, k), 0) v = self._flag_cache[k] if v is not None: return v else: raise KeyError('Ambiguous flag name: {}'.format(k)) def get( self, src, acl_type='ACCESS', text_options=['ABBREVIATE', 'ALL_EFFECTIVE'] ): if isinstance(src, types.StringTypes): func = self.libacl.acl_get_file else: if not isinstance(src, (int, long)): src = src.fileno() func = self.libacl.acl_get_fd acl = func(src, self._flag(acl_type)) try: if acl == self.ffi.NULL: if self.ffi.errno == errno.ENODATA: return '' raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) acl_str = self.libacl.acl_to_any_text( acl, self.ffi.NULL, '\n', self._flag(text_options) ) if acl == self.ffi.NULL: raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) acl_str = self.ffi.string(acl_str) return acl_str finally: if acl != self.ffi.NULL and self.libacl.acl_free(acl): raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) def _set(self, dst, acl_str, acl_type='ACCESS'): acl = self.libacl.acl_from_text(acl_str)\ if acl_str is not None else self.libacl.acl_init(5) if acl == self.ffi.NULL: raise ValueError('Invalid ACL specification: {!r}'.format(acl_str)) try: acl_p = self.ffi.new('acl_t *', acl) if self.libacl.acl_calc_mask(acl_p): raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) acl_type = self._flag(acl_type) if isinstance(dst, types.StringTypes): err = self.libacl.acl_set_file(dst, acl_type, acl) else: if not isinstance(dst, (int, long)): dst = dst.fileno() err = self.libacl.acl_set_fd(dst, acl) if err: raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) finally: if self.libacl.acl_free(acl): raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) def set(self, dst, acl_str, acl_type='ACCESS'): return self._set(dst, acl_str, acl_type=acl_type) def unset(self, dst, acl_type='ACCESS'): return self._set(dst, None, acl_type=acl_type) def from_mode( self, mode, text_options=['ABBREVIATE', 'ALL_EFFECTIVE'] ): acl = self.libacl.acl_from_mode(mode) if acl == self.ffi.NULL: raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) try: acl_str = self.libacl.acl_to_any_text( acl, self.ffi.NULL, '\n', self._flag(text_options) ) return self.ffi.string(acl_str) finally: if self.libacl.acl_free(acl): raise OSError(self.ffi.errno, os.strerror(self.ffi.errno))
print "ret errno", ret, ffi.errno if ret != 0: print "errno is ", ffi.errno assert ret == 0 def test_shm(): shmstep0() shmstep1() shmstep2() def setup_function(function): print ("setting up %s" % function) if __name__ == "__main__": global shm import sys shmstep0() print shm.fd, shm.size,ffi.string(shm.name) c= sys.stdin.readline() print "readlins is return",c if c[:4] == "open": print "into openex test process 2" shmstep1x() print "copy 7 bytes " caddr = ffi.cast("void*", shm.addr) C.memcpy(caddr, "welcome", 7) sys.stdin.readline() print "copy %d bytes" % (4096*2+1) C.memcpy(caddr, "welcome"*2000, 4096*2+1) sys.stdin.readline() shmstep2() elif c[:5] == "close": pass
'version_info', ] ffi = FFI() ffi.cdef("const char *SSLeay_version(int type);") libcrypto_path = find_library('crypto') if not libcrypto_path: raise LibraryNotFoundError('The library libcrypto could not be found') libcrypto = ffi.dlopen(libcrypto_path) register_ffi(libcrypto, ffi) version_string = ffi.string(libcrypto.SSLeay_version(0)).decode('utf-8') version_match = re.search('\\b(\\d\\.\\d\\.\\d[a-z]*)\\b', version_string) if not version_match: version_match = re.search('(?<=LibreSSL )(\\d\\.\\d(\\.\\d)?)\\b', version_string) if not version_match: raise LibraryNotFoundError('Error detecting the version of libcrypto') version = version_match.group(1) version_parts = re.sub('(\\d)([a-z]+)', '\\1.\\2', version).split('.') version_info = tuple(int(part) if part.isdigit() else part for part in version_parts) if version_info < (0, 9, 8): raise LibraryNotFoundError(pretty_message( ''' OpenSSL versions older than 0.9.8 are not supported - found version %s ''', version
JSON_FALSE, JSON_NULL } json_type; typedef struct json_t { json_type type; size_t refcount; } json_t; ''') py_boot = ffi.cast("t_pypy_bootstrap *",c_argument) try: import os.path gfile = os.path.join(ffi.string(py_boot.paths.data).decode('utf-8'),'..','c_src','globals.h') print("trying for globals.h at '%s'"%gfile) if not os.path.isfile(gfile): raise OSError("could not find globals.h! eeeeep!") gfile = open(gfile,'r').read() cdefs = io.StringIO() lines = gfile.splitlines() for i,line in enumerate(lines): line = line.strip() if line.startswith('#'): continue cdefs.write(line+'\n') ffi.cdef(cdefs.getvalue(), override=True)#over ride old def's if they exist. trust globals.h
rc = ngspice_shared.ngSpice_Command('bg_run'.encode('utf8')) print('ngSpice_Command returned', rc) time.sleep(.1) # required before to test if the simulation is running while (ngspice_shared.ngSpice_running()): time.sleep(.1) print("Simulation is done") all_plots = ngspice_shared.ngSpice_AllPlots() i = 0 while (True): if all_plots[i] == ffi.NULL: break else: print(ffi.string(all_plots[i])) i += 1 plot_name = 'tran1' all_vectors = ngspice_shared.ngSpice_AllVecs(plot_name.encode('utf8')) i = 0 while (True): if all_vectors[i] == ffi.NULL: break else: vector_name = ffi.string(all_vectors[i]) name = '.'.join((plot_name, vector_name.decode('utf8'))) vector_info = ngspice_shared.ngGet_Vec_Info(name.encode('utf8')) length = vector_info.v_length print("vector[{}] {} type {} flags {} length {}".format( i, vector_name, vector_info.v_type, vector_info.v_flags, length))
class CStrCaps(object): _lazy = None @classmethod def lazy_instance(cls): if not cls._lazy: cls._lazy = cls() return cls._lazy def __init__(self): self.ffi = FFI() cdef = ''' struct _cap_struct; typedef struct _cap_struct *cap_t; cap_t cap_get_file(const char *path_p); int cap_set_file(const char *path_p, cap_t cap_p); cap_t cap_get_fd(int fd); int cap_set_fd(int fd, cap_t caps); cap_t cap_from_text(const char *buf_p); char *cap_to_text(cap_t caps, ssize_t *length_p); int cap_free(void *obj_d); ''' self.ffi.cdef(cdef) self.libcap = self.ffi.verify(''' #include <sys/types.h> #include <sys/capability.h> ''', libraries=['cap']) def get_file(self, src): if isinstance(src, types.StringTypes): func = self.libcap.cap_get_file else: if not isinstance(src, (int, long)): src = src.fileno() func = self.libcap.cap_get_fd caps = func(src) try: if caps == self.ffi.NULL: if self.ffi.errno == errno.ENODATA: return '' raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) else: caps_len_p = self.ffi.new('ssize_t *') caps_p = self.libcap.cap_to_text(caps, caps_len_p) if caps_p == self.ffi.NULL: raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) return self.ffi.string(caps_p, caps_len_p[0]) finally: if caps != self.ffi.NULL and self.libcap.cap_free(caps): raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) def set_file(self, dst, caps_str): caps = self.libcap.cap_from_text(caps_str) if caps == self.ffi.NULL: raise ValueError('Invalid capabilities specification: {!r}'.format(caps_str)) try: if isinstance(dst, types.StringTypes): err = self.libcap.cap_set_file(dst, caps) else: if not isinstance(dst, (int, long)): dst = dst.fileno() err = self.libcap.cap_set_fd(dst, caps) if err: raise OSError(self.ffi.errno, os.strerror(self.ffi.errno)) finally: if self.libcap.cap_free(caps): raise OSError(self.ffi.errno, os.strerror(self.ffi.errno))
class RangeLib(object): def __init__(self, config_file): self.ffi = FFI() self.ffi.cdef(""" typedef void easy_lr ; // avoid exposing the struct internals, fake it as void easy_lr* range_easy_create(const char* config_file); const char ** range_easy_expand(easy_lr* elr, const char * c_range); const char * range_easy_eval(easy_lr* elr, const char * c_range); char * range_easy_compress(easy_lr* elr, const char ** c_nodes); int range_easy_destroy(easy_lr* elr); void free(void *ptr); """) self.rangelib_ffi = self.ffi.dlopen("libcrange.so") self.libc_ffi = self.ffi.dlopen("libc.so.6") self.elr = self.rangelib_ffi.range_easy_create(self.ffi.new("char[]", config_file)) def __charpp_to_native(self, arg): i = 0 arr = [] while arg[i] != self.ffi.NULL: x = self.ffi.string(arg[i]) self.libc_ffi.free(arg[i]) arr.append(x) i += 1 self.libc_ffi.free(arg) return arr def expand(self, c_range): ret = self.rangelib_ffi.range_easy_expand(self.elr, self.ffi.new("char[]", c_range)) x = self.__charpp_to_native(ret) return x def compress(self, nodes): char_arg = [ self.ffi.new("char[]", x) for x in nodes ] char_arg.append(self.ffi.NULL) retptr = self.rangelib_ffi.range_easy_compress(self.elr, self.ffi.new("char*[]", char_arg)) ret = self.ffi.string(retptr) self.libc_ffi.free(retptr) return ret def eval(self, c_range): retptr = self.rangelib_ffi.range_easy_eval(self.elr, self.ffi.new("char[]", c_range)) ret = self.ffi.string(retptr) self.libc_ffi.free(retptr) return ret def __del__(self): self.rangelib_ffi.range_easy_destroy(self.elr)