cafe-grader-web

Commit r177:5f8c24384d1c public

parent | child
Description:
added .gitignore to hold empty dirs, fixed deprecation warnings on const char* for box.cc git-svn-id: http://theory.cpe.ku.ac.th/grader/web/trunk@379 6386c4cd-e34a-4fa8-8920-d93eb39b512e
Commit status:
[Not Reviewed]
References:
default
Diff options:
Raw Diff | Patch Diff | Download Diff | Ignore whitespace | Increase context
Comments:
0 Commit comments 0 Inline Comments
Unresolved TODOs:
There are no unresolved TODOs
Side by Side Unified
Expand All Files Collapse All Files Wide Mode Diff
Add another comment
Browse Files

r177:5f8c24384d1c - - 4 files changed: 6 inserted, 2 deleted

Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -0,0 +1,2
1 + [^.]*
2 +
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -0,0 +1,1
1 + [^.]*
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -0,0 +1,1
1 + [^.]*
Show file before | Show file after | Raw diff | Download diff | Ignore whitespace Increase context Show commentsHide comments
@@ -1,506 +1,506
1 1 /*
2 2 * A Simple Testing Sandbox
3 3 *
4 4 * (c) 2001--2004 Martin Mares <mj@ucw.cz>
5 5 */
6 6
7 7 #define _LARGEFILE64_SOURCE
8 8 //#define _GNU_SOURCE
9 9
10 10 #include <errno.h>
11 11 #include <stdio.h>
12 12 #include <fcntl.h>
13 13 #include <stdlib.h>
14 14 #include <string.h>
15 15 #include <stdarg.h>
16 16 #include <unistd.h>
17 17 #include <getopt.h>
18 18 #include <time.h>
19 19 #include <sys/wait.h>
20 20 #include <sys/user.h>
21 21 #include <sys/time.h>
22 22 #include <sys/ptrace.h>
23 23 #include <sys/signal.h>
24 24 #include <sys/sysinfo.h>
25 25 #include <sys/syscall.h>
26 26 #include <sys/resource.h>
27 27
28 28 #define NONRET __attribute__((noreturn))
29 29 #define UNUSED __attribute__((unused))
30 30
31 31 static int filter_syscalls; /* 0=off, 1=liberal, 2=totalitarian */
32 32 static double timeout;
33 33 static int pass_environ;
34 34 static int use_wall_clock;
35 35 static int file_access;
36 36 static int verbose;
37 37 static int memory_limit;
38 38 static int allow_times;
39 39 static char *redir_stdin, *redir_stdout;
40 40 static char *set_cwd;
41 41
42 42 static pid_t box_pid;
43 43 static int is_ptraced;
44 44 static volatile int timer_tick;
45 45 static time_t start_time;
46 46 static int ticks_per_sec;
47 47 static int page_size;
48 48
49 49 #if defined(__GLIBC__) && __GLIBC__ == 2 && __GLIBC_MINOR__ > 0
50 50 /* glibc 2.1 or newer -> has lseek64 */
51 51 #define long_seek(f,o,w) lseek64(f,o,w)
52 52 #else
53 53 /* Touching clandestine places in glibc */
54 54 extern loff_t llseek(int fd, loff_t pos, int whence);
55 55 #define long_seek(f,o,w) llseek(f,o,w)
56 56 #endif
57 57
58 58 int max_mem_used = 0;
59 59
60 60 void print_running_stat(double wall_time,
61 61 double user_time,
62 62 double system_time,
63 63 int mem_usage)
64 64 {
65 65 fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dm\n",
66 66 wall_time, user_time, system_time, mem_usage);
67 67 }
68 68
69 69 static void NONRET
70 70 box_exit(void)
71 71 {
72 72 if (box_pid > 0) {
73 73 if (is_ptraced)
74 74 ptrace(PTRACE_KILL, box_pid);
75 75 kill(-box_pid, SIGKILL);
76 76 kill(box_pid, SIGKILL);
77 77 }
78 78
79 79 struct timeval total;
80 80 int wall;
81 81 struct rusage rus;
82 82 int stat;
83 83 pid_t p;
84 84
85 85 // wait so that we can get information
86 86 p = wait4(box_pid, &stat, WUNTRACED, &rus);
87 87 if (p < 0) {
88 88 fprintf(stderr,"wait4: error\n");
89 89 print_running_stat(0,0,0,max_mem_used);
90 90 } else if (p != box_pid) {
91 91 fprintf(stderr,"wait4: unknown pid %d exited!\n", p);
92 92 print_running_stat(0,0,0,max_mem_used);
93 93 } else {
94 94 if (!WIFEXITED(stat))
95 95 fprintf(stderr,"wait4: unknown status\n");
96 96 struct timeval total;
97 97 int wall;
98 98 wall = time(NULL) - start_time;
99 99 timeradd(&rus.ru_utime, &rus.ru_stime, &total);
100 100
101 101 print_running_stat((double)wall,
102 102 (double) rus.ru_utime.tv_sec +
103 103 ((double) rus.ru_utime.tv_usec/1000000.0),
104 104 (double) rus.ru_stime.tv_sec +
105 105 ((double) rus.ru_stime.tv_usec/1000000.0),
106 106 max_mem_used);
107 107 }
108 108 exit(1);
109 109 }
110 110
111 111 static void NONRET __attribute__((format(printf,1,2)))
112 - die(char *msg, ...)
112 + die(const char *msg, ...)
113 113 {
114 114 va_list args;
115 115 va_start(args, msg);
116 116 vfprintf(stderr, msg, args);
117 117 fputc('\n', stderr);
118 118 box_exit();
119 119 }
120 120
121 121 static void __attribute__((format(printf,1,2)))
122 - log(char *msg, ...)
122 + log(const char *msg, ...)
123 123 {
124 124 va_list args;
125 125 va_start(args, msg);
126 126 if (verbose)
127 127 {
128 128 vfprintf(stderr, msg, args);
129 129 fflush(stderr);
130 130 }
131 131 va_end(args);
132 132 }
133 133
134 134 static void
135 135 valid_filename(unsigned long addr)
136 136 {
137 137 char namebuf[4096], *p, *end;
138 138 static int mem_fd;
139 139
140 140 if (!file_access)
141 141 die("File access forbidden.");
142 142 if (file_access >= 9)
143 143 return;
144 144
145 145 if (!mem_fd)
146 146 {
147 147 sprintf(namebuf, "/proc/%d/mem", (int) box_pid);
148 148 mem_fd = open(namebuf, O_RDONLY);
149 149 if (mem_fd < 0)
150 150 die("open(%s): %m", namebuf);
151 151 }
152 152 p = end = namebuf;
153 153 do
154 154 {
155 155 if (p >= end)
156 156 {
157 157 int remains = PAGE_SIZE - (addr & (PAGE_SIZE-1));
158 158 int l = namebuf + sizeof(namebuf) - end;
159 159 if (l > remains)
160 160 l = remains;
161 161 if (!l)
162 162 die("Access to file with name too long.");
163 163 if (long_seek(mem_fd, addr, SEEK_SET) < 0)
164 164 die("long_seek(mem): %m");
165 165 remains = read(mem_fd, end, l);
166 166 if (remains < 0)
167 167 die("read(mem): %m");
168 168 if (!remains)
169 169 die("Access to file with name out of memory.");
170 170 end += l;
171 171 addr += l;
172 172 }
173 173 }
174 174 while (*p++);
175 175
176 176 log("[%s] ", namebuf);
177 177 if (file_access >= 3)
178 178 return;
179 179 if (!strchr(namebuf, '/') && strcmp(namebuf, ".."))
180 180 return;
181 181 if (file_access >= 2)
182 182 {
183 183 if ((!strncmp(namebuf, "/etc/", 5) ||
184 184 !strncmp(namebuf, "/lib/", 5) ||
185 185 !strncmp(namebuf, "/usr/lib/", 9))
186 186 && !strstr(namebuf, ".."))
187 187 return;
188 188 if (!strcmp(namebuf, "/dev/null") ||
189 189 !strcmp(namebuf, "/dev/zero") ||
190 190 !strcmp(namebuf, "/proc/meminfo") ||
191 191 !strcmp(namebuf, "/proc/self/stat") ||
192 192 !strncmp(namebuf, "/usr/share/zoneinfo/", 20))
193 193 return;
194 194 }
195 195 die("Forbidden access to file `%s'.", namebuf);
196 196 }
197 197
198 198 static int
199 199 valid_syscall(struct user *u)
200 200 {
201 201 switch (u->regs.orig_eax)
202 202 {
203 203 case __NR_execve:
204 204 {
205 205 static int exec_counter;
206 206 return !exec_counter++;
207 207 }
208 208 case __NR_open:
209 209 case __NR_creat:
210 210 case __NR_unlink:
211 211 case __NR_oldstat:
212 212 case __NR_access:
213 213 case __NR_oldlstat:
214 214 case __NR_truncate:
215 215 case __NR_stat:
216 216 case __NR_lstat:
217 217 case __NR_truncate64:
218 218 case __NR_stat64:
219 219 case __NR_lstat64:
220 220 valid_filename(u->regs.ebx);
221 221 return 1;
222 222 case __NR_exit:
223 223 case __NR_read:
224 224 case __NR_write:
225 225 case __NR_close:
226 226 case __NR_lseek:
227 227 case __NR_getpid:
228 228 case __NR_getuid:
229 229 case __NR_oldfstat:
230 230 case __NR_dup:
231 231 case __NR_brk:
232 232 case __NR_getgid:
233 233 case __NR_geteuid:
234 234 case __NR_getegid:
235 235 case __NR_dup2:
236 236 case __NR_ftruncate:
237 237 case __NR_fstat:
238 238 case __NR_personality:
239 239 case __NR__llseek:
240 240 case __NR_readv:
241 241 case __NR_writev:
242 242 case __NR_getresuid:
243 243 #ifdef __NR_pread64
244 244 case __NR_pread64:
245 245 case __NR_pwrite64:
246 246 #else
247 247 case __NR_pread:
248 248 case __NR_pwrite:
249 249 #endif
250 250 case __NR_ftruncate64:
251 251 case __NR_fstat64:
252 252 case __NR_fcntl:
253 253 case __NR_fcntl64:
254 254 case __NR_mmap:
255 255 case __NR_munmap:
256 256 case __NR_ioctl:
257 257 case __NR_uname:
258 258 case 252:
259 259 case 243:
260 260 // added for free pascal
261 261 case __NR_ugetrlimit:
262 262 case __NR_readlink:
263 263 return 1;
264 264 // case __NR_time:
265 265 case __NR_alarm:
266 266 // case __NR_pause:
267 267 case __NR_signal:
268 268 case __NR_fchmod:
269 269 case __NR_sigaction:
270 270 case __NR_sgetmask:
271 271 case __NR_ssetmask:
272 272 case __NR_sigsuspend:
273 273 case __NR_sigpending:
274 274 case __NR_getrlimit:
275 275 case __NR_getrusage:
276 276 case __NR_gettimeofday:
277 277 case __NR_select:
278 278 case __NR_readdir:
279 279 case __NR_setitimer:
280 280 case __NR_getitimer:
281 281 case __NR_sigreturn:
282 282 case __NR_mprotect:
283 283 case __NR_sigprocmask:
284 284 case __NR_getdents:
285 285 case __NR_getdents64:
286 286 case __NR__newselect:
287 287 case __NR_fdatasync:
288 288 case __NR_mremap:
289 289 case __NR_poll:
290 290 case __NR_getcwd:
291 291 case __NR_nanosleep:
292 292 case __NR_rt_sigreturn:
293 293 case __NR_rt_sigaction:
294 294 case __NR_rt_sigprocmask:
295 295 case __NR_rt_sigpending:
296 296 case __NR_rt_sigtimedwait:
297 297 case __NR_rt_sigqueueinfo:
298 298 case __NR_rt_sigsuspend:
299 299 case __NR_mmap2:
300 300 case __NR__sysctl:
301 301 return (filter_syscalls == 1);
302 302 case __NR_times:
303 303 case __NR_time:
304 304 return allow_times;
305 305 case __NR_kill:
306 306 if (u->regs.ebx == box_pid)
307 307 die("Commited suicide by signal %d.", (int)u->regs.ecx);
308 308 return 0;
309 309 default:
310 310 return 0;
311 311 }
312 312 }
313 313
314 314 static void
315 315 signal_alarm(int unused UNUSED)
316 316 {
317 317 /* Time limit checks are synchronous, so we only schedule them there. */
318 318 timer_tick = 1;
319 319
320 320 //NOTE: do not use alarm, changed to setitimer for precision
321 321 // alarm(1);
322 322 }
323 323
324 324 static void
325 325 signal_int(int unused UNUSED)
326 326 {
327 327 /* Interrupts are fatal, so no synchronization requirements. */
328 328 die("Interrupted.");
329 329 }
330 330
331 331 static void
332 332 check_timeout(void)
333 333 {
334 334 double sec;
335 335
336 336 if (use_wall_clock)
337 337 sec = (double)(time(NULL) - start_time);
338 338 else
339 339 {
340 340 char buf[4096], *x;
341 341 int c, utime, stime;
342 342 static int proc_status_fd;
343 343 if (!proc_status_fd)
344 344 {
345 345 sprintf(buf, "/proc/%d/stat", (int) box_pid);
346 346 proc_status_fd = open(buf, O_RDONLY);
347 347 if (proc_status_fd < 0)
348 348 die("open(%s): %m", buf);
349 349 }
350 350 lseek(proc_status_fd, 0, SEEK_SET);
351 351 if ((c = read(proc_status_fd, buf, sizeof(buf)-1)) < 0)
352 352 die("read on /proc/$pid/stat: %m");
353 353 if (c >= (int) sizeof(buf) - 1)
354 354 die("/proc/$pid/stat too long");
355 355 buf[c] = 0;
356 356 x = buf;
357 357 while (*x && *x != ' ')
358 358 x++;
359 359 while (*x == ' ')
360 360 x++;
361 361 if (*x++ != '(')
362 362 die("proc syntax error 1");
363 363 while (*x && (*x != ')' || x[1] != ' '))
364 364 x++;
365 365 while (*x == ')' || *x == ' ')
366 366 x++;
367 367 if (sscanf(x, "%*c %*d %*d %*d %*d %*d %*d %*d %*d %*d %*d %d %d", &utime, &stime) != 2)
368 368 die("proc syntax error 2");
369 369 //printf("%s - %d\n",x,ticks_per_sec);
370 370 sec = ((double)(utime + stime))/(double)ticks_per_sec;
371 371 }
372 372 if (verbose > 1)
373 373 fprintf(stderr, "[timecheck: %d seconds]\n", sec);
374 374 if (sec > timeout) {
375 375 die("Time limit exceeded.",sec,timeout);
376 376 }
377 377 }
378 378
379 379 static void
380 380 check_memory_usage()
381 381 {
382 382 char proc_fname[100];
383 383 sprintf(proc_fname,"/proc/%d/statm",box_pid);
384 384 //printf("proc fname: %s\n",proc_fname);
385 385 FILE *fp = fopen(proc_fname,"r");
386 386 if(fp!=NULL) {
387 387 char line[1000];
388 388 fgets(line,999,fp);
389 389 //printf("%s\n",line);
390 390 int m;
391 391
392 392 if(sscanf(line,"%d",&m)==1) {
393 393 m = (m*page_size+1023)/1024;
394 394 if(m>max_mem_used)
395 395 max_mem_used = m;
396 396 }
397 397
398 398 fclose(fp);
399 399 }
400 400 }
401 401
402 402 static void
403 403 boxkeeper(void)
404 404 {
405 405 int syscall_count = 0;
406 406 struct sigaction sa;
407 407
408 408 is_ptraced = 1;
409 409 bzero(&sa, sizeof(sa));
410 410 sa.sa_handler = signal_int;
411 411 sigaction(SIGINT, &sa, NULL);
412 412 start_time = time(NULL);
413 413 ticks_per_sec = sysconf(_SC_CLK_TCK);
414 414 page_size = getpagesize();
415 415 if (ticks_per_sec <= 0)
416 416 die("Invalid ticks_per_sec!");
417 417
418 418 check_memory_usage();
419 419
420 420 sa.sa_handler = signal_alarm;
421 421 sigaction(SIGALRM, &sa, NULL);
422 422 //alarm(1);
423 423
424 424 struct itimerval val;
425 425 val.it_interval.tv_sec = 0;
426 426 val.it_interval.tv_usec = 50000;
427 427 val.it_value.tv_sec = 0;
428 428 val.it_value.tv_usec = 50000;
429 429 setitimer(ITIMER_REAL,&val,NULL);
430 430
431 431 /*
432 432 --- add alarm handler no matter what..
433 433 if (timeout)
434 434 {
435 435 sa.sa_handler = signal_alarm;
436 436 sigaction(SIGALRM, &sa, NULL);
437 437 alarm(1);
438 438 }
439 439 */
440 440
441 441 for(;;)
442 442 {
443 443 struct rusage rus;
444 444 int stat;
445 445 pid_t p;
446 446
447 447 if (timer_tick)
448 448 {
449 449 check_timeout();
450 450 check_memory_usage();
451 451 timer_tick = 0;
452 452 }
453 453 p = wait4(box_pid, &stat, WUNTRACED, &rus);
454 454
455 455 if (p < 0)
456 456 {
457 457 if (errno == EINTR)
458 458 continue;
459 459 die("wait4: %m");
460 460 }
461 461 if (p != box_pid)
462 462 die("wait4: unknown pid %d exited!", p);
463 463 if (WIFEXITED(stat))
464 464 {
465 465 struct timeval total;
466 466 int wall;
467 467 wall = time(NULL) - start_time;
468 468 timeradd(&rus.ru_utime, &rus.ru_stime, &total);
469 469
470 470 box_pid = 0;
471 471 if (WEXITSTATUS(stat))
472 472 fprintf(stderr,"Exited with error status %d.\n", WEXITSTATUS(stat));
473 473 else if ((use_wall_clock ?
474 474 wall :
475 475 (double) total.tv_sec +
476 476 ((double) total.tv_usec/1000000.0)) > timeout)
477 477 fprintf(stderr,"Time limit exceeded.\n");
478 478 else
479 479 // report OK and statistics
480 480 fprintf(stderr,"OK\n");
481 481
482 482 print_running_stat((double) wall,
483 483 (double) rus.ru_utime.tv_sec +
484 484 ((double) rus.ru_utime.tv_usec/1000000.0),
485 485 (double) rus.ru_stime.tv_sec +
486 486 ((double) rus.ru_stime.tv_usec/1000000.0),
487 487 max_mem_used);
488 488 /*
489 489 (%.4lf sec real (%d), %d sec wall, %d syscalls, %d kb)\n",
490 490 (double) total.tv_sec + ((double)total.tv_usec / 1000000.0),
491 491 (int) total.tv_usec,
492 492 wall,
493 493 syscall_count,
494 494 max_mem_used);
495 495 */
496 496 exit(0);
497 497 }
498 498 if (WIFSIGNALED(stat))
499 499 {
500 500 box_pid = 0;
501 501 fprintf(stderr,"Caught fatal signal %d.\n", WTERMSIG(stat));
502 502
503 503 struct timeval total;
504 504 int wall;
505 505 wall = time(NULL) - start_time;
506 506 timeradd(&rus.ru_utime, &rus.ru_stime, &total);
You need to be logged in to leave comments. Login now