← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/interpret.py

  • Committer: William Grant
  • Date: 2010-07-20 04:52:31 UTC
  • mto: This revision was merged to the branch mainline in revision 1826.
  • Revision ID: grantw@unimelb.edu.au-20100720045231-8ia3uk8nao8zdq1i
Replace cjson with json, or simplejson if json is not available (Python <2.6)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/interpret.py
21
21
 
22
22
# Runs a student script in a safe execution environment.
23
23
 
 
24
import ivle
24
25
from ivle import studpath
25
 
from ivle.util import IVLEError, IVLEJailError
26
 
import ivle.conf
 
26
from ivle.util import IVLEJailError, split_path
27
27
 
28
28
import functools
29
29
 
37
37
# working on smaller output
38
38
 
39
39
CGI_BLOCK_SIZE = 65535
 
40
PATH = "/usr/local/bin:/usr/bin:/bin"
40
41
 
41
42
def interpret_file(req, owner, jail_dir, filename, interpreter, gentle=True):
42
43
    """Serves a file by interpreting it using one of IVLE's builtin
73
74
    # (Note that paths "relative" to the jail actually begin with a '/' as
74
75
    # they are absolute in the jailspace)
75
76
 
76
 
    return interpreter(owner.unixid, jail_dir, working_dir, filename_abs, req,
 
77
    return interpreter(owner, jail_dir, working_dir, filename_abs, req,
77
78
                       gentle)
78
79
 
79
80
class CGIFlags:
88
89
        self.linebuf = ""
89
90
        self.headers = {}       # Header names : values
90
91
 
91
 
def execute_cgi(interpreter, trampoline, uid, jail_dir, working_dir,
92
 
                script_path, req, gentle):
 
92
def execute_cgi(interpreter, owner, jail_dir, working_dir, script_path,
 
93
                req, gentle):
93
94
    """
94
95
    trampoline: Full path on the local system to the CGI wrapper program
95
96
        being executed.
96
 
    uid: User ID of the owner of the file.
 
97
    owner: User object of the owner of the file.
97
98
    jail_dir: Absolute path of owner's jail directory.
98
99
    working_dir: Directory containing the script file relative to owner's
99
100
        jail.
105
106
    its environment.
106
107
    """
107
108
 
 
109
    trampoline = os.path.join(req.config['paths']['lib'], 'trampoline')
 
110
 
108
111
    # Support no-op trampoline runs.
109
112
    if interpreter is None:
110
113
        interpreter = '/bin/true'
127
130
        f.seek(0)       # Rewind, for reading
128
131
 
129
132
    # Set up the environment
130
 
    # This automatically asks mod_python to load up the CGI variables into the
131
 
    # environment (which is a good first approximation)
132
 
    old_env = os.environ.copy()
133
 
    for k in os.environ.keys():
134
 
        del os.environ[k]
135
 
    for (k,v) in req.get_cgi_environ().items():
136
 
        os.environ[k] = v
137
 
    fixup_environ(req)
 
133
    environ = cgi_environ(req, script_path, owner)
138
134
 
139
135
    # usage: tramp uid jail_dir working_dir script_path
140
 
    pid = subprocess.Popen(
141
 
        [trampoline, str(uid), jail_dir, working_dir, interpreter,
142
 
        script_path],
 
136
    cmd_line = [trampoline, str(owner.unixid),
 
137
            req.config['paths']['jails']['mounts'],
 
138
            req.config['paths']['jails']['src'],
 
139
            req.config['paths']['jails']['template'],
 
140
            jail_dir, working_dir, interpreter, script_path]
 
141
    # Popen doesn't like unicode strings. It hateses them.
 
142
    cmd_line = [(s.encode('utf-8') if isinstance(s, unicode) else s)
 
143
                for s in cmd_line]
 
144
    pid = subprocess.Popen(cmd_line,
143
145
        stdin=f, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
144
 
        cwd=tramp_dir)
145
 
 
146
 
    # Restore the environment
147
 
    for k in os.environ.keys():
148
 
        del os.environ[k]
149
 
    for (k,v) in old_env.items():
150
 
        os.environ[k] = v
 
146
        cwd=tramp_dir, env=environ)
151
147
 
152
148
    # We don't want any output! Bail out after the process terminates.
153
149
    if noop:
219
215
            if len(split) == 1:
220
216
                split = headers.split('\n', 1)
221
217
 
222
 
        # Is this an internal IVLE error condition?
223
 
        hs = cgiflags.headers
224
 
        if 'X-IVLE-Error-Type' in hs:
225
 
            t = hs['X-IVLE-Error-Type']
226
 
            if t == IVLEError.__name__:
227
 
                raise IVLEError(int(hs['X-IVLE-Error-Code']),
228
 
                                hs['X-IVLE-Error-Message'])
229
 
            else:
 
218
        # If not executing in gentle mode (which presents CGI violations
 
219
        # to users nicely), check if this an internal IVLE error
 
220
        # condition.
 
221
        if not cgiflags.gentle:
 
222
            hs = cgiflags.headers
 
223
            if 'X-IVLE-Error-Type' in hs:
230
224
                try:
231
225
                    raise IVLEJailError(hs['X-IVLE-Error-Type'],
232
226
                                        hs['X-IVLE-Error-Message'],
233
227
                                        hs['X-IVLE-Error-Info'])
234
228
                except KeyError:
235
 
                    raise IVLEError(500, 'bad error headers written by CGI')
 
229
                    raise AssertionError("Bad error headers written by CGI.")
236
230
 
237
231
        # Check to make sure the required headers were written
238
232
        if cgiflags.wrote_html_warning or not cgiflags.gentle:
292
286
        process_cgi_output(req, line + '\n', cgiflags)
293
287
        return
294
288
 
 
289
    # Check if CGI field-name is valid
 
290
    CGI_SEPERATORS = set(['(', ')', '<', '>', '@', ',', ';', ':', '\\', '"',
 
291
            '/', '[', ']', '?', '=', '{', '}', ' ', '\t'])
 
292
    if any((char in CGI_SEPERATORS for char in name)):
 
293
        warning = "Warning"
 
294
        if not cgiflags.gentle:
 
295
            message = """An unexpected server error has occured."""
 
296
            warning = "Error"
 
297
        else:
 
298
            # Header contained illegal characters
 
299
            message = """You printed an invalid CGI header. CGI header
 
300
            field-names can not contain any of the following characters: 
 
301
            <code>( ) &lt; &gt; @ , ; : \\ " / [ ] ? = { } <em>SPACE 
 
302
            TAB</em></code>."""
 
303
        write_html_warning(req, message, warning=warning)
 
304
        cgiflags.wrote_html_warning = True
 
305
        # Handle the rest of this line as normal data
 
306
        process_cgi_output(req, line + '\n', cgiflags)
 
307
        return
 
308
 
295
309
    # Read CGI headers
296
310
    value = value.strip()
297
311
    if name == "Content-Type":
341
355
    <pre>
342
356
""" % (warning, text))
343
357
 
344
 
location_cgi_python = os.path.join(ivle.conf.lib_path, "trampoline")
345
 
 
346
358
# Mapping of interpreter names (as given in conf/app/server.py) to
347
359
# interpreter functions.
348
360
 
349
361
interpreter_objects = {
350
362
    'cgi-python'
351
 
        : functools.partial(execute_cgi, "/usr/bin/python",
352
 
            location_cgi_python),
 
363
        : functools.partial(execute_cgi, "/usr/bin/python"),
353
364
    'noop'
354
 
        : functools.partial(execute_cgi, None,
355
 
            location_cgi_python),
 
365
        : functools.partial(execute_cgi, None),
356
366
    # Should also have:
357
367
    # cgi-generic
358
368
    # python-server-page
359
369
}
360
370
 
361
 
def fixup_environ(req):
362
 
    """Assuming os.environ has been written with the CGI variables from
363
 
    apache, make a few changes for security and correctness.
 
371
def cgi_environ(req, script_path, user):
 
372
    """Gets CGI variables from apache and makes a few changes for security and 
 
373
    correctness.
364
374
 
365
375
    Does not modify req, only reads it.
366
376
    """
367
 
    env = os.environ
 
377
    env = {}
368
378
    # Comments here are on the heavy side, explained carefully for security
369
379
    # reasons. Please read carefully before making changes.
 
380
    
 
381
    # This automatically asks mod_python to load up the CGI variables into the
 
382
    # environment (which is a good first approximation)
 
383
    for (k,v) in req.get_cgi_environ().items():
 
384
        env[k] = v
370
385
 
371
386
    # Remove DOCUMENT_ROOT and SCRIPT_FILENAME. Not part of CGI spec and
372
387
    # exposes unnecessary details about server.
384
399
        del env['PATH']
385
400
    except: pass
386
401
 
387
 
    # Remove SCRIPT_FILENAME. Not part of CGI spec (see SCRIPT_NAME).
388
 
 
389
 
    # PATH_INFO is wrong because the script doesn't physically exist.
390
 
    # Apache makes it relative to the "serve" app. It should actually be made
391
 
    # relative to the student's script. intepretservice does that in the jail,
392
 
    # so here we just clear it.
393
 
    env['PATH_INFO'] = ''
394
 
    env['PATH_TRANSLATED'] = ''
395
 
 
396
402
    # CGI specifies that REMOTE_HOST SHOULD be set, and MAY just be set to
397
403
    # REMOTE_ADDR. Since Apache does not appear to set this, set it to
398
404
    # REMOTE_ADDR.
399
405
    if 'REMOTE_HOST' not in env and 'REMOTE_ADDR' in env:
400
406
        env['REMOTE_HOST'] = env['REMOTE_ADDR']
401
407
 
 
408
    env['PATH_INFO'] = ''
 
409
    del env['PATH_TRANSLATED']
 
410
 
 
411
    normuri = os.path.normpath(req.uri)
 
412
    env['SCRIPT_NAME'] = normuri
 
413
 
402
414
    # SCRIPT_NAME is the path to the script WITHOUT PATH_INFO.
403
 
    script_name = req.uri
404
 
    env['SCRIPT_NAME'] = script_name
 
415
    # We don't care about these if the script is null (ie. noop).
 
416
    # XXX: We check for /home because we don't want to interfere with
 
417
    # CGIRequest, which fileservice still uses.
 
418
    if script_path and script_path.startswith('/home'):
 
419
        normscript = os.path.normpath(script_path)
 
420
 
 
421
        uri_into_jail = studpath.to_home_path(os.path.normpath(req.path))
 
422
 
 
423
        # PATH_INFO is wrong because the script doesn't physically exist.
 
424
        env['PATH_INFO'] = uri_into_jail[len(normscript):]
 
425
        if len(env['PATH_INFO']) > 0:
 
426
            env['SCRIPT_NAME'] = normuri[:-len(env['PATH_INFO'])]
405
427
 
406
428
    # SERVER_SOFTWARE is actually not Apache but IVLE, since we are
407
429
    # custom-making the CGI request.
408
 
    env['SERVER_SOFTWARE'] = "IVLE/" + str(ivle.conf.ivle_version)
 
430
    env['SERVER_SOFTWARE'] = "IVLE/" + ivle.__version__
409
431
 
410
432
    # Additional environment variables
411
 
    username = studpath.url_to_jailpaths(req.path)[0]
 
433
    username = user.login
412
434
    env['HOME'] = os.path.join('/home', username)
 
435
 
 
436
    return env
 
437
 
 
438
class ExecutionError(Exception):
 
439
    pass
 
440
 
 
441
def execute_raw(config, user, jail_dir, working_dir, binary, args):
 
442
    '''Execute a binary in a user's jail, returning the raw output.
 
443
 
 
444
    The binary is executed in the given working directory with the given
 
445
    args. A tuple of (stdout, stderr) is returned.
 
446
    '''
 
447
 
 
448
    tramp = os.path.join(config['paths']['lib'], 'trampoline')
 
449
    tramp_dir = os.path.split(tramp)[0]
 
450
 
 
451
    # Fire up trampoline. Vroom, vroom.
 
452
    cmd_line = [tramp, str(user.unixid), config['paths']['jails']['mounts'],
 
453
         config['paths']['jails']['src'],
 
454
         config['paths']['jails']['template'],
 
455
         jail_dir, working_dir, binary] + args
 
456
    # Popen doesn't like unicode strings. It hateses them.
 
457
    cmd_line = [(s.encode('utf-8') if isinstance(s, unicode) else s)
 
458
                for s in cmd_line]
 
459
    proc = subprocess.Popen(cmd_line,
 
460
        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
 
461
        stderr=subprocess.PIPE, cwd=tramp_dir, close_fds=True,
 
462
        env={'HOME': os.path.join('/home', user.login),
 
463
             'PATH': PATH,
 
464
             'USER': user.login,
 
465
             'LOGNAME': user.login})
 
466
 
 
467
    (stdout, stderr) = proc.communicate()
 
468
    exitcode = proc.returncode
 
469
 
 
470
    if exitcode != 0:
 
471
        raise ExecutionError('subprocess ended with code %d, stderr: "%s"' %
 
472
                             (exitcode, stderr))
 
473
    return (stdout, stderr)