← 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-27 12:09:13 UTC
  • mto: This revision was merged to the branch mainline in revision 1826.
  • Revision ID: grantw@unimelb.edu.au-20100727120913-v0kfnwxzbiwrjnue
(simple)json always returns a unicode when decoding, while cjson returned a str where possible. This makes cPickle unhappy, so convert back to a str.

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, script_path)
 
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), ivle.conf.jail_base, ivle.conf.jail_src_base,
142
 
         ivle.conf.jail_system, jail_dir, working_dir, interpreter,
143
 
        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,
144
145
        stdin=f, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
145
 
        cwd=tramp_dir)
146
 
 
147
 
    # Restore the environment
148
 
    for k in os.environ.keys():
149
 
        del os.environ[k]
150
 
    for (k,v) in old_env.items():
151
 
        os.environ[k] = v
 
146
        cwd=tramp_dir, env=environ)
152
147
 
153
148
    # We don't want any output! Bail out after the process terminates.
154
149
    if noop:
220
215
            if len(split) == 1:
221
216
                split = headers.split('\n', 1)
222
217
 
223
 
        # Is this an internal IVLE error condition?
224
 
        hs = cgiflags.headers
225
 
        if 'X-IVLE-Error-Type' in hs:
226
 
            t = hs['X-IVLE-Error-Type']
227
 
            if t == IVLEError.__name__:
228
 
                raise IVLEError(int(hs['X-IVLE-Error-Code']),
229
 
                                hs['X-IVLE-Error-Message'])
230
 
            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:
231
224
                try:
232
225
                    raise IVLEJailError(hs['X-IVLE-Error-Type'],
233
226
                                        hs['X-IVLE-Error-Message'],
234
227
                                        hs['X-IVLE-Error-Info'])
235
228
                except KeyError:
236
 
                    raise IVLEError(500, 'bad error headers written by CGI')
 
229
                    raise AssertionError("Bad error headers written by CGI.")
237
230
 
238
231
        # Check to make sure the required headers were written
239
232
        if cgiflags.wrote_html_warning or not cgiflags.gentle:
293
286
        process_cgi_output(req, line + '\n', cgiflags)
294
287
        return
295
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
 
296
309
    # Read CGI headers
297
310
    value = value.strip()
298
311
    if name == "Content-Type":
342
355
    <pre>
343
356
""" % (warning, text))
344
357
 
345
 
location_cgi_python = os.path.join(ivle.conf.lib_path, "trampoline")
346
 
 
347
358
# Mapping of interpreter names (as given in conf/app/server.py) to
348
359
# interpreter functions.
349
360
 
350
361
interpreter_objects = {
351
362
    'cgi-python'
352
 
        : functools.partial(execute_cgi, "/usr/bin/python",
353
 
            location_cgi_python),
 
363
        : functools.partial(execute_cgi, "/usr/bin/python"),
354
364
    'noop'
355
 
        : functools.partial(execute_cgi, None,
356
 
            location_cgi_python),
 
365
        : functools.partial(execute_cgi, None),
357
366
    # Should also have:
358
367
    # cgi-generic
359
368
    # python-server-page
360
369
}
361
370
 
362
 
def fixup_environ(req, script_path):
363
 
    """Assuming os.environ has been written with the CGI variables from
364
 
    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.
365
374
 
366
375
    Does not modify req, only reads it.
367
376
    """
368
 
    env = os.environ
 
377
    env = {}
369
378
    # Comments here are on the heavy side, explained carefully for security
370
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
371
385
 
372
386
    # Remove DOCUMENT_ROOT and SCRIPT_FILENAME. Not part of CGI spec and
373
387
    # exposes unnecessary details about server.
404
418
    if script_path and script_path.startswith('/home'):
405
419
        normscript = os.path.normpath(script_path)
406
420
 
407
 
        uri_into_jail = studpath.url_to_jailpaths(os.path.normpath(req.path))[2]
 
421
        uri_into_jail = studpath.to_home_path(os.path.normpath(req.path))
408
422
 
409
423
        # PATH_INFO is wrong because the script doesn't physically exist.
410
424
        env['PATH_INFO'] = uri_into_jail[len(normscript):]
413
427
 
414
428
    # SERVER_SOFTWARE is actually not Apache but IVLE, since we are
415
429
    # custom-making the CGI request.
416
 
    env['SERVER_SOFTWARE'] = "IVLE/" + str(ivle.conf.ivle_version)
 
430
    env['SERVER_SOFTWARE'] = "IVLE/" + ivle.__version__
417
431
 
418
432
    # Additional environment variables
419
 
    username = studpath.url_to_jailpaths(req.path)[0]
 
433
    username = user.login
420
434
    env['HOME'] = os.path.join('/home', username)
421
435
 
 
436
    return env
 
437
 
422
438
class ExecutionError(Exception):
423
439
    pass
424
440
 
425
 
def execute_raw(user, jail_dir, working_dir, binary, args):
 
441
def execute_raw(config, user, jail_dir, working_dir, binary, args):
426
442
    '''Execute a binary in a user's jail, returning the raw output.
427
443
 
428
444
    The binary is executed in the given working directory with the given
429
445
    args. A tuple of (stdout, stderr) is returned.
430
446
    '''
431
447
 
432
 
    tramp = location_cgi_python
433
 
    tramp_dir = os.path.split(location_cgi_python)[0]
 
448
    tramp = os.path.join(config['paths']['lib'], 'trampoline')
 
449
    tramp_dir = os.path.split(tramp)[0]
434
450
 
435
451
    # Fire up trampoline. Vroom, vroom.
436
 
    proc = subprocess.Popen(
437
 
        [tramp, str(user.unixid), ivle.conf.jail_base,
438
 
         ivle.conf.jail_src_base, ivle.conf.jail_system, jail_dir,
439
 
         working_dir, binary] + args,
 
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,
440
460
        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
441
 
        stderr=subprocess.PIPE, cwd=tramp_dir, close_fds=True)
442
 
    exitcode = proc.wait()
 
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
443
469
 
444
470
    if exitcode != 0:
445
 
        raise ExecutionError('subprocess ended with code %d, stderr %s' %
446
 
                             (exitcode, proc.stderr.read()))
447
 
    return (proc.stdout.read(), proc.stderr.read())
 
471
        raise ExecutionError('subprocess ended with code %d, stderr: "%s"' %
 
472
                             (exitcode, stderr))
 
473
    return (stdout, stderr)