async def check_file_exist( path: str, headers: Optional[Dict[str, str]] = None, ): try: if check_support(path): session = ClientSession() response: ClientResponse = await session.get( path, timeout=5, headers=headers, ) response.close() await session.close() if response.status == 200 or \ response.status == 403: return else: py_logger.info( f'{path} returned with {response.status} code', ) except ClientConnectorError: pass except TimeoutError: pass if S_ISFIFO(os.stat(path).st_mode): return if not os.path.isfile(path): raise FileNotFoundError()
def get_stdin(): #check if programm is being piped if S_ISFIFO(os.fstat(0).st_mode): for line in sys.stdin: line = line.replace('\n', '') line = line.replace(' ', '') stdincontent.append(line)
def run(self): start = time.time() try: if os.path.exists(self.location): mode = os.stat(self.location)[ST_MODE] if S_ISFIFO(mode): cmd = open(self.location, 'w', buffering=1) if len(self.data) == 1: cmd.write(self.data[0].encode('utf-8') + '\n') else: cmd.write( ('\n'.join(self.data) + '\n').encode('utf-8')) cmd.close() end = time.time() self.logger.info( "Data succesfully submitted to %s in %s seconds. %s commands processed. Delivery queue left %s items. Size: %s bytes." % (self.location, round(end - start, 3), self.size, self.queue_size, self.queue_bytes)) self.status = True else: self.logger.error("%s is not a named pipe" % (self.location)) self.status = False else: self.logger.error("%s does not exist" % (self.location)) self.status = False except Exception as error: self.logger.error( "Error submitting data to %s. Reason: %s. Delivery queue left %s items. Size: %s bytes" % (self.location, error, self.queue_size, self.queue_bytes)) self.status = False
def run(self, interval): """ Main loop, listen to named pipe and emit calls on each message. Before starting, first ensures that the named pipe exists. Exit the main loop by raising the exception Quit. """ if not exists(self.name): umask = os.umask(0o000) os.mkfifo(self.name, mode=0o666) os.umask(umask) elif not S_ISFIFO(os.stat(self.name).st_mode): raise NotFifoError(self.name) fifo = os.open(self.name, os.O_RDONLY | os.O_NONBLOCK) try: while True: try: _msg = os.read(fifo, 9999).decode('utf-8').strip() except OSError as err: if err.errno == EAGAIN or err.errno == EWOULDBLOCK: _msg = '' else: raise for msg in _msg.split('\n'): self.emit(msg.strip()) sleep(interval) except Quit: pass os.close(fifo)
def main2(): hash_md5 = hashlib.md5() hash_sha256 = hashlib.sha256() hash_sha1 = hashlib.sha1() logger.info("Now we are hashing files on the disk!") csvfile = open(argv.outputDir + "/" + "filehash.csv", 'a') csvwriter = csv.writer(csvfile, dialect=("excel")) csvwriter.writerow( ["File Fullpath", "MD5 Hash", "SHA1 Hash", "SHA256 Hash"]) for volume in volumeInfo: for parent, dirnames, filenames in os.walk(argv.mountDir + "/" + volume.split(" ")[-1], followlinks=False): for filename in filenames: file_path = os.path.join(parent, filename) if S_ISFIFO(os.stat(file_path).st_mode): continue try: with open(file_path, "rb") as inputFile: for chunk in iter(lambda: inputFile.read(4096), b""): hash_md5.update(chunk) hash_sha256.update(chunk) hash_sha1.update(chunk) except FileNotFoundError: logger.critical("Error getting file %s content." % file_path) continue csvwriter.writerow([ file_path, hash_md5.hexdigest(), hash_sha256.hexdigest(), hash_sha1.hexdigest() ])
def sys_main(): import sys PY2 = sys.version_info[0] == 2 if PY2: reload(sys); sys.setdefaultencoding('utf-8') import os from stat import S_ISFIFO err = None try: cols = get_cols() except Exception as ex: err = str(ex) cols = 80 if S_ISFIFO(os.fstat(0).st_mode): # pipe mode md = sys.stdin.read() else: if not len(sys.argv) > 1 or '-h' in sys.argv: md = get_help(cols, PY2) else: md = sys.argv[1] if os.path.exists(md): with open(md) as fd: md = fd.read() if err: print(err) print md else: main(md, term_width=cols)
def safe_make_fifo(path, mode=0o666): if os.path.exists(path): mode = os.stat(path)[ST_MODE] if not S_ISFIFO(mode): raise Exception("Path is not a FIFO: %s" % path) else: os.mkfifo(path, mode)
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 get_fifo(): candidates = glob('/tmp/uzbl_fifo_*') for file in candidates: if S_ISFIFO(os_stat(file).st_mode): return file else: return None
def __init__(self, config_file, uri, venv): self.config_file = config_file self.uri = uri self.venv = venv self.venvs = [] self.process_name = venv if venv else 'main' self._input_detected = True if S_ISFIFO( os.fstat(0).st_mode) or S_ISREG(os.fstat(0).st_mode) else False self._stdin_mode = True if uri else False try: config.initialize_config(filename=self.config_file) logging.initialize_logging(self.process_name) if self._input_detected != self._stdin_mode: if self._stdin_mode: raise RuntimeError( 'uri parameter found, but no input detected') else: raise RuntimeError( 'stdin data detected, but no uri parameter found') self.session = session.initialize_komlog_session() except Exception as e: sys.stderr.write('Error initializing komlogd.\n') sys.stderr.write(str(e) + '\n') if logging.logger is not None and len(logging.logger.handlers) > 0: sys.stderr.write('Log info: ' + logging.logger.handlers[0].baseFilename + '\n') ex_info = traceback.format_exc().splitlines() for line in ex_info: logging.logger.error(line) else: ex_info = traceback.format_exc().splitlines() for line in ex_info: print(line) exit()
def gen_obj(path, stat=None, chksum_handlers=None, real_location=None, stat_func=os.lstat, **overrides): """ given a fs path, and an optional stat, create an appropriate fs obj. :param stat: stat object to reuse if available :param real_location: real path to the object if path is the desired location, rather then existent location. :raise KeyError: if no obj type matches the stat checks :return: :obj:`pkgcore.fs.fs.fsBase` derivative """ if real_location is None: real_location = path if stat is None: try: stat = stat_func(real_location) except EnvironmentError as e: if stat_func == os.lstat or e.errno != errno.ENOENT: raise stat = os.lstat(real_location) mode = stat.st_mode d = { "mtime": stat.st_mtime, "mode": S_IMODE(mode), "uid": stat.st_uid, "gid": stat.st_gid } if S_ISREG(mode): d["size"] = stat.st_size d["data"] = local_source(real_location) d["dev"] = stat.st_dev d["inode"] = stat.st_ino if chksum_handlers is not None: d["chf_types"] = chksum_handlers d.update(overrides) return fsFile(path, **d) d.update(overrides) if S_ISDIR(mode): return fsDir(path, **d) elif S_ISLNK(mode): d["target"] = os.readlink(real_location) return fsSymlink(path, **d) elif S_ISFIFO(mode): return fsFifo(path, **d) else: major, minor = get_major_minor(stat) d["minor"] = minor d["major"] = major d["mode"] = mode return fsDev(path, **d)
def check_if_there_is_data_being_piped_to_stdin(): import sys import os from stat import S_ISFIFO if S_ISFIFO(os.fstat(0).st_mode): return True else: return False
def is_fifo(self): """ Whether this path is a FIFO. """ try: return S_ISFIFO(self.stat().st_mode) except OSError as e: if e.errno not in (ENOENT, ENOTDIR): raise return False
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 fs_modes(stat: int) -> Iterator[Mode]: if S_ISDIR(stat): yield Mode.folder if S_ISREG(stat): yield Mode.file if S_ISFIFO(stat): yield Mode.pipe if S_ISSOCK(stat): yield Mode.socket for bit, mode in FILE_MODES.items(): if stat & bit == bit: yield mode
def is_fifo(self): """ Whether this path is a FIFO. """ try: return S_ISFIFO(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_fifo(self): """ Whether this path is a FIFO. """ try: return S_ISFIFO(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 main(): MODE = fstat(stdin.fileno()).st_mode if S_ISREG(MODE) or S_ISFIFO(MODE): PROMPT = "" else: PROMPT = "roll> " try: while True: for line in execute(input(PROMPT)): print(line) except (KeyboardInterrupt, EOFError): exit()
def get_fifo(self): """ Look for UZBL's FIFO-file in /tmp. Don't give up until it has been found. """ candidates = glob('/tmp/uzbl_fifo_*') for file in candidates: if S_ISFIFO(os_stat(file).st_mode): self.mon.log(self, 'Found UZBL fifo in %s.' % file) self.fifo=file self.start_play_signal=True return # print 'not found trying again' self.widget.after(500,self.get_fifo)
def is_fifo(self): """ Whether this path is a FIFO. """ try: return S_ISFIFO(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
def is_fifo(self): """ Whether this path is a FIFO. """ try: return S_ISFIFO(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 check(binary): if not access(binary, X_OK): print_silent("[-] Binary can't be executed") print_silent("[-] Exiting") exit(1) else: print_silent("[+] Binary is executable") try: if not S_ISFIFO(stat(FIFO).st_mode): print_silent("[-] Unable to create named pipe") print_silent("[-] Exiting") exit(1) except OSError as oe: mkfifo(FIFO) pass
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 __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
async def is_fifo(self) -> bool: """ Whether this path is a FIFO. """ try: stat = await self.stat() return S_ISFIFO(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 __init__(self): self.dlv = dlv() self.actions = [] self.shot = None self.grabbed = None self.world = {} self.position = Location(1, 1) self.orientation = Orientation.RIGHT self.killed = False self.bumped = None self.previousAction = None self.size = 2 self.paint = exists('agent') and S_ISFIFO(stat('agent').st_mode) _, self.prog = mkstemp() unlite(join(dirname(__file__), 'agent.md'), self.prog)
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 "?"