iframe-proxy | Sunbelt Computer Software

History

122 lines (100 loc) · 4.69 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

import atheris # pragma: no cover

import os # pragma: no cover

import re # pragma: no cover

import traceback # pragma: no cover

import sys # pragma: no cover

from typing import Set, Tuple, List # pragma: no cover

@atheris.instrument_func

def is_expected_exception_message(exception: Exception, error_message_list: List[str]) -> bool: # pragma: no cover

"""

Checks if the message of a given exception matches any of the expected error messages, case-insensitively.

Args:

exception (Exception): The exception object raised during execution.

error_message_list (List[str]): A list of error message substrings to check against the exception's message.

Returns:

bool: True if the exception's message contains any of the substrings from the error_message_list,

case-insensitively, otherwise False.

"""

exception_message = str(exception).lower()

for error in error_message_list:

if error.lower() in exception_message:

return True

return False

@atheris.instrument_func

def get_max_filename_length(path: str) -> int: # pragma: no cover

"""

Get the maximum filename length for the filesystem containing the given path.

Args:

path (str): The path to check the filesystem for.

Returns:

int: The maximum filename length.

"""

return os.pathconf(path, "PC_NAME_MAX")

@atheris.instrument_func

def read_lines_from_file(file_path: str) -> list:

"""Read lines from a file and return them as a list."""

try:

with open(file_path, "r") as f:

return [line.strip() for line in f if line.strip()]

except FileNotFoundError:

print(f"File not found: {file_path}")

return []

except IOError as e:

print(f"Error reading file {file_path}: {e}")

return []

@atheris.instrument_func

def load_exception_list(file_path: str = "explicit-exceptions-list.txt") -> Set[Tuple[str, str]]:

"""Load and parse the exception list from a default or specified file."""

try:

bundle_dir = os.path.dirname(os.path.abspath(__file__))

full_path = os.path.join(bundle_dir, file_path)

lines = read_lines_from_file(full_path)

exception_list: Set[Tuple[str, str]] = set()

for line in lines:

match = re.match(r"(.+):(\d+):", line)

if match:

file_path: str = match.group(1).strip()

line_number: str = str(match.group(2).strip())

exception_list.add((file_path, line_number))

return exception_list

except Exception as e:

print(f"Error loading exception list: {e}")

return set()

@atheris.instrument_func

def match_exception_with_traceback(exception_list: Set[Tuple[str, str]], exc_traceback) -> bool:

"""Match exception traceback with the entries in the exception list."""

for filename, lineno, _, _ in traceback.extract_tb(exc_traceback):

for file_pattern, line_pattern in exception_list:

# Ensure filename and line_number are strings for regex matching

if re.fullmatch(file_pattern, filename) and re.fullmatch(line_pattern, str(lineno)):

return True

return False

@atheris.instrument_func

def check_exception_against_list(exc_traceback, exception_file: str = "explicit-exceptions-list.txt") -> bool:

"""Check if the exception traceback matches any entry in the exception list."""

exception_list = load_exception_list(exception_file)

return match_exception_with_traceback(exception_list, exc_traceback)

@atheris.instrument_func

def handle_exception(e: Exception) -> int:

"""Encapsulate exception handling logic for reusability."""

exc_traceback = e.__traceback__

if check_exception_against_list(exc_traceback):

return -1

else:

raise e

@atheris.instrument_func

def setup_git_environment() -> None:

"""Set up the environment variables for Git."""

bundle_dir = os.path.dirname(os.path.abspath(__file__))

if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"): # pragma: no cover

bundled_git_binary_path = os.path.join(bundle_dir, "git")

os.environ["GIT_PYTHON_GIT_EXECUTABLE"] = bundled_git_binary_path

if not sys.warnoptions: # pragma: no cover

# The warnings filter below can be overridden by passing the -W option

# to the Python interpreter command line or setting the `PYTHONWARNINGS` environment variable.

import warnings

import logging

# Fuzzing data causes some modules to generate a large number of warnings

# which are not usually interesting and make the test output hard to read, so we ignore them.

warnings.simplefilter("ignore")

logging.getLogger().setLevel(logging.ERROR)

Sunbelt Computer Software

PL/B Language Development and Support

Navigation Menu

Uh oh!

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

Uh oh!

FilesExpand file tree

utils.py

Latest commit

History

utils.py

File metadata and controls