← 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-01-20 00:37:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1090.
  • Revision ID: grantw@unimelb.edu.au-20090120003729-cjplw80wuit76mn6
userdb: login.state now defaults to 'no_agreement'.
        The migration is 20090120-01.

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 import db
 
26
from ivle.util import IVLEError, IVLEJailError
 
27
import ivle.conf
27
28
 
28
29
import functools
29
30
 
31
32
import pwd
32
33
import subprocess
33
34
import cgi
34
 
import StringIO
35
35
 
36
36
# TODO: Make progressive output work
37
37
# Question: Will having a large buffer size stop progressive output from
38
38
# working on smaller output
39
39
 
40
40
CGI_BLOCK_SIZE = 65535
41
 
PATH = "/usr/local/bin:/usr/bin:/bin"
42
41
 
43
 
def interpret_file(req, owner, jail_dir, filename, interpreter, gentle=True,
44
 
    overrides=None):
 
42
def interpret_file(req, owner, jail_dir, filename, interpreter, gentle=True):
45
43
    """Serves a file by interpreting it using one of IVLE's builtin
46
44
    interpreters. All interpreters are intended to run in the user's jail. The
47
45
    jail location is provided as an argument to the interpreter but it is up
52
50
    jail_dir: Absolute path to the user's jail.
53
51
    filename: Absolute filename within the user's jail.
54
52
    interpreter: A function object to call.
55
 
    gentle: ?
56
 
    overrides: A dict mapping env var names to strings, to override arbitrary
57
 
        environment variables in the resulting CGI environent.
58
53
    """
59
54
    # We can't test here whether or not the target file actually exists,
60
55
    # because the apache user may not have permission. Instead we have to
79
74
    # (Note that paths "relative" to the jail actually begin with a '/' as
80
75
    # they are absolute in the jailspace)
81
76
 
82
 
    return interpreter(owner, jail_dir, working_dir, filename_abs, req,
83
 
                       gentle, overrides=overrides)
 
77
    return interpreter(owner.unixid, jail_dir, working_dir, filename_abs, req,
 
78
                       gentle)
84
79
 
85
80
class CGIFlags:
86
81
    """Stores flags regarding the state of reading CGI output.
94
89
        self.linebuf = ""
95
90
        self.headers = {}       # Header names : values
96
91
 
97
 
def execute_cgi(interpreter, owner, jail_dir, working_dir, script_path,
98
 
                req, gentle, overrides=None):
 
92
def execute_cgi(interpreter, trampoline, uid, jail_dir, working_dir,
 
93
                script_path, req, gentle):
99
94
    """
100
95
    trampoline: Full path on the local system to the CGI wrapper program
101
96
        being executed.
102
 
    owner: User object of the owner of the file.
 
97
    uid: User ID of the owner of the file.
103
98
    jail_dir: Absolute path of owner's jail directory.
104
99
    working_dir: Directory containing the script file relative to owner's
105
100
        jail.
106
101
    script_path: CGI script relative to the owner's jail.
107
102
    req: IVLE request object.
108
 
    gentle: ?
109
 
    overrides: A dict mapping env var names to strings, to override arbitrary
110
 
        environment variables in the resulting CGI environent.
111
103
 
112
104
    The called CGI wrapper application shall be called using popen and receive
113
105
    the HTTP body on stdin. It shall receive the CGI environment variables to
114
106
    its environment.
115
107
    """
116
108
 
117
 
    trampoline = os.path.join(req.config['paths']['lib'], 'trampoline')
118
 
 
119
109
    # Support no-op trampoline runs.
120
110
    if interpreter is None:
121
111
        interpreter = '/bin/true'
138
128
        f.seek(0)       # Rewind, for reading
139
129
 
140
130
    # Set up the environment
141
 
    environ = cgi_environ(req, script_path, owner, overrides=overrides)
 
131
    # This automatically asks mod_python to load up the CGI variables into the
 
132
    # environment (which is a good first approximation)
 
133
    old_env = os.environ.copy()
 
134
    for k in os.environ.keys():
 
135
        del os.environ[k]
 
136
    for (k,v) in req.get_cgi_environ().items():
 
137
        os.environ[k] = v
 
138
    fixup_environ(req)
142
139
 
143
140
    # usage: tramp uid jail_dir working_dir script_path
144
 
    cmd_line = [trampoline, str(owner.unixid),
145
 
            req.config['paths']['jails']['mounts'],
146
 
            req.config['paths']['jails']['src'],
147
 
            req.config['paths']['jails']['template'],
148
 
            jail_dir, working_dir, interpreter, script_path]
149
 
    # Popen doesn't like unicode strings. It hateses them.
150
 
    cmd_line = [(s.encode('utf-8') if isinstance(s, unicode) else s)
151
 
                for s in cmd_line]
152
 
    pid = subprocess.Popen(cmd_line,
 
141
    pid = subprocess.Popen(
 
142
        [trampoline, str(uid), jail_dir, working_dir, interpreter,
 
143
        script_path],
153
144
        stdin=f, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
154
 
        cwd=tramp_dir, env=environ)
 
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
155
152
 
156
153
    # We don't want any output! Bail out after the process terminates.
157
154
    if noop:
223
220
            if len(split) == 1:
224
221
                split = headers.split('\n', 1)
225
222
 
226
 
        # If not executing in gentle mode (which presents CGI violations
227
 
        # to users nicely), check if this an internal IVLE error
228
 
        # condition.
229
 
        if not cgiflags.gentle:
230
 
            hs = cgiflags.headers
231
 
            if 'X-IVLE-Error-Type' in hs:
 
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:
232
231
                try:
233
232
                    raise IVLEJailError(hs['X-IVLE-Error-Type'],
234
233
                                        hs['X-IVLE-Error-Message'],
235
234
                                        hs['X-IVLE-Error-Info'])
236
235
                except KeyError:
237
 
                    raise AssertionError("Bad error headers written by CGI.")
 
236
                    raise IVLEError(500, 'bad error headers written by CGI')
238
237
 
239
238
        # Check to make sure the required headers were written
240
239
        if cgiflags.wrote_html_warning or not cgiflags.gentle:
294
293
        process_cgi_output(req, line + '\n', cgiflags)
295
294
        return
296
295
 
297
 
    # Check if CGI field-name is valid
298
 
    CGI_SEPERATORS = set(['(', ')', '<', '>', '@', ',', ';', ':', '\\', '"',
299
 
            '/', '[', ']', '?', '=', '{', '}', ' ', '\t'])
300
 
    if any((char in CGI_SEPERATORS for char in name)):
301
 
        warning = "Warning"
302
 
        if not cgiflags.gentle:
303
 
            message = """An unexpected server error has occured."""
304
 
            warning = "Error"
305
 
        else:
306
 
            # Header contained illegal characters
307
 
            message = """You printed an invalid CGI header. CGI header
308
 
            field-names can not contain any of the following characters: 
309
 
            <code>( ) &lt; &gt; @ , ; : \\ " / [ ] ? = { } <em>SPACE 
310
 
            TAB</em></code>."""
311
 
        write_html_warning(req, message, warning=warning)
312
 
        cgiflags.wrote_html_warning = True
313
 
        # Handle the rest of this line as normal data
314
 
        process_cgi_output(req, line + '\n', cgiflags)
315
 
        return
316
 
 
317
296
    # Read CGI headers
318
297
    value = value.strip()
319
298
    if name == "Content-Type":
363
342
    <pre>
364
343
""" % (warning, text))
365
344
 
 
345
location_cgi_python = os.path.join(ivle.conf.lib_path, "trampoline")
 
346
 
366
347
# Mapping of interpreter names (as given in conf/app/server.py) to
367
348
# interpreter functions.
368
349
 
369
350
interpreter_objects = {
370
351
    'cgi-python'
371
 
        : functools.partial(execute_cgi, "/usr/bin/python"),
 
352
        : functools.partial(execute_cgi, "/usr/bin/python",
 
353
            location_cgi_python),
372
354
    'noop'
373
 
        : functools.partial(execute_cgi, None),
 
355
        : functools.partial(execute_cgi, None,
 
356
            location_cgi_python),
374
357
    # Should also have:
375
358
    # cgi-generic
376
359
    # python-server-page
377
360
}
378
361
 
379
 
def cgi_environ(req, script_path, user, overrides=None):
380
 
    """Gets CGI variables from apache and makes a few changes for security and 
381
 
    correctness.
 
362
def fixup_environ(req):
 
363
    """Assuming os.environ has been written with the CGI variables from
 
364
    apache, make a few changes for security and correctness.
382
365
 
383
366
    Does not modify req, only reads it.
384
 
 
385
 
    overrides: A dict mapping env var names to strings, to override arbitrary
386
 
        environment variables in the resulting CGI environent.
387
367
    """
388
 
    env = {}
 
368
    env = os.environ
389
369
    # Comments here are on the heavy side, explained carefully for security
390
370
    # reasons. Please read carefully before making changes.
391
 
    
392
 
    # This automatically asks mod_python to load up the CGI variables into the
393
 
    # environment (which is a good first approximation)
394
 
    for (k,v) in req.get_cgi_environ().items():
395
 
        env[k] = v
396
371
 
397
372
    # Remove DOCUMENT_ROOT and SCRIPT_FILENAME. Not part of CGI spec and
398
373
    # exposes unnecessary details about server.
410
385
        del env['PATH']
411
386
    except: pass
412
387
 
 
388
    # Remove SCRIPT_FILENAME. Not part of CGI spec (see SCRIPT_NAME).
 
389
 
 
390
    # PATH_INFO is wrong because the script doesn't physically exist.
 
391
    # Apache makes it relative to the "serve" app. It should actually be made
 
392
    # relative to the student's script. intepretservice does that in the jail,
 
393
    # so here we just clear it.
 
394
    env['PATH_INFO'] = ''
 
395
    env['PATH_TRANSLATED'] = ''
 
396
 
413
397
    # CGI specifies that REMOTE_HOST SHOULD be set, and MAY just be set to
414
398
    # REMOTE_ADDR. Since Apache does not appear to set this, set it to
415
399
    # REMOTE_ADDR.
416
400
    if 'REMOTE_HOST' not in env and 'REMOTE_ADDR' in env:
417
401
        env['REMOTE_HOST'] = env['REMOTE_ADDR']
418
402
 
419
 
    env['PATH_INFO'] = ''
420
 
    del env['PATH_TRANSLATED']
421
 
 
422
 
    normuri = os.path.normpath(req.uri)
423
 
    env['SCRIPT_NAME'] = normuri
424
 
 
425
403
    # SCRIPT_NAME is the path to the script WITHOUT PATH_INFO.
426
 
    # We don't care about these if the script is null (ie. noop).
427
 
    # XXX: We check for /home because we don't want to interfere with
428
 
    # CGIRequest, which fileservice still uses.
429
 
    if script_path and script_path.startswith('/home'):
430
 
        normscript = os.path.normpath(script_path)
431
 
 
432
 
        uri_into_jail = studpath.to_home_path(os.path.normpath(req.path))
433
 
 
434
 
        # PATH_INFO is wrong because the script doesn't physically exist.
435
 
        env['PATH_INFO'] = uri_into_jail[len(normscript):]
436
 
        if len(env['PATH_INFO']) > 0:
437
 
            env['SCRIPT_NAME'] = normuri[:-len(env['PATH_INFO'])]
 
404
    script_name = req.uri
 
405
    env['SCRIPT_NAME'] = script_name
438
406
 
439
407
    # SERVER_SOFTWARE is actually not Apache but IVLE, since we are
440
408
    # custom-making the CGI request.
441
 
    env['SERVER_SOFTWARE'] = "IVLE/" + ivle.__version__
 
409
    env['SERVER_SOFTWARE'] = "IVLE/" + str(ivle.conf.ivle_version)
442
410
 
443
411
    # Additional environment variables
444
 
    username = user.login
 
412
    username = studpath.url_to_jailpaths(req.path)[0]
445
413
    env['HOME'] = os.path.join('/home', username)
446
 
 
447
 
    if overrides is not None:
448
 
        env.update(overrides)
449
 
    return env
450
 
 
451
 
class ExecutionError(Exception):
452
 
    pass
453
 
 
454
 
def execute_raw(config, user, jail_dir, working_dir, binary, args):
455
 
    '''Execute a binary in a user's jail, returning the raw output.
456
 
 
457
 
    The binary is executed in the given working directory with the given
458
 
    args. A tuple of (stdout, stderr) is returned.
459
 
    '''
460
 
 
461
 
    tramp = os.path.join(config['paths']['lib'], 'trampoline')
462
 
    tramp_dir = os.path.split(tramp)[0]
463
 
 
464
 
    # Fire up trampoline. Vroom, vroom.
465
 
    cmd_line = [tramp, str(user.unixid), config['paths']['jails']['mounts'],
466
 
         config['paths']['jails']['src'],
467
 
         config['paths']['jails']['template'],
468
 
         jail_dir, working_dir, binary] + args
469
 
    # Popen doesn't like unicode strings. It hateses them.
470
 
    cmd_line = [(s.encode('utf-8') if isinstance(s, unicode) else s)
471
 
                for s in cmd_line]
472
 
    proc = subprocess.Popen(cmd_line,
473
 
        stdin=subprocess.PIPE, stdout=subprocess.PIPE,
474
 
        stderr=subprocess.PIPE, cwd=tramp_dir, close_fds=True,
475
 
        env={'HOME': os.path.join('/home', user.login),
476
 
             'PATH': PATH,
477
 
             'USER': user.login,
478
 
             'LOGNAME': user.login})
479
 
 
480
 
    (stdout, stderr) = proc.communicate()
481
 
    exitcode = proc.returncode
482
 
 
483
 
    if exitcode != 0:
484
 
        raise ExecutionError('subprocess ended with code %d, stderr: "%s"' %
485
 
                             (exitcode, stderr))
486
 
    return (stdout, stderr)
487
 
 
488
 
def jail_call(req, cgi_script, script_name, query_string=None,
489
 
    request_method="GET", extra_overrides=None):
490
 
    """
491
 
    Makes a call to a CGI script inside the jail from outside the jail.
492
 
    This can be used to allow Python scripts to access jail-only functions and
493
 
    data without having to perform a full API request.
494
 
 
495
 
    req: A Request object (will not be written to or attributes modified).
496
 
    cgi_script: Path to cgi script outside of jail.
497
 
        eg: os.path.join(req.config['paths']['share'],
498
 
                         'services/fileservice')
499
 
    script_name: Name to set as SCRIPT_NAME for the CGI environment.
500
 
        eg: "/fileservice/"
501
 
    query_string: Query string to set as QUERY_STRING for the CGI environment.
502
 
        eg: "action=svnrepostat&path=/users/studenta/"
503
 
    request_method: Method to set as REQUEST_METHOD for the CGI environment.
504
 
        eg: "POST". Defaults to "GET".
505
 
    extra_overrides: A dict mapping env var names to strings, to override
506
 
        arbitrary environment variables in the resulting CGI environent.
507
 
 
508
 
    Returns a triple (status_code, content_type, contents).
509
 
    """
510
 
    interp_object = interpreter_objects["cgi-python"]
511
 
    user_jail_dir = os.path.join(req.config['paths']['jails']['mounts'],
512
 
                                 req.user.login)
513
 
    overrides = {
514
 
        "SCRIPT_NAME": script_name,
515
 
        "QUERY_STRING": query_string,
516
 
        "REQUEST_URI": "%s%s%s" % (script_name, "?" if query_string else "",
517
 
                                   query_string),
518
 
        "REQUEST_METHOD": request_method,
519
 
    }
520
 
    if extra_overrides is not None:
521
 
        overrides.update(extra_overrides)
522
 
    result = DummyReq(req)
523
 
    interpret_file(result, req.user, user_jail_dir, cgi_script, interp_object,
524
 
                   gentle=False, overrides=overrides)
525
 
    return result.status, result.content_type, result.getvalue()
526
 
 
527
 
class DummyReq(StringIO.StringIO):
528
 
    """A dummy request object, built from a real request object, which can be
529
 
    used like a req but doesn't mutate the existing request.
530
 
    (Used for reading CGI responses as strings rather than forwarding their
531
 
    output to the current request.)
532
 
    """
533
 
    def __init__(self, req):
534
 
        StringIO.StringIO.__init__(self)
535
 
        self._real_req = req
536
 
    def get_cgi_environ(self):
537
 
        return self._real_req.get_cgi_environ()
538
 
    def __getattr__(self, name):
539
 
        return getattr(self._real_req, name)