cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r263:7950cf0bb006` public

parent | child

Description:

Merge pull request #14 from nattee/master upgrade to current working snapshot

Commit status:

[Not Reviewed]

References:

merge default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r263:7950cf0bb006 - Sat, 17 Jun 2017 06:22:31 - 12 files changed: 420 inserted, 12 deleted

check_similar created 755 ¶ +93

@@ -0,0 +1,93
	1	+ #!/usr/bin/env ruby
	2	+
	3	+ def config
	4	+ Grader::Configuration.get_instance
	5	+ end
	6	+
	7	+ def display_manual
	8	+ puts <<USAGE
	9	+ Check similarity between submission
	10	+ using: check_similar sub1 sub2
	11	+ -- or --
	12	+ check_similar problem_name
	13	+ sub1 and sub2 are submission IDs to be checked
	14	+ problem_name will check all submissions of the problem wit problem short name is 'problem_name'
	15	+
	16	+ The output are given as
	17	+ sub1.login, sub1.id, sub1.point, sub2.login, sub2.id, sub2.point, similarity
	18	+
	19	+ USAGE
	20	+ end
	21	+
	22	+ def process_options_and_stop_file
	23	+
	24	+ # Process 'help' option
	25	+ if (ARGV.length == 0) or ((ARGV.length==1) and (/help/.match(ARGV[0])))
	26	+ display_manual
	27	+ exit(0)
	28	+ end
	29	+
	30	+ #default options
	31	+ options = {
	32	+ :dry_run => false,
	33	+ }
	34	+
	35	+
	36	+ if ARGV.length == 2
	37	+ options[:sub1] = ARGV[0].to_i
	38	+ options[:sub2] = ARGV[1].to_i
	39	+ elsif ARGV.length == 1
	40	+ options[:problem] = ARGV[0]
	41	+ end
	42	+
	43	+
	44	+ return options
	45	+ end
	46	+
	47	+ def compare(sub1,sub2,full = sub1.problem.full_score)
	48	+ dis = @jarow.getDistance(sub1.source, sub2.source)
	49	+ puts [sub1.user.login,"##{sub1.id}",(sub1.points * 100.0 / full).to_i,
	50	+ sub2.user.login,"##{sub2.id}",(sub2.points * 100.0 / full).to_i,
	51	+ "#{dis * 100}%"].join(',')
	52	+ end
	53	+
	54	+ #########################################
	55	+ # main program
	56	+ #########################################
	57	+
	58	+ options = process_options_and_stop_file
	59	+
	60	+ # load grader environment
	61	+ GRADER_ENV = 'grading'
	62	+ require File.join(File.dirname(__FILE__),'config/environment')
	63	+
	64	+ # boot rails, to be able to use the active record
	65	+ RAILS_ENV = config.rails_env
	66	+ require RAILS_ROOT + '/config/environment'
	67	+
	68	+ # load comparator
	69	+ require 'fuzzystringmatch'
	70	+ @jarow = FuzzyStringMatch::JaroWinkler.create( :native )
	71	+
	72	+ if options[:problem]
	73	+ p = Problem.where(name: options[:problem]).first
	74	+ unless p
	75	+ puts "cannot find problem #{options[:problem]}"
	76	+ exit(0)
	77	+ end
	78	+ subs = Submission.where(problem: p)
	79	+ full_score = p.full_score.to_i
	80	+ subs.each.with_index do \|s1,i\|
	81	+ puts "processing #{i+1} out of #{subs.length}"
	82	+ subs.each do \|s2\|
	83	+ if s1.user != s2.user
	84	+ compare(s1,s2,full_score)
	85	+ end
	86	+ end
	87	+ end
	88	+ else
	89	+ sub1 = Submission.find(options[:sub1])
	90	+ sub2 = Submission.find(options[:sub2])
	91	+ compare(sub1,sub2)
	92	+ end
	93	+

grader-process-check created 755 ¶ +6

@@ -0,0 +1,6
	1	+ #!/bin/bash
	2	+ count=`ps aux \| grep "cafe_grader" \| grep "grader grading queue" \| wc -l`
	3	+ if [ $count -lt 1 ]; then
	4	+ cd /home/dae/cafe_grader/judge
	5	+ /home/dae/.rvm/wrappers/ruby-2.3.0/ruby /home/dae/cafe_grader/judge/scripts/grader grading queue > /home/dae/grading.log &
	6	+ fi

installer/install-opensuse.sh created 644 ¶ +179

@@ -0,0 +1,179
	1	+ #!/bin/sh
	2	+
	3	+ echo "This script will install and configure Cafe grader."
	4	+
	5	+ RUBY_VERSION=2.1.2
	6	+ echo "This will install Ruby $RUBY_VERSION under RVM"
	7	+
	8	+ echo "Installing required apts"
	9	+
	10	+ sudo zypper install \
	11	+ g++ gcc libmysqlclient18 build-essential \
	12	+ git-core openssl libreadline6 libreadline6-devel \
	13	+ zlib1g zlib1g-devel libssl37 libyaml-devel sqlite3-devel \
	14	+ sqlite3 libxml2-devel libxslt-devel autoconf libc6-devel \
	15	+ ncurses-devel automake libtool bison subversion \
	16	+ pkg-config curl nodejs unzip pyflakes java-1_8_0-openjdk \
	17	+ libmysqld-devel mercurial python-setuptools python-devel
	18	+
	19	+
	20	+ echo "Installing Ruby $RUBY_VERSION in RVM"
	21	+
	22	+ rvm install $RUBY_VERSION
	23	+ rvm use $RUBY_VERSION
	24	+
	25	+ echo "Fetching Cafe Grader from Git repositories"
	26	+
	27	+ echo "Fetching web interface"
	28	+
	29	+ mkdir cafe_grader
	30	+ cd cafe_grader
	31	+ #git clone -q git://github.com/jittat/cafe-grader-web.git web
	32	+ hg clone git+ssh://git@github.com/nattee/cafe-grader-web.git web
	33	+
	34	+ echo "Configuring rails app"
	35	+
	36	+ cp web/config/application.rb.SAMPLE web/config/application.rb
	37	+ cp web/config/initializers/cafe_grader_config.rb.SAMPLE web/config/initializers/cafe_grader_config.rb
	38	+
	39	+ #replace UTC in application.rb with the system timezone
	40	+ timezone='UTC'
	41	+ if [ -f '/etc/timezone' ]; then
	42	+ timezone=\"`cat /etc/timezone`\"
	43	+ else
	44	+ if [ -f '/etc/sysconfig/clock' ]; then
	45	+ timezone=`grep -e '^TIMEZONE' /etc/sysconfig/clock \| grep -o -e '\".*\"'`
	46	+ fi
	47	+ fi
	48	+ replace="s!'UTC'!$timezone!g"
	49	+ sed -i $replace web/config/application.rb
	50	+
	51	+ echo "At this point we will need MySQL user and database."
	52	+ echo "Have you created MySQL user and database for Cafe grader? (Y/N) "
	53	+ read ch
	54	+
	55	+ if [ "$ch" = "n" -o "$ch" = "N" ]
	56	+ then
	57	+ echo "Please open another terminal and create the user and database for Cafe grader."
	58	+ echo "Don't forget to grant access to that database for the user."
	59	+ echo "Please have username, password, and database name ready before continue."
	60	+ echo
	61	+ echo "The following are instructions:"
	62	+ echo "1. Run mysql:"
	63	+ echo
	64	+ echo " mysql -u root -p"
	65	+ echo
	66	+ echo " if you have just installed mysql, the root password is the one that you have just entered"
	67	+ echo "2. Create a new database, a new user, and grant access to grader database:"
	68	+ echo
	69	+ echo " create user 'USERNAME'@'localhost' identified by 'PASSWORD';"
	70	+ echo " create database \`DATABASENEME\`;"
	71	+ echo " grant all on \`DATABASENAME\`.* to 'USERNAME'@'localhost';"
	72	+ echo
	73	+ echo " Replace USERNAME, PASSWORD, and DATABASENAME accordingly."
	74	+ echo
	75	+ echo "Hit enter when ready..."
	76	+ read dummy
	77	+ fi
	78	+
	79	+ CAFE_PATH=`pwd`
	80	+
	81	+ cd web
	82	+
	83	+ echo "Please provide grader database:"
	84	+ read database
	85	+
	86	+ echo "Please provide grader username:"
	87	+ read username
	88	+
	89	+ echo "Please provide $username password:"
	90	+ read password
	91	+
	92	+ echo "development:" > config/database.yml
	93	+ echo " adapter: mysql2" >> config/database.yml
	94	+ echo " encoding: utf8" >> config/database.yml
	95	+ echo " reconnect: false" >> config/database.yml
	96	+ echo " database: $database" >> config/database.yml
	97	+ echo " pool: 5" >> config/database.yml
	98	+ echo " username: $username" >> config/database.yml
	99	+ echo " password: $password" >> config/database.yml
	100	+ echo " host: localhost" >> config/database.yml
	101	+ echo " socket: /run/mysql/mysql.sock" >> config/database.yml
	102	+ echo "" >> config/database.yml
	103	+ echo "production:" >> config/database.yml
	104	+ echo " adapter: mysql2" >> config/database.yml
	105	+ echo " encoding: utf8" >> config/database.yml
	106	+ echo " reconnect: false" >> config/database.yml
	107	+ echo " database: $database" >> config/database.yml
	108	+ echo " pool: 5" >> config/database.yml
	109	+ echo " username: $username" >> config/database.yml
	110	+ echo " password: $password" >> config/database.yml
	111	+ echo " host: localhost" >> config/database.yml
	112	+ echo " socket: /run/mysql/mysql.sock" >> config/database.yml
	113	+
	114	+ echo "Object.instance_eval{remove_const :GRADER_ROOT_DIR}" >> config/initializers/cafe_grader_config.rb
	115	+ echo "Object.instance_eval{remove_const :GRADING_RESULT_DIR}" >> config/initializers/cafe_grader_config.rb
	116	+ echo "GRADER_ROOT_DIR = '$CAFE_PATH/judge'" >> config/initializers/cafe_grader_config.rb
	117	+ echo "GRADING_RESULT_DIR = '$CAFE_PATH/judge/result'" >> config/initializers/cafe_grader_config.rb
	118	+
	119	+ echo "Installing required gems"
	120	+ gem install bundler
	121	+ bundle install
	122	+
	123	+ echo "Running rake tasks to initialize database"
	124	+
	125	+ rake db:migrate
	126	+ rake db:seed
	127	+
	128	+ echo "Running rake tasks to precompile the assets"
	129	+
	130	+ rake assets:precompile
	131	+
	132	+ echo "Intalling web interface complete..."
	133	+ echo
	134	+ echo "Fetching grader"
	135	+
	136	+ cd ..
	137	+
	138	+ mkdir judge
	139	+ cd judge
	140	+ #git clone -q git://github.com/jittat/cafe-grader-judge-scripts.git scripts
	141	+ hg clone git+ssh://git@github.com/nattee/cafe-grader-judge-scripts.git scripts
	142	+ mkdir raw
	143	+ mkdir ev-exam
	144	+ mkdir ev
	145	+ mkdir result
	146	+ mkdir log
	147	+
	148	+ echo "Configuring grader"
	149	+
	150	+ cp scripts/config/env_exam.rb.SAMPLE scripts/config/env_exam.rb
	151	+ cp scripts/config/env_grading.rb.SAMPLE scripts/config/env_grading.rb
	152	+
	153	+ # create new environment.rb file
	154	+ echo "RAILS_ROOT = '$CAFE_PATH/web'" > scripts/config/environment.rb
	155	+ echo "GRADER_ROOT = '$CAFE_PATH/judge/scripts'" >> scripts/config/environment.rb
	156	+ echo "require File.join(File.dirname(__FILE__),'../lib/boot')" >> scripts/config/environment.rb
	157	+ echo "require File.dirname(__FILE__) + \"/env_#{GRADER_ENV}.rb\"" >> scripts/config/environment.rb
	158	+
	159	+ # compiling box
	160	+ MACHINE_TYPE=`uname -m`
	161	+ if [ ${MACHINE_TYPE} == 'x86_64' ]; then
	162	+ gcc -std=c99 -o scripts/std-script/box scripts/std-script/box64-new.c
	163	+ else
	164	+ g++ -o scripts/std-script/box scripts/std-script/box.cc
	165	+ fi
	166	+
	167	+
	168	+ cd ..
	169	+
	170	+ echo "Now you are ready to run cafe grader...."
	171	+ echo
	172	+ echo "Try:"
	173	+ echo
	174	+ echo " cd web"
	175	+ echo " rails s"
	176	+ echo
	177	+ echo "and access web at http://localhost:3000/"
	178	+ echo "The root username is 'root', its password is 'ioionrails'."
	179	+

load_testcase created 755 ¶ +85

@@ -0,0 +1,85
	1	+ #!/usr/bin/env ruby
	2	+
	3	+ def config
	4	+ Grader::Configuration.get_instance
	5	+ end
	6	+
	7	+ def display_manual
	8	+ puts <<USAGE
	9	+ load_testcases
	10	+ using: load_testcases [problem_name ...]
	11	+ problem_name are list of "short name" of the problems
	12	+
	13	+ options:
	14	+ --dry-run do nothing, just simulate the run
	15	+ --all import all problem. This might take several minutes
	16	+
	17	+ USAGE
	18	+ end
	19	+
	20	+ def process_options_and_stop_file
	21	+
	22	+ # Process 'help' option
	23	+ if (ARGV.length == 0) or ((ARGV.length==1) and (/help/.match(ARGV[0])))
	24	+ display_manual
	25	+ exit(0)
	26	+ end
	27	+
	28	+ #default options
	29	+ options = {
	30	+ :dry_run => false,
	31	+ }
	32	+
	33	+ options[:dry_run] = (ARGV.delete('--dry') != nil)
	34	+ options[:all] = (ARGV.delete('--all') != nil)
	35	+
	36	+ return options
	37	+ end
	38	+
	39	+ def process_problem(prob,dry_run = false)
	40	+ prob.testcases.destroy_all
	41	+ testcases_root = File.expand_path(GRADER_ROOT+"/../ev/#{prob.name}/test_cases/")
	42	+ num = 1
	43	+ puts "Processing problem #{prob.name}"
	44	+ loop do
	45	+ file_root = testcases_root + "/#{num}/"
	46	+ puts " checking file #{file_root}"
	47	+ break unless File.exists? file_root
	48	+ input = File.read(file_root + "/input-#{num}.txt")
	49	+ answer = File.read(file_root + "/answer-#{num}.txt")
	50	+ puts " got test case ##{num} of size #{input.size} and #{answer.size}"
	51	+
	52	+ #THIS IS JUST A PLACE HOLDER
	53	+ group = num #this is wrong!!! fix it!!
	54	+ score = 10
	55	+ #BEWARE
	56	+
	57	+ prob.testcases.create(input: input,sol: answer, num: num, score:score,group: group) unless dry_run
	58	+ num += 1
	59	+ end
	60	+ end
	61	+
	62	+ #########################################
	63	+ # main program
	64	+ #########################################
	65	+
	66	+ options = process_options_and_stop_file
	67	+
	68	+ # load grader environment
	69	+ GRADER_ENV = 'grading'
	70	+ require File.join(File.dirname(__FILE__),'config/environment')
	71	+
	72	+ # boot rails, to be able to use the active record
	73	+ RAILS_ENV = config.rails_env
	74	+ require RAILS_ROOT + '/config/environment'
	75	+
	76	+ if options[:all]
	77	+ Problem.all.each { \|prob\| process_problem(prob,options[:dry_run]) }
	78	+ else
	79	+ ARGV.each do \|name\|
	80	+ prob = Problem.find_by(name: name)
	81	+ process_problem(prob,options[:dry_run]) if prob
	82	+ puts "Cannot find the problem #{name}" unless prob
	83	+ end
	84	+ end
	85	+

import_problem ¶ +6

               #!/usr/bin/env ruby
               require 'erb'
               require 'fileutils'
               require File.join(File.dirname(__FILE__),'lib/import_helper')
               JUDGE_ENVIRONMENTS = [:grading, :exam]
               ENV_INFO = {
                 :grading => {
                   :ev_dir => 'ev',
                   :raw_prefix => '',
                 },
                 :exam => {
                   :ev_dir => 'ev-exam',
                   :raw_prefix => 'ex.',
                 }
               }
               def input_filename(dir,i)
                 "#{dir}/input-#{i}.txt"
               end
               def answer_filename(dir,i)
                 "#{dir}/answer-#{i}.txt"
               end
               def build_testrun_info_from_dir(num_testruns, importing_test_dir, raw_prefix='')
                 filenames = Dir["#{importing_test_dir}/#{raw_prefix}*.in"].collect do |filename|
                   File.basename((/(.*)\.in/.match(filename))[1])
                 end
                 build_testrun_info(num_testruns,filenames,raw_prefix)
               end
               def copy_testcase(importing_test_dir,fname,dir,i)
                 FileUtils.cp("#{importing_test_dir}/#{fname}.in", "#{input_filename(dir,i)}")
                 FileUtils.cp("#{importing_test_dir}/#{fname}.sol", "#{answer_filename(dir,i)}")
               end
               def process_options(options)
                 i = 3
                 while i<ARGV.length
                   if ARGV[i]=='-t'
                     options[:time_limit] = ARGV[i+1].to_f if ARGV.length>i+1
                     i += 1
                   end
                   if ARGV[i]=='-m'
                     options[:mem_limit] = ARGV[i+1].to_i if ARGV.length>i+1
                     i += 1
                   end
                   i += 1
                 end
               end
               def print_usage
                 puts "using: import_problem_new name dir check [options]
               where: name = problem_name (put '-' (dash) to use dir name)
                      dir = importing testcase directory
                      check = check script, which can be
                              'integer', 'text' (for standard script),
                              path_to_your_script, or
                              'wrapper:(path_to_your_wrapped_script)'
               options: -t time-limit (in seconds)
                        -m memory-limit (in megabytes)
               The script looks at test data files in the dir of the forms: *.in and
               *.sol and import them to the evaluation dir for their environment,
               based on their prefixes.
               Currently supporting environments are:"
                 JUDGE_ENVIRONMENTS.each do |env|
                   prefix = ENV_INFO[env][:raw_prefix]
                   prefix = 'no prefix' if prefix==''
                   puts "  * #{env}"
                   puts "      import to: #{ENV_INFO[env][:ev_dir]}"
                   puts "      prefix with: #{prefix}  (e.g., #{ENV_INFO[env][:raw_prefix]}1.in, #{ENV_INFO[env][:raw_prefix]}5a.sol)"
                 end
                 puts"
               For each environment, the script
                 * creates a directory for a problem in ev dir of that environment,
                 * copies testdata in the old format and create standard testcase config file
                 * copies a check script for grading
                 * creates a test_request template in the ev dir + '/test_request'
               For wrapped checked script see comment in templates/check_wrapper for
                 information."
               end
               def count_testruns(testcase_dir, raw_prefix)
                 n = 0
                 begin
                   # check for test case n+1
                   if ((Dir["#{testcase_dir}/#{raw_prefix}#{n+1}.in"].length==0) and
                       (Dir["#{testcase_dir}/#{raw_prefix}#{n+1}[a-z].in"].length==0))
                     return n
                   end
                   n += 1
                 end while true
               end
               def create_dir_if_not_exists(dir)
                 if ! FileTest.exists? dir
                   FileUtils.mkdir(dir)
                 end
               end
               def import_problem(ev_dir, problem, testcase_dir, num_testruns, raw_prefix, check_script, options)
                 testrun_info = build_testrun_info_from_dir(num_testruns, testcase_dir, raw_prefix)
                 if !(FileTest.exists? ev_dir)
                   puts "Testdata dir (#{ev_dir}) not found."
                   return
                 end
                 problem_dir = "#{ev_dir}/#{problem}"
                 # start working
                 puts "creating directories"
                 create_dir_if_not_exists("#{problem_dir}")
                 create_dir_if_not_exists("#{problem_dir}/script")
                 create_dir_if_not_exists("#{problem_dir}/test_cases")
                 puts "copying testcases"
                 tr_num = 0
                 num_testcases = 0
                 testrun_info.each do |testrun|
                   tr_num += 1
                   puts "testrun: #{tr_num}"
                   testrun.each do |testcase_info|
                     testcase_num, testcase_fname = testcase_info
                     puts "copy #{testcase_fname} to #{testcase_num}"
                     create_dir_if_not_exists("#{problem_dir}/test_cases/#{testcase_num}")
                     copy_testcase("#{testcase_dir}",testcase_fname,"#{problem_dir}/test_cases/#{testcase_num}",testcase_num)
                     num_testcases += 1
                   end
                 end
+            +   #also include any .txt files
+            +   Dir.glob("#{testcase_dir}/*.txt") do |file|
+            +     puts "copy data file #{file}"
+            +     FileUtils.cp(file,"#{problem_dir}")
+            +   end
+            +
                 # generating all_tests.cfg
                 puts "generating testcase config file"
                 template = File.open(SCRIPT_DIR + "/templates/all_tests.cfg.erb").read
                 all_test_cfg = ERB.new(template)
                 cfg_file = File.open("#{problem_dir}/test_cases/all_tests.cfg","w")
                 cfg_file.puts all_test_cfg.result binding
                 cfg_file.close
                 # copy check script
                 if res = /^wrapper:(.*)$/.match(check_script)
                   # wrapper script
                   check_script_fname = res[1]
                   script_name = File.basename(check_script_fname)
                   check_wrapper_template = File.open(SCRIPT_DIR + "/templates/check_wrapper").read
                   check_wrapper = ERB.new(check_wrapper_template)
                   check_file = File.open("#{problem_dir}/script/check","w")
                   check_file.puts check_wrapper.result binding
                   check_file.close
                   File.chmod(0755,"#{problem_dir}/script/check")
                   FileUtils.cp("#{check_script_fname}", "#{problem_dir}/script/#{script_name}")
                 else
                   if File.exists?(SCRIPT_DIR + "/templates/check.#{check_script}")
                     check_script_fname = SCRIPT_DIR + "/templates/check.#{check_script}"
                   else
                     check_script_fname = check_script
                   end
                   FileUtils.cp("#{check_script_fname}", "#{problem_dir}/script/check", :preserve => true)
                 end
                 # generating test_request directory
                 puts "generating test_request template"
                 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/script")
                 FileUtils.mkdir_p("#{ev_dir}/test_request/#{problem}/test_cases/1")
                 template = File.open(SCRIPT_DIR + "/templates/test_request_all_tests.cfg.erb").read
                 test_request_all_test_cfg = ERB.new(template)
                 cfg_file = File.open("#{ev_dir}/test_request/#{problem}/test_cases/all_tests.cfg","w")
                 cfg_file.puts test_request_all_test_cfg.result
                 cfg_file.close
                 FileUtils.cp("#{SCRIPT_DIR}/templates/check_empty",
                              "#{ev_dir}/test_request/#{problem}/script/check")
                 FileUtils.cp("#{SCRIPT_DIR}/templates/answer-1.txt",
                              "#{ev_dir}/test_request/#{problem}/test_cases/1")
                 puts "done"
               end
               SCRIPT_DIR = File.dirname(__FILE__)
               # print usage
               if (ARGV.length < 3) or (ARGV[2][0,1]=="-")
                 print_usage
                 exit(127)
               end
               # processing arguments
               problem = ARGV[0]
               testcase_dir = ARGV[1]
               problem = File.basename(testcase_dir) if problem=="-"
               check_script = ARGV[2]
               options = {:time_limit => 1,  :mem_limit => 16}
               process_options(options)
               JUDGE_ENVIRONMENTS.each do |env|
                 ev_dir = ENV_INFO[env][:ev_dir]
                 raw_prefix = ENV_INFO[env][:raw_prefix]
                 num_testruns = count_testruns(testcase_dir,raw_prefix)
                 puts ""
                 puts "*** Environment: #{env} (#{num_testruns} test runs) ***"
                 puts ""
                 import_problem(ev_dir,
                                problem,
                                testcase_dir,
                                num_testruns,
                                raw_prefix,
                                check_script,
                                options)
               end

installer/install.sh ¶ +3 -2

               #!/bin/sh
               echo "This script will install and configure Cafe grader."
               RUBY_VERSION=2.1.2
               echo "This will install Ruby $RUBY_VERSION under RVM"
               echo "Installing required apts"
               sudo apt-get update
               sudo apt-get install mysql-server mysql-client \
-            -   g++ gcc apache2 libmysqlclient15-dev build-essential \
+            +   g++ gcc apache2 libmysqlclient20 build-essential \
                 git-core openssl libreadline6 libreadline6-dev \
                 zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev \
                 sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev \
                 ncurses-dev automake libtool bison subversion \
-            -   pkg-config curl nodejs unzip pyflakes ruby default-jdk
+            +   pkg-config curl nodejs unzip pyflakes ruby default-jdk \
+            +   libmysqld-dev mercurial python-setuptools python-dev python3-numpy
               echo "Installing RVM"
               curl -k -L https://get.rvm.io | bash -s stable
               source ~/.rvm/scripts/rvm
               echo "Installing Ruby $RUBY_VERSION in RVM"
               rvm install $RUBY_VERSION
               rvm use $RUBY_VERSION
               echo "Fetching Cafe Grader from Git repositories"
               echo "Fetching web interface"
               mkdir cafe_grader
               cd cafe_grader
               git clone -q git://github.com/jittat/cafe-grader-web.git web
               echo "Configuring rails app"
               cp web/config/application.rb.SAMPLE web/config/application.rb
               cp web/config/initializers/cafe_grader_config.rb.SAMPLE web/config/initializers/cafe_grader_config.rb
               #replace UTC in application.rb with the system timezone
               timezone='UTC'
               if [ -f '/etc/timezone' ]; then
                 timezone=\"`cat /etc/timezone`\"
               else
                 if [ -f '/etc/sysconfig/clock' ]; then
                   timezone=`grep -e '^TIMEZONE' /etc/sysconfig/clock | grep -o -e '\".*\"'`
                 fi
               fi
               replace="s!'UTC'!$timezone!g"
               sed -i $replace web/config/application.rb
               echo "At this point we will need MySQL user and database."
               echo "Have you created MySQL user and database for Cafe grader? (Y/N) "
               read ch
               if [ "$ch" = "n" -o "$ch" = "N" ]
               then
                 echo "Please open another terminal and create the user and database for Cafe grader."
                 echo "Don't forget to grant access to that database for the user."
                 echo "Please have username, password, and database name ready before continue."
                 echo
                 echo "The following are instructions:"
                 echo "1. Run mysql:"
                 echo
                 echo "      mysql -u root -p"
                 echo
                 echo "   if you have just installed mysql, the root password is the one that you have just entered"
                 echo "2. Create a new database, a new user, and grant access to grader database:"
                 echo
                 echo "      create user 'USERNAME'@'localhost' identified by 'PASSWORD';"
                 echo "      create database \`DATABASENEME\`;"
                 echo "      grant all on \`DATABASENAME\`.* to 'USERNAME'@'localhost';"
                 echo
                 echo "   Replace USERNAME, PASSWORD, and DATABASENAME accordingly."
                 echo
                 echo "Hit enter when ready..."
                 read dummy
               fi
               CAFE_PATH=`pwd`
               cd web
               echo "Please provide grader database:"
               read database
               echo "Please provide grader username:"
               read username
               echo "Please provide $username password:"
               read password
               echo "development:" > config/database.yml
               echo "  adapter: mysql2" >> config/database.yml
               echo "  encoding: utf8" >> config/database.yml
               echo "  reconnect: false" >> config/database.yml
               echo "  database: $database" >> config/database.yml
               echo "  pool: 5" >> config/database.yml
               echo "  username: $username" >> config/database.yml
               echo "  password: $password" >> config/database.yml
               echo "  host: localhost" >> config/database.yml
               echo "  socket: /var/run/mysqld/mysqld.sock" >> config/database.yml
               echo "" >> config/database.yml
               echo "production:" >> config/database.yml
               echo "  adapter: mysql2" >> config/database.yml
               echo "  encoding: utf8" >> config/database.yml
               echo "  reconnect: false" >> config/database.yml
               echo "  database: $database" >> config/database.yml
               echo "  pool: 5" >> config/database.yml
               echo "  username: $username" >> config/database.yml
               echo "  password: $password" >> config/database.yml
               echo "  host: localhost" >> config/database.yml
               echo "  socket: /var/run/mysqld/mysqld.sock" >> config/database.yml
               echo "Object.instance_eval{remove_const :GRADER_ROOT_DIR}" >> config/initializers/cafe_grader_config.rb
               echo "Object.instance_eval{remove_const :GRADING_RESULT_DIR}" >> config/initializers/cafe_grader_config.rb
               echo "GRADER_ROOT_DIR = '$CAFE_PATH/judge'" >> config/initializers/cafe_grader_config.rb
               echo "GRADING_RESULT_DIR = '$CAFE_PATH/judge/result'" >> config/initializers/cafe_grader_config.rb
               echo "Installing required gems"
               gem install bundler
               bundle install
               echo "Running rake tasks to initialize database"
               rake db:migrate
               rake db:seed
               echo "Running rake tasks to precompile the assets"
               rake assets:precompile
               echo "Intalling web interface complete..."
               echo
               echo "Fetching grader"
               cd ..
               mkdir judge
               cd judge
               git clone -q git://github.com/jittat/cafe-grader-judge-scripts.git scripts
               mkdir raw
               mkdir ev-exam
               mkdir ev
               mkdir result
               mkdir log
               echo "Configuring grader"
               cp scripts/config/env_exam.rb.SAMPLE scripts/config/env_exam.rb
               cp scripts/config/env_grading.rb.SAMPLE scripts/config/env_grading.rb
               # create new environment.rb file
               echo "RAILS_ROOT = '$CAFE_PATH/web'" > scripts/config/environment.rb
               echo "GRADER_ROOT = '$CAFE_PATH/judge/scripts'" >> scripts/config/environment.rb
               echo "require File.join(File.dirname(__FILE__),'../lib/boot')" >> scripts/config/environment.rb
               echo "require File.dirname(__FILE__) + \"/env_#{GRADER_ENV}.rb\"" >> scripts/config/environment.rb
               # compiling box
               MACHINE_TYPE=`uname -m`
               if [ ${MACHINE_TYPE} == 'x86_64' ]; then
                 gcc -std=c99 -o scripts/std-script/box scripts/std-script/box64-new.c
               else
                 g++ -o scripts/std-script/box scripts/std-script/box.cc
               fi
               cd ..
               echo "Now you are ready to run cafe grader...."
               echo
               echo "Try:"
               echo
               echo "  cd web"
               echo "  rails s"
               echo
               echo "and access web at http://localhost:3000/"
               echo "The root username is 'root', its password is 'ioionrails'."

rename_problem ¶ +2 -2

               #!/usr/bin/env ruby
               ENVIRONMENT_DIRS = ['ev', 'ev-exam']
               def config
                 Grader::Configuration.get_instance
               end
               def rename_problem(old_problem_name, new_problem_name)
-            -   if valid_problem_name(new_problem_name)
+            +   unless valid_problem_name(new_problem_name)
                   puts "Bad new problem name: #{new_problem_name}"
                   return
                 end
                 problem = Problem.find_by_name(old_problem_name)
                 if problem==nil
                   puts "Problem #{old_problem_name} does not exist."
                   return
                 end
                 puts "Problem: #{old_problem_name} -> #{new_problem_name}"
                 ENVIRONMENT_DIRS.each do |dir|
                   problem_dir = File.join(GRADER_ROOT,'..',dir,old_problem_name)
                   new_problem_dir = File.join(GRADER_ROOT,'..',dir,new_problem_name)
                   if FileTest.exists? problem_dir
                     puts "Moving #{problem_dir} to #{new_problem_dir}."
                     File.rename(problem_dir, new_problem_dir)
                     tr_problem_dir = File.join(GRADER_ROOT,'..',dir,
                                                'test_request',old_problem_name)
                     new_tr_problem_dir = File.join(GRADER_ROOT,'..',dir,
                                                    'test_request',new_problem_name)
                     File.rename(tr_problem_dir, new_tr_problem_dir)
                   end
                 end
                 problem.name = new_problem_name
                 problem.save
               end
               def usage
                 puts <<USAGE
               Usage:
                 rename_problem [old_name] [new_name]
               or
                 rename_problem -f [filename]
               When using with -f, that file should contain, for each line, the old
               problem name and its new name.
               This script should be called at the judge root dir where dirs 'ev' and
               'ev-exam' are.
               USAGE
               end
               def valid_problem_name(name)
                 if name.length==0:
                     return false
                 else
-            -     return !(/^[a-zA-Z0-9_\-]+$/ === name)
+            +     return (/^[a-zA-Z0-9_\-]+$/ === name)
                 end
               end
               if (ARGV.length!=2)
                 usage
                 exit(0)
               end
               if ARGV[0]=='-f' and !FileTest.exists?(ARGV[1])
                 puts "File #{ARGV[1]} does not exist."
                 usage
                 exit(0)
               end
               # load grader environment
               GRADER_ENV = 'grading'
               require File.join(File.dirname(__FILE__),'config/environment')
               # boot rails, to be able to rename the problem
               RAILS_ENV = config.rails_env
               require RAILS_ROOT + '/config/environment'
               if ARGV[0]!='-f'
                 old_problem_name = ARGV[0]
                 new_problem_name = ARGV[1]
                 rename_problem(old_problem_name, new_problem_name)
               else
                 lines = IO.readlines(ARGV[1])
                 lines.each do |line|
                   items = line.split
                   if items.length==2
                     old_name, new_name = items
                     rename_problem(old_name, new_name)
                   end
                 end
               end

std-script/box64-new.c ¶ +12

               /*
                *	A Simple Sandbox for Moe
                *
                *	(c) 2001--2010 Martin Mares <mj@ucw.cz>
                */
               #define _LARGEFILE64_SOURCE
               #define _GNU_SOURCE
               /* Generated automatically by ./configure, please don't touch manually. */
               #define CONFIG_BOX_KERNEL_AMD64 1
               #define CONFIG_BOX_USER_AMD64 1
               #define CONFIG_DIR "cf"
               #define CONFIG_DIRECT_IO 1
               #define CONFIG_ISOLATE_BOX_DIR "/tmp/box"
               #define CONFIG_ISOLATE_CGROUP_ROOT "/sys/fs/cgroup"
               #define CONFIG_ISOLATE_FIRST_GID 60000
               #define CONFIG_ISOLATE_FIRST_UID 60000
               #define CONFIG_ISOLATE_NUM_BOXES 100
               #define CONFIG_LARGE_FILES 1
               #define CONFIG_LFS 1
               #define CONFIG_LINUX 1
               #define CONFIG_LOCAL 1
               #define CONFIG_UCW_PARTMAP_IS_MMAP 1
               #define CONFIG_UCW_PERL 1
               #define CONFIG_UCW_POOL_IS_MMAP 1
               #define CONFIG_UCW_RADIX_SORTER_BITS 10
               #define CONFIG_UCW_SHELL_UTILS 1
               #define CPU_64BIT_POINTERS 1
               #define CPU_ALLOW_UNALIGNED 1
               #define CPU_AMD64 1
               #define CPU_ARCH "default"
               #define CPU_LITTLE_ENDIAN 1
               #define CPU_PAGE_SIZE 4096
               #define CPU_STRUCT_ALIGN 8
               #define CWARNS_OFF " -Wno-pointer-sign"
               #define HAVE_ASCII_DOC "none"
               #define INSTALL_BIN_DIR "bin"
               #define INSTALL_CONFIG_DIR "cf"
               #define INSTALL_DOC_DIR "share/doc"
               #define INSTALL_INCLUDE_DIR "include"
               #define INSTALL_LIB_DIR "lib"
               #define INSTALL_LOG_DIR "log"
               #define INSTALL_MAN_DIR "share/man"
               #define INSTALL_PERL_DIR "lib/perl5"
               #define INSTALL_PKGCONFIG_DIR "lib/pkgconfig"
               #define INSTALL_PREFIX
               #define INSTALL_RUN_DIR "run"
               #define INSTALL_SBIN_DIR "sbin"
               #define INSTALL_SHARE_DIR "share"
               #define INSTALL_STATE_DIR "lib"
               #define INSTALL_USR_PREFIX
               #define INSTALL_VAR_PREFIX
               #define SHERLOCK_VERSION "3.99.2"
               #define SHERLOCK_VERSION_CODE 3099002
               #define SONAME_PREFIX "lib/"
               #define UCW_VERSION "3.99.2"
               #define UCW_VERSION_CODE 3099002
               #include <errno.h>
               #include <stdio.h>
               #include <fcntl.h>
               #include <stdlib.h>
               #include <string.h>
               #include <stdarg.h>
               #include <stdint.h>
               #include <unistd.h>
               #include <getopt.h>
               #include <time.h>
               #include <sys/wait.h>
               #include <sys/user.h>
               #include <sys/time.h>
               #include <sys/ptrace.h>
               #include <sys/signal.h>
               #include <sys/sysinfo.h>
               #include <sys/resource.h>
               #include <sys/utsname.h>
               //#include <linux/ptrace.h>
               #if defined(CONFIG_BOX_KERNEL_AMD64) && !defined(CONFIG_BOX_USER_AMD64)
               #include <asm/unistd_32.h>
               #define NATIVE_NR_execve 59		/* 64-bit execve */
               #else
               #include <asm/unistd.h>
               #define NATIVE_NR_execve __NR_execve
               #endif
               #define NONRET __attribute__((noreturn))
               #define UNUSED __attribute__((unused))
               #define ARRAY_SIZE(a) (int)(sizeof(a)/sizeof(a[0]))
               static int filter_syscalls;		/* 0=off, 1=liberal, 2=totalitarian */
               static int timeout;			/* milliseconds */
               static int wall_timeout;
               static int extra_timeout;
               static int pass_environ;
               static int file_access;
               static int verbose;
               static int memory_limit;
               static int stack_limit;
               static char *redir_stdin, *redir_stdout, *redir_stderr;
               static char *set_cwd;
               static pid_t box_pid;
               static int is_ptraced;
               static volatile int timer_tick;
               static struct timeval start_time;
               static int ticks_per_sec;
               static int exec_seen;
               static int partial_line;
               static int mem_peak_kb;
               static int total_ms, wall_ms, sys_ms;
               static void die(char *msg, ...) NONRET;
               static void sample_mem_peak(void);
               /*** Meta-files ***/
               static FILE *metafile;
               static void
               meta_open(const char *name)
               {
                 if (!strcmp(name, "-"))
                   {
                     metafile = stdout;
                     return;
                   }
                 metafile = fopen(name, "w");
                 if (!metafile)
                   die("Failed to open metafile '%s'",name);
               }
               static void
               meta_close(void)
               {
                 if (metafile && metafile != stdout)
                   fclose(metafile);
               }
               static void __attribute__((format(printf,1,2)))
               meta_printf(const char *fmt, ...)
               {
                 if (!metafile)
                   return;
                 va_list args;
                 va_start(args, fmt);
                 vfprintf(metafile, fmt, args);
                 va_end(args);
               }
               static void print_running_stat(double wall_time,
               			double user_time,
               			double system_time,
               			int mem_usage)
               {
                 //total is user
                 //wall is wall
                 //
                 fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dkbytes\n",
               	  wall_time, user_time, system_time, mem_usage);
               }
               static void
               final_stats(struct rusage *rus)
               {
                 struct timeval total, now, wall;
                 timeradd(&rus->ru_utime, &rus->ru_stime, &total);
                 total_ms = total.tv_sec*1000 + total.tv_usec/1000;
                 gettimeofday(&now, NULL);
                 timersub(&now, &start_time, &wall);
                 wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
                 sys_ms = rus->ru_stime.tv_sec * 1000 + rus->ru_stime.tv_usec / 1000;
                 meta_printf("time:%d.%03d\n", total_ms/1000, total_ms%1000);
                 meta_printf("time-wall:%d.%03d\n", wall_ms/1000, wall_ms%1000);
                 meta_printf("mem:%llu\n", (unsigned long long) mem_peak_kb * 1024);
               }
               /*** Messages and exits ***/
               static void NONRET
               box_exit(int rc)
               {
                 if (box_pid > 0)
                   {
                     sample_mem_peak();
                     if (is_ptraced)
               	ptrace(PTRACE_KILL, box_pid);
                     kill(-box_pid, SIGKILL);
                     kill(box_pid, SIGKILL);
                     meta_printf("killed:1\n");
                     struct rusage rus;
                     int p, stat;
                     do
               	p = wait4(box_pid, &stat, 0, &rus);
                     while (p < 0 && errno == EINTR);
                     if (p < 0)
               	fprintf(stderr, "UGH: Lost track of the process (%m)\n");
                     else {
               	final_stats(&rus);
                     }
                   }
                 print_running_stat(
                       (double)wall_ms/1000,
                       (double)total_ms/1000,
                       (double)sys_ms/1000,
                       mem_peak_kb);
                 meta_close();
                 exit(rc);
               }
               static void
               flush_line(void)
               {
                 if (partial_line)
                   fputc('\n', stderr);
                 partial_line = 0;
               }
               /* Report an error of the sandbox itself */
               static void NONRET __attribute__((format(printf,1,2)))
               die(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 flush_line();
                 char buf[1024];
                 vsnprintf(buf, sizeof(buf), msg, args);
                 meta_printf("status:XX\nmessage:%s\n", buf);
                 fputs(buf, stderr);
                 fputc('\n', stderr);
                 box_exit(2);
               }
               /* Report an error of the program inside the sandbox */
               static void NONRET __attribute__((format(printf,1,2)))
               err(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 flush_line();
                 if (msg[0] && msg[1] && msg[2] == ':' && msg[3] == ' ')
                   {
                     meta_printf("status:%c%c\n", msg[0], msg[1]);
                     msg += 4;
                   }
                 char buf[1024];
                 vsnprintf(buf, sizeof(buf), msg, args);
                 meta_printf("message:%s\n", buf);
                 fputs(buf, stderr);
                 fputc('\n', stderr);
                 box_exit(1);
               }
               /* Write a message, but only if in verbose mode */
               static void __attribute__((format(printf,1,2)))
               msg(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 if (verbose)
                   {
                     int len = strlen(msg);
                     if (len > 0)
                       partial_line = (msg[len-1] != '\n');
                     vfprintf(stderr, msg, args);
                     fflush(stderr);
                   }
                 va_end(args);
               }
               static void *
               xmalloc(size_t size)
               {
                 void *p = malloc(size);
                 if (!p)
                   die("Out of memory");
                 return p;
               }
               /*** Syscall rules ***/
               static const char * const syscall_names[] = {
               /* Syscall table automatically generated by mk-syscall-table */
               /* 0 */ [ __NR_read ] = "read",
               /* 1 */ [ __NR_write ] = "write",
               /* 2 */ [ __NR_open ] = "open",
               /* 3 */ [ __NR_close ] = "close",
               /* 4 */ [ __NR_stat ] = "stat",
               /* 5 */ [ __NR_fstat ] = "fstat",
               /* 6 */ [ __NR_lstat ] = "lstat",
               /* 7 */ [ __NR_poll ] = "poll",
               /* 8 */ [ __NR_lseek ] = "lseek",
               /* 9 */ [ __NR_mmap ] = "mmap",
               /* 10 */ [ __NR_mprotect ] = "mprotect",
               /* 11 */ [ __NR_munmap ] = "munmap",
               /* 12 */ [ __NR_brk ] = "brk",
               /* 13 */ [ __NR_rt_sigaction ] = "rt_sigaction",
               /* 14 */ [ __NR_rt_sigprocmask ] = "rt_sigprocmask",
               /* 15 */ [ __NR_rt_sigreturn ] = "rt_sigreturn",
               /* 16 */ [ __NR_ioctl ] = "ioctl",
               /* 17 */ [ __NR_pread64 ] = "pread64",
               /* 18 */ [ __NR_pwrite64 ] = "pwrite64",
               /* 19 */ [ __NR_readv ] = "readv",
               /* 20 */ [ __NR_writev ] = "writev",
               /* 21 */ [ __NR_access ] = "access",
               /* 22 */ [ __NR_pipe ] = "pipe",
               /* 23 */ [ __NR_select ] = "select",
               /* 24 */ [ __NR_sched_yield ] = "sched_yield",
               /* 25 */ [ __NR_mremap ] = "mremap",
               /* 26 */ [ __NR_msync ] = "msync",
               /* 27 */ [ __NR_mincore ] = "mincore",
               /* 28 */ [ __NR_madvise ] = "madvise",
               /* 29 */ [ __NR_shmget ] = "shmget",
               /* 30 */ [ __NR_shmat ] = "shmat",
               /* 31 */ [ __NR_shmctl ] = "shmctl",
               /* 32 */ [ __NR_dup ] = "dup",
               /* 33 */ [ __NR_dup2 ] = "dup2",
               /* 34 */ [ __NR_pause ] = "pause",
               /* 35 */ [ __NR_nanosleep ] = "nanosleep",
               /* 36 */ [ __NR_getitimer ] = "getitimer",
               /* 37 */ [ __NR_alarm ] = "alarm",
               /* 38 */ [ __NR_setitimer ] = "setitimer",
               /* 39 */ [ __NR_getpid ] = "getpid",
               /* 40 */ [ __NR_sendfile ] = "sendfile",
               /* 41 */ [ __NR_socket ] = "socket",
               /* 42 */ [ __NR_connect ] = "connect",
               /* 43 */ [ __NR_accept ] = "accept",
               /* 44 */ [ __NR_sendto ] = "sendto",
               /* 45 */ [ __NR_recvfrom ] = "recvfrom",
               /* 46 */ [ __NR_sendmsg ] = "sendmsg",
               /* 47 */ [ __NR_recvmsg ] = "recvmsg",
               /* 48 */ [ __NR_shutdown ] = "shutdown",
               /* 49 */ [ __NR_bind ] = "bind",
               /* 50 */ [ __NR_listen ] = "listen",
               /* 51 */ [ __NR_getsockname ] = "getsockname",
               /* 52 */ [ __NR_getpeername ] = "getpeername",
               /* 53 */ [ __NR_socketpair ] = "socketpair",
               /* 54 */ [ __NR_setsockopt ] = "setsockopt",
               /* 55 */ [ __NR_getsockopt ] = "getsockopt",
               /* 56 */ [ __NR_clone ] = "clone",
               /* 57 */ [ __NR_fork ] = "fork",
               /* 58 */ [ __NR_vfork ] = "vfork",
               /* 59 */ [ __NR_execve ] = "execve",
               /* 60 */ [ __NR_exit ] = "exit",
               /* 61 */ [ __NR_wait4 ] = "wait4",
               /* 62 */ [ __NR_kill ] = "kill",
               /* 63 */ [ __NR_uname ] = "uname",
               /* 64 */ [ __NR_semget ] = "semget",
               /* 65 */ [ __NR_semop ] = "semop",
               /* 66 */ [ __NR_semctl ] = "semctl",
               /* 67 */ [ __NR_shmdt ] = "shmdt",
               /* 68 */ [ __NR_msgget ] = "msgget",
               /* 69 */ [ __NR_msgsnd ] = "msgsnd",
               /* 70 */ [ __NR_msgrcv ] = "msgrcv",
               /* 71 */ [ __NR_msgctl ] = "msgctl",
               /* 72 */ [ __NR_fcntl ] = "fcntl",
               /* 73 */ [ __NR_flock ] = "flock",
               /* 74 */ [ __NR_fsync ] = "fsync",
               /* 75 */ [ __NR_fdatasync ] = "fdatasync",
               /* 76 */ [ __NR_truncate ] = "truncate",
               /* 77 */ [ __NR_ftruncate ] = "ftruncate",
               /* 78 */ [ __NR_getdents ] = "getdents",
               /* 79 */ [ __NR_getcwd ] = "getcwd",
               /* 80 */ [ __NR_chdir ] = "chdir",
               /* 81 */ [ __NR_fchdir ] = "fchdir",
               /* 82 */ [ __NR_rename ] = "rename",
               /* 83 */ [ __NR_mkdir ] = "mkdir",
               /* 84 */ [ __NR_rmdir ] = "rmdir",
               /* 85 */ [ __NR_creat ] = "creat",
               /* 86 */ [ __NR_link ] = "link",
               /* 87 */ [ __NR_unlink ] = "unlink",
               /* 88 */ [ __NR_symlink ] = "symlink",
               /* 89 */ [ __NR_readlink ] = "readlink",
               /* 90 */ [ __NR_chmod ] = "chmod",
               /* 91 */ [ __NR_fchmod ] = "fchmod",
               /* 92 */ [ __NR_chown ] = "chown",
               /* 93 */ [ __NR_fchown ] = "fchown",
               /* 94 */ [ __NR_lchown ] = "lchown",
               /* 95 */ [ __NR_umask ] = "umask",
               /* 96 */ [ __NR_gettimeofday ] = "gettimeofday",
               /* 97 */ [ __NR_getrlimit ] = "getrlimit",
               /* 98 */ [ __NR_getrusage ] = "getrusage",
               /* 99 */ [ __NR_sysinfo ] = "sysinfo",
               /* 100 */ [ __NR_times ] = "times",
               /* 101 */ [ __NR_ptrace ] = "ptrace",
               /* 102 */ [ __NR_getuid ] = "getuid",
               /* 103 */ [ __NR_syslog ] = "syslog",
               /* 104 */ [ __NR_getgid ] = "getgid",
               /* 105 */ [ __NR_setuid ] = "setuid",
               /* 106 */ [ __NR_setgid ] = "setgid",
               /* 107 */ [ __NR_geteuid ] = "geteuid",
               /* 108 */ [ __NR_getegid ] = "getegid",
               /* 109 */ [ __NR_setpgid ] = "setpgid",
               /* 110 */ [ __NR_getppid ] = "getppid",
               /* 111 */ [ __NR_getpgrp ] = "getpgrp",
               /* 112 */ [ __NR_setsid ] = "setsid",
               /* 113 */ [ __NR_setreuid ] = "setreuid",
               /* 114 */ [ __NR_setregid ] = "setregid",
               /* 115 */ [ __NR_getgroups ] = "getgroups",
               /* 116 */ [ __NR_setgroups ] = "setgroups",
               /* 117 */ [ __NR_setresuid ] = "setresuid",
               /* 118 */ [ __NR_getresuid ] = "getresuid",
               /* 119 */ [ __NR_setresgid ] = "setresgid",
               /* 120 */ [ __NR_getresgid ] = "getresgid",
               /* 121 */ [ __NR_getpgid ] = "getpgid",
               /* 122 */ [ __NR_setfsuid ] = "setfsuid",
               /* 123 */ [ __NR_setfsgid ] = "setfsgid",
               /* 124 */ [ __NR_getsid ] = "getsid",
               /* 125 */ [ __NR_capget ] = "capget",
               /* 126 */ [ __NR_capset ] = "capset",
               /* 127 */ [ __NR_rt_sigpending ] = "rt_sigpending",
               /* 128 */ [ __NR_rt_sigtimedwait ] = "rt_sigtimedwait",
               /* 129 */ [ __NR_rt_sigqueueinfo ] = "rt_sigqueueinfo",
               /* 130 */ [ __NR_rt_sigsuspend ] = "rt_sigsuspend",
               /* 131 */ [ __NR_sigaltstack ] = "sigaltstack",
               /* 132 */ [ __NR_utime ] = "utime",
               /* 133 */ [ __NR_mknod ] = "mknod",
               /* 134 */ [ __NR_uselib ] = "uselib",
               /* 135 */ [ __NR_personality ] = "personality",
               /* 136 */ [ __NR_ustat ] = "ustat",
               /* 137 */ [ __NR_statfs ] = "statfs",
               /* 138 */ [ __NR_fstatfs ] = "fstatfs",
               /* 139 */ [ __NR_sysfs ] = "sysfs",
               /* 140 */ [ __NR_getpriority ] = "getpriority",
               /* 141 */ [ __NR_setpriority ] = "setpriority",
               /* 142 */ [ __NR_sched_setparam ] = "sched_setparam",
               /* 143 */ [ __NR_sched_getparam ] = "sched_getparam",
               /* 144 */ [ __NR_sched_setscheduler ] = "sched_setscheduler",
               /* 145 */ [ __NR_sched_getscheduler ] = "sched_getscheduler",
               /* 146 */ [ __NR_sched_get_priority_max ] = "sched_get_priority_max",
               /* 147 */ [ __NR_sched_get_priority_min ] = "sched_get_priority_min",
               /* 148 */ [ __NR_sched_rr_get_interval ] = "sched_rr_get_interval",
               /* 149 */ [ __NR_mlock ] = "mlock",
               /* 150 */ [ __NR_munlock ] = "munlock",
               /* 151 */ [ __NR_mlockall ] = "mlockall",
               /* 152 */ [ __NR_munlockall ] = "munlockall",
               /* 153 */ [ __NR_vhangup ] = "vhangup",
               /* 154 */ [ __NR_modify_ldt ] = "modify_ldt",
               /* 155 */ [ __NR_pivot_root ] = "pivot_root",
               /* 156 */ [ __NR__sysctl ] = "_sysctl",
               /* 157 */ [ __NR_prctl ] = "prctl",
               /* 158 */ [ __NR_arch_prctl ] = "arch_prctl",
               /* 159 */ [ __NR_adjtimex ] = "adjtimex",
               /* 160 */ [ __NR_setrlimit ] = "setrlimit",
               /* 161 */ [ __NR_chroot ] = "chroot",
               /* 162 */ [ __NR_sync ] = "sync",
               /* 163 */ [ __NR_acct ] = "acct",
               /* 164 */ [ __NR_settimeofday ] = "settimeofday",
               /* 165 */ [ __NR_mount ] = "mount",
               /* 166 */ [ __NR_umount2 ] = "umount2",
               /* 167 */ [ __NR_swapon ] = "swapon",
               /* 168 */ [ __NR_swapoff ] = "swapoff",
               /* 169 */ [ __NR_reboot ] = "reboot",
               /* 170 */ [ __NR_sethostname ] = "sethostname",
               /* 171 */ [ __NR_setdomainname ] = "setdomainname",
               /* 172 */ [ __NR_iopl ] = "iopl",
               /* 173 */ [ __NR_ioperm ] = "ioperm",
               /* 174 */ [ __NR_create_module ] = "create_module",
               /* 175 */ [ __NR_init_module ] = "init_module",
               /* 176 */ [ __NR_delete_module ] = "delete_module",
               /* 177 */ [ __NR_get_kernel_syms ] = "get_kernel_syms",
               /* 178 */ [ __NR_query_module ] = "query_module",
               /* 179 */ [ __NR_quotactl ] = "quotactl",
               /* 180 */ [ __NR_nfsservctl ] = "nfsservctl",
               /* 181 */ [ __NR_getpmsg ] = "getpmsg",
               /* 182 */ [ __NR_putpmsg ] = "putpmsg",
               /* 183 */ [ __NR_afs_syscall ] = "afs_syscall",
               /* 184 */ [ __NR_tuxcall ] = "tuxcall",
               /* 185 */ [ __NR_security ] = "security",
               /* 186 */ [ __NR_gettid ] = "gettid",
               /* 187 */ [ __NR_readahead ] = "readahead",
               /* 188 */ [ __NR_setxattr ] = "setxattr",
               /* 189 */ [ __NR_lsetxattr ] = "lsetxattr",
               /* 190 */ [ __NR_fsetxattr ] = "fsetxattr",
               /* 191 */ [ __NR_getxattr ] = "getxattr",
               /* 192 */ [ __NR_lgetxattr ] = "lgetxattr",
               /* 193 */ [ __NR_fgetxattr ] = "fgetxattr",
               /* 194 */ [ __NR_listxattr ] = "listxattr",
               /* 195 */ [ __NR_llistxattr ] = "llistxattr",
               /* 196 */ [ __NR_flistxattr ] = "flistxattr",
               /* 197 */ [ __NR_removexattr ] = "removexattr",
               /* 198 */ [ __NR_lremovexattr ] = "lremovexattr",
               /* 199 */ [ __NR_fremovexattr ] = "fremovexattr",
               /* 200 */ [ __NR_tkill ] = "tkill",
               /* 201 */ [ __NR_time ] = "time",
               /* 202 */ [ __NR_futex ] = "futex",
               /* 203 */ [ __NR_sched_setaffinity ] = "sched_setaffinity",
               /* 204 */ [ __NR_sched_getaffinity ] = "sched_getaffinity",
               /* 205 */ [ __NR_set_thread_area ] = "set_thread_area",
               /* 206 */ [ __NR_io_setup ] = "io_setup",
               /* 207 */ [ __NR_io_destroy ] = "io_destroy",
               /* 208 */ [ __NR_io_getevents ] = "io_getevents",
               /* 209 */ [ __NR_io_submit ] = "io_submit",
               /* 210 */ [ __NR_io_cancel ] = "io_cancel",
               /* 211 */ [ __NR_get_thread_area ] = "get_thread_area",
               /* 212 */ [ __NR_lookup_dcookie ] = "lookup_dcookie",
               /* 213 */ [ __NR_epoll_create ] = "epoll_create",
               /* 214 */ [ __NR_epoll_ctl_old ] = "epoll_ctl_old",
               /* 215 */ [ __NR_epoll_wait_old ] = "epoll_wait_old",
               /* 216 */ [ __NR_remap_file_pages ] = "remap_file_pages",
               /* 217 */ [ __NR_getdents64 ] = "getdents64",
               /* 218 */ [ __NR_set_tid_address ] = "set_tid_address",
               /* 219 */ [ __NR_restart_syscall ] = "restart_syscall",
               /* 220 */ [ __NR_semtimedop ] = "semtimedop",
               /* 221 */ [ __NR_fadvise64 ] = "fadvise64",
               /* 222 */ [ __NR_timer_create ] = "timer_create",
               /* 223 */ [ __NR_timer_settime ] = "timer_settime",
               /* 224 */ [ __NR_timer_gettime ] = "timer_gettime",
               /* 225 */ [ __NR_timer_getoverrun ] = "timer_getoverrun",
               /* 226 */ [ __NR_timer_delete ] = "timer_delete",
               /* 227 */ [ __NR_clock_settime ] = "clock_settime",
               /* 228 */ [ __NR_clock_gettime ] = "clock_gettime",
               /* 229 */ [ __NR_clock_getres ] = "clock_getres",
               /* 230 */ [ __NR_clock_nanosleep ] = "clock_nanosleep",
               /* 231 */ [ __NR_exit_group ] = "exit_group",
               /* 232 */ [ __NR_epoll_wait ] = "epoll_wait",
               /* 233 */ [ __NR_epoll_ctl ] = "epoll_ctl",
               /* 234 */ [ __NR_tgkill ] = "tgkill",
               /* 235 */ [ __NR_utimes ] = "utimes",
               /* 236 */ [ __NR_vserver ] = "vserver",
               /* 237 */ [ __NR_mbind ] = "mbind",
               /* 238 */ [ __NR_set_mempolicy ] = "set_mempolicy",
               /* 239 */ [ __NR_get_mempolicy ] = "get_mempolicy",
               /* 240 */ [ __NR_mq_open ] = "mq_open",
               /* 241 */ [ __NR_mq_unlink ] = "mq_unlink",
               /* 242 */ [ __NR_mq_timedsend ] = "mq_timedsend",
               /* 243 */ [ __NR_mq_timedreceive ] = "mq_timedreceive",
               /* 244 */ [ __NR_mq_notify ] = "mq_notify",
               /* 245 */ [ __NR_mq_getsetattr ] = "mq_getsetattr",
               /* 246 */ [ __NR_kexec_load ] = "kexec_load",
               /* 247 */ [ __NR_waitid ] = "waitid",
               /* 248 */ [ __NR_add_key ] = "add_key",
               /* 249 */ [ __NR_request_key ] = "request_key",
               /* 250 */ [ __NR_keyctl ] = "keyctl",
               /* 251 */ [ __NR_ioprio_set ] = "ioprio_set",
               /* 252 */ [ __NR_ioprio_get ] = "ioprio_get",
               /* 253 */ [ __NR_inotify_init ] = "inotify_init",
               /* 254 */ [ __NR_inotify_add_watch ] = "inotify_add_watch",
               /* 255 */ [ __NR_inotify_rm_watch ] = "inotify_rm_watch",
               /* 256 */ [ __NR_migrate_pages ] = "migrate_pages",
               /* 257 */ [ __NR_openat ] = "openat",
               /* 258 */ [ __NR_mkdirat ] = "mkdirat",
               /* 259 */ [ __NR_mknodat ] = "mknodat",
               /* 260 */ [ __NR_fchownat ] = "fchownat",
               /* 261 */ [ __NR_futimesat ] = "futimesat",
               /* 262 */ [ __NR_newfstatat ] = "newfstatat",
               /* 263 */ [ __NR_unlinkat ] = "unlinkat",
               /* 264 */ [ __NR_renameat ] = "renameat",
               /* 265 */ [ __NR_linkat ] = "linkat",
               /* 266 */ [ __NR_symlinkat ] = "symlinkat",
               /* 267 */ [ __NR_readlinkat ] = "readlinkat",
               /* 268 */ [ __NR_fchmodat ] = "fchmodat",
               /* 269 */ [ __NR_faccessat ] = "faccessat",
               /* 270 */ [ __NR_pselect6 ] = "pselect6",
               /* 271 */ [ __NR_ppoll ] = "ppoll",
               /* 272 */ [ __NR_unshare ] = "unshare",
               /* 273 */ [ __NR_set_robust_list ] = "set_robust_list",
               /* 274 */ [ __NR_get_robust_list ] = "get_robust_list",
               /* 275 */ [ __NR_splice ] = "splice",
               /* 276 */ [ __NR_tee ] = "tee",
               /* 277 */ [ __NR_sync_file_range ] = "sync_file_range",
               /* 278 */ [ __NR_vmsplice ] = "vmsplice",
               /* 279 */ [ __NR_move_pages ] = "move_pages",
               /* 280 */ [ __NR_utimensat ] = "utimensat",
               /* 281 */ [ __NR_epoll_pwait ] = "epoll_pwait",
               /* 282 */ [ __NR_signalfd ] = "signalfd",
               /* 283 */ [ __NR_timerfd_create ] = "timerfd_create",
               /* 284 */ [ __NR_eventfd ] = "eventfd",
               /* 285 */ [ __NR_fallocate ] = "fallocate",
               /* 286 */ [ __NR_timerfd_settime ] = "timerfd_settime",
               /* 287 */ [ __NR_timerfd_gettime ] = "timerfd_gettime",
               /* 288 */ [ __NR_accept4 ] = "accept4",
               /* 289 */ [ __NR_signalfd4 ] = "signalfd4",
               /* 290 */ [ __NR_eventfd2 ] = "eventfd2",
               /* 291 */ [ __NR_epoll_create1 ] = "epoll_create1",
               /* 292 */ [ __NR_dup3 ] = "dup3",
               /* 293 */ [ __NR_pipe2 ] = "pipe2",
               /* 294 */ [ __NR_inotify_init1 ] = "inotify_init1",
               /* 295 */ [ __NR_preadv ] = "preadv",
               /* 296 */ [ __NR_pwritev ] = "pwritev",
               /* 297 */ [ __NR_rt_tgsigqueueinfo ] = "rt_tgsigqueueinfo",
               /* 298 */ [ __NR_perf_event_open ] = "perf_event_open",
               /* 299 */ [ __NR_recvmmsg ] = "recvmmsg",
               /* 300 */ [ __NR_fanotify_init ] = "fanotify_init",
               /* 301 */ [ __NR_fanotify_mark ] = "fanotify_mark",
               /* 302 */ [ __NR_prlimit64 ] = "prlimit64",
               /* 303 */ [ __NR_name_to_handle_at ] = "name_to_handle_at",
               /* 304 */ [ __NR_open_by_handle_at ] = "open_by_handle_at",
               /* 305 */ [ __NR_clock_adjtime ] = "clock_adjtime",
               /* 306 */ [ __NR_syncfs ] = "syncfs",
               /* 307 */ [ __NR_sendmmsg ] = "sendmmsg",
               /* 308 */ [ __NR_setns ] = "setns",
               /* 309 */ [ __NR_getcpu ] = "getcpu",
               /* 310 */ [ __NR_process_vm_readv ] = "process_vm_readv",
               /* 311 */ [ __NR_process_vm_writev ] = "process_vm_writev",
               /* 312 */ [ __NR_kcmp ] = "kcmp",
               /* 313 */ [ __NR_finit_module ] = "finit_module",
+            + /* 314 */ [ __NR_sched_setattr ] = "sched_setattr",
+            + /* 315 */ [ __NR_sched_getattr ] = "sched_getattr",
+            + /* 316 */ [ __NR_renameat2 ] = "renameat2",
+            + /* 317 */ [ __NR_seccomp ] = "seccomp",
+            + /* 318 */ [ __NR_getrandom ] = "getrandom",
+            + /* 319 */ [ __NR_memfd_create ] = "memfd_create",
+            + /* 320 */ [ __NR_kexec_file_load ] = "kexec_file_load",
+            + /* 321 */ [ __NR_bpf ] = "bpf",
+            + /* 322 */ [ __NR_execveat ] = "execveat",
+            + /* 323 */ [ __NR_userfaultfd ] = "userfaultfd",
+            + /* 324 */ [ __NR_membarrier ] = "membarrier",
+            + /* 325 */ [ __NR_mlock2 ] = "mlock2",
               };
               #define NUM_SYSCALLS ARRAY_SIZE(syscall_names)
               #define NUM_ACTIONS (NUM_SYSCALLS+64)
               enum action {
                 A_DEFAULT,		// Use the default action
                 A_NO,			// Always forbid
                 A_YES,		// Always permit
                 A_FILENAME,		// Permit if arg1 is a known filename
                 A_ACTION_MASK = 15,
                 A_NO_RETVAL = 32,	// Does not return a value
                 A_SAMPLE_MEM = 64,	// Sample memory usage before the syscall
                 A_LIBERAL = 128,	// Valid only in liberal mode
                 // Must fit in a unsigned char
               };
               static unsigned char syscall_action[NUM_ACTIONS] = {
               #define S(x) [__NR_##x]
                   // Syscalls permitted for specific file names
                   S(open) = A_FILENAME,
                   S(creat) = A_FILENAME,
                   S(unlink) = A_FILENAME,
                   S(access) = A_FILENAME,
                   S(truncate) = A_FILENAME,
                   S(stat) = A_FILENAME,
                   S(lstat) = A_FILENAME,
                   S(readlink) = A_FILENAME,
               #ifndef CONFIG_BOX_USER_AMD64
                   S(oldstat) = A_FILENAME,
                   S(oldlstat) = A_FILENAME,
                   S(truncate64) = A_FILENAME,
                   S(stat64) = A_FILENAME,
                   S(lstat64) = A_FILENAME,
               #endif
                   // Syscalls permitted always
                   S(exit) = A_YES | A_SAMPLE_MEM,
                   S(read) = A_YES,
                   S(write) = A_YES,
                   S(close) = A_YES,
                   S(lseek) = A_YES,
                   S(getpid) = A_YES,
                   S(getuid) = A_YES,
                   S(dup) = A_YES,
                   S(brk) = A_YES,
                   S(getgid) = A_YES,
                   S(geteuid) = A_YES,
                   S(getegid) = A_YES,
                   S(dup2) = A_YES,
                   S(ftruncate) = A_YES,
                   S(fstat) = A_YES,
                   S(personality) = A_YES,
                   S(readv) = A_YES,
                   S(writev) = A_YES,
                   S(getresuid) = A_YES,
               #ifdef __NR_pread64
                   S(pread64) = A_YES,
                   S(pwrite64) = A_YES,
               #else
                   S(pread) = A_YES,
                   S(pwrite) = A_YES,
               #endif
                   S(fcntl) = A_YES,
                   S(mmap) = A_YES,
                   S(munmap) = A_YES,
                   S(ioctl) = A_YES,
                   S(uname) = A_YES,
                   S(gettid) = A_YES,
                   S(set_thread_area) = A_YES,
                   S(get_thread_area) = A_YES,
                   S(set_tid_address) = A_YES,
                   S(exit_group) = A_YES | A_SAMPLE_MEM,
               #ifdef CONFIG_BOX_USER_AMD64
                   S(arch_prctl) = A_YES,
               #else
                   S(oldfstat) = A_YES,
                   S(ftruncate64) = A_YES,
                   S(_llseek) = A_YES,
                   S(fstat64) = A_YES,
                   S(fcntl64) = A_YES,
                   S(mmap2) = A_YES,
               #endif
                   // Syscalls permitted only in liberal mode
                   S(time) = A_YES | A_LIBERAL,
                   S(alarm) = A_YES | A_LIBERAL,
                   S(pause) = A_YES | A_LIBERAL,
                   S(fchmod) = A_YES | A_LIBERAL,
                   S(getrlimit) = A_YES | A_LIBERAL,
                   S(getrusage) = A_YES | A_LIBERAL,
                   S(gettimeofday) = A_YES | A_LIBERAL,
                   S(select) = A_YES | A_LIBERAL,
                   S(setitimer) = A_YES | A_LIBERAL,
                   S(getitimer) = A_YES | A_LIBERAL,
                   S(mprotect) = A_YES | A_LIBERAL,
                   S(getdents) = A_YES | A_LIBERAL,
                   S(getdents64) = A_YES | A_LIBERAL,
                   S(fdatasync) = A_YES | A_LIBERAL,
                   S(mremap) = A_YES | A_LIBERAL,
                   S(poll) = A_YES | A_LIBERAL,
                   S(getcwd) = A_YES | A_LIBERAL,
                   S(nanosleep) = A_YES | A_LIBERAL,
                   S(rt_sigreturn) = A_YES | A_LIBERAL | A_NO_RETVAL,
                   S(rt_sigaction) = A_YES | A_LIBERAL,
                   S(rt_sigprocmask) = A_YES | A_LIBERAL,
                   S(rt_sigpending) = A_YES | A_LIBERAL,
                   S(rt_sigtimedwait) = A_YES | A_LIBERAL,
                   S(rt_sigqueueinfo) = A_YES | A_LIBERAL,
                   S(rt_sigsuspend) = A_YES | A_LIBERAL,
                   S(_sysctl) = A_YES | A_LIBERAL,
               #ifndef CONFIG_BOX_USER_AMD64
                   S(sigaction) = A_YES | A_LIBERAL,
                   S(sgetmask) = A_YES | A_LIBERAL,
                   S(ssetmask) = A_YES | A_LIBERAL,
                   S(sigsuspend) = A_YES | A_LIBERAL,
                   S(sigpending) = A_YES | A_LIBERAL,
                   S(sigreturn) = A_YES | A_LIBERAL | A_NO_RETVAL,
                   S(sigprocmask) = A_YES | A_LIBERAL,
                   S(ugetrlimit) = A_YES | A_LIBERAL,
                   S(readdir) = A_YES | A_LIBERAL,
                   S(signal) = A_YES | A_LIBERAL,
                   S(_newselect) = A_YES | A_LIBERAL,
               #endif
               #undef S
               };
               static const char *
               syscall_name(unsigned int id, char *buf)
               {
                 if (id < NUM_SYSCALLS && syscall_names[id])
                   return syscall_names[id];
                 else
                   {
                     sprintf(buf, "#%d", id);
                     return buf;
                   }
               }
               static int
               syscall_by_name(char *name)
               {
                 for (unsigned int i=0; i<NUM_SYSCALLS; i++)
                   if (syscall_names[i] && !strcmp(syscall_names[i], name))
                     return i;
                 if (name[0] == '#')
                   name++;
                 if (!*name)
                   return -1;
                 char *ep;
                 unsigned long l = strtoul(name, &ep, 0);
                 if (*ep)
                   return -1;
                 if (l >= NUM_ACTIONS)
                   return NUM_ACTIONS;
                 return l;
               }
               static int
               set_syscall_action(char *a)
               {
                 char *sep = strchr(a, '=');
                 enum action act = A_YES;
                 if (sep)
                   {
                     *sep++ = 0;
                     if (!strcmp(sep, "yes"))
               	act = A_YES;
                     else if (!strcmp(sep, "no"))
               	act = A_NO;
                     else if (!strcmp(sep, "file"))
               	act = A_FILENAME;
                     else
               	return 0;
                   }
                 int sys = syscall_by_name(a);
                 if (sys < 0)
                   die("Unknown syscall `%s'", a);
                 if (sys >= NUM_ACTIONS)
                   die("Syscall `%s' out of range", a);
                 syscall_action[sys] = act;
                 return 1;
               }
               /*** Path rules ***/
               struct path_rule {
                 char *path;
                 enum action action;
                 struct path_rule *next;
               };
               static struct path_rule default_path_rules[] = {
                 { "/etc/", A_YES },
                 { "/lib/", A_YES },
                 { "/usr/lib/", A_YES },
                 { "/opt/lib/", A_YES },
                 { "/usr/share/zoneinfo/", A_YES },
                 { "/usr/share/locale/", A_YES },
                 { "/dev/null", A_YES },
                 { "/dev/zero", A_YES },
                 { "/proc/meminfo", A_YES },
                 { "/proc/self/stat", A_YES },
                 { "/proc/self/exe", A_YES },			// Needed by FPC 2.0.x runtime
                 { "/proc/self/maps", A_YES },			// Needed by glibc when it reports arena corruption
               };
               static struct path_rule *user_path_rules;
               static struct path_rule **last_path_rule = &user_path_rules;
               static int
               set_path_action(char *a)
               {
                 char *sep = strchr(a, '=');
                 enum action act = A_YES;
                 if (sep)
                   {
                     *sep++ = 0;
                     if (!strcmp(sep, "yes"))
               	act = A_YES;
                     else if (!strcmp(sep, "no"))
               	act = A_NO;
                     else
               	return 0;
                   }
                 struct path_rule *r = xmalloc(sizeof(*r) + strlen(a) + 1);
                 r->path = (char *)(r+1);
                 strcpy(r->path, a);
                 r->action = act;
                 r->next = NULL;
                 *last_path_rule = r;
                 last_path_rule = &r->next;
                 return 1;
               }
               static enum action
               match_path_rule(struct path_rule *r, char *path)
               {
                 char *rr = r->path;
                 while (*rr)
                   if (*rr++ != *path++)
                     {
               	if (rr[-1] == '/' && !path[-1])
               	  break;
               	return A_DEFAULT;
                     }
                 if (rr > r->path && rr[-1] != '/' && *path)
                   return A_DEFAULT;
                 return r->action;
               }
               /*** Environment rules ***/
               struct env_rule {
                 char *var;			// Variable to match
                 char *val;			// ""=clear, NULL=inherit
                 int var_len;
                 struct env_rule *next;
               };
               static struct env_rule *first_env_rule;
               static struct env_rule **last_env_rule = &first_env_rule;
               static struct env_rule default_env_rules[] = {
                 { "LIBC_FATAL_STDERR_", "1" }
               };
               static int
               set_env_action(char *a0)
               {
                 struct env_rule *r = xmalloc(sizeof(*r) + strlen(a0) + 1);
                 char *a = (char *)(r+1);
                 strcpy(a, a0);
                 char *sep = strchr(a, '=');
                 if (sep == a)
                   return 0;
                 r->var = a;
                 if (sep)
                   {
                     *sep++ = 0;
                     r->val = sep;
                   }
                 else
                   r->val = NULL;
                 *last_env_rule = r;
                 last_env_rule = &r->next;
                 r->next = NULL;
                 return 1;
               }
               static int
               match_env_var(char *env_entry, struct env_rule *r)
               {
                 if (strncmp(env_entry, r->var, r->var_len))
                   return 0;
                 return (env_entry[r->var_len] == '=');
               }
               static void
               apply_env_rule(char **env, int *env_sizep, struct env_rule *r)
               {
                 // First remove the variable if already set
                 int pos = 0;
                 while (pos < *env_sizep && !match_env_var(env[pos], r))
                   pos++;
                 if (pos < *env_sizep)
                   {
                     (*env_sizep)--;
                     env[pos] = env[*env_sizep];
                     env[*env_sizep] = NULL;
                   }
                 // What is the new value?
                 char *new;
                 if (r->val)
                   {
                     if (!r->val[0])
               	return;
                     new = xmalloc(r->var_len + 1 + strlen(r->val) + 1);
                     sprintf(new, "%s=%s", r->var, r->val);
                   }
                 else
                   {
                     pos = 0;
                     while (environ[pos] && !match_env_var(environ[pos], r))
               	pos++;
                     if (!(new = environ[pos]))
               	return;
                   }
                 // Add it at the end of the array
                 env[(*env_sizep)++] = new;
                 env[*env_sizep] = NULL;
               }
               static char **
               setup_environment(void)
               {
                 // Link built-in rules with user rules
                 for (int i=ARRAY_SIZE(default_env_rules)-1; i >= 0; i--)
                   {
                     default_env_rules[i].next = first_env_rule;
                     first_env_rule = &default_env_rules[i];
                   }
                 // Scan the original environment
                 char **orig_env = environ;
                 int orig_size = 0;
                 while (orig_env[orig_size])
                   orig_size++;
                 // For each rule, reserve one more slot and calculate length
                 int num_rules = 0;
                 for (struct env_rule *r = first_env_rule; r; r=r->next)
                   {
                     num_rules++;
                     r->var_len = strlen(r->var);
                   }
                 // Create a new environment
                 char **env = xmalloc((orig_size + num_rules + 1) * sizeof(char *));
                 int size;
                 if (pass_environ)
                   {
                     memcpy(env, environ, orig_size * sizeof(char *));
                     size = orig_size;
                   }
                 else
                   size = 0;
                 env[size] = NULL;
                 // Apply the rules one by one
                 for (struct env_rule *r = first_env_rule; r; r=r->next)
                   apply_env_rule(env, &size, r);
                 // Return the new env and pass some gossip
                 if (verbose > 1)
                   {
                     fprintf(stderr, "Passing environment:\n");
                     for (int i=0; env[i]; i++)
               	fprintf(stderr, "\t%s\n", env[i]);
                   }
                 return env;
               }
               /*** Low-level parsing of syscalls ***/
               #ifdef CONFIG_BOX_KERNEL_AMD64
               typedef uint64_t arg_t;
               #else
               typedef uint32_t arg_t;
               #endif
               struct syscall_args {
                 arg_t sys;
                 arg_t arg1, arg2, arg3;
                 arg_t result;
                 struct user user;
               };
               static int user_mem_fd;
               static int read_user_mem(arg_t addr, char *buf, int len)
               {
                 if (!user_mem_fd)
                   {
                     char memname[64];
                     sprintf(memname, "/proc/%d/mem", (int) box_pid);
                     user_mem_fd = open(memname, O_RDONLY);
                     if (user_mem_fd < 0)
               	die("open(%s): %m", memname);
                   }
                 if (lseek64(user_mem_fd, addr, SEEK_SET) < 0)
                   die("lseek64(mem): %m");
                 return read(user_mem_fd, buf, len);
               }
               static void close_user_mem(void)
               {
                 if (user_mem_fd)
                   {
                     close(user_mem_fd);
                     user_mem_fd = 0;
                   }
               }
               #ifdef CONFIG_BOX_KERNEL_AMD64
               static void
               get_syscall_args(struct syscall_args *a, int is_exit)
               {
                 if (ptrace(PTRACE_GETREGS, box_pid, NULL, &a->user) < 0)
                   die("ptrace(PTRACE_GETREGS): %m");
                 a->sys = a->user.regs.orig_rax;
                 a->result = a->user.regs.rax;
                 /*
                  *  CAVEAT: We have to check carefully that this is a real 64-bit syscall.
                  *  We test whether the process runs in 64-bit mode, but surprisingly this
                  *  is not enough: a 64-bit process can still issue the INT 0x80 instruction
                  *  which performs a 32-bit syscall. Currently, the only known way how to
                  *  detect this situation is to inspect the instruction code (the kernel
                  *  keeps a syscall type flag internally, but it is not accessible from
                  *  user space). Hopefully, there is no instruction whose suffix is the
                  *  code of the SYSCALL instruction. Sometimes, one would wish the
                  *  instruction codes to be unique even when read backwards :)
                  */
                 if (is_exit)
                   return;
                 int sys_type;
                 uint16_t instr;
                 switch (a->user.regs.cs)
                   {
                   case 0x23:
                     // 32-bit CPU mode => only 32-bit syscalls can be issued
                     sys_type = 32;
                     break;
                   case 0x33:
                     // 64-bit CPU mode
                     if (read_user_mem(a->user.regs.rip-2, (char *) &instr, 2) != 2)
               	err("FO: Cannot read syscall instruction");
                     switch (instr)
               	{
               	case 0x050f:
               	  break;
               	case 0x80cd:
               	  err("FO: Forbidden 32-bit syscall in 64-bit mode");
               	default:
               	  err("XX: Unknown syscall instruction %04x", instr);
               	}
                     sys_type = 64;
                     break;
                   default:
                     err("XX: Unknown code segment %04jx", (intmax_t) a->user.regs.cs);
                   }
               #ifdef CONFIG_BOX_USER_AMD64
                 if (sys_type != 64)
                   err("FO: Forbidden %d-bit mode syscall", sys_type);
               #else
                 if (sys_type != (exec_seen ? 32 : 64))
                   err("FO: Forbidden %d-bit mode syscall", sys_type);
               #endif
                 if (sys_type == 32)
                   {
                     a->arg1 = a->user.regs.rbx;
                     a->arg2 = a->user.regs.rcx;
                     a->arg3 = a->user.regs.rdx;
                   }
                 else
                   {
                     a->arg1 = a->user.regs.rdi;
                     a->arg2 = a->user.regs.rsi;
                     a->arg3 = a->user.regs.rdx;
                   }
               }
               static void
               set_syscall_nr(struct syscall_args *a, arg_t sys)
               {
                 a->sys = sys;
                 a->user.regs.orig_rax = sys;
                 if (ptrace(PTRACE_SETREGS, box_pid, NULL, &a->user) < 0)
                   die("ptrace(PTRACE_SETREGS): %m");
               }
               static void
               sanity_check(void)
               {
               }
               #else
               static void
               get_syscall_args(struct syscall_args *a, int is_exit UNUSED)
               {
                 if (ptrace(PTRACE_GETREGS, box_pid, NULL, &a->user) < 0)
                   die("ptrace(PTRACE_GETREGS): %m");
                 a->sys = a->user.regs.orig_eax;
                 a->arg1 = a->user.regs.ebx;
                 a->arg2 = a->user.regs.ecx;
                 a->arg3 = a->user.regs.edx;
                 a->result = a->user.regs.eax;
               }
               static void
               set_syscall_nr(struct syscall_args *a, arg_t sys)
               {
                 a->sys = sys;
                 a->user.regs.orig_eax = sys;
                 if (ptrace(PTRACE_SETREGS, box_pid, NULL, &a->user) < 0)
                   die("ptrace(PTRACE_SETREGS): %m");
               }
               static void
               sanity_check(void)
               {
               #if !defined(CONFIG_BOX_ALLOW_INSECURE)
                 struct utsname uts;
                 if (uname(&uts) < 0)
                   die("uname() failed: %m");
                 if (!strcmp(uts.machine, "x86_64"))
                   die("Running 32-bit sandbox on 64-bit kernels is inherently unsafe. Please get a 64-bit version.");
               #endif
               }
               #endif
               /*** Syscall checks ***/
               static void
               valid_filename(arg_t addr)
               {
                 char namebuf[4096], *p, *end;
                 if (!file_access)
                   err("FA: File access forbidden");
                 if (file_access >= 9)
                   return;
                 p = end = namebuf;
                 do
                   {
                     if (p >= end)
               	{
               	  int remains = PAGE_SIZE - (addr & (PAGE_SIZE-1));
               	  int l = namebuf + sizeof(namebuf) - end;
               	  if (l > remains)
               	    l = remains;
               	  if (!l)
               	    err("FA: Access to file with name too long");
               	  remains = read_user_mem(addr, end, l);
               	  if (remains < 0)
               	    die("read(mem): %m");
               	  if (!remains)
               	    err("FA: Access to file with name out of memory");
               	  end += remains;
               	  addr += remains;
               	}
                   }
                 while (*p++);
                 msg("[%s] ", namebuf);
                 if (file_access >= 3)
                   return;
                 // Everything in current directory is permitted
                 if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
                   return;
                 // ".." anywhere in the path is forbidden
                 enum action act = A_DEFAULT;
                 if (strstr(namebuf, ".."))
                   act = A_NO;
                 // Scan user rules
                 for (struct path_rule *r = user_path_rules; r && !act; r=r->next)
                   act = match_path_rule(r, namebuf);
                 // Scan built-in rules
                 if (file_access >= 2)
                   for (int i=0; i<ARRAY_SIZE(default_path_rules) && !act; i++)
                     act = match_path_rule(&default_path_rules[i], namebuf);
                 if (act != A_YES)
                   err("FA: Forbidden access to file `%s'", namebuf);
               }
               // Check syscall. If invalid, return -1, otherwise return the action mask.
               static int
               valid_syscall(struct syscall_args *a)
               {
                 unsigned int sys = a->sys;
                 unsigned int act = (sys < NUM_ACTIONS) ? syscall_action[sys] : A_DEFAULT;
                 if (act & A_LIBERAL)
                   {
                     if (filter_syscalls != 1)
                       act = A_DEFAULT;
                   }
                 switch (act & A_ACTION_MASK)
                   {
                   case A_YES:
                     return act;
                   case A_NO:
                     return -1;
                   case A_FILENAME:
                     valid_filename(a->arg1);
                     return act;
                   default: ;
                   }
                 switch (sys)
                   {
                   case __NR_kill:
                     if (a->arg1 == (arg_t) box_pid)
               	{
               	  meta_printf("exitsig:%d\n", (int) a->arg2);
               	  err("SG: Committed suicide by signal %d", (int) a->arg2);
               	}
                     return -1;
                   case __NR_tgkill:
                     if (a->arg1 == (arg_t) box_pid && a->arg2 == (arg_t) box_pid)
               	{
               	  meta_printf("exitsig:%d\n", (int) a->arg3);
               	  err("SG: Committed suicide by signal %d", (int) a->arg3);
               	}
                     return -1;
                   default:
                     return -1;
                   }
               }
               static void
               signal_alarm(int unused UNUSED)
               {
                 /* Time limit checks are synchronous, so we only schedule them there. */
                 timer_tick = 1;
                 alarm(1);
               }
               static void
               signal_int(int unused UNUSED)
               {
                 /* Interrupts are fatal, so no synchronization requirements. */
                 meta_printf("exitsig:%d\n", SIGINT);
                 err("SG: Interrupted");
               }
               #define PROC_BUF_SIZE 4096
               static void
               read_proc_file(char *buf, char *name, int *fdp)
               {
                 int c;
                 if (!*fdp)
                   {
                     sprintf(buf, "/proc/%d/%s", (int) box_pid, name);
                     *fdp = open(buf, O_RDONLY);
                     if (*fdp < 0)
               	die("open(%s): %m", buf);
                   }
                 lseek(*fdp, 0, SEEK_SET);
                 if ((c = read(*fdp, buf, PROC_BUF_SIZE-1)) < 0)
                   die("read on /proc/$pid/%s: %m", name);
                 if (c >= PROC_BUF_SIZE-1)
                   die("/proc/$pid/%s too long", name);
                 buf[c] = 0;
               }
               static void
               check_timeout(void)
               {
                 if (wall_timeout)
                   {
                     struct timeval now, wall;
                     int wall_ms;
                     gettimeofday(&now, NULL);
                     timersub(&now, &start_time, &wall);
                     wall_ms = wall.tv_sec*1000 + wall.tv_usec/1000;
                     if (wall_ms > wall_timeout)
                       err("TO: Time limit exceeded (wall clock)");
                     if (verbose > 1)
                       fprintf(stderr, "[wall time check: %d msec]\n", wall_ms);
                   }
                 if (timeout)
                   {
                     char buf[PROC_BUF_SIZE], *x;
                     int utime, stime, ms;
                     static int proc_stat_fd;
                     read_proc_file(buf, "stat", &proc_stat_fd);
                     x = buf;
                     while (*x && *x != ' ')
               	x++;
                     while (*x == ' ')
               	x++;
                     if (*x++ != '(')
               	die("proc stat syntax error 1");
                     while (*x && (*x != ')' || x[1] != ' '))
               	x++;
                     while (*x == ')' || *x == ' ')
               	x++;
                     if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
               	die("proc stat syntax error 2");
                     ms = (utime + stime) * 1000 / ticks_per_sec;
                     if (verbose > 1)
               	fprintf(stderr, "[time check: %d msec]\n", ms);
                     if (ms > timeout && ms > extra_timeout)
               	err("TO: Time limit exceeded");
                   }
               }
               static void
               sample_mem_peak(void)
               {
                 /*
                  *  We want to find out the peak memory usage of the process, which is
                  *  maintained by the kernel, but unforunately it gets lost when the
                  *  process exits (it is not reported in struct rusage). Therefore we
                  *  have to sample it whenever we suspect that the process is about
                  *  to exit.
                  */
                 char buf[PROC_BUF_SIZE], *x;
                 static int proc_status_fd;
                 read_proc_file(buf, "status", &proc_status_fd);
                 x = buf;
                 while (*x)
                   {
                     char *key = x;
                     while (*x && *x != ':' && *x != '\n')
               	x++;
                     if (!*x || *x == '\n')
               	break;
                     *x++ = 0;
                     while (*x == ' ' || *x == '\t')
               	x++;
                     char *val = x;
                     while (*x && *x != '\n')
               	x++;
                     if (!*x)
               	break;
                     *x++ = 0;
                     if (!strcmp(key, "VmPeak"))
               	{
               	  int peak = atoi(val);
               	  if (peak > mem_peak_kb)
               	    mem_peak_kb = peak;
               	}
                   }
                 if (verbose > 1)
                   msg("[mem-peak: %u KB]\n", mem_peak_kb);
               }
               static void
               boxkeeper(void)
               {
                 int syscall_count = (filter_syscalls ? 0 : 1);
                 struct sigaction sa;
                 is_ptraced = 1;
                 bzero(&sa, sizeof(sa));
                 sa.sa_handler = signal_int;
                 sigaction(SIGINT, &sa, NULL);
                 gettimeofday(&start_time, NULL);
                 ticks_per_sec = sysconf(_SC_CLK_TCK);
                 if (ticks_per_sec <= 0)
                   die("Invalid ticks_per_sec!");
                 if (timeout || wall_timeout)
                   {
                     sa.sa_handler = signal_alarm;
                     sigaction(SIGALRM, &sa, NULL);
                     alarm(1);
                   }
                 for(;;)
                   {
                     struct rusage rus;
                     int stat;
                     pid_t p;
                     if (timer_tick)
               	{
               	  check_timeout();
               	  timer_tick = 0;
               	}
                     p = wait4(box_pid, &stat, WUNTRACED, &rus);
                     if (p < 0)
               	{
               	  if (errno == EINTR)
               	    continue;
               	  die("wait4: %m");
               	}
                     if (p != box_pid)
               	die("wait4: unknown pid %d exited!", p);
                     if (WIFEXITED(stat))
               	{
               	  box_pid = 0;
               	  final_stats(&rus);
               	  if (WEXITSTATUS(stat))
               	    {
               	      if (syscall_count)
               		{
               		  meta_printf("exitcode:%d\n", WEXITSTATUS(stat));
               		  err("RE: Exited with error status %d", WEXITSTATUS(stat));
               		}
               	      else
               		{
               		  // Internal error happened inside the child process and it has been already reported.
               		  box_exit(2);
               		}
               	    }
               	  if (timeout && total_ms > timeout)
               	    err("TO: Time limit exceeded");
               	  if (wall_timeout && wall_ms > wall_timeout)
               	    err("TO: Time limit exceeded (wall clock)");
               	  flush_line();
                   fprintf(stderr,"OK\n");
               	  box_exit(0);
               	}
                     if (WIFSIGNALED(stat))
               	{
               	  box_pid = 0;
               	  meta_printf("exitsig:%d\n", WTERMSIG(stat));
               	  final_stats(&rus);
               	  err("SG: Caught fatal signal %d%s", WTERMSIG(stat), (syscall_count ? "" : " during startup"));
               	}
                     if (WIFSTOPPED(stat))
               	{
               	  int sig = WSTOPSIG(stat);
               	  if (sig == SIGTRAP)
               	    {
               	      if (verbose > 2)
               		msg("[ptrace status %08x] ", stat);
               	      static int stop_count;
               	      if (!stop_count++)		/* Traceme request */
               		msg(">> Traceme request caught\n");
               	      else
               		err("SG: Breakpoint");
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig == (SIGTRAP | 0x80))
               	    {
               	      if (verbose > 2)
               		msg("[ptrace status %08x] ", stat);
               	      struct syscall_args a;
               	      static unsigned int sys_tick, last_act;
               	      static arg_t last_sys;
               	      if (++sys_tick & 1)		/* Syscall entry */
               		{
               		  char namebuf[32];
               		  int act;
               		  get_syscall_args(&a, 0);
               		  arg_t sys = a.sys;
               		  msg(">> Syscall %-12s (%08jx,%08jx,%08jx) ", syscall_name(sys, namebuf), (intmax_t) a.arg1, (intmax_t) a.arg2, (intmax_t) a.arg3);
               		  if (!exec_seen)
               		    {
               		      msg("[master] ");
               		      if (sys == NATIVE_NR_execve)
               			{
               			  exec_seen = 1;
               			  close_user_mem();
               			}
               		    }
               		  else if ((act = valid_syscall(&a)) >= 0)
               		    {
               		      last_act = act;
               		      syscall_count++;
               		      if (act & A_SAMPLE_MEM)
               			sample_mem_peak();
               		    }
               		  else
               		    {
               		      /*
               		       * Unfortunately, PTRACE_KILL kills _after_ the syscall completes,
               		       * so we have to change it to something harmless (e.g., an undefined
               		       * syscall) and make the program continue.
               		       */
               		      set_syscall_nr(&a, ~(arg_t)0);
               		      err("FO: Forbidden syscall %s", syscall_name(sys, namebuf));
               		    }
               		  last_sys = sys;
               		}
               	      else					/* Syscall return */
               		{
               		  get_syscall_args(&a, 1);
               		  if (a.sys == ~(arg_t)0)
               		    {
               		      /* Some syscalls (sigreturn et al.) do not return a value */
               		      if (!(last_act & A_NO_RETVAL))
               			err("XX: Syscall does not return, but it should");
               		    }
               		  else
               		    {
               		      if (a.sys != last_sys)
               			err("XX: Mismatched syscall entry/exit");
               		    }
               		  if (last_act & A_NO_RETVAL)
               		    msg("= ?\n");
               		  else
               		    msg("= %jd\n", (intmax_t) a.result);
               		}
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig == SIGSTOP)
               	    {
               	      msg(">> SIGSTOP\n");
               	      if (ptrace(PTRACE_SETOPTIONS, box_pid, NULL, (void *) PTRACE_O_TRACESYSGOOD) < 0)
               		die("ptrace(PTRACE_SETOPTIONS): %m");
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, 0);
               	    }
               	  else if (sig != SIGXCPU && sig != SIGXFSZ)
               	    {
               	      msg(">> Signal %d\n", sig);
               	      sample_mem_peak();			/* Signal might be fatal, so update mem-peak */
               	      ptrace(PTRACE_SYSCALL, box_pid, 0, sig);
               	    }
               	  else
               	    {
               	      meta_printf("exitsig:%d", sig);
               	      err("SG: Received signal %d", sig);
               	    }
               	}
                     else
               	die("wait4: unknown status %x, giving up!", stat);
                   }
               }
               static void
               box_inside(int argc, char **argv)
               {
                 struct rlimit rl;
                 char *args[argc+1];
                 memcpy(args, argv, argc * sizeof(char *));
                 args[argc] = NULL;
                 if (set_cwd && chdir(set_cwd))
                   die("chdir: %m");
                 if (redir_stdin)
                   {
                     close(0);
                     if (open(redir_stdin, O_RDONLY) != 0)
               	die("open(\"%s\"): %m", redir_stdin);
                   }
                 if (redir_stdout)
                   {
                     close(1);
                     if (open(redir_stdout, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 1)
               	die("open(\"%s\"): %m", redir_stdout);
                   }
                 if (redir_stderr)
                   {
                     close(2);
                     if (open(redir_stderr, O_WRONLY | O_CREAT | O_TRUNC, 0666) != 2)
               	die("open(\"%s\"): %m", redir_stderr);
                   }
                 else
                   dup2(1, 2);
                 setpgrp();
                 if (memory_limit)
                   {
                     rl.rlim_cur = rl.rlim_max = memory_limit * 1024;
                     if (setrlimit(RLIMIT_AS, &rl) < 0)
               	die("setrlimit(RLIMIT_AS): %m");
                   }
                 rl.rlim_cur = rl.rlim_max = (stack_limit ? (rlim_t)stack_limit * 1024 : RLIM_INFINITY);
                 if (setrlimit(RLIMIT_STACK, &rl) < 0)
                   die("setrlimit(RLIMIT_STACK): %m");
                 rl.rlim_cur = rl.rlim_max = 64;
                 if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
                   die("setrlimit(RLIMIT_NOFILE): %m");
                 char **env = setup_environment();
                 if (filter_syscalls)
                   {
                     if (ptrace(PTRACE_TRACEME) < 0)
               	die("ptrace(PTRACE_TRACEME): %m");
                     /* Trick: Make sure that we are stopped until the boxkeeper wakes up. */
                     raise(SIGSTOP);
                   }
                 execve(args[0], args, env);
                 die("execve(\"%s\"): %m", args[0]);
               }
               static void
               usage(void)
               {
                 fprintf(stderr, "Invalid arguments!\n");
                 printf("\
               Usage: box [<options>] -- <command> <arguments>\n\
               \n\
               Options:\n\
               -a <level>\tSet file access level (0=none, 1=cwd, 2=/etc,/lib,..., 3=whole fs, 9=no checks; needs -f)\n\
               -c <dir>\tChange directory to <dir> first\n\
               -e\t\tInherit full environment of the parent process\n\
               -E <var>\tInherit the environment variable <var> from the parent process\n\
               -E <var>=<val>\tSet the environment variable <var> to <val>; unset it if <var> is empty\n\
               -f\t\tFilter system calls (-ff=very restricted)\n\
               -i <file>\tRedirect stdin from <file>\n\
               -k <size>\tLimit stack size to <size> KB (default: 0=unlimited)\n\
               -m <size>\tLimit address space to <size> KB\n\
               -M <file>\tOutput process information to <file> (name:value)\n\
               -o <file>\tRedirect stdout to <file>\n\
               -p <path>\tPermit access to the specified path (or subtree if it ends with a `/')\n\
               -p <path>=<act>\tDefine action for the specified path (<act>=yes/no)\n\
               -r <file>\tRedirect stderr to <file>\n\
               -s <sys>\tPermit the specified syscall (be careful)\n\
               -s <sys>=<act>\tDefine action for the specified syscall (<act>=yes/no/file)\n\
               -t <time>\tSet run time limit (seconds, fractions allowed)\n\
               -T\t\tAllow syscalls for measuring run time\n\
               -v\t\tBe verbose (use multiple times for even more verbosity)\n\
               -w <time>\tSet wall clock time limit (seconds, fractions allowed)\n\
               -x <time>\tSet extra timeout, before which a timing-out program is not yet killed,\n\
               \t\tso that its real execution time is reported (seconds, fractions allowed)\n\
               -A <opt>\tPass <opt> as additional argument to the <command>\n\
               \t\tBe noted that this option will be appended after <arguments> respectively\n\
               ");
                 exit(2);
               }
               int
               main(int argc, char **argv)
               {
                 int c;
                 uid_t uid;
                 char **prog_argv = xmalloc(sizeof(char*) * argc);
                 int prog_argc = 0;
                 while ((c = getopt(argc, argv, "a:c:eE:fi:k:m:M:o:p:r:s:t:Tvw:x:A:")) >= 0)
                   switch (c)
                     {
                     case 'a':
               	file_access = atol(optarg);
               	break;
                     case 'c':
               	set_cwd = optarg;
               	break;
                     case 'e':
               	pass_environ = 1;
               	break;
                     case 'E':
               	if (!set_env_action(optarg))
               	  usage();
               	break;
                     case 'f':
               	filter_syscalls++;
               	break;
                     case 'k':
               	stack_limit = atol(optarg);
               	break;
                     case 'i':
               	redir_stdin = optarg;
               	break;
                     case 'm':
               	memory_limit = atol(optarg);
               	break;
                     case 'M':
               	meta_open(optarg);
               	break;
                     case 'o':
               	redir_stdout = optarg;
               	break;
                     case 'p':
               	if (!set_path_action(optarg))
               	  usage();
               	break;
                     case 'r':
               	redir_stderr = optarg;
               	break;
                     case 's':
               	if (!set_syscall_action(optarg))
               	  usage();
               	break;
                     case 't':
               	timeout = 1000*atof(optarg);
               	break;
                     case 'T':
               	syscall_action[__NR_times] = A_YES;
               	break;
                     case 'v':
               	verbose++;
               	break;
                     case 'w':
                       wall_timeout = 1000*atof(optarg);
               	break;
                     case 'x':
               	extra_timeout = 1000*atof(optarg);
                     case 'A':
                 prog_argv[prog_argc++] = strdup(optarg);
                 break;
               	break;
                     default:
               	usage();
                     }
                 if (optind >= argc)
                   usage();
                 sanity_check();
                 uid = geteuid();
                 if (setreuid(uid, uid) < 0)
                   die("setreuid: %m");
                 box_pid = fork();
                 if (box_pid < 0)
                   die("fork: %m");
                 if (!box_pid) {
                   int real_argc = prog_argc + argc - optind;
                   char **real_argv = xmalloc(sizeof(char*) * (real_argc));
                   for (int i = 0;i < argc-optind;i++)
                     real_argv[i] = strdup(argv[i+optind]);
                   for (int i = 0;i < prog_argc;i++)
                     real_argv[argc - optind + i] = strdup(prog_argv[i]);
                   box_inside(real_argc, real_argv);
                 } else
                   boxkeeper();
                 die("Internal error: fell over edge of the world");
               }

std-script/compile ¶ +13 -5

               #!/usr/bin/env ruby
               require 'fileutils'
               ##############################
               #
               # Standard Compile Script
               #
               # Supported compilers:
               #   gcc, g++, and fpc.
               #
               ##############################
               def talk(str='')
                 if ENV['TALKATIVE']!=nil
                   puts str
                 end
                 if ENV['GRADER_LOGGING']!=nil
                   log_fname = ENV['GRADER_LOGGING']
                   fp = File.open(log_fname,"a")
                   fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               C_COMPILER = "/usr/bin/gcc"
               CPLUSPLUS_COMPILER = "/usr/bin/g++"
               PASCAL_COMPILER = "/usr/bin/fpc"
               JAVA_COMPILER = "/usr/bin/javac"
               RUBY_INTERPRETER = "/usr/bin/ruby"
-            - PYTHON_INTERPRETER = "/usr/bin/python"
+            + PYTHON_INTERPRETER = "/usr/bin/python3"
               PYTHON_CHECKER = "/usr/bin/pyflakes"
               PHP_INTERPRETER = "/usr/bin/php"
+            + HASKELL_COMPILER = "/usr/bin/ghc"
               C_OPTIONS = "-O2 -s -static -std=c99 -DCONTEST -lm -Wall"
               CPLUSPLUS_OPTIONS = "-O2 -s -std=c++11 -static -DCONTEST -lm -Wall"
               PASCAL_OPTIONS = "-O1 -XS -dCONTEST"
               JAVA_OPTIONS = ""
               PYTHON_OPTIONS = ""
               PHP_OPTIONS = "-l"
+            + HASKELL_OPTIONS = ""
               # Check for the correct number of arguments. Otherwise, print usage.
               if ARGV.length == 0 or ARGV.length > 4
                 puts "Usage: compile <language> [<source-file>] [<output-file>] [<message-file>]"
                 puts
                 puts "<source-file>  is defaulted to \"source\"."
                 puts "<output-file>  is defaulted to \"a.out\"."
                 puts "<message-file> is defaulted to \"compiler_message\"."
                 puts
                 exit(127)
               end
               PARAMS = {
                 :source_file => [1,'source'],
                 :output_file => [2,'a.out'],
                 :message_file => [3,'compiler_message']
               }
               params = {}
               params[:prog_lang] = ARGV[0]
               PARAMS.each_key do |param_name|
                 index, default = PARAMS[param_name]
                 if ARGV.length > index
                   params[param_name] = ARGV[index]
                 else
                   params[param_name] = default
                 end
                 talk "#{param_name}: #{params[param_name]}"
               end
               # Remove any remaining output files or message files.
               if FileTest.exists? params[:output_file]
                 FileUtils.rm(params[:output_file])
               end
               if FileTest.exists? params[:message_file]
                 FileUtils.rm(params[:message_file])
               end
               # Check if the source file exists before attempt compiling.
               if !FileTest.exists? params[:source_file]
                 talk("ERROR: The source file does not exist!")
                 open(params[:message_file],"w") do |f|
                   f.puts "ERROR: The source file did not exist."
                 end
                 exit(127)
               end
               if params[:prog_lang]=='cpp'
                 params[:prog_lang] = 'c++'
               end
               # Compile.
               case params[:prog_lang]
               when "c"
                 command = "#{C_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{C_OPTIONS}"
                 system(command, err: params[:message_file])
               when "c++"
                 command = "#{CPLUSPLUS_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{CPLUSPLUS_OPTIONS}"
                 system(command, err: params[:message_file])
               when "pas"
                 command = "#{PASCAL_COMPILER} #{params[:source_file]} -ooutpas #{PASCAL_OPTIONS}"
                 system(command,out: params[:message_file])
                 FileUtils.mv("output", params[:output_file])
               when "java"
                 #rename the file to the public class name
                 #get the class name
                 classname = 'DUMMY'
                 source = Array.new
                 File.foreach(params[:source_file],'r:UTF-8') do |line|
                   line.encode!('UTF-8','UTF-8',invalid: :replace, replace: '')
                   md = /\s*public\s*class\s*(\w*)/.match(line)
                   classname=md[1] if md
                   source << line unless line =~ /\s*package\s*\w+\s*\;/
                 end
                 File.open("#{classname}.java","w") do |file|
                   source.each do |s|
                     file.puts s
                   end
                 end
                 #system("cp #{params[:source_file]} #{classname}.java")
                 command = "#{JAVA_COMPILER} -encoding utf8 #{classname}.java"
                 system(command, err: params[:message_file])
                 if File.exists?(classname + ".class")
                   File.open(params[:output_file],"w") {|file| file.write("#{classname}")}
                 end
                 if classname == 'DUMMY'
                   File.open(params[:message_file],"w") {|file| file.write("Cannot find any public class in the source code\n")}
                 end
               when "ruby"
                 command = "#{RUBY_INTERPRETER} -c #{params[:source_file]}"
                 if system(command, err: params[:message_file])
                   File.open(params[:output_file],"w") do |out_file|
                     out_file.puts "#!#{RUBY_INTERPRETER}"
                     File.open(params[:source_file],"r").each do |line|
                       out_file.print line
                     end
                   end
                   File.chmod(0755, params[:output_file])
                 end
               when "python"
-            -   command = "#{PYTHON_CHECKER} #{params[:source_file]}"
+            +   #command = "#{PYTHON_CHECKER} #{params[:source_file]}"
-            -   if system(command, out: params[:message_file])
+            +   #if system(command, out: params[:message_file])
                   #compile to python bytecode
-            -     command = "#{PYTHON_INTERPRETER} -m py_compile #{params[:source_file]}"
+            +     command = "#{PYTHON_INTERPRETER} -c \"import py_compile; py_compile.compile('#{params[:source_file]}','#{params[:source_file]}c');\""
                   puts "compile: #{command}"
-            -     system(command)
+            +     system(command, err: params[:message_file])
+            +     if FileTest.exists?("#{params[:source_file]}c")
                     puts "pwd: " + Dir.pwd
                     Dir.new('.').each {|file| puts file}
                     File.open(params[:output_file],"w") do |out_file|
                       out_file.puts "#!#{PYTHON_INTERPRETER} #{params[:source_file]}c"
                     end
                     File.chmod(0755, params[:output_file])
                     FileUtils.cp("#{params[:source_file]}c",params[:output_file])
                   end
+            +   #end
               when "php"
                 command = "#{PHP_INTERPRETER} #{PHP_OPTIONS} #{params[:source_file]}"
                 if system(command, err: params[:message_file])
                   File.open(params[:output_file],"w") do |out_file|
                     out_file.puts "#!#{PHP_INTERPRETER}"
                     File.open(params[:source_file],"r").each do |line|
                       out_file.print line
                     end
                   end
                   File.chmod(0755, params[:output_file])
                 end
+            + when "haskell"
+            +   command = "#{HASKELL_COMPILER} #{params[:source_file]} -o #{params[:output_file]} #{HASKELL_OPTIONS}"
+            +   system(command, err: params[:message_file])
+            +
               else
                 talk("ERROR: Invalid language specified!")
                 open(params[:message_file],"w") do |f|
                   f.puts "ERROR: Invalid language specified!"
                 end
                 exit(127)
               end
               # Report success or failure.
               if FileTest.exists? params[:output_file]
                 talk "Compilation was successful!"
               else
                 talk "ERROR: Something was wrong during the compilation!"
               end

std-script/judge ¶ +7 -1

               #!/usr/bin/env ruby
               require 'fileutils'
               def log(str='')
                 if ENV['TALKATIVE']!=nil
                   puts str
                 end
                 if ENV['GRADER_LOGGING']!=nil
                   log_fname = ENV['GRADER_LOGGING']
                   fp = File.open(log_fname,"a")
                   fp.puts("judge: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               problem_home = ENV['PROBLEM_HOME']
               def execute(command, error_message="")
                 if not system(command)
                   msg = "ERROR: #{error_message}"
                   log msg
                   raise(msg)
                 end
               end
               def call_and_log(error_message)
                 begin
                   yield
                 rescue
                   msg = "ERROR: #{error_message}"
                   log msg
                   raise msg
                 end
               end
               def clear_and_create_empty_dir(dir)
                 FileUtils.rm_rf(dir, :secure => true)
                 call_and_log("Cannot make directory #{dir}.") { FileUtils.mkdir(dir) }
               end
               # ARGV[0] --- language
               # ARGV[1] --- program source file
               # ARGV[2] --- test result directory
               # ARGV[3] --- sandbox directory
               if ARGV.length < 2 || ARGV.length > 4
                 puts "Usage: judge <language> <program-source> [<test-result-directory>] [<sandbox-directory>]"
                 puts "  <sandbox-directory> is defaulted to ./sandbox"
                 puts "  <test-result-directory> is defaulted to ./test-result"
                 puts "WARNING: The judge script will forcefully create the (implicitly and explicitly) specified directories and remove anything inside it."
                 exit(127)
               end
               language = ARGV[0]
-            - if language != "c" && language != "c++" && language != "pas" && language != "java" && language != "ruby" && language != "python" && language != "php"
+            + if language != "c" && language != "c++" && language != "pas" && language != "java" && language != "ruby" && language != "python" && language != "php" && language != "haskell"
                 log "You specified a language that is not supported: #{language}."
                 exit(127)
               end
               source_file = ARGV[1]
               ENV['SOURCE_NAME'] = source_file
               if File.exist?(source_file) == false
                 log "The source file does not exist."
                 exit(127)
               end
               log "Making test result and sandbox directories..."
               current_dir = FileUtils.pwd
               current_dir.strip!
               if ARGV.length >= 3
                 test_result_dir = ARGV[2]
               else
                 test_result_dir = "#{current_dir}/test-result"
               end
               log "Test result directory: #{test_result_dir}"
               clear_and_create_empty_dir(test_result_dir)
               if ARGV.length >= 4
                 sandbox_dir = ARGV[3]
               else
                 sandbox_dir = "#{current_dir}/sandbox"
               end
               log "Sandbox directory: #{sandbox_dir}"
               clear_and_create_empty_dir(sandbox_dir)
               # Compile
               log
               log "Compiling..."
               call_and_log("Cannot copy the source file to #{sandbox_dir}") {
                 FileUtils.cp(source_file, sandbox_dir)
               }
               begin
                 Dir.chdir sandbox_dir
               rescue
                 log "ERROR: Cannot change directory to #{sandbox_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/compile #{language} #{source_file}", "Compilation error!")
               compile_message = open("compiler_message").read
               compile_message.strip!
               call_and_log("Cannot move the compiler message to #{test_result_dir}.") {
                 FileUtils.mv("compiler_message", test_result_dir)
               }
               if !FileTest.exist?("a.out")
                 log "Cannot compile the source code. See message in #{test_result_dir}/compile_message"
                 exit(127)
               else
                 call_and_log("Cannot move the compiled program to #{test_result_dir}") {
                   FileUtils.mv("a.out",test_result_dir)
                   if language == "java" then Dir["*.class"].each { |file| FileUtils.mv(file,test_result_dir)} end
                   if language == "python" then Dir["*.pyc"].each { |file| FileUtils.mv(file,test_result_dir)} end
                 }
                 FileUtils.rm_rf("#{sandbox_dir}/.")
               end
               require "#{problem_home}/script/test_dsl.rb"
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               if problem.well_formed? == false
                 log "The problem specification is not well formed."
                 exit(127)
               end
               # Doing the testing.
               (1..(problem.num_tests)).each do |test_num|
                 $stdout.print "[#{test_num}]"
                 $stdout.flush
                 log "Test number: #{test_num}"
                 call_and_log("Cannot copy the compiled program into #{sandbox_dir}") {
                   FileUtils.cp("#{test_result_dir}/a.out", sandbox_dir, :preserve => true)
                   if language == "java" then Dir["#{test_result_dir}/*.class"].each { |file| FileUtils.cp(file,sandbox_dir)} end
                   if language == "python" then Dir["#{test_result_dir}/*.pyc"].each { |file| FileUtils.cp(file,sandbox_dir)} end
                 }
+            +   #additionally copy any extra .txt file
+            +   data_files = Dir[problem_home + '/*.txt']
+            +   data_files.each do |file|
+            +     FileUtils.cp(file,sandbox_dir)
+            +   end
+            +
                 begin
                   execute("#{problem_home}/script/run #{language} #{test_num} ", "Error occured during execution of the run script")
                 rescue
                   # do nothing
                 end
                 call_and_log("Cannot create directory #{test_result_dir}/#{test_num}") {
                   FileUtils.mkdir "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot copy the result file into #{test_result_dir}/#{test_num}") {
                   FileUtils.mv "#{sandbox_dir}/result", "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot copy the comment file into #{test_result_dir}/#{test_num}") {
                   FileUtils.mv "#{sandbox_dir}/comment", "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot copy the output file into #{test_result_dir}/#{test_num}") {
                   FileUtils.mv "#{sandbox_dir}/output.txt", "#{test_result_dir}/#{test_num}"
                 }
                 call_and_log("Cannot clear #{sandbox_dir}") {
                   FileUtils.rm_rf(Dir.glob("#{sandbox_dir}/*"), :secure => true)
                 }
               end
               $stdout.print "[done]\n"
               # Grade
               log
               log "Grading..."
               begin
                 Dir.chdir test_result_dir
               rescue
                 log "ERROR: Cannot change directory to #{test_result_dir}."
                 exit(127)
               end
               execute("#{problem_home}/script/grade", "An error occured during grading!")
               log
               log "All done!"

std-script/run ¶ +5 -2

               #!/usr/bin/env ruby
               require 'fileutils'
               def log(str='')
                 if ENV['TALKATIVE']!=nil
                   puts str
                 end
                 if ENV['GRADER_LOGGING']!=nil
                   log_fname = ENV['GRADER_LOGGING']
                   fp = File.open(log_fname,"a")
                   fp.puts("run: #{Time.new.strftime("%H:%M")} #{str}")
                   fp.close
                 end
               end
               def extract_time(t)
                 #  puts "TIME: #{t}"
                 if (result=/^(.*)r(.*)u(.*)s/.match(t))
                   {:real => result[1], :user => result[2], :sys => result[3]}
                 else
                   #{:real => 0, :user => 0, :sys => 0}
                   #puts "ERROR READING RUNNING TIME: #{t}"
                   raise "Error reading running time: #{t}"
                 end
               end
               def compile_box(source,bin)
                 system("g++ #{source} -o #{bin}")
               end
               if ARGV.length < 2 || ARGV.length > 3
                 puts "Usage: run <language> <test-num> [<program-name>]"
                 exit(127)
               end
               language = ARGV[0]
               test_num = ARGV[1].to_i
               if ARGV.length > 2
                 program_name = ARGV[2]
               else
                 program_name = "a.out"
               end
               problem_home = ENV['PROBLEM_HOME']
               source_name = ENV['SOURCE_NAME']
               require "#{problem_home}/script/test_dsl.rb"
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               sandbox_dir = Dir.getwd
               if problem.well_formed? == false
                 log "The problem specification is not well formed."
                 exit(127)
               end
               # Check if the test number is okay.
               if test_num <= 0 || test_num > problem.num_tests
                 log "You have specified a wrong test number."
                 exit(127)
               end
               #####################################
               # Set the relavant file names here. #
               #####################################
               input_file_name = "#{problem_home}/test_cases/#{test_num}/input-#{test_num}.txt"
               #####################################
               time_limit = problem.get_time_limit test_num
               mem_limit = problem.get_mem_limit(test_num) * 1024
               # Copy the input file.
               #`cp #{problem_home}/test_cases/#{test_num}/#{input_file_name} .`
               # check if box is there, if not, compile it!
               if !File.exists?("#{problem_home}/script/box")
                 log "WARNING: Compiling box: to increase efficiency, it should be compile manually"
                 compile_box("#{problem_home}/script/box.cc",
                             "#{problem_home}/script/box")
               end
               # Hide PROBLEM_HOME
               ENV['PROBLEM_HOME'] = nil
               ENV['SOURCE_NAME'] = nil
               # Run the program.
               #run_command = "/usr/bin/time -f \"#{time_output_format}\" 2>run_result #{problem_home}/script/box_new -a 2 -f -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name}"
               #
               JAVA_OPTION = "-s set_robust_list -s futex -s clone -s getppid -s clone -s wait4 -p /usr/bin/ -p ./"
               RUBY_OPTION   = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /lib64/ -p /dev/urandom -p #{sandbox_dir}/#{program_name} -p #{sandbox_dir}/ -s set_robust_list -s sched_getaffinity -s clock_gettime -s sigaltstack -s pipe2 -s clone -s futex -s openat -s pipe"
-            - PYTHON_OPTION = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /usr/bin/ -p /lib64/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p #{sandbox_dir}/#{source_name} -s set_robust_list -s openat -s recvmsg -s connect -s socket -s sendto -s futex -E PYTHONNOUSERSITE=yes"
+            + PYTHON_OPTION = "-p /usr/lib64/ -p /usr/local/lib64/ -p /usr/local/lib/ -p /usr/bin/ -p /lib64/ -p /dev/urandom -p /usr/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p #{sandbox_dir}/#{source_name} -p /proc/sys/crypto/fips_enabled -p /proc/self/status -p /proc/mounts -p /var/lib/dpkg/status -s statfs -s set_robust_list -s openat -s sysinfo -s recvmsg -s connect -s socket -s sendto -s futex -s sigaltstack -s getrandom -E PYTHONNOUSERSITE=yes"
               PHP_OPTION = "-p /usr/lib64/ -p/lib64/ -p /usr/bin/ -p #{sandbox_dir}/#{program_name} -p ./#{program_name} -p /usr/share/ -s setfsuid -s setfsgid -s openat -s set_robust_list -s futex -s clone -s socket -s connect"
+            + HASKELL_OPTION = "-s set_robust_list -s clock_gettime -s sysinfo -s timer_create -s timer_settime -s futex -s timer_delete"
               case language
                 when "java"
                   # for java, extract the classname
                   # wne have to add additional systemcall and we don't check the mem limit (dunno how to fix...)
                   classname = 'DUMMY'
                   File.open(program_name,"r").each do |line|
                     classname = line
                   end
                   #for java, we cannot really check the memory limit...
                   run_command = "#{problem_home}/script/box -a 3 -f -T -t #{time_limit} #{JAVA_OPTION} -i #{input_file_name} -o output.txt /usr/bin/java -A -Xmx#{mem_limit}k -A #{classname} "
                 when "ruby"
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{RUBY_OPTION} -i #{input_file_name} -o output.txt /usr/bin/ruby #{program_name} "
                 when "python"
-            -     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{mem_limit} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python #{program_name} "
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[128 * 1024,mem_limit].max} #{PYTHON_OPTION} -i #{input_file_name} -o output.txt /usr/bin/python3 #{program_name} "
+            +   when "haskell"
+            +     run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{[512 * 1024,mem_limit].max} #{HASKELL_OPTION} -i #{input_file_name} -o output.txt #{program_name} "
                 when "php"
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit*=2} -m #{[128 * 1024,mem_limit].max} #{PHP_OPTION} -i #{input_file_name} -o output.txt /usr/bin/php -A -d -A memory_limit=#{mem_limit}k -A #{program_name} "
                 else # for c++, pascal, we do the normal checking
                   run_command = "#{problem_home}/script/box -a 2 -f -T -t #{time_limit} -m #{mem_limit} -i #{input_file_name} -o output.txt #{program_name} "
               end
               log "Running test #{test_num}..."
               log run_command
               log
               system(run_command,err: 'run_result')
               # Restore PROBLEM_HOME
               ENV['PROBLEM_HOME'] = problem_home
               # Create the result file.
               result_file = File.new("result", "w")
               comment_file = File.new("comment", "w")
               # Check if the program actually produced any output.
               run_result_file = File.new("run_result", "r")
               run_result = run_result_file.readlines
               run_result_file.close
               run_stat = run_result[run_result.length-1]
               running_time = extract_time(run_stat)
               report = lambda{ |status, points, comment|
                 result_file.write status.strip
                 result_file.write "\n"
                 result_file.write points.to_s.strip
                 result_file.write "\n"
                 result_file.write run_stat.strip
                 result_file.write "\n"
                 result_file.close
                 FileUtils.rm "run_result"
                 # `rm output.txt`   --- keep the output
                 comment_file.write comment
                 # added for debuggin --- jittat
                 comment_file.write "--run-result--\n"
                 run_result.each do |l|
                   comment_file.write l
                 end
                 comment_file.close
                 log "Done!"
                 exit(0)
               }
               if run_result[0][0,2] != "OK"
                 log "There was a runtime error."
                 report.call(run_result[0], 0, "No comment.\n")
               end
               if running_time[:user].to_f > time_limit
                 log "Time limit exceeded."
                 report.call("Time limit exceeded", 0, "No comment.\n")
               end
               # Run 'check' to evaluate the output.
               #puts "There was no runtime error. Proceed to checking the output."
               check_command = "#{problem_home}/script/check #{language} #{test_num}"
               log "Checking the output..."
               log check_command
               if not system(check_command)
                 log "Problem with check script"
                 report.call("Incorrect",0,"Check script error.\n")
                 exit(127)
               end
               check_file = File.new("check_result", "r")
               check_file_lines = check_file.readlines
               report.call(check_file_lines[0], check_file_lines[1], "No comment.\n")

templates/check.float ¶ +9

               #!/usr/bin/env ruby
               problem_home = ENV['PROBLEM_HOME']
               require "#{problem_home}/script/test_dsl.rb"
               if ARGV.length < 2
                 puts "Usage: check <language> <test-number> [<output-file>]"
                 exit(0)
               end
               language = ARGV[0]
               test_num = ARGV[1].to_i
               if ARGV.length >= 3
                 output_file_name = ARGV[2]
               else
                 output_file_name = "output.txt"
               end
               load "#{problem_home}/test_cases/all_tests.cfg"
               problem = Problem.get_instance
               output_file = File.new(output_file_name, "r")
               answer_file = File.new("#{problem_home}/test_cases/#{test_num}/answer-#{test_num}.txt")
               result_file = File.new("check_result", "w")
               output_file_content = output_file.read
               answer_file_content = answer_file.read
               report_correct = lambda {
                 result_file.write "Correct\n"
                 result_file.write problem.get_score(test_num)
                 result_file.write "\n"
                 result_file.close
                 exit(0)
               }
               report_wrong = lambda {
                 result_file.write "Incorrect\n"
                 result_file.write "0\n"
                 result_file.close
                 exit(0)
               }
               ##################
               # Your code here #
               ##################
               ########### THIS IS FOR CHECKING FLOAT with EPSILON error ##########
+            +
+            + def is_float?(fl)
+            +   !!Float(fl) rescue false
+            + end
+            +
               EPSILON = 0.000001
               out_items = output_file_content.split
               ans_items = answer_file_content.split
               if out_items.length != ans_items.length
                 report_wrong.call
               else
                 out_items.length.times do |i|
+            +     if is_float?(out_items[i]) && is_float?(ans_items[i])
                     out_value = out_items[i].to_f
                     ans_value = ans_items[i].to_f
                     if (out_value - ans_value).abs > EPSILON * [out_value.abs,ans_value.abs].max
                       report_wrong.call
                     end
+            +     else
+            +       report_wrong.call if out_items[i] != ans_items[i]
+            +     end
                 end
                 report_correct.call
               end

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r263:7950cf0bb006 - Sat, 17 Jun 2017 06:22:31 - 12 files changed: 420 inserted, 12 deleted

Sign in to your account

Commit r263:7950cf0bb006 public

Author

r263:7950cf0bb006 - Sat, 17 Jun 2017 06:22:31 - 12 files changed: 420 inserted, 12 deleted

Commit `r263:7950cf0bb006` public