596 lines
19 KiB
Python
Executable File
596 lines
19 KiB
Python
Executable File
#!/usr/bin/env python
|
|
###
|
|
# Copyright (c) 2005-2007 Dennis Kaarsemaker
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of version 2 of the GNU General Public License as
|
|
# published by the Free Software Foundation.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
###
|
|
|
|
import sys
|
|
import time, datetime, pytz
|
|
import ConfigParser
|
|
import sqlite
|
|
import cPickle as pickle
|
|
|
|
CONFIG_FILENAME = "bantracker.conf"
|
|
config = ConfigParser.RawConfigParser()
|
|
config.add_section('webpage')
|
|
|
|
# set default values
|
|
config.set('webpage', 'database', '/home/bot/data/bans.db')
|
|
config.set('webpage', 'results_per_page', '100')
|
|
config.set('webpage', 'anonymous_access', 'True')
|
|
config.set('webpage', 'PLUGIN_PATH', '/var/www/bot')
|
|
config.set('webpage', 'irc_network', 'irc.freenode.net')
|
|
config.set('webpage', 'irc_channel', '#ubuntu-ops')
|
|
|
|
try:
|
|
config.readfp(open(CONFIG_FILENAME))
|
|
except IOError:
|
|
try:
|
|
config.write(open(CONFIG_FILENAME, 'w'))
|
|
except IOError:
|
|
pass
|
|
|
|
# This needs to be set to the location of the commoncgi.py file
|
|
PLUGIN_PATH = config.get('webpage', 'PLUGIN_PATH')
|
|
if PLUGIN_PATH:
|
|
sys.path.append(PLUGIN_PATH)
|
|
|
|
try:
|
|
from commoncgi import *
|
|
except:
|
|
print "Content-Type: text/html"
|
|
print
|
|
print "<p>Failed to load the module commoncgi</p>"
|
|
print "<p>Check that the configured option PLUGIN_PATH is correct.</p>"
|
|
sys.exit(-1)
|
|
|
|
db = config.get('webpage', 'database')
|
|
num_per_page = config.getint('webpage', 'results_per_page')
|
|
anonymous_access = config.getboolean('webpage', 'anonymous_access')
|
|
irc_network = config.get('webpage', 'irc_network')
|
|
irc_channel = config.get('webpage', 'irc_channel')
|
|
|
|
t1 = time.time()
|
|
|
|
try:
|
|
con = sqlite.connect(db)
|
|
cur = con.cursor()
|
|
except sqlite.DatabaseError:
|
|
print >> sys.stderr, "Unable to connect to to database '%s'" % db
|
|
send_page('bans.tmpl')
|
|
|
|
def db_execute(query, args):
|
|
try:
|
|
cur.execute(query, args)
|
|
return cur
|
|
except sqlite.OperationalError:
|
|
print >> sys.stderr, "The database is locked, wait a bit and try again."
|
|
send_page('bans.tmpl')
|
|
|
|
# Login check
|
|
error = ''
|
|
user = None
|
|
|
|
# Delete old sessions
|
|
try:
|
|
session_timeout = int(time.time()) - (2592000 * 3)
|
|
cur.execute('DELETE FROM sessions WHERE time < %d', (session_timeout,))
|
|
except:
|
|
pass
|
|
|
|
# Session handling
|
|
if 'sess' in form:
|
|
cookie['sess'] = form['sess'].value
|
|
if 'sess' in cookie:
|
|
sess = cookie['sess'].value
|
|
try:
|
|
cur.execute('SELECT user FROM sessions WHERE session_id=%s',(sess,))
|
|
user = cur.fetchall()[0][0]
|
|
except:
|
|
con.commit()
|
|
pass
|
|
|
|
if not user and not anonymous_access:
|
|
print "Sorry, bantracker is not available for anonymous users<br />"
|
|
print 'Join <a href="irc://%s/%s">%s</a> on %s to discuss bans.' % (irc_network, irc_channel[1:], irc_channel, irc_network)
|
|
send_page('bans.tmpl')
|
|
|
|
haveQuery = False
|
|
|
|
def urlencode(**kwargs):
|
|
"""Return the url options as a string, inserting additional ones if given."""
|
|
d = dict([ (i.name, i.value) for i in form.list ])
|
|
d.update(kwargs)
|
|
return utils.web.urlencode(d.items())
|
|
|
|
def isTrue(value):
|
|
"""Returns True if the form value is one of "1", "true", "yes", or "on", case insensitive"""
|
|
if not value:
|
|
return False
|
|
return value.lower() in ('1', 'true', 'yes', 'on')
|
|
|
|
def isFalse(value):
|
|
"""Returns True if the form value is one of "0", "false", "no", or "off", case insensitive"""
|
|
if not value:
|
|
return False
|
|
return value.lower() in ('0', 'false', 'no', 'off')
|
|
|
|
def isOn(k):
|
|
global haveQuery
|
|
default = not haveQuery
|
|
if not k in form:
|
|
return default
|
|
if isTrue(form[k].value):
|
|
return True
|
|
if isFalse(form[k].value):
|
|
return False
|
|
return default
|
|
|
|
|
|
# Log
|
|
if 'log' in form:
|
|
log_id = form['log'].value
|
|
plain = False
|
|
mark = False
|
|
mark_value = ''
|
|
regex = False
|
|
regex_value = ''
|
|
|
|
if 'plain' in form and isTrue(form['plain'].value):
|
|
plain = True
|
|
|
|
if 'mark' in form:
|
|
mark = True
|
|
mark_value = form['mark'].value
|
|
if 'regex' in form and isTrue(form['regex'].value):
|
|
regex = True
|
|
regex_value = 'checked="checked"'
|
|
|
|
log = db_execute("SELECT log FROM bans WHERE id=%s", log_id).fetchall()
|
|
|
|
if not log or not log[0] or not log[0][0]:
|
|
if plain:
|
|
print >> sys.stderr, '<div id="error">No such log with ID: %s' % q(log_id)
|
|
send_page('empty.tmpl')
|
|
else:
|
|
print >> sys.stderr, 'No such log with ID: %s' % q(log_id)
|
|
send_page('log.tmpl')
|
|
|
|
log = log[0][0]
|
|
|
|
if not plain:
|
|
print ' <div class="main">'
|
|
print ' <form id="hform" action="" method="get">'
|
|
print ' <fieldset>'
|
|
print ' <input type="hidden" name="log" id="log" value="%s">' % q(log_id)
|
|
print ' <label for="mark">Highlight:</label>'
|
|
print ' <input type="text" name="mark" id="mark" value="%s"/>' % q(mark_value)
|
|
print ' <input type="checkbox" name="regex" id="regex" %s>' % regex_value
|
|
print ' <label for="regex">Regex</label>'
|
|
print ' </fieldset>'
|
|
print ' <input class="input" type="submit" id="hform_submit" value="Update">'
|
|
print ' </form>'
|
|
print ' </div>'
|
|
|
|
pad = '<br />'
|
|
if plain:
|
|
pad = ''
|
|
print '<pre id="textlog">'
|
|
else:
|
|
print '<div id="textlog">'
|
|
|
|
if mark:
|
|
if regex:
|
|
try:
|
|
mark = re.compile(mark_value, re.I)
|
|
except:
|
|
print >> sys.stderr, "Malformed regex %r" % mark_value
|
|
mark = False
|
|
else:
|
|
escaped = re.escape(mark_value).replace('%', '.*')
|
|
mark = re.compile(escaped, re.I)
|
|
|
|
lines = log.splitlines()
|
|
for line in lines:
|
|
if plain:
|
|
print q(line)
|
|
elif mark:
|
|
if mark.search(line):
|
|
print ' <span class="highlight">%s</span>%s' % (q(line), pad)
|
|
else:
|
|
print " <span>%s</span>%s" % (q(line), pad)
|
|
else:
|
|
print ' <span>%s</span>%s' % (q(line), pad)
|
|
|
|
if plain:
|
|
print '</pre>'
|
|
send_page('empty.tmpl')
|
|
|
|
print '</div><br />'
|
|
print '<div>'
|
|
print ' <form id="comment_form" action="" method="post">'
|
|
print ' <fieldset>'
|
|
print ' <legend>Add a comment</legend>'
|
|
print ' <textarea cols="50" rows="5" class="input" name="comment"></textarea><br />'
|
|
print ' <input type="hidden" name="comment_id" value="%s" />' % log_id
|
|
print ' <input class="submit" type="submit" value="Send" />'
|
|
print ' </fieldset>'
|
|
print ' </form>'
|
|
print '</div>'
|
|
|
|
send_page('log.tmpl')
|
|
|
|
# Main page
|
|
# Process comments
|
|
if 'comment' in form and 'comment_id' in form and user:
|
|
cur.execute('SELECT ban_id FROM comments WHERE ban_id=%s and comment=%s', (form['comment_id'].value, form['comment'].value))
|
|
comm = cur.fetchall()
|
|
if not len(comm):
|
|
try:
|
|
cur.execute('INSERT INTO comments (ban_id, who, comment, time) VALUES (%s, %s, %s, %s)',
|
|
(form['comment_id'].value, user,form['comment'].value, pickle.dumps(datetime.datetime.now(pytz.UTC))))
|
|
con.commit()
|
|
except sqlite.DatabaseError:
|
|
con.rollback()
|
|
print >> sys.stderr, "Sorry, failed to submit comment to the database. Please try again later."
|
|
|
|
# Write the page
|
|
print '<form action="" method="POST">'
|
|
|
|
# Personal data
|
|
print '<div class="pdata">'
|
|
if user:
|
|
print 'Logged in as: %s <br /> ' % user
|
|
|
|
print 'Timezone: '
|
|
if 'tz' in form and form['tz'].value in pytz.common_timezones:
|
|
tz = form['tz'].value
|
|
elif 'tz' in cookie and cookie['tz'].value in pytz.common_timezones:
|
|
tz = cookie['tz'].value
|
|
else:
|
|
tz = 'UTC'
|
|
|
|
cookie['tz'] = tz
|
|
|
|
print '<select class="input" name="tz">'
|
|
for zone in pytz.common_timezones:
|
|
if zone == tz:
|
|
print '<option value="%s" selected="selected">%s</option>' % (zone, zone)
|
|
else:
|
|
print '<option value="%s">%s</option>' % (zone, zone)
|
|
print '</select>'
|
|
print '<input class="submit" type="submit" value="change" />'
|
|
print '</form><br />'
|
|
print '</div>'
|
|
|
|
tz = pytz.timezone(tz)
|
|
|
|
haveQuery = 'query' in form or 'channel' in form or 'operator' in form
|
|
|
|
def makeInput(name, label, before=False, type="checkbox", extra=''):
|
|
if before:
|
|
print '<label for="%s">%s</label>' % (name, label)
|
|
value = ''
|
|
if type == "checkbox":
|
|
if isOn(name):
|
|
value = ' checked="checked"'
|
|
else:
|
|
if name in form:
|
|
value = ' value="%s"' % form[name].value,
|
|
|
|
print '<input class="input" type="%s" name="%s" id="%s"%s /> %s' \
|
|
% (type, name, name, value, extra)
|
|
if not before:
|
|
print '<label for="%s">%s</label>' % (name, label)
|
|
print '<br />'
|
|
|
|
# Search form
|
|
print '<div class="search">'
|
|
print '<form action="" method="GET">'
|
|
makeInput("channel", "Channel:", True, "text")
|
|
makeInput("operator", "Operator:", True, "text")
|
|
makeInput("query", "Search:", True, "text", extra="(% and _ are wildcards)")
|
|
|
|
# Search fields
|
|
print '<div style="float:left">'
|
|
makeInput("kicks", "Kicks")
|
|
makeInput("bans", "Bans")
|
|
makeInput("oldbans", "Removed bans")
|
|
makeInput("marks", "Marks")
|
|
print '</div>'
|
|
|
|
print '<div style="float:left">'
|
|
makeInput("mutes", "Mutes")
|
|
makeInput("oldmutes", "Removed mutes")
|
|
makeInput("floodbots", "Include Floodbots")
|
|
print '</div>'
|
|
|
|
print '<div style="clear:both"><input class="submit" type="submit" value="search" /></div>'
|
|
print '</form></div>'
|
|
|
|
if not haveQuery:
|
|
# sqlite2 sucks, getting the last bans takes a lot of time.
|
|
# so lets disable that so at least the page loads quickly.
|
|
## Maybe we should include a link on the main page for those who do want
|
|
## to list the latest bans? --tsimpson
|
|
print '<div style="clear: both"></div>'
|
|
send_page('bans.tmpl')
|
|
|
|
# Select and filter bans
|
|
def getBans(id=None, mask=None, kicks=True, oldbans=True, bans=True, marks=True, floodbots=True, operator=None,
|
|
channel=None, limit=None, offset=0, withCount=False):
|
|
sql = "SELECT channel, mask, operator, time, removal, removal_op, id FROM bans"
|
|
args = []
|
|
where = []
|
|
if id:
|
|
where.append("id=%s")
|
|
args.append(id)
|
|
if mask:
|
|
where.append("mask LIKE %s")
|
|
args.append('%' + mask + '%')
|
|
if not floodbots:
|
|
where.append("operator NOT LIKE 'floodbot%%'")
|
|
if operator:
|
|
where.append("operator LIKE %s")
|
|
args.append(operator)
|
|
if channel:
|
|
where.append("channel LIKE %s")
|
|
args.append(channel)
|
|
if not marks:
|
|
where.append("id NOT IN (SELECT ban_id FROM comments WHERE comment LIKE '**MARK**%%')")
|
|
if not kicks:
|
|
where.append("mask LIKE '%%!%%'")
|
|
if not (oldbans or bans):
|
|
where.append("mask NOT LIKE '%%!%%'")
|
|
else:
|
|
if kicks:
|
|
s = "(mask NOT LIKE '%%%%!%%%%' OR (mask LIKE '%%%%!%%%%' AND %s))"
|
|
else:
|
|
s = "%s"
|
|
if not oldbans:
|
|
where.append(s % "removal IS NULL")
|
|
elif not bans:
|
|
where.append(s % "removal IS NOT NULL")
|
|
if where:
|
|
where = " WHERE " + " AND ".join(where)
|
|
else:
|
|
where = ''
|
|
sql += where
|
|
sql += " ORDER BY id DESC"
|
|
if limit:
|
|
sql += " LIMIT %s OFFSET %s" % (limit, offset)
|
|
#print sql, "<br/>"
|
|
#print args, "<br/>"
|
|
# Things seems faster if we do the query BEFORE counting. Due to caches probably.
|
|
bans = db_execute(sql, args).fetchall()
|
|
count = None
|
|
if withCount:
|
|
sql_count = "SELECT count(*) FROM bans%s" % where
|
|
count = int(db_execute(sql_count, args).fetchone()[0])
|
|
return bans, count
|
|
return bans
|
|
|
|
def filterMutes(item):
|
|
if item[1][0] == '%':
|
|
return False
|
|
return True
|
|
|
|
def getQueryTerm(query, term):
|
|
if term[-1] != ':':
|
|
term += ':'
|
|
if term in query:
|
|
idx = query.index(term) + len(term)
|
|
ret = query[idx:].split(None, 1)[0]
|
|
query = query.replace(term + ret, '', 1).strip()
|
|
return (query, ret)
|
|
return (query, None)
|
|
|
|
page = 0
|
|
if 'page' in form:
|
|
page = int(form['page'].value)
|
|
|
|
bans = []
|
|
ban_count = 0
|
|
query = oper = chan = None
|
|
if 'query' in form:
|
|
query = form['query'].value
|
|
|
|
if query and query.isdigit():
|
|
bans = getBans(id=int(query))
|
|
ban_count = len(bans)
|
|
|
|
if not bans:
|
|
if 'channel' in form:
|
|
chan = form['channel'].value
|
|
if 'operator' in form:
|
|
oper = form['operator'].value
|
|
|
|
filter_mutes = not (isOn('mutes') or isOn('oldmutes'))
|
|
filter_bans = not (isOn('bans') or isOn('oldbans'))
|
|
filter_bans_or_mutes = bool(filter_bans) ^ bool(filter_mutes)
|
|
if filter_bans_or_mutes:
|
|
# we are going to filter the mutes from ban list, this sucks, because then we can't
|
|
# paginate correctly using SQL with LIMIT and OFFSET, so we *have* to get all bans and
|
|
# paginate manually.
|
|
limit = offset = None
|
|
else:
|
|
limit = num_per_page
|
|
offset = num_per_page * page
|
|
bans, ban_count = getBans(mask=query, kicks=isOn('kicks'),
|
|
oldbans=isOn('oldbans') or isOn('oldmutes'),
|
|
bans=isOn('bans') or isOn('mutes'),
|
|
marks=isOn('marks'),
|
|
floodbots=isOn('floodbots'),
|
|
operator=oper,
|
|
channel=chan,
|
|
limit=limit,
|
|
offset=offset,
|
|
withCount=True)
|
|
|
|
#print 'filtering', filter_bans_or_mutes, '<br/>'
|
|
#print "total count", ban_count, "bans", len(bans), '<br/>'
|
|
if filter_bans_or_mutes:
|
|
if filter_mutes:
|
|
bans = filter(lambda x: filterMutes(x), bans)
|
|
elif filter_bans:
|
|
bans = filter(lambda x: not filterMutes(x), bans)
|
|
ban_count = len(bans)
|
|
# pick the bans for current page, since we didn't do it with SQL
|
|
if ban_count > num_per_page:
|
|
bans = bans[page * num_per_page: (page + 1) * num_per_page]
|
|
#print "total count after filtering", ban_count, '<br/>'
|
|
|
|
# Sort the bans
|
|
def _sortf(x1,x2,field):
|
|
if x1[field] < x2[field]: return -1
|
|
if x1[field] > x2[field]: return 1
|
|
return 0
|
|
|
|
if 'sort' in form:
|
|
try:
|
|
field = int(form['sort'].value)
|
|
except:
|
|
pass
|
|
else:
|
|
if field in (0,1,2,6,10,11,12,16):
|
|
bans.sort(lambda x1,x2: _sortf(x1,x2,field%10))
|
|
if field >= 10:
|
|
bans.reverse()
|
|
|
|
if haveQuery:
|
|
if not ban_count:
|
|
print '<div style="clear: both">Nothing found.</div>'
|
|
elif ban_count == 1:
|
|
print '<div style="clear: both">Found one match.</div>'
|
|
else:
|
|
print '<div style="clear: both">Found %s matches.</div>' % ban_count
|
|
|
|
# Pagination
|
|
if bans:
|
|
pagination = '<div style="clear: both">\n·\n'
|
|
num_pages = int(math.ceil(ban_count / float(num_per_page)))
|
|
for i in range(num_pages):
|
|
if page == i:
|
|
pagination += '<a href="?%s">[%d]</a> ·\n' % (urlencode(page=i), i + 1)
|
|
else:
|
|
pagination += '<a href="?%s">%d</a> ·\n' % (urlencode(page=i), i + 1)
|
|
pagination += '</div>\n'
|
|
print pagination
|
|
else:
|
|
# nothign to show
|
|
print '<div style="clear: both"></div>' # if I don't print this the page is messed up.
|
|
send_page('bans.tmpl')
|
|
|
|
# Empty log div, will be filled with AJAX
|
|
print '<div id="log" class="log"> </div>'
|
|
|
|
# Main bans table
|
|
# Table heading
|
|
print '<div>'
|
|
print '<table cellspacing="0">'
|
|
print '<thead>'
|
|
print '<tr>'
|
|
for h in [ ('Channel', 0, 45),
|
|
('Nick/Mask', 1, 25),
|
|
('Operator', 2, 0),
|
|
('Time', 6, 15) ]:
|
|
# Negative integers for backwards searching
|
|
try:
|
|
v = int(form['sort'].value)
|
|
if v < 10: h[1] += 10
|
|
except:
|
|
pass
|
|
#print '<th style="width: %s%%"><a href="?sort=%s">%s</a></th>' % (h[2], h[1], h[0])
|
|
print '<th style="width: %s%%">%s</th>' % (h[2], h[0])
|
|
print '<th style="width: 15%">Log</th>'
|
|
print '<th>ID</th>'
|
|
print '</tr>'
|
|
print '</thead>'
|
|
print '<tbody>'
|
|
|
|
# And finally, display them!
|
|
i = 0
|
|
for b in bans:
|
|
if i % 2:
|
|
print '<tr class="bg2">'
|
|
else:
|
|
print "<tr>"
|
|
# Channel
|
|
print '<td id="channel-%d">%s %s</td>' % (b[6],'',b[0])
|
|
# Mask
|
|
print '<td id="mask-%d">%s' % (b[6], b[1])
|
|
# Ban removal
|
|
if b[4]:
|
|
print '<br /><span class="removal">(Removed)</span>'
|
|
print'</td>'
|
|
# Operator
|
|
print '<td id="operator-%d">%s' % (b[6], b[2])
|
|
if b[4]: # Ban removal
|
|
print u'<br /><span class="removal">%s</span>' % b[5]
|
|
print '</td>'
|
|
# Time
|
|
print '<td id="time-%d">%s' % (b[6], pickle.loads(b[3]).astimezone(tz).strftime("%b %d %Y %H:%M:%S"))
|
|
if b[4]: # Ban removal
|
|
print '<br /><span class="removal">%s</span>' % pickle.loads(b[4]).astimezone(tz).strftime("%b %d %Y %H:%M:%S")
|
|
print '</td>'
|
|
# Log link
|
|
print """<td>
|
|
Show log <a class="pseudolink" id="loglink-%s" onclick="showlog('%s')">inline</a>
|
|
| <a href="?log=%d">full</a>
|
|
</td>""" % (b[6], b[6], b[6])
|
|
|
|
# ID
|
|
print '<td id="id-%d">%d</td>' % (b[6], b[6])
|
|
print "</tr>"
|
|
|
|
# Comments
|
|
if i % 2:
|
|
print '<tr class="bg2">'
|
|
else:
|
|
print "<tr>"
|
|
db_execute('SELECT who, comment, time FROM comments WHERE ban_id=%d', (b[6],))
|
|
comments = cur.fetchall()
|
|
if len(comments) == 0:
|
|
print '<td colspan="5" class="comment">'
|
|
print '<div class="invisible" id="comments">%d</div>' % b[6]
|
|
print '<span class="removal">(No comments) </span>'
|
|
else:
|
|
print '<td colspan="5" class="comment" id="comments-%d">' % b[6]
|
|
print '<div class="invisible" id="comments">%d</div>' % b[6]
|
|
for c in comments:
|
|
print q(c[1]).replace('\n', '<br />')
|
|
print u' <span class="removal"><br />%s, %s</span><br />' % \
|
|
(c[0],pickle.loads(c[2]).astimezone(tz).strftime("%b %d %Y %H:%M:%S"))
|
|
if user:
|
|
print """<span class="pseudolink" onclick="toggle('%s','comment')">Add comment</span>""" % b[6]
|
|
print """<div class="invisible" id="comment_%s"><br />""" % b[6]
|
|
print """ <form action="" method="post">"""
|
|
print """ <textarea cols="50" rows="5" class="input" name="comment"></textarea><br />"""
|
|
print """ <input type="hidden" name="comment_id" value="%s" />""" % b[6]
|
|
print """ <input class="submit" type="submit" value="Send" />"""
|
|
print """ </form>"""
|
|
print """</div>"""
|
|
print '</td><td></td></tr>'
|
|
i += 1
|
|
|
|
|
|
print '</table>'
|
|
if bans:
|
|
print pagination
|
|
|
|
t2 = time.time()
|
|
|
|
print "<!-- Generated in %.4f seconds -->" % (t2 - t1)
|
|
|
|
# Aaaaaaaaaaaaaaaaand send!
|
|
send_page('bans.tmpl')
|