← Back to branch summary

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

« back to all changes in this revision

Viewing changes to www/dispatch/__init__.py

  • Committer: wagrant
  • Date: 2008-07-17 02:04:16 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:901
svnlogservice: Fix arbitrary content injection by commit message.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/dispatch/__init__.py
29
29
import mod_python
30
30
from mod_python import apache
31
31
 
 
32
import sys
32
33
import os
33
34
import os.path
 
35
import urllib
 
36
 
34
37
import conf
35
38
import conf.apps
 
39
import conf.conf
36
40
import apps
37
41
 
38
42
from request import Request
39
43
import html
 
44
import cgi
40
45
import login
41
 
from common import util
 
46
from common import (util, forumutil)
 
47
import traceback
 
48
import plugins.console
 
49
import logging
 
50
import socket
42
51
 
43
52
def handler(req):
44
53
    """Handles a request which may be to anywhere in the site except media.
48
57
    """
49
58
    # Make the request object into an IVLE request which can be passed to apps
50
59
    apachereq = req
51
 
    req = Request(req, html.write_html_head)
 
60
    try:
 
61
        req = Request(req, html.write_html_head)
 
62
    except Exception:
 
63
        # Pass the apachereq to error reporter, since ivle req isn't created
 
64
        # yet.
 
65
        handle_unknown_exception(apachereq, *sys.exc_info())
 
66
        # Tell Apache not to generate its own errors as well
 
67
        return apache.OK
 
68
 
 
69
    # Run the main handler, and catch all exceptions
 
70
    try:
 
71
        return handler_(req, apachereq)
 
72
    except mod_python.apache.SERVER_RETURN:
 
73
        # An apache error. We discourage these, but they might still happen.
 
74
        # Just raise up.
 
75
        raise
 
76
    except Exception:
 
77
        handle_unknown_exception(req, *sys.exc_info())
 
78
        # Tell Apache not to generate its own errors as well
 
79
        return apache.OK
 
80
 
 
81
def handler_(req, apachereq):
 
82
    """
 
83
    Nested handler function. May raise exceptions. The top-level handler is
 
84
    just used to catch exceptions.
 
85
    Takes both an IVLE request and an Apache req.
 
86
    """
 
87
    # Hack? Try and get the user login early just in case we throw an error
 
88
    # (most likely 404) to stop us seeing not logged in even when we are.
 
89
    req.user = login.get_user_details(req)
52
90
 
53
91
    # Check req.app to see if it is valid. 404 if not.
54
92
    if req.app is not None and req.app not in conf.apps.app_url:
56
94
        if req.app == 'logout':
57
95
            logout(req)
58
96
        else:
59
 
            # TODO: Nicer 404 message?
60
 
            req.throw_error(Request.HTTP_NOT_FOUND)
 
97
            req.throw_error(Request.HTTP_NOT_FOUND,
 
98
                "There is no application called %s." % repr(req.app))
 
99
 
 
100
    # Special handling for public mode - just call public app and get out
 
101
    # NOTE: This will not behave correctly if the public app uses
 
102
    # write_html_head_foot, but "serve" does not.
 
103
    if req.publicmode:
 
104
        app = conf.apps.app_url[conf.apps.public_app]
 
105
        apps.call_app(app.dir, req)
 
106
        return req.OK
61
107
 
62
108
    # app is the App object for the chosen app
63
109
    if req.app is None:
66
112
        app = conf.apps.app_url[req.app]
67
113
 
68
114
    # Check if app requires auth. If so, perform authentication and login.
 
115
    # This will either return a User object, None, or perform a redirect
 
116
    # which we will not catch here.
69
117
    if app.requireauth:
70
 
        req.username = login.login(req)
71
 
        logged_in = req.username is not None
 
118
        req.user = login.login(req)
 
119
        logged_in = req.user is not None
72
120
    else:
73
 
        req.username = login.get_username(req)
 
121
        req.user = login.get_user_details(req)
74
122
        logged_in = True
75
123
 
76
124
    if logged_in:
 
125
        # Keep the user's session alive by writing to the session object.
 
126
        # req.get_session().save()
 
127
        # Well, it's a fine idea, but it creates considerable grief in the
 
128
        # concurrent update department, so instead, we'll just make the
 
129
        # sessions not time out.
 
130
        
77
131
        # If user did not specify an app, HTTP redirect to default app and
78
132
        # exit.
79
133
        if req.app is None:
88
142
 
89
143
        # Call the specified app with the request object
90
144
        apps.call_app(app.dir, req)
 
145
 
91
146
    # if not logged in, login.login will have written the login box.
92
147
    # Just clean up and exit.
93
148
 
98
153
 
99
154
    # When done, write out the HTML footer if the app has requested it
100
155
    if req.write_html_head_foot:
 
156
        # Show the console if required
 
157
        if logged_in and app.useconsole:
 
158
            plugins.console.present(req, windowpane=True)
101
159
        html.write_html_foot(req)
102
160
 
103
161
    # Note: Apache will not write custom HTML error messages here.
110
168
    session = req.get_session()
111
169
    session.invalidate()
112
170
    session.delete()
 
171
    req.add_cookie(forumutil.invalidated_forum_cookie())
113
172
    req.throw_redirect(util.make_path(''))
 
173
 
 
174
def handle_unknown_exception(req, exc_type, exc_value, exc_traceback):
 
175
    """
 
176
    Given an exception that has just been thrown from IVLE, print its details
 
177
    to the request.
 
178
    This is a full handler. It assumes nothing has been written, and writes a
 
179
    complete HTML page.
 
180
    req: May be EITHER an IVLE req or an Apache req.
 
181
    IVLE reqs may have the HTML head/foot written (on a 400 error), but
 
182
    the handler code may pass an apache req if an exception occurs before
 
183
    the IVLE request is created.
 
184
    """
 
185
    req.content_type = "text/html"
 
186
    logfile = os.path.join(conf.conf.log_path, 'ivle_error.log')
 
187
    logfail = False
 
188
    # For some reason, some versions of mod_python have "_server" instead of
 
189
    # "main_server". So we check for both.
 
190
    try:
 
191
        admin_email = apache.main_server.server_admin
 
192
    except AttributeError:
 
193
        try:
 
194
            admin_email = apache._server.server_admin
 
195
        except AttributeError:
 
196
            admin_email = ""
 
197
    try:
 
198
        httpcode = exc_value.httpcode
 
199
        req.status = httpcode
 
200
    except AttributeError:
 
201
        httpcode = None
 
202
        req.status = apache.HTTP_INTERNAL_SERVER_ERROR
 
203
    try:
 
204
        login = req.user.login
 
205
    except AttributeError:
 
206
        login = None
 
207
 
 
208
    # Log File
 
209
    try:
 
210
        logging.basicConfig(level=logging.INFO,
 
211
            format='%(asctime)s %(levelname)s: ' +
 
212
                '(HTTP: ' + str(req.status) +
 
213
                ', Ref: ' + str(login) + '@' +
 
214
                str(socket.gethostname()) + str(req.uri) +
 
215
                ') %(message)s',
 
216
            filename=logfile,
 
217
            filemode='a')
 
218
    except IOError:
 
219
        logfail = True
 
220
    logging.debug('Logging Unhandled Exception')
 
221
 
 
222
    # We handle 3 types of error.
 
223
    # IVLEErrors with 4xx response codes (client error).
 
224
    # IVLEErrors with 5xx response codes (handled server error).
 
225
    # Other exceptions (unhandled server error).
 
226
    # IVLEErrors should not have other response codes than 4xx or 5xx
 
227
    # (eg. throw_redirect should have been used for 3xx codes).
 
228
    # Therefore, that is treated as an unhandled error.
 
229
 
 
230
    if (exc_type == util.IVLEError and httpcode >= 400
 
231
        and httpcode <= 499):
 
232
        # IVLEErrors with 4xx response codes are client errors.
 
233
        # Therefore, these have a "nice" response (we even coat it in the IVLE
 
234
        # HTML wrappers).
 
235
        
 
236
        req.write_html_head_foot = True
 
237
        req.write('<div id="ivle_padding">\n')
 
238
        try:
 
239
            codename, msg = req.get_http_codename(httpcode)
 
240
        except AttributeError:
 
241
            codename, msg = None, None
 
242
        # Override the default message with the supplied one,
 
243
        # if available.
 
244
        if exc_value.message is not None:
 
245
            msg = exc_value.message
 
246
        if codename is not None:
 
247
            req.write("<h1>Error: %s</h1>\n" % cgi.escape(codename))
 
248
        else:
 
249
            req.write("<h1>Error</h1>\n")
 
250
        if msg is not None:
 
251
            req.write("<p>%s</p>\n" % cgi.escape(msg))
 
252
        else:
 
253
            req.write("<p>An unknown error occured.</p>\n")
 
254
        
 
255
        # Logging
 
256
        logging.info(str(msg))
 
257
        
 
258
        req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
259
        if logfail:
 
260
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
261
                %cgi.escape(logfile))
 
262
        req.write('</div>\n')
 
263
    else:
 
264
        # A "bad" error message. We shouldn't get here unless IVLE
 
265
        # misbehaves (which is currently very easy, if things aren't set up
 
266
        # correctly).
 
267
        # Write the traceback.
 
268
        # If this is a non-4xx IVLEError, get the message and httpcode and
 
269
        # make the error message a bit nicer (but still include the
 
270
        # traceback).
 
271
        # We also need to special-case IVLEJailError, as we can get another
 
272
        # almost-exception out of it.
 
273
 
 
274
        codename, msg = None, None
 
275
 
 
276
        if exc_type is util.IVLEJailError:
 
277
            msg = exc_value.type_str + ": " + exc_value.message
 
278
            tb = 'Exception information extracted from IVLEJailError:\n'
 
279
            tb += urllib.unquote(exc_value.info)
 
280
        else:
 
281
            try:
 
282
                codename, msg = req.get_http_codename(httpcode)
 
283
            except AttributeError:
 
284
                pass
 
285
            # Override the default message with the supplied one,
 
286
            # if available.
 
287
            if hasattr(exc_value, 'message') and exc_value.message is not None:
 
288
                msg = exc_value.message
 
289
                # Prepend the exception type
 
290
                if exc_type != util.IVLEError:
 
291
                    msg = exc_type.__name__ + ": " + msg
 
292
 
 
293
            tb = ''.join(traceback.format_exception(exc_type, exc_value,
 
294
                                                    exc_traceback))
 
295
 
 
296
        # Logging
 
297
        logging.error('%s\n%s'%(str(msg), tb))
 
298
 
 
299
        req.write("""<html>
 
300
<head><title>IVLE Internal Server Error</title></head>
 
301
<body>
 
302
<h1>IVLE Internal Server Error""")
 
303
        if (codename is not None
 
304
            and httpcode != apache.HTTP_INTERNAL_SERVER_ERROR):
 
305
            req.write(": %s" % cgi.escape(codename))
 
306
        req.write("""</h1>
 
307
<p>An error has occured which is the fault of the IVLE developers or
 
308
administration.</p>
 
309
""")
 
310
        if msg is not None:
 
311
            req.write("<p>%s</p>\n" % cgi.escape(msg))
 
312
        if httpcode is not None:
 
313
            req.write("<p>(HTTP error code %d)</p>\n" % httpcode)
 
314
        req.write("""
 
315
<p>Please report this to <a href="mailto:%s">%s</a> (the system
 
316
administrator). Include the following information:</p>
 
317
""" % (cgi.escape(admin_email), cgi.escape(admin_email)))
 
318
 
 
319
        req.write("<pre>\n%s\n</pre>\n"%cgi.escape(tb))
 
320
        if logfail:
 
321
            req.write("<p>Warning: Could not open Error Log: '%s'</p>\n"
 
322
                %cgi.escape(logfile))
 
323
        req.write("</body>")