← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/dispatch/__init__.py

  • Committer: William Grant
  • Date: 2010-02-23 08:08:27 UTC
  • Revision ID: grantw@unimelb.edu.au-20100223080827-wklsx122pcw79wi7
https://launchpad.net/bugs/525559
Reject off-site non-GET requests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/dispatch/__init__.py
30
30
import os
31
31
import os.path
32
32
import urllib
 
33
import urlparse
33
34
import cgi
34
35
import traceback
35
36
import logging
37
38
import time
38
39
 
39
40
import mod_python
40
 
import routes
41
41
 
42
42
from ivle import util
43
 
import ivle.conf
 
43
import ivle.config
44
44
from ivle.dispatch.request import Request
45
45
import ivle.webapp.security
46
46
from ivle.webapp.base.plugins import ViewPlugin, PublicViewPlugin
47
47
from ivle.webapp.base.xhtml import XHTMLView, XHTMLErrorView
48
 
from ivle.webapp.errors import HTTPError, Unauthorized, NotFound
49
 
 
50
 
def generate_route_mapper(view_plugins, attr):
 
48
from ivle.webapp.errors import BadRequest, HTTPError, NotFound, Unauthorized
 
49
from ivle.webapp.publisher import Publisher, PublishingError
 
50
from ivle.webapp import ApplicationRoot
 
51
 
 
52
config = ivle.config.Config()
 
53
 
 
54
class ObjectPermissionCheckingPublisher(Publisher):
 
55
    """A specialised publisher that checks object permissions.
 
56
 
 
57
    This publisher verifies that the user holds any permission at all
 
58
    on the model objects through which the resolution path passes. If
 
59
    no permission is held, resolution is aborted with an Unauthorized
 
60
    exception.
 
61
 
 
62
    IMPORTANT: This does NOT check view permissions. It only checks
 
63
    the objects in between the root and the view, exclusive!
 
64
    """
 
65
 
 
66
    def traversed_to_object(self, obj):
 
67
        """Check that the user has any permission at all over the object."""
 
68
        if (hasattr(obj, 'get_permissions') and
 
69
            len(obj.get_permissions(self.root.user, config)) == 0):
 
70
            # Indicate the forbidden object if this is an admin.
 
71
            if self.root.user and self.root.user.admin:
 
72
                raise Unauthorized('Unauthorized: %s' % obj)
 
73
            else:
 
74
                raise Unauthorized()
 
75
 
 
76
 
 
77
def generate_publisher(view_plugins, root, publicmode=False):
51
78
    """
52
79
    Build a Mapper object for doing URL matching using 'routes', based on the
53
80
    given plugin registry.
54
81
    """
55
 
    m = routes.Mapper(explicit=True)
 
82
    r = ObjectPermissionCheckingPublisher(root=root)
 
83
 
 
84
    r.add_set_switch('api', 'api')
 
85
 
 
86
    if publicmode:
 
87
        view_attr = 'public_views'
 
88
        forward_route_attr = 'public_forward_routes'
 
89
        reverse_route_attr = 'public_reverse_routes'
 
90
    else:
 
91
        view_attr = 'views'
 
92
        forward_route_attr = 'forward_routes'
 
93
        reverse_route_attr = 'reverse_routes'
 
94
 
 
95
 
56
96
    for plugin in view_plugins:
57
 
        # Establish a URL pattern for each element of plugin.urls
58
 
        assert hasattr(plugin, 'urls'), "%r does not have any urls" % plugin 
59
 
        for url in getattr(plugin, attr):
60
 
            routex = url[0]
61
 
            view_class = url[1]
62
 
            kwargs_dict = url[2] if len(url) >= 3 else {}
63
 
            m.connect(routex, view=view_class, **kwargs_dict)
64
 
    return m
 
97
        if hasattr(plugin, forward_route_attr):
 
98
            for fr in getattr(plugin, forward_route_attr):
 
99
                # An annotated function can also be passed in directly.
 
100
                if hasattr(fr, '_forward_route_meta'):
 
101
                    r.add_forward_func(fr)
 
102
                else:
 
103
                    r.add_forward(*fr)
 
104
 
 
105
        if hasattr(plugin, reverse_route_attr):
 
106
            for rr in getattr(plugin, reverse_route_attr):
 
107
                # An annotated function can also be passed in directly.
 
108
                if hasattr(rr, '_reverse_route_src'):
 
109
                    r.add_reverse_func(rr)
 
110
                else:
 
111
                    r.add_reverse(*rr)
 
112
 
 
113
        if hasattr(plugin, view_attr):
 
114
            for v in getattr(plugin, view_attr):
 
115
                r.add_view(*v)
 
116
 
 
117
    return r
65
118
 
66
119
def handler(apachereq):
67
120
    """Handles an HTTP request.
71
124
    @param apachereq: An Apache request object.
72
125
    """
73
126
    # Make the request object into an IVLE request which can be given to views
74
 
    req = Request(apachereq)
 
127
    req = Request(apachereq, config)
75
128
 
76
129
    # Hack? Try and get the user login early just in case we throw an error
77
130
    # (most likely 404) to stop us seeing not logged in even when we are.
82
135
        if user and user.valid:
83
136
            req.user = user
84
137
 
85
 
    conf = ivle.config.Config()
86
 
    req.config = conf
87
 
 
88
 
    if req.publicmode:
89
 
        req.mapper = generate_route_mapper(conf.plugin_index[PublicViewPlugin],
90
 
                                           'public_urls')
91
 
    else:
92
 
        req.mapper = generate_route_mapper(conf.plugin_index[ViewPlugin],
93
 
                                           'urls')
94
 
 
95
 
    matchdict = req.mapper.match(req.uri)
96
 
    if matchdict is not None:
97
 
        viewcls = matchdict['view']
98
 
        # Get the remaining arguments, less 'view', 'action' and 'controller'
99
 
        # (The latter two seem to be built-in, and we don't want them).
100
 
        kwargs = matchdict.copy()
101
 
        del kwargs['view']
 
138
    req.publisher = generate_publisher(
 
139
        config.plugin_index[ViewPlugin],
 
140
        ApplicationRoot(req.config, req.store, req.user),
 
141
        publicmode=req.publicmode)
 
142
 
 
143
    try:
 
144
        obj, viewcls, subpath = req.publisher.resolve(req.uri.decode('utf-8'))
102
145
        try:
 
146
            # We 404 if we have a subpath but the view forbids it.
 
147
            if not viewcls.subpath_allowed and subpath:
 
148
                raise NotFound()
 
149
 
103
150
            # Instantiate the view, which should be a BaseView class
104
 
            view = viewcls(req, **kwargs)
 
151
            view = viewcls(req, obj, subpath)
105
152
 
106
153
            # Check that the request (mainly the user) is permitted to access
107
154
            # the view.
108
155
            if not view.authorize(req):
109
 
                raise Unauthorized()
 
156
                # Indicate the forbidden object if this is an admin.
 
157
                if req.user and req.user.admin:
 
158
                    raise Unauthorized('Unauthorized: %s' % view)
 
159
                else:
 
160
                    raise Unauthorized()
 
161
 
 
162
            # Non-GET requests from other sites leave us vulnerable to
 
163
            # CSRFs. Block them.
 
164
            referer = req.headers_in.get('Referer')
 
165
            if (referer is None or
 
166
                urlparse.urlparse(req.headers_in.get('Referer')).netloc !=
 
167
                    req.hostname):
 
168
                if req.method != 'GET' and not view.offsite_posts_allowed:
 
169
                    raise BadRequest(
 
170
                        "Non-GET requests from external sites are forbidden "
 
171
                        "for security reasons.")
 
172
 
110
173
            # Render the output
111
174
            view.render(req)
112
175
        except HTTPError, e:
120
183
                errviewcls = XHTMLView.get_error_view(e)
121
184
 
122
185
            if errviewcls:
123
 
                errview = errviewcls(req, e)
 
186
                errview = errviewcls(req, e, obj)
124
187
                errview.render(req)
125
188
                return req.OK
126
189
            elif e.message:
128
191
                return req.OK
129
192
            else:
130
193
                return e.code
 
194
        except mod_python.apache.SERVER_RETURN:
 
195
            # A mod_python-specific Apache error.
 
196
            # XXX: We need to raise these because req.throw_error() uses them.
 
197
            # Remove this after Google Code issue 117 is fixed.
 
198
            raise
131
199
        except Exception, e:
132
200
            # A non-HTTPError appeared. We have an unknown exception. Panic.
133
201
            handle_unknown_exception(req, *sys.exc_info())
135
203
        else:
136
204
            req.store.commit()
137
205
            return req.OK
138
 
    else:
139
 
        XHTMLErrorView(req, NotFound()).render(req)
140
 
        return req.OK
 
206
    except Unauthorized, e:
 
207
        # Resolution failed due to a permission check. Display a pretty
 
208
        # error, or maybe a login page.
 
209
        XHTMLView.get_error_view(e)(req, e, req.publisher.root).render(req)
 
210
        return req.OK
 
211
    except PublishingError, e:
 
212
        req.status = 404
 
213
 
 
214
        if req.user and req.user.admin:
 
215
            XHTMLErrorView(req, NotFound('Not found: ' +
 
216
                                         str(e.args)), e[0]).render(req)
 
217
        else:
 
218
            XHTMLErrorView(req, NotFound(), e[0]).render(req)
 
219
 
 
220
        return req.OK
 
221
    finally:
 
222
        req.store.close()
141
223
 
142
224
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
143
225
    """
150
232
    the IVLE request is created.
151
233
    """
152
234
    req.content_type = "text/html"
153
 
    logfile = os.path.join(ivle.conf.log_path, 'ivle_error.log')
 
235
    logfile = os.path.join(config['paths']['logs'], 'ivle_error.log')
154
236
    logfail = False
 
237
 
 
238
    # XXX: This remains here for ivle.interpret's IVLEErrors. Once we rewrite
 
239
    #      fileservice, req.status should always be 500 (ISE) here.
155
240
    try:
156
241
        httpcode = exc_value.httpcode
157
242
        req.status = httpcode
158
243
    except AttributeError:
159
244
        httpcode = None
160
245
        req.status = mod_python.apache.HTTP_INTERNAL_SERVER_ERROR
 
246
 
161
247
    try:
162
248
        publicmode = req.publicmode
163
249
    except AttributeError:
186
272
    # misbehaves (which is currently very easy, if things aren't set up
187
273
    # correctly).
188
274
    # Write the traceback.
189
 
    # If this is a non-4xx IVLEError, get the message and httpcode and
190
 
    # make the error message a bit nicer (but still include the
191
 
    # traceback).
192
 
    # We also need to special-case IVLEJailError, as we can get another
 
275
 
 
276
    # We need to special-case IVLEJailError, as we can get another
193
277
    # almost-exception out of it.
194
 
 
195
 
    codename, msg = None, None
196
 
 
197
278
    if exc_type is util.IVLEJailError:
198
 
        msg = exc_value.type_str + ": " + exc_value.message
199
279
        tb = 'Exception information extracted from IVLEJailError:\n'
200
280
        tb += urllib.unquote(exc_value.info)
201
281
    else:
202
 
        try:
203
 
            codename, msg = req.get_http_codename(httpcode)
204
 
        except AttributeError:
205
 
            pass
206
 
 
207
282
        tb = ''.join(traceback.format_exception(exc_type, exc_value,
208
283
                                                exc_traceback))
209
284
 
210
 
    logging.error('%s\n%s'%(str(msg), tb))
 
285
    logging.error('\n' + tb)
211
286
 
212
287
    # Error messages are only displayed is the user is NOT a student,
213
288
    # or if there has been a problem logging the error message
217
292
<html xmlns="http://www.w3.org/1999/xhtml">
218
293
<head><title>IVLE Internal Server Error</title></head>
219
294
<body>
220
 
<h1>IVLE Internal Server Error""")
221
 
    if show_errors:
222
 
        if codename is not None and \
223
 
           httpcode != mod_python.apache.HTTP_INTERNAL_SERVER_ERROR:
224
 
            req.write(": %s" % cgi.escape(codename))
225
 
 
226
 
    req.write("""</h1>
 
295
<h1>IVLE Internal Server Error</h1>
227
296
<p>An error has occured which is the fault of the IVLE developers or
228
297
administrators. """)
229
298
 
235
304
    req.write("</p>")
236
305
 
237
306
    if show_errors:
238
 
        if msg is not None:
239
 
            req.write("<p>%s</p>\n" % cgi.escape(msg))
240
 
        if httpcode is not None:
241
 
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
242
307
        req.write("<h2>Debugging information</h2>")
243
 
 
244
308
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
245
309
    req.write("</body></html>")