val = __orig_fork()

if val == 0 and safe._builtin_globals_backup != None:

safe._builtin_restore()

# These will be the functions and variables in the user's namespace (along

# with the builtins allowed by the safe module).

usercontext = {'mycontext':{}}

# Add to the user's namespace wrapped versions of the API functions we make

# available to the untrusted user code.

namespace.wrap_and_insert_api_functions(usercontext)

# Convert the usercontext from a dict to a SafeDict

usercontext = safe.SafeDict(usercontext)

# Allow some introspection by providing a reference to the context

usercontext["_context"] = usercontext

# call the initialize function

usercontext['callfunc'] = 'initialize'

usercontext['callargs'] = args[:]

# I'll use this to detect when the program is idle so I know when to quit...

idlethreadcount = threading.activeCount()

# add my thread to the set of threads that are used...

event_id = idhelper.getuniqueid()

try:

nanny.tattle_add_item('events', event_id)

except Exception as e:

tracebackrepy.handle_internalerror("Failed to acquire event for '" + \

"initialize' event.\n(Exception was: %s)" % e.message, 140)

try:

thisnamespace.evaluate(thiscontext)

except SystemExit:

raise

except:

# I think it makes sense to exit if their code throws an exception...

tracebackrepy.handle_exception()

harshexit.harshexit(6)

finally:

nanny.tattle_remove_item('events', event_id)

# I've changed to the threading library, so this should increase if there are

# pending events

while threading.activeCount() > idlethreadcount:

# do accounting here?

time.sleep(0.25)

# Once there are no more events, return...

# Translate into an absolute path

if os.path.isabs(repy_directory):

absolute_repy_directory = repy_directory

else:

# This will join the currect directory with the relative path

# and then get the absolute path to that location

absolute_repy_directory = os.path.abspath(os.path.join(os.getcwd(), repy_directory))

# Store the absolute path as the repy startup directory

repy_constants.REPY_START_DIR = absolute_repy_directory

# For security, we need to make sure that the Python path doesn't change even

# if the directory does...

newsyspath = []

for item in sys.path[:]:

if item == '' or item == '.':

newsyspath.append(os.getcwd())

else:

newsyspath.append(item)

# It should be safe now. I'm assuming the user isn't trying to undercut us

# by setting a crazy python path

"""Adds the Repy command-line options to the specified optparser

"""

#parser.add_option('--ip',

# action="append", type="string", dest="ip" ,

# help="Explicitly allow Repy to bind to the specified IP. This option can be used multiple times."

# )

parser.add_option('--execinfo',

action="store_true", dest="execinfo", default=False,

help="Display information regarding the current execution state."

)

#parser.add_option('--iface',

# action="append", type="string", dest="interface",

# help="Explicitly allow Repy to bind to the specified interface. This option can be used multiple times."

# )

#parser.add_option('--nootherips',

# action="store_true", dest="nootherips",default=False,

# help="Do not allow IPs or interfaces that are not explicitly specified"

# )

parser.add_option('--logfile',

action="store", type="string", dest="logfile",

help="Set up a circular log buffer and output to logfile"

)

parser.add_option('--stop',

action="store", type="string", dest="stopfile",

help="Watch for the creation of stopfile and abort when it is created"

)

parser.add_option('--status',

action="store", type="string", dest="statusfile",

help="Write status information into statusfile"

)

parser.add_option('--cwd',

action="store", type="string", dest="cwd",

help="Set Current working directory to cwd"

)

parser.add_option('--servicelog',

action="store_true", dest="servicelog",

help="Enable usage of the servicelogger for internal errors"

""" Parse the specified options and initialize all required structures

Note: This modifies global state, specifically, the emulcomm module

"""

#if options.ip:

# emulcomm.user_ip_interface_preferences = True

# Append this ip to the list of available ones if it is new

# for ip in options.ip:

# if (True, ip) not in emulcomm.user_specified_ip_interface_list:

# emulcomm.user_specified_ip_interface_list.append((True, ip))

#if options.interface:

# emulcomm.user_ip_interface_preferences = True

# Append this interface to the list of available ones if it is new

# for interface in options.interface:

# if (False, interface) not in emulcomm.user_specified_ip_interface_list:

# emulcomm.user_specified_ip_interface_list.append((False, interface))

# Check if they have told us to only use explicitly allowed IP's and interfaces

#if options.nootherips:

# Set user preference to True

# emulcomm.user_ip_interface_preferences = True

# Disable nonspecified IP's

# emulcomm.allow_nonspecified_ips = False

# set up the circular log buffer...

# Armon: Initialize the circular logger before starting the nanny

if options.logfile:

# time to set up the circular logger

loggerfo = loggingrepy.circular_logger(options.logfile)

# and redirect err and out there...

sys.stdout = loggerfo

sys.stderr = loggerfo

else:

# let's make it so that the output (via print) is always flushed

sys.stdout = loggingrepy.flush_logger(sys.stdout)

# We also need to pass in whether or not we are going to be using the service

# log for repy. We provide the repy directory so that the vessel information

# can be found regardless of where we are called from...

tracebackrepy.initialize(options.servicelog, repy_constants.REPY_START_DIR)

# Set Current Working Directory

if options.cwd:

os.chdir(options.cwd)

# Update repy current directory

repy_constants.REPY_CURRENT_DIR = os.path.abspath(os.getcwd())

# Initialize the NM status interface

nmstatusinterface.init(options.stopfile, options.statusfile)

# Write out our initial status

# start the nanny up and read the resource file.

# JAC: Should this take a string instead?

nanny.start_resource_nanny(resourcefn)

# now, let's fire up the cpu / disk / memory monitor...

nonportable.monitor_cpu_disk_and_mem()

repy_location = sys.argv[0]

repy_directory = os.path.dirname(repy_location)

init_repy_location(repy_directory)

usage = "USAGE: repy.py [options] program_to_run.r2py [program args]"

parser = optparse.OptionParser(usage=usage)

parser.disable_interspersed_args()

add_repy_options(parser)

options, args = parser.parse_args()

if len(args) < 1:

print("Repy requires a program to run!")

parser.print_help()

sys.exit(1)

#resourcefn = args[0]

progname = args[0]

progargs = args[1:]

parse_options(options)

nmstatusinterface.launch(None)

try:

filehandle = open(progname)

usercode = filehandle.read()

filehandle.close()

except:

print(f"FATAL ERROR: Unable to read the specified program file: {progname}")

sys.exit(1)

try:

newnamespace = virtual_namespace.VirtualNamespace(usercode, progname)

except CodeUnsafeError as e:

print("Specified repy program is unsafe!")

print("Static-code analysis failed with error: " + str(e))

harshexit.harshexit(5)

del usercode

if options.execinfo:

print("="*40)

print("Running program: " + progname)

print("Arguments: " + progargs)

print("="*40)

newcontext = get_safe_context(progargs)

try:

newnamespace.evaluate(newcontext)

except SystemExit:

raise

except:

tracebackrepy.handle_exception()

harshexit.harshexit(6)