← 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: 2009-02-17 00:58:59 UTC
  • mto: (1099.1.143 new-dispatch)
  • mto: This revision was merged to the branch mainline in revision 1100.
  • Revision ID: grantw@unimelb.edu.au-20090217005859-q3m4zrca69x8h9e5
Move serve over to the new framework. It sort of works, except not.

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
25
24
from ivle import studpath
26
 
from ivle.util import IVLEJailError, split_path
 
25
from ivle.util import IVLEError, IVLEJailError
 
26
import ivle.conf
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"
41
40
 
42
41
def interpret_file(req, owner, jail_dir, filename, interpreter, gentle=True):
43
42
    """Serves a file by interpreting it using one of IVLE's builtin
74
73
    # (Note that paths "relative" to the jail actually begin with a '/' as
75
74
    # they are absolute in the jailspace)
76
75
 
77
 
    return interpreter(owner, jail_dir, working_dir, filename_abs, req,
 
76
    return interpreter(owner.unixid, jail_dir, working_dir, filename_abs, req,
78
77
                       gentle)
79
78
 
80
79
class CGIFlags:
89
88
        self.linebuf = ""
90
89
        self.headers = {}       # Header names : values
91
90
 
92
 
def execute_cgi(interpreter, owner, jail_dir, working_dir, script_path,
93
 
                req, gentle):
 
91
def execute_cgi(interpreter, trampoline, uid, jail_dir, working_dir,
 
92
                script_path, req, gentle):
94
93
    """
95
94
    trampoline: Full path on the local system to the CGI wrapper program
96
95
        being executed.
97
 
    owner: User object of the owner of the file.
 
96
    uid: User ID of the owner of the file.
98
97
    jail_dir: Absolute path of owner's jail directory.
99
98
    working_dir: Directory containing the script file relative to owner's
100
99
        jail.
106
105
    its environment.
107
106
    """
108
107
 
109
 
    trampoline = os.path.join(req.config['paths']['lib'], 'trampoline')
110
 
 
111
108
    # Support no-op trampoline runs.
112
109
    if interpreter is None:
113
110
        interpreter = '/bin/true'
130
127
        f.seek(0)       # Rewind, for reading
131
128
 
132
129
    # Set up the environment
133
 
    environ = cgi_environ(req, script_path, owner)
 
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)
134
138
 
135
139
    # usage: tramp uid jail_dir working_dir 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,
 
140
    pid = subprocess.Popen(
 
141
        [trampoline, str(uid), jail_dir, working_dir, interpreter,
 
142
        script_path],
145
143
        stdin=f, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
146
 
        cwd=tramp_dir, env=environ)
 
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
147
151
 
148
152
    # We don't want any output! Bail out after the process terminates.
149
153
    if noop:
218
222
        # Is this an internal IVLE error condition?
219
223
        hs = cgiflags.headers
220
224
        if 'X-IVLE-Error-Type' in hs:
221
 
            try:
222
 
                raise IVLEJailError(hs['X-IVLE-Error-Type'],
223
 
                                    hs['X-IVLE-Error-Message'],
224
 
                                    hs['X-IVLE-Error-Info'])
225
 
            except KeyError:
226
 
                raise AssertionError("Bad error headers written by CGI.")
 
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:
 
230
                try:
 
231
                    raise IVLEJailError(hs['X-IVLE-Error-Type'],
 
232
                                        hs['X-IVLE-Error-Message'],
 
233
                                        hs['X-IVLE-Error-Info'])
 
234
                except KeyError:
 
235
                    raise IVLEError(500, 'bad error headers written by CGI')
227
236
 
228
237
        # Check to make sure the required headers were written
229
238
        if cgiflags.wrote_html_warning or not cgiflags.gentle:
332
341
    <pre>
333
342
""" % (warning, text))
334
343
 
 
344
location_cgi_python = os.path.join(ivle.conf.lib_path, "trampoline")
 
345
 
335
346
# Mapping of interpreter names (as given in conf/app/server.py) to
336
347
# interpreter functions.
337
348
 
338
349
interpreter_objects = {
339
350
    'cgi-python'
340
 
        : functools.partial(execute_cgi, "/usr/bin/python"),
 
351
        : functools.partial(execute_cgi, "/usr/bin/python",
 
352
            location_cgi_python),
341
353
    'noop'
342
 
        : functools.partial(execute_cgi, None),
 
354
        : functools.partial(execute_cgi, None,
 
355
            location_cgi_python),
343
356
    # Should also have:
344
357
    # cgi-generic
345
358
    # python-server-page
346
359
}
347
360
 
348
 
def cgi_environ(req, script_path, user):
349
 
    """Gets CGI variables from apache and makes a few changes for security and 
350
 
    correctness.
 
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.
351
364
 
352
365
    Does not modify req, only reads it.
353
366
    """
354
 
    env = {}
 
367
    env = os.environ
355
368
    # Comments here are on the heavy side, explained carefully for security
356
369
    # reasons. Please read carefully before making changes.
357
 
    
358
 
    # This automatically asks mod_python to load up the CGI variables into the
359
 
    # environment (which is a good first approximation)
360
 
    for (k,v) in req.get_cgi_environ().items():
361
 
        env[k] = v
362
370
 
363
371
    # Remove DOCUMENT_ROOT and SCRIPT_FILENAME. Not part of CGI spec and
364
372
    # exposes unnecessary details about server.
376
384
        del env['PATH']
377
385
    except: pass
378
386
 
 
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
 
379
396
    # CGI specifies that REMOTE_HOST SHOULD be set, and MAY just be set to
380
397
    # REMOTE_ADDR. Since Apache does not appear to set this, set it to
381
398
    # REMOTE_ADDR.
382
399
    if 'REMOTE_HOST' not in env and 'REMOTE_ADDR' in env:
383
400
        env['REMOTE_HOST'] = env['REMOTE_ADDR']
384
401
 
385
 
    env['PATH_INFO'] = ''
386
 
    del env['PATH_TRANSLATED']
387
 
 
388
 
    normuri = os.path.normpath(req.uri)
389
 
    env['SCRIPT_NAME'] = normuri
390
 
 
391
402
    # SCRIPT_NAME is the path to the script WITHOUT PATH_INFO.
392
 
    # We don't care about these if the script is null (ie. noop).
393
 
    # XXX: We check for /home because we don't want to interfere with
394
 
    # CGIRequest, which fileservice still uses.
395
 
    if script_path and script_path.startswith('/home'):
396
 
        normscript = os.path.normpath(script_path)
397
 
 
398
 
        uri_into_jail = studpath.to_home_path(os.path.normpath(req.path))
399
 
 
400
 
        # PATH_INFO is wrong because the script doesn't physically exist.
401
 
        env['PATH_INFO'] = uri_into_jail[len(normscript):]
402
 
        if len(env['PATH_INFO']) > 0:
403
 
            env['SCRIPT_NAME'] = normuri[:-len(env['PATH_INFO'])]
 
403
    script_name = req.uri
 
404
    env['SCRIPT_NAME'] = script_name
404
405
 
405
406
    # SERVER_SOFTWARE is actually not Apache but IVLE, since we are
406
407
    # custom-making the CGI request.
407
 
    env['SERVER_SOFTWARE'] = "IVLE/" + ivle.__version__
 
408
    env['SERVER_SOFTWARE'] = "IVLE/" + str(ivle.conf.ivle_version)
408
409
 
409
410
    # Additional environment variables
410
 
    username = user.login
 
411
    username = studpath.url_to_jailpaths(req.path)[0]
411
412
    env['HOME'] = os.path.join('/home', username)
412
413
 
413
 
    return env
414
 
 
415
414
class ExecutionError(Exception):
416
415
    pass
417
416
 
418
 
def execute_raw(config, user, jail_dir, working_dir, binary, args):
 
417
def execute_raw(user, jail_dir, working_dir, binary, args):
419
418
    '''Execute a binary in a user's jail, returning the raw output.
420
419
 
421
420
    The binary is executed in the given working directory with the given
422
421
    args. A tuple of (stdout, stderr) is returned.
423
422
    '''
424
423
 
425
 
    tramp = os.path.join(config['paths']['lib'], 'trampoline')
426
 
    tramp_dir = os.path.split(tramp)[0]
 
424
    tramp = location_cgi_python
 
425
    tramp_dir = os.path.split(location_cgi_python)[0]
427
426
 
428
427
    # Fire up trampoline. Vroom, vroom.
429
 
    cmd_line = [tramp, str(user.unixid), config['paths']['jails']['mounts'],
430
 
         config['paths']['jails']['src'],
431
 
         config['paths']['jails']['template'],
432
 
         jail_dir, working_dir, binary] + args
433
 
    # Popen doesn't like unicode strings. It hateses them.
434
 
    cmd_line = [(s.encode('utf-8') if isinstance(s, unicode) else s)
435
 
                for s in cmd_line]
436
 
    proc = subprocess.Popen(cmd_line,
 
428
    proc = subprocess.Popen(
 
429
        [tramp, str(user.unixid), jail_dir, working_dir, binary] + args,
437
430
        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
438
 
        stderr=subprocess.PIPE, cwd=tramp_dir, close_fds=True,
439
 
        env={'HOME': os.path.join('/home', user.login),
440
 
             'PATH': PATH,
441
 
             'USER': user.login,
442
 
             'LOGNAME': user.login})
443
 
 
444
 
    (stdout, stderr) = proc.communicate()
445
 
    exitcode = proc.returncode
 
431
        stderr=subprocess.PIPE, cwd=tramp_dir, close_fds=True)
 
432
    exitcode = proc.wait()
446
433
 
447
434
    if exitcode != 0:
448
 
        raise ExecutionError('subprocess ended with code %d, stderr: "%s"' %
449
 
                             (exitcode, stderr))
450
 
    return (stdout, stderr)
 
435
        raise ExecutionError('subprocess ended with code %d, stderr %s' %
 
436
                             (exitcode, proc.stderr.read()))
 
437
    return (proc.stdout.read(), proc.stderr.read())