← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/util.py

Fix public mode serve authorization to traverse to the deepest directory,
not just the previous path segment. Otherwise PATH_INFO can't be used in
public mode - it takes PATH_INFO to be part of the authorization path

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/util.py
 
1
# IVLE - Informatics Virtual Learning Environment
 
2
# Copyright (C) 2007-2008 The University of Melbourne
 
3
#
 
4
# This program is free software; you can redistribute it and/or modify
 
5
# it under the terms of the GNU General Public License as published by
 
6
# the Free Software Foundation; either version 2 of the License, or
 
7
# (at your option) any later version.
 
8
#
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
# GNU General Public License for more details.
 
13
#
 
14
# You should have received a copy of the GNU General Public License
 
15
# along with this program; if not, write to the Free Software
 
16
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
17
 
 
18
# Module: util
 
19
# Author: Matt Giuca
 
20
# Date: 12/12/2007
 
21
 
 
22
# Contains common utility functions.
 
23
# Also initialises mime types library. You must import util before using
 
24
# Python's builtin mimetypes module to make sure local settings are applied.
 
25
 
 
26
import os
 
27
import mimetypes
 
28
import datetime
 
29
 
 
30
import ivle.conf
 
31
import ivle.conf.mimetypes
 
32
 
 
33
class IVLEError(Exception):
 
34
    """
 
35
    This is the "standard" exception class for IVLE errors.
 
36
    It is the ONLY exception which should propagate to the top - it will then
 
37
    be displayed to the user as an HTTP error with the given code.
 
38
 
 
39
    All other exceptions are considered IVLE bugs and should not occur
 
40
    (they will display a traceback).
 
41
 
 
42
    This error should not be raised directly. Call req.throw_error.
 
43
    """
 
44
    def __init__(self, httpcode, message=None):
 
45
        self.httpcode = httpcode
 
46
        self.message = message
 
47
        self.args = (httpcode, message)
 
48
 
 
49
class IVLEJailError(Exception):
 
50
    """
 
51
    This exception indicates an error that occurred inside an IVLE CGI script
 
52
    inside the jail. It should never be raised directly - only by the 
 
53
    interpreter.
 
54
 
 
55
    Information will be retrieved from it, and then treated as a normal
 
56
    error.
 
57
    """
 
58
    def __init__(self, type_str, message, info):
 
59
        self.type_str = type_str
 
60
        self.message = message
 
61
        self.info = info
 
62
 
 
63
class FakeObject(object):
 
64
    """ A representation of an object that can't be Pickled """
 
65
    def __init__(self, type, name, attrib={}):
 
66
        self.type = type
 
67
        self.name = name
 
68
        self.attrib = attrib
 
69
 
 
70
    def __repr__(self):
 
71
        return "<Fake %s %s>"%(self.type, self.name)
 
72
 
 
73
 
 
74
def make_path(path):
 
75
    """Given a path relative to the IVLE root, makes the path relative to the
 
76
    site root using ivle.conf.root_dir. This path can be used in URLs sent to
 
77
    the client."""
 
78
    return os.path.join(ivle.conf.root_dir, path)
 
79
 
 
80
def make_local_path(path):
 
81
    """Given a path relative to the IVLE root, on the local file system, makes
 
82
    the path relative to the root using ivle.conf.share_path. This path can
 
83
    be used in reading files from the local file system."""
 
84
    return os.path.join(ivle.conf.share_path, 'www', path)
 
85
 
 
86
def unmake_path(path):
 
87
    """Given a path relative to the site root, makes the path relative to the
 
88
    IVLE root by removing ivle.conf.root_dir if it appears at the beginning. If
 
89
    it does not appear at the beginning, returns path unchanged. Also
 
90
    normalises the path."""
 
91
    path = os.path.normpath(path)
 
92
    root = os.path.normpath(ivle.conf.root_dir)
 
93
 
 
94
    if path.startswith(root):
 
95
        path = path[len(root):]
 
96
        # Take out the slash as well
 
97
        if len(path) > 0 and path[0] == os.sep:
 
98
            path = path[1:]
 
99
 
 
100
    return path
 
101
 
 
102
def split_path(path):
 
103
    """Given a path, returns a tuple consisting of the top-level directory in
 
104
    the path, and the rest of the path. Note that both items in the tuple will
 
105
    NOT begin with a slash, regardless of whether the original path did. Also
 
106
    normalises the path.
 
107
 
 
108
    Always returns a pair of strings, except for one special case, in which
 
109
    the path is completely empty (or just a single slash). In this case the
 
110
    return value will be (None, ''). But still always returns a pair.
 
111
 
 
112
    Examples:
 
113
 
 
114
    >>> split_path("")
 
115
    (None, '')
 
116
    >>> split_path("/")
 
117
    (None, '')
 
118
    >>> split_path("home")
 
119
    ('home', '')
 
120
    >>> split_path("home/docs/files")
 
121
    ('home', 'docs/files')
 
122
    >>> split_path("//home/docs/files")
 
123
    ('', 'home/docs/files')
 
124
    """
 
125
    path = os.path.normpath(path)
 
126
    # Ignore the opening slash
 
127
    if path.startswith(os.sep):
 
128
        path = path[len(os.sep):]
 
129
    if path == '' or path == '.':
 
130
        return (None, '')
 
131
    splitpath = path.split(os.sep, 1)
 
132
    if len(splitpath) == 1:
 
133
        return (splitpath[0], '')
 
134
    else:
 
135
        return tuple(splitpath)
 
136
 
 
137
def open_exercise_file(exercisename):
 
138
    """Given an exercise name, opens the corresponding XML file for reading.
 
139
    Returns None if the exercise file was not found.
 
140
    (For tutorials / worksheets).
 
141
    """
 
142
    # First normalise the path
 
143
    exercisename = os.path.normpath(exercisename)
 
144
    # Now if it begins with ".." or separator, then it's illegal
 
145
    if exercisename.startswith("..") or exercisename.startswith(os.sep):
 
146
        exercisefile = None
 
147
    else:
 
148
        exercisefile = os.path.join(ivle.conf.exercises_base, exercisename)
 
149
 
 
150
    try:
 
151
        return open(exercisefile)
 
152
    except (TypeError, IOError):    # TypeError if exercisefile == None
 
153
        return None
 
154
 
 
155
# Initialise mime types library
 
156
mimetypes.init()
 
157
for (ext, mimetype) in ivle.conf.mimetypes.additional_mime_types.items():
 
158
    mimetypes.add_type(mimetype, ext)
 
159
 
 
160
def nice_filetype(filename):
 
161
    """Given a filename or basename, returns a "friendly" name for that
 
162
    file's type.
 
163
    eg. nice_mimetype("file.py") == "Python source code".
 
164
        nice_filetype("file.bzg") == "BZG file".
 
165
        nice_filetype("directory/") == "Directory".
 
166
    """
 
167
    if filename[-1] == os.sep:
 
168
        return "Directory"
 
169
    else:
 
170
        try:
 
171
            return ivle.conf.mimetypes.nice_mimetypes[
 
172
                mimetypes.guess_type(filename)[0]]
 
173
        except KeyError:
 
174
            filename = os.path.basename(filename)
 
175
            try:
 
176
                return filename[filename.rindex('.')+1:].upper() + " file"
 
177
            except ValueError:
 
178
                return "File"
 
179
 
 
180
def get_terms_of_service():
 
181
    """
 
182
    Sends the Terms of Service document to the req object.
 
183
    This consults conf to find out where the TOS is located on disk, and sends
 
184
    that. If it isn't found, it sends a generic message explaining to admins
 
185
    how to create a real one.
 
186
    """
 
187
    try:
 
188
        return open(ivle.conf.tos_path).read()
 
189
    except IOError:
 
190
        return """<h1>Terms of Service</h1>
 
191
<p><b>*** SAMPLE ONLY ***</b></p>
 
192
<p>This is the text of the IVLE Terms of Service.</p>
 
193
<p>The administrator should create a license file with an appropriate
 
194
"Terms of Service" license for your organisation.</p>
 
195
<h2>Instructions for Administrators</h2>
 
196
<p>You are seeing this message because you have not configured a Terms of
 
197
Service document.</p>
 
198
<p>When you configured IVLE, you specified a path to the Terms of Service
 
199
document (this is found in <b><tt>ivle/conf/conf.py</tt></b> under
 
200
"<tt>tos_path</tt>").</p>
 
201
<p>Create a file at this location; an HTML file with the appropriately-worded
 
202
license.</p>
 
203
<p>This should be a normal XHTML file, except it should not contain
 
204
<tt>html</tt>, <tt>head</tt> or <tt>body</tt> elements - it should
 
205
just be the contents of a body element (IVLE will wrap it accordingly).</p>
 
206
<p>This will automatically be used as the license text instead of this
 
207
placeholder text.</p>
 
208
"""
 
209
 
 
210
def parse_iso8601(str):
 
211
    """Parses ISO8601 string into a datetime object."""
 
212
    # FIXME: Terrific hack that means we only accept the format that is 
 
213
    # produced by json.js module when it encodes date objects.
 
214
    return datetime.datetime.strptime(str, "%Y-%m-%dT%H:%M:%SZ")
 
215
 
 
216
def incomplete_utf8_sequence(byteseq):
 
217
    """
 
218
    str -> int
 
219
    Given a UTF-8-encoded byte sequence (str), returns the number of bytes at
 
220
    the end of the string which comprise an incomplete UTF-8 character
 
221
    sequence.
 
222
 
 
223
    If the string is empty or ends with a complete character OR INVALID
 
224
    sequence, returns 0.
 
225
    Otherwise, returns 1-3 indicating the number of bytes in the final
 
226
    incomplete (but valid) character sequence.
 
227
 
 
228
    Does not check any bytes before the final sequence for correctness.
 
229
 
 
230
    >>> incomplete_utf8_sequence("")
 
231
    0
 
232
    >>> incomplete_utf8_sequence("xy")
 
233
    0
 
234
    >>> incomplete_utf8_sequence("xy\xc3\xbc")
 
235
    0
 
236
    >>> incomplete_utf8_sequence("\xc3")
 
237
    1
 
238
    >>> incomplete_utf8_sequence("\xbc\xc3")
 
239
    1
 
240
    >>> incomplete_utf8_sequence("xy\xbc\xc3")
 
241
    1
 
242
    >>> incomplete_utf8_sequence("xy\xe0\xa0")
 
243
    2
 
244
    >>> incomplete_utf8_sequence("xy\xf4")
 
245
    1
 
246
    >>> incomplete_utf8_sequence("xy\xf4\x8f")
 
247
    2
 
248
    >>> incomplete_utf8_sequence("xy\xf4\x8f\xa0")
 
249
    3
 
250
    """
 
251
    count = 0
 
252
    expect = None
 
253
    for b in byteseq[::-1]:
 
254
        b = ord(b)
 
255
        count += 1
 
256
        if b & 0x80 == 0x0:
 
257
            # 0xxxxxxx (single-byte character)
 
258
            expect = 1
 
259
            break
 
260
        elif b & 0xc0 == 0x80:
 
261
            # 10xxxxxx (subsequent byte)
 
262
            pass
 
263
        elif b & 0xe0 == 0xc0:
 
264
            # 110xxxxx (start of 2-byte sequence)
 
265
            expect = 2
 
266
            break
 
267
        elif b & 0xf0 == 0xe0:
 
268
            # 1110xxxx (start of 3-byte sequence)
 
269
            expect = 3
 
270
            break
 
271
        elif b & 0xf8 == 0xf0:
 
272
            # 11110xxx (start of 4-byte sequence)
 
273
            expect = 4
 
274
            break
 
275
        else:
 
276
            # Invalid byte
 
277
            return 0
 
278
 
 
279
        if count >= 4:
 
280
            # Seen too many "subsequent bytes", invalid
 
281
            return 0
 
282
 
 
283
    if expect is None:
 
284
        # We never saw a "first byte", invalid
 
285
        return 0
 
286
 
 
287
    # We now know expect and count
 
288
    if count >= expect:
 
289
        # Complete, or we saw an invalid sequence
 
290
        return 0
 
291
    elif count < expect:
 
292
        # Incomplete
 
293
        return count
 
294
 
 
295
def object_to_dict(attrnames, obj):
 
296
    """
 
297
    Convert an object into a dictionary. This takes a shallow copy of the
 
298
    object.
 
299
    attrnames: Set (or iterable) of names of attributes to be copied into the
 
300
        dictionary. (We don't auto-lookup, because this function needs to be
 
301
        used on magical objects).
 
302
    """
 
303
    return dict((k, getattr(obj, k))
 
304
        for k in attrnames if not k.startswith('_'))