cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r53:45abc6ae27d1` public

parent | child

Description:

[grader] fixed to work with free pascal git-svn-id: http://theory.cpe.ku.ac.th/grader/judge/trunk/scripts@221 6386c4cd-e34a-4fa8-8920-d93eb39b512e

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r53:45abc6ae27d1 - Sat, 03 May 2008 06:57:14 - 3 files changed: 10 inserted, 7 deleted

std-script/box.cc ¶ +3

               static void NONRET
               box_exit(void)
               {
                 if (box_pid > 0) {
                   if (is_ptraced)
                     ptrace(PTRACE_KILL, box_pid);
                   kill(-box_pid, SIGKILL);
                   kill(box_pid, SIGKILL);
                 }
                 struct timeval total;
                 int wall;
                 struct rusage rus;
                 int stat;
                 pid_t p;
                 // wait so that we can get information
                 p = wait4(box_pid, &stat, WUNTRACED, &rus);
                 if (p < 0) {
                   fprintf(stderr,"wait4: error\n");
                   print_running_stat(0,0,0,max_mem_used);
                 } else if (p != box_pid) {
                   fprintf(stderr,"wait4: unknown pid %d exited!\n", p);
                   print_running_stat(0,0,0,max_mem_used);
                 } else {
                   if (!WIFEXITED(stat))
                     fprintf(stderr,"wait4: unknown status\n");
                   struct timeval total;
                   int wall;
                   wall = time(NULL) - start_time;
                   timeradd(&rus.ru_utime, &rus.ru_stime, &total);
                   print_running_stat((double)wall,
               		       (double) rus.ru_utime.tv_sec +
               		       ((double) rus.ru_utime.tv_usec/1000000.0),
               		       (double) rus.ru_stime.tv_sec +
               		       ((double) rus.ru_stime.tv_usec/1000000.0),
               		       max_mem_used);
                 }
                 exit(1);
               }
               static void NONRET __attribute__((format(printf,1,2)))
               die(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 vfprintf(stderr, msg, args);
                 fputc('\n', stderr);
                 box_exit();
               }
               static void __attribute__((format(printf,1,2)))
               log(char *msg, ...)
               {
                 va_list args;
                 va_start(args, msg);
                 if (verbose)
                   {
                     vfprintf(stderr, msg, args);
                     fflush(stderr);
                   }
                 va_end(args);
               }
               static void
               valid_filename(unsigned long addr)
               {
                 char namebuf[4096], *p, *end;
                 static int mem_fd;
                 if (!file_access)
                   die("File access forbidden.");
                 if (file_access >= 9)
                   return;
                 if (!mem_fd)
                   {
                     sprintf(namebuf, "/proc/%d/mem", (int) box_pid);
                     mem_fd = open(namebuf, O_RDONLY);
                     if (mem_fd < 0)
               	die("open(%s): %m", namebuf);
                   }
                 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)
               	    die("Access to file with name too long.");
               	  if (long_seek(mem_fd, addr, SEEK_SET) < 0)
               	    die("long_seek(mem): %m");
               	  remains = read(mem_fd, end, l);
               	  if (remains < 0)
               	    die("read(mem): %m");
               	  if (!remains)
               	    die("Access to file with name out of memory.");
               	  end += l;
               	  addr += l;
               	}
                   }
                 while (*p++);
                 log("[%s] ", namebuf);
                 if (file_access >= 3)
                   return;
                 if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
                   return;
                 if (file_access >= 2)
                   {
                     if ((!strncmp(namebuf, "/etc/", 5) ||
               	   !strncmp(namebuf, "/lib/", 5) ||
               	   !strncmp(namebuf, "/usr/lib/", 9))
               	  && !strstr(namebuf, ".."))
               	return;
                     if (!strcmp(namebuf, "/dev/null") ||
               	  !strcmp(namebuf, "/dev/zero") ||
               	  !strcmp(namebuf, "/proc/meminfo") ||
               	  !strcmp(namebuf, "/proc/self/stat") ||
               	  !strncmp(namebuf, "/usr/share/zoneinfo/", 20))
               	return;
                   }
                 die("Forbidden access to file `%s'.", namebuf);
               }
               static int
               valid_syscall(struct user *u)
               {
                 switch (u->regs.orig_eax)
                   {
                   case __NR_execve:
                     {
               	static int exec_counter;
               	return !exec_counter++;
                     }
                   case __NR_open:
                   case __NR_creat:
                   case __NR_unlink:
                   case __NR_oldstat:
                   case __NR_access:
                   case __NR_oldlstat:
                   case __NR_truncate:
                   case __NR_stat:
                   case __NR_lstat:
                   case __NR_truncate64:
                   case __NR_stat64:
                   case __NR_lstat64:
                     valid_filename(u->regs.ebx);
                     return 1;
                   case __NR_exit:
                   case __NR_read:
                   case __NR_write:
                   case __NR_close:
                   case __NR_lseek:
                   case __NR_getpid:
                   case __NR_getuid:
                   case __NR_oldfstat:
                   case __NR_dup:
                   case __NR_brk:
                   case __NR_getgid:
                   case __NR_geteuid:
                   case __NR_getegid:
                   case __NR_dup2:
                   case __NR_ftruncate:
                   case __NR_fstat:
                   case __NR_personality:
                   case __NR__llseek:
                   case __NR_readv:
                   case __NR_writev:
                   case __NR_getresuid:
               #ifdef __NR_pread64
                   case __NR_pread64:
                   case __NR_pwrite64:
               #else
                   case __NR_pread:
                   case __NR_pwrite:
               #endif
                   case __NR_ftruncate64:
                   case __NR_fstat64:
                   case __NR_fcntl:
                   case __NR_fcntl64:
                   case __NR_mmap:
                   case __NR_munmap:
                   case __NR_ioctl:
                   case __NR_uname:
                   case 252:
                   case 243:
+            + // added for free pascal
+            +     case __NR_ugetrlimit:
+            +     case __NR_readlink:
                     return 1;
                     //    case __NR_time:
                   case __NR_alarm:
                     //    case __NR_pause:
                   case __NR_signal:
                   case __NR_fchmod:
                   case __NR_sigaction:
                   case __NR_sgetmask:
                   case __NR_ssetmask:
                   case __NR_sigsuspend:
                   case __NR_sigpending:
                   case __NR_getrlimit:
                   case __NR_getrusage:
                   case __NR_gettimeofday:
                   case __NR_select:
                   case __NR_readdir:
                   case __NR_setitimer:
                   case __NR_getitimer:
                   case __NR_sigreturn:
                   case __NR_mprotect:
                   case __NR_sigprocmask:
                   case __NR_getdents:
                   case __NR_getdents64:
                   case __NR__newselect:
                   case __NR_fdatasync:
                   case __NR_mremap:
                   case __NR_poll:
                   case __NR_getcwd:
                   case __NR_nanosleep:
                   case __NR_rt_sigreturn:
                   case __NR_rt_sigaction:
                   case __NR_rt_sigprocmask:
                   case __NR_rt_sigpending:
                   case __NR_rt_sigtimedwait:
                   case __NR_rt_sigqueueinfo:
                   case __NR_rt_sigsuspend:
                   case __NR_mmap2:
                   case __NR__sysctl:
                     return (filter_syscalls == 1);
                   case __NR_times:
                     return allow_times;
                   case __NR_kill:
                     if (u->regs.ebx == box_pid)
               	die("Commited suicide by signal %d.", (int)u->regs.ecx);
                     return 0;
                   default:
                     return 0;
                   }
               }
               static void
               signal_alarm(int unused UNUSED)
               {
                 /* Time limit checks are synchronous, so we only schedule them there. */
                 timer_tick = 1;
                 //NOTE: do not use alarm, changed to setitimer for precision
                 //  alarm(1);
               }
               static void
               signal_int(int unused UNUSED)
               {
                 /* Interrupts are fatal, so no synchronization requirements. */
                 die("Interrupted.");
               }
               static void
               check_timeout(void)
               {
                 double sec;
                 if (use_wall_clock)
                   sec = (double)(time(NULL) - start_time);
                 else
                   {
                     char buf[4096], *x;
                     int c, utime, stime;
                     static int proc_status_fd;
                     if (!proc_status_fd)
               	{
               	  sprintf(buf, "/proc/%d/stat", (int) box_pid);
               	  proc_status_fd = open(buf, O_RDONLY);
               	  if (proc_status_fd < 0)
               	    die("open(%s): %m", buf);
               	}
                     lseek(proc_status_fd, 0, SEEK_SET);
                     if ((c = read(proc_status_fd, buf, sizeof(buf)-1)) < 0)
               	die("read on /proc/$pid/stat: %m");
                     if (c >= (int) sizeof(buf) - 1)
               	die("/proc/$pid/stat too long");
                     buf[c] = 0;
                     x = buf;
                     while (*x && *x != ' ')
               	x++;
                     while (*x == ' ')
               	x++;
                     if (*x++ != '(')
               	die("proc 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 syntax error 2");
                     //printf("%s - %d\n",x,ticks_per_sec);
                     sec = ((double)(utime + stime))/(double)ticks_per_sec;
                   }
                 if (verbose > 1)
                   fprintf(stderr, "[timecheck: %d seconds]\n", sec);
                 if (sec > timeout) {
                   die("Time limit exceeded.",sec,timeout);
                 }
               }
               static void
               check_memory_usage()
               {
                 char proc_fname[100];
                 sprintf(proc_fname,"/proc/%d/statm",box_pid);
                 //printf("proc fname: %s\n",proc_fname);
                 FILE *fp = fopen(proc_fname,"r");
                 if(fp!=NULL) {
                   char line[1000];
                   fgets(line,999,fp);
                   //printf("%s\n",line);
                   int m;
                   if(sscanf(line,"%d",&m)==1) {
                     m = (m*page_size+1023)/1024;
                     if(m>max_mem_used)
               	max_mem_used = m;
                   }
                   fclose(fp);
                 }
               }
               static void
               boxkeeper(void)
               {
                 int syscall_count = 0;
                 struct sigaction sa;
                 is_ptraced = 1;
                 bzero(&sa, sizeof(sa));
                 sa.sa_handler = signal_int;
                 sigaction(SIGINT, &sa, NULL);
                 start_time = time(NULL);
                 ticks_per_sec = sysconf(_SC_CLK_TCK);
                 page_size = getpagesize();
                 if (ticks_per_sec <= 0)
                   die("Invalid ticks_per_sec!");
                 check_memory_usage();
                 sa.sa_handler = signal_alarm;
                 sigaction(SIGALRM, &sa, NULL);
                 //alarm(1);
                 struct itimerval val;
                 val.it_interval.tv_sec = 0;
                 val.it_interval.tv_usec = 50000;
                 val.it_value.tv_sec = 0;
                 val.it_value.tv_usec = 50000;
                 setitimer(ITIMER_REAL,&val,NULL);
                 /*
                   --- add alarm handler no matter what..
                 if (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();
               	  check_memory_usage();
               	  timer_tick = 0;
               	}
                     p = wait4(box_pid, &stat, WUNTRACED, &rus);
                     if (p < 0)

std-script/compile ¶ +5 -5

               #!/bin/sh
               ##############################
               #
               # Standard Compile Script
               #
               # Supported compilers:
-            - #   gcc, g++, and gpc.
+            + #   gcc, g++, and fpc.
               #
               ##############################
               talk ()
               {
                   if [ "$TALKATIVE" != "" ]; then
               	echo "$1"
                   fi
               }
               export C_COMPILER=/usr/bin/gcc
               export CPLUSPLUS_COMPILER=/usr/bin/g++
-            - export PASCAL_COMPILER=/usr/bin/gpc
+            + export PASCAL_COMPILER=/usr/bin/fpc
               export C_OPTIONS="-O2 -s -static -lm -Wall"
               export CPLUSPLUS_OPTIONS="-O2 -s -static -lm -Wall"
-            - export PASCAL_OPTIONS="-O2 -XS -lm -Wall"
+            + export PASCAL_OPTIONS="-O1 -XS"
               # Check for the correct number of arguments. Otherwise, print usage.
               if [ $# -eq 0 -o $# -gt 4 ]
               then
                   echo "Usage: $0 <language> [<source-file>] [<output-file>] [<message-file>]"
                   echo
                   echo "<source-file>  is defaulted to \"source\"."
                   echo "<output-file>  is defaulted to \"a.out\"."
                   echo "<message-file> is defaulted to \"compiler_message\"."
                   echo
                   exit 127
               fi
               # Retrieve the arguments.
               if [ $# -ge 1 ]
               then
                   export PROG_LANG=$1
                   talk "programming language: ${PROG_LANG}"
               fi
               if [ $# -ge 2 ]
               then
                   export SOURCE_FILE=$2
               else
                   export SOURCE_FILE=source
               fi
               talk "         source file: $SOURCE_FILE"
               if [ $# -ge 3 ]
               then
                   export OUTPUT_FILE=$3
               else
                   export OUTPUT_FILE=a.out
               fi
               talk "         output file: $OUTPUT_FILE"
               if [ $# -eq 4 ]
               then
                   export MESSAGE_FILE=$4
               else
                   export MESSAGE_FILE=compiler_message
               fi
               talk "        message file: $MESSAGE_FILE"
               # Remove any remaining output files or message files.
               rm -Rf $OUTPUT_FILE
               rm -Rf $MESSAGE_FILE
               # Check if the source file exists before attempt compiling.
               if [ ! -f $SOURCE_FILE ]
               then
                   talk "ERROR: The source file does not exist!"
                   echo "ERROR: The source file did not exist." > $MESSAGE_FILE
                   exit 127
               fi
               # Compile.
               if [ $PROG_LANG = "c" ]
               then
                   $C_COMPILER $SOURCE_FILE -o $OUTPUT_FILE $C_OPTIONS 2>$MESSAGE_FILE
               elif [ $PROG_LANG = "c++" ]
               then
                   $CPLUSPLUS_COMPILER $SOURCE_FILE -o $OUTPUT_FILE $CPLUSPLUS_OPTIONS 2>$MESSAGE_FILE
-            - elif [ $PROG_LANG = "pascal" ]
+            + elif [ $PROG_LANG = "pas" ]
               then
-            -     $PASCAL_COMPILER $SOURCE_FILE -o $OUTPUT_FILE $PASCAL_OPTIONS 2>$MESSAGE_FILE
+            +     $PASCAL_COMPILER $SOURCE_FILE -o$OUTPUT_FILE $PASCAL_OPTIONS >$MESSAGE_FILE
               else
                   talk "ERROR: Invalid language specified!"
                   echo "ERROR: Invalid language specified!" > $MESSAGE_FILE
                   exit 127
               fi
               # Report success or failure.
               if [ -f $OUTPUT_FILE ]
               then
                   talk "Compilation was successful!"
               else
                   talk "ERROR: Something was wrong during the compilation!"
                   talk "Dumping compiler message:"
                   #cat $MESSAGE_FILE
               fi

std-script/judge ¶ +2 -2

               #!/usr/bin/ruby
               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
               # 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 != "pascal"
+            + if language != "c" && language != "c++" && language != "pas"
-            -   log "You specified a language that is not supported."
+            +   log "You specified a language that is not supported: #{language}."
                 exit(127)
               end
               source_file = ARGV[1]
               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 = `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}"
               system("rm -Rf #{test_result_dir}")
               execute("mkdir #{test_result_dir}", "Cannot make directory #{test_result_dir}.")
               if ARGV.length >= 4
                 sandbox_dir = ARGV[3]
               else
                 sandbox_dir = "#{current_dir}/sandbox"
               end
               log "Sandbox directory: #{sandbox_dir}"
               system("rm -Rf #{sandbox_dir}")
               execute("mkdir #{sandbox_dir}", "Cannot make directory #{sandbox_dir}")
               # Compile
               log
               log "Compiling..."
               execute("cp #{source_file} #{sandbox_dir}", "Cannot copy the source file to #{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 = `cat compiler_message`
               compile_message.strip!
               execute("mv compiler_message #{test_result_dir}", "Cannot move the compiler message to #{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
                 execute("mv a.out #{test_result_dir}", "Cannot move the compiled program to #{test_result_dir}")
                 system("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|
                 log "Test number: #{test_num}"
                 execute("cp #{test_result_dir}/a.out #{sandbox_dir}", "Cannot copy the compiled program into #{sandbox_dir}")
                 begin
                   execute("#{problem_home}/script/run #{language} #{test_num}", "Error occured during execution of the run script")
                 rescue
                   # do nothing
                 end
                 execute("mkdir #{test_result_dir}/#{test_num}", "Cannot create directory #{test_result_dir}/#{test_num}")
                 execute("mv #{sandbox_dir}/result #{test_result_dir}/#{test_num}", "Cannot copy the result file into #{test_result_dir}/#{test_num}")
                 execute("mv #{sandbox_dir}/comment #{test_result_dir}/#{test_num}", "Cannot copy the comment file into #{test_result_dir}/#{test_num}")
                 execute("mv #{sandbox_dir}/output.txt #{test_result_dir}/#{test_num}", "Cannot copy the output file into #{test_result_dir}/#{test_num}")
                 execute("rm -Rf #{sandbox_dir}/*", "Cannot clear #{sandbox_dir}")
               end
               # 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!"

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

r53:45abc6ae27d1 - Sat, 03 May 2008 06:57:14 - 3 files changed: 10 inserted, 7 deleted

Sign in to your account

Commit r53:45abc6ae27d1 public

Author

r53:45abc6ae27d1 - Sat, 03 May 2008 06:57:14 - 3 files changed: 10 inserted, 7 deleted

Commit `r53:45abc6ae27d1` public