def at_probe(): found = [] if environment == 'linux': print('Probing for ttyACM devices...') for i in range(10): devname = '/dev/ttyACM%d' % i if not os.path.exists(devname): continue mode = os.stat(devname).st_mode if S_ISCHR(mode): found += [devname] elif environment == 'windows': print('Probing for COM ports...') for i in range(256): port = 'COM%d' % i try: s = serial.Serial(port) s.close() found.append(port) except (OSError, serial.SerialException): pass else: raise Exception('EnvironmentError: unknow OS') return found
def inode_type(self, inode, symtab, addr_space): imode = inode.m('i_mode').v() type = "UNKN" if S_ISREG(imode): type = "REG" elif S_ISLNK(imode): type = "LNK" elif S_ISCHR(imode): type = "CHR" elif S_ISBLK(imode): type = "BLK" elif S_ISDIR(imode): type = "DIR" elif S_ISSOCK(imode): type = "SOCK" elif S_ISFIFO(imode): type = "FIFO" if symtab.lookup("rdwr_pipe_fops"): i_fop_offset = inode.get_member_offset('i_fop') if i_fop_offset > 0: i_fop = inode.get_member('i_fop').v() if i_fop == symtab.lookup("rdwr_pipe_fops"): type = "PIPE" return type
def is_block(fthing): """Take in a file object and checks to see if it's a block or fifo.""" if fthing is sys.stdout or fthing is sys.stdin: return True else: mode = os.stat(fthing.name).st_mode return S_ISBLK(mode) or S_ISCHR(mode)
def format_device(mode, major, minor): if S_ISCHR(mode): kind = 'character' elif S_ISBLK(mode): kind = 'block' else: kind = 'weird' return 'device:%s\nmajor: %d\nminor: %d\n' % (kind, major, minor)
def main(): parser = argparse.ArgumentParser() parser.add_argument('device', help='Serial port device e.g. /dev/ttyS1') parser.add_argument('--baudrate', default=9600, type=int) parser.add_argument('--bytesize', choices=[5, 6, 7, 8], type=int, help='set bytesize, one of {5, 6, 7, 8}, default: 8', default=8) parser.add_argument('--parity', choices=['N', 'E', 'O', 'S', 'M'], type=lambda c: c.upper(), help='set parity, one of {N E O S M}, default: N', default='N') parser.add_argument('--stopbits', choices=[1, 2], type=int, help='set stopbits, one of {1, 2}, default: 1', default=1) args = parser.parse_args() print('Device name: {}'.format(args.device)) mode = os.stat(args.device).st_mode if not S_ISCHR(mode): raise SystemExit('Expected a character device file') with serial.Serial(args.device, baudrate=args.baudrate, bytesize=args.bytesize, parity=args.parity, stopbits=args.stopbits, timeout=1) as f_dev: attempts = 30 print('Attempting to parse {} sentences:'.format(attempts)) bad_msg_count = 0 for _ in range(attempts): try: str_from_serial = f_dev.readline().decode('UTF-8') except UnicodeDecodeError: print(' Bad sentence: couldn\'t decode line') bad_msg_count += 1 continue try: msg = pynmea2.parse(str_from_serial, check=True) except pynmea2.ChecksumError: print(' Bad sentence: checksum error') bad_msg_count += 1 continue except pynmea2.ParseError: print(' Bad sentence: parse error') bad_msg_count += 1 continue print(' Got sentence type: {}'.format(msg.sentence_type)) print('Total bad sentences: {}'.format(bad_msg_count)) if bad_msg_count > 3: raise SystemExit('Too many bad NMEA sentences') else: print('Acceptable number of bad NMEA sentences')
def is_char_device(self): """ Whether this path is a character device. """ try: return S_ISCHR(self.stat().st_mode) except OSError as e: if e.errno not in (ENOENT, ENOTDIR): raise return False
def _check_interactive(*descriptors): for desc in descriptors: try: if not S_ISCHR(fstat(desc.fileno()).st_mode): return False except Exception: # Anything broken we are going to pretend this is not # interactive return False return True # pragma: no cover
def filetype_str(mode): if S_ISCHR(mode): msg = 'character special device file' elif S_ISBLK(mode): msg = 'block special device file' elif S_ISFIFO(mode): msg = 'FIFO (named pipe)' elif S_ISSOCK(mode): msg = 'socket' else: msg = 'unknown file type' return msg
def is_char_device(self): """ Whether this path is a character device. """ try: return S_ISCHR(self.stat().st_mode) except OSError as e: if not _ignore_error(e): raise # Path doesn't exist or is a broken symlink # (see https://bitbucket.org/pitrou/pathlib/issue/12/) return False
def is_char_device(self): """ Whether this path is a character device. """ try: return S_ISCHR(self.stat().st_mode) except OSError as e: # if e.errno not in (ENOENT, ENOTDIR): if e_errno_not_in_ENOENT_ENOTDIR(e): ### raise # Path doesn't exist or is a broken symlink # (see https://bitbucket.org/pitrou/pathlib/issue/12/) return False
def is_char_device(self): """ Whether this path is a character device. """ try: return S_ISCHR(self.stat().st_mode) except OSError as e: if e.errno not in _IGNORED_ERROS: raise # Path doesn't exist or is a broken symlink # (see https://bitbucket.org/pitrou/pathlib/issue/12/) return False except ValueError: # Non-encodable path return False
def is_char_device(self): """ Whether this path is a character device. """ try: return S_ISCHR(self.stat().st_mode) except OSError as e: if not _ignore_error(e): raise # Path doesn't exist or is a broken symlink # (see http://web.archive.org/web/20200623061726/https://bitbucket.org/pitrou/pathlib/issues/12/ ) return False except ValueError: # Non-encodable path return False
async def __new__(cls, loop, pipe, protocol, extra=None): fileno = pipe.fileno() mode = os.fstat(fileno).st_mode is_char = S_ISCHR(mode) is_fifo = S_ISFIFO(mode) is_socket = S_ISSOCK(mode) if not (is_char or is_fifo or is_socket): raise ValueError( 'Pipe transport is only for pipes, sockets and character devices.' ) if extra is None: extra = {} extra['pipe'] = pipe self = object.__new__(cls) self._extra = extra self.loop = loop self.protocol_paused = False self.pipe = pipe self.fileno = fileno self.protocol = protocol self._buffer = bytearray() self._connection_lost = 0 self.closing = False # Set when close() or write_eof() called. self._high_water = 65536 self._low_water = 16384 try: os.set_blocking(fileno, False) # skip 1 callback loop future = Future(loop) loop.call_soon(Future.set_result_if_pending, future, None) await future protocol.connection_made(self) # On AIX, the reader trick (to be notified when the read end of the socket is closed) only works for # sockets. On other platforms it works for pipes and sockets. if is_socket or (is_fifo and not IS_AIX): loop.add_reader(fileno, self._read_ready) except: self.close() raise return self
def file_hl_group(self, file, stat_res=None, stat_error=None): """Return the highlight group that `file` should be colored in.""" if stat_error is not None: return 'Error' if stat_res is None: return self.file_hl_group(file, *stat_path(file)) mode = stat_res.st_mode if not S_ISREG(mode): # Not a regular file if S_ISLNK(mode): if self._colors_special.get('ln') == 'target': # TODO # resolved = file.resolve() # if resolved == file: # # Don't try to resolve another time # # TODO # raise Exception('recursion! %s' % resolved) return self.file_hl_group(file, *stat_path(file, lstat=False)) else: ansi_color = self._colors_special.get('ln') elif S_ISCHR(mode): ansi_color = self._colors_special.get('cd') elif S_ISDIR(mode): ansi_color = self._colors_special.get('di') elif S_ISFIFO(mode): ansi_color = self._colors_special.get('pi') elif S_ISBLK(mode): ansi_color = self._colors_special.get('bd') elif S_ISSOCK(mode): ansi_color = self._colors_special.get('so') else: # TODO Does this happen? return 'Error' elif mode & S_IXUSR: # Executable ansi_color = self._colors_special.get('ex') else: # Regular file needle = file.name.lower() for pattern, colorcode in self._colors.items(): if needle.endswith(pattern): ansi_color = colorcode break else: # TODO Could not find a target color return None if ansi_color is None: return None hl_group = 'color' + ansi_color.replace(';', '_') return hl_group
async def is_char_device(self) -> bool: """ Whether this path is a character device. """ try: stat = await self.stat() return S_ISCHR(stat.st_mode) except OSError as e: if not _ignore_error(e): raise # Path doesn't exist or is a broken symlink # (see https://bitbucket.org/pitrou/pathlib/issue/12/) return False except ValueError: # Non-encodable path return False
def check_input_files(file_path, force): """Check the status of the file. If the file is empty or doesn't exist AND if the file is NOT a fifo/block/named pipe then a warning is printed and sys.exit(1) is called """ mode = None if file_path == '-': return try: mode = os.stat(file_path).st_mode except OSError: print("ERROR: Input file %s does not exist" % file_path, file=sys.stderr) if not force: print("NOTE: This can be overridden using the --force argument", file=sys.stderr) print("Exiting", file=sys.stderr) sys.exit(1) else: return # block devices/stdin will be nonzero if S_ISBLK(mode) or S_ISFIFO(mode) or S_ISCHR(mode): return if not os.path.exists(file_path): print("ERROR: Input file %s does not exist; exiting" % file_path, file=sys.stderr) if not force: print("NOTE: This can be overridden using the --force argument", file=sys.stderr) sys.exit(1) else: if os.stat(file_path).st_size == 0: print("ERROR: Input file %s is empty; exiting." % file_path, file=sys.stderr) if not force: print( "NOTE: This can be overridden using the --force" " argument", file=sys.stderr) sys.exit(1)
def connect(device=DEFAULT_DEVICE): device = os.getenv("BLEMU_DEVICE", device) if not os.path.exists(device): raise ValueError("Device `%s` does not exist. Cannot connect" % device) mode = os.stat(device).st_mode ser = None if S_ISCHR(mode): ser = serial.Serial(port=device, baudrate=BAUD_RATE) elif S_ISFIFO(mode) or S_ISREG(mode): ser = open(device, "w") # So! Apparently when you connect to the arduino serial port, the # bootloader kicks in, resets the arduino and waits a second for a new # program to be loaded before running the actual already stored code time.sleep(2) return ser
def analyze(src, length=io.DEFAULT_BUFFER_SIZE): md5 = hashlib.md5() src = os.path.abspath(src) try: mode = os.stat(src).st_mode if S_ISREG(mode): upsert_file_metadata(src, stat_types['REGULAR'], size=os.path.getsize(src), extension=os.path.splitext(src)[1]) elif S_ISDIR(mode): upsert_file_metadata(src, stat_types['DIRECTORY']) elif S_ISCHR(mode): upsert_file_metadata(src, stat_types['CHAR']) elif S_ISBLK(mode): upsert_file_metadata(src, stat_types['BLOCK']) elif S_ISFIFO(mode): upsert_file_metadata(src, stat_types['FIFO']) elif S_ISLNK(mode): upsert_file_metadata(src, stat_types['SYMLINK']) elif S_ISSOCK(mode): upsert_file_metadata(src, stat_types['SOCKET']) else: upsert_file_metadata(src, stat_types['UNKNOWN']) except FileNotFoundError: mode = os.stat(src, follow_symlinks=False).st_mode if S_ISLNK(mode): upsert_file_metadata(src, stat_types['BROKEN_SYMLINK']) # Just return the MD5 hash of an empty string for non-regular files if not S_ISREG(mode): return md5 try: upsert_file_metadata(src, mime_type=(magic.from_file(src, mime=True)), mime_detail=magic.from_file(src)) with io.open(src, mode="rb") as fd: for chunk in iter(lambda: fd.read(length), b''): md5.update(chunk) except OSError: upsert_file_metadata(src, stat_types['ERROR']) pass return md5
def get_file_type(self, root, filename): filepath = fpath.join(root, filename) filemode = stat(filepath).st_mode if S_ISREG(filemode): return "f" elif S_ISSOCK(filemode): return "s" elif S_ISFIFO(filemode): return "p" elif S_ISLNK(filemode): return "l" elif S_ISDIR(filemode): return "d" elif S_ISCHR(filemode): return "c" elif S_ISBLK(filemode): return "b" return "?"
def get_ftype_and_perm(mode): """ Returns a tuple of whether the file is: file(regular file)/dir/slink /char. spec/block spec/pipe/socket and the permission bits of the file. If it does not match any of the cases below (it will return "unknown" twice)""" if S_ISREG(mode): return "file", S_IMODE(mode) if S_ISDIR(mode): return "dir", S_IMODE(mode) if S_ISLNK(mode): return "slink", S_IMODE(mode) if S_ISCHR(mode): return "character special", S_IMODE(mode) if S_ISBLK(mode): return "block special", S_IMODE(mode) if S_ISFIFO(mode): return "pipe", S_IMODE(mode) if S_ISSOCK(mode): return "socket", S_IMODE(mode) return "unknown", "unknown"
def _is_gpiochip_cdev(path: str) -> bool: try: statbuf = lstat(path) except FileNotFoundError: return False # Is it a character device? if not S_ISCHR(statbuf.st_mode): # Passing a file descriptor not associated with a character # device to ioctl() makes it set errno to ENOTTY. Let's do # the same in order to stay compatible with the versions of # libgpiod from before the introduction of this routine. set_errno(ENOTTY) return False # Do we have a corresponding sysfs attribute? name = basename(path) sysfsp = "/sys/bus/gpio/devices/{}/dev".format(name) if not access(sysfsp, R_OK): # This is a character device but not the one we're after. # Before the introduction of this function, we'd fail with # ENOTTY on the first GPIO ioctl() call for this file # descriptor. Let's stay compatible here and keep returning # the same error code. set_errno(ENOTTY) return False # Make sure the major and minor numbers of the character device # correspond to the ones in the dev attribute in sysfs. devstr = "{}:{}".format(major(statbuf.st_rdev), minor(statbuf.st_rdev)) try: with open(sysfsp, "r") as fd: sysfsdev = fd.read(len(devstr)) except FileNotFoundError: return False if sysfsdev != devstr: set_errno(ENODEV) return False return True
def get_ctl(path, mode): """get the string to control device access for cgroup :param path: the device file path :param mode: either "r" or "rw" :return: the string to control device access """ try: st = os.stat(path) except OSError as e: log.error("Failed to get stat of {}: {}".format(path, str(e))) raise t = "" if S_ISBLK(st.st_mode): t = "b" elif S_ISCHR(st.st_mode): t = "c" if t and mode in ("r", "rw"): return "{} {}:{} {}".format(t, os.major(st.st_rdev), os.minor(st.st_rdev), mode) raise RuntimeError("Failed to get control string of {}".format(path))
def check_WDC_drive(dev): print('Checking if %s is a Western Digital drive...' % dev, end='') from os import getuid, path, stat from stat import S_ISCHR # Perform some extra sanity checks first... if not path.exists('/dev/%s' % dev): print(' nonexistent device') return False if not S_ISCHR(stat('/dev/%s' % dev).st_mode): print(' not a character device') return False p = run([ 'camcontrol', 'cmd', dev, '-v', '-a', 'EC 00 00 00 00 00 00 00 00 00 01 00', '-i', '512', '-' ], capture_output=True) if p.returncode != 0: print(' failed') # Hint: camcontrol(8) requires root to access /dev/xpt0 if getuid() != 0: print('Are you running %s as root?' % sys.argv[0]) return False # XXX: should probably check for "FX", "NEC", "Pioneer", or "SHARP" # because they don't require byteswap, but I haven't seen those in # usage for quite a while, so let's just waive the check for now :) model = struct.pack('<20H', *struct.unpack_from('>20H', p.stdout, 54)) if model[:3] == b'WDC': print(' apparently so!') return True print(' no :(') print('The drive says its model is %s' % model.strip().decode()) if not force: return False verbose_print('Proceeding anyway because --force option was given') return True
async def __new__(cls, loop, pipe, protocol, extra=None): fileno = pipe.fileno() mode = os.fstat(fileno).st_mode if not (S_ISFIFO(mode) or S_ISSOCK(mode) or S_ISCHR(mode)): raise ValueError( 'Pipe transport is only for pipes, sockets and character devices.' ) self = object.__new__(cls) if extra is None: extra = {} extra['pipe'] = pipe self._extra = extra self.loop = loop self.pipe = pipe self.fileno = fileno self.protocol = protocol self.closing = False self._paused = False try: os.set_blocking(fileno, False) # skip 1 callback loop future = Future(loop) loop.call_soon(Future.set_result_if_pending, future, None) await future protocol.connection_made(self) loop.add_reader(fileno, self._read_ready) except: self.close() raise return self
def regfile(a): """Return if st_mode info in 'a' points to a file or file like filesystem object""" return S_ISREG(a) or S_ISFIFO(a) or S_ISSOCK(a) or S_ISCHR(a)
def is_device(self): mode = os.lstat(self._name).st_mode return S_ISCHR(mode) or S_ISBLK(mode)
def is_terminal(fileno: int) -> bool: """ Returns true if the given file number belongs to a terminal (stdout)""" return S_ISCHR(os.fstat(fileno).st_mode)
def stat_is_special(attr): return S_ISCHR(attr.st_mode) or S_ISBLK(attr.st_mode)
def isdev(self): from stat import S_ISBLK, S_ISCHR mode = self.__st_mode() return S_ISBLK(mode) or S_ISCHR(mode)
def ischardev(self): from stat import S_ISCHR return S_ISCHR(self.__st_mode())