# coding=utf-8
import os
import cgi
import datetime
import time
import hashlib
import pickle
import socket
import _mysql
import urllib
import re
from Cookie import SimpleCookie
from settings import Settings
from database import *
def setBoard(dir):
"""
Sets the board which the script is operating on by filling Settings._.BOARD
with the data from the db.
"""
if not dir:
raise UserError, _("The specified board is invalid.")
logTime("Seteando el board " + dir)
board = FetchOne("SELECT * FROM `boards` WHERE `dir` = '%s' LIMIT 1" % _mysql.escape_string(dir))
if not board:
raise UserError, _("The specified board is invalid.")
board["filetypes"] = FetchAll("SELECT * FROM `boards_filetypes` INNER JOIN `filetypes` ON filetypes.id = boards_filetypes.filetypeid WHERE `boardid` = %s ORDER BY `ext` ASC" % _mysql.escape_string(board['id']))
board["filetypes_ext"] = [filetype['ext'] for filetype in board['filetypes']]
logTime("Board seteado.")
Settings._.BOARD = board
return board
def cleanDir(path, ext=None):
if ext:
filelist = [ f for f in os.listdir(path) if f.endswith("." + ext) ]
else:
filelist = os.listdir(path)
for f in filelist:
os.remove(os.path.join(path, f))
def addressIsBanned(ip, board):
packed_ip = inet_aton(ip)
bans = FetchAll("SELECT * FROM `bans` WHERE (`netmask` IS NULL AND `ip` = '"+str(packed_ip)+"') OR (`netmask` IS NOT NULL AND '"+str(packed_ip)+"' & `netmask` = `ip`)")
logTime("SELECT * FROM `bans` WHERE (`netmask` IS NULL AND `ip` = '"+str(packed_ip)+"') OR (`netmask` IS NOT NULL AND '"+str(packed_ip)+"' & `netmask` = `ip`)")
for ban in bans:
if ban["boards"] != "":
boards = pickle.loads(ban["boards"])
if ban["boards"] == "" or board in boards:
if board not in Settings.EXCLUDE_GLOBAL_BANS:
return True
return False
def addressIsTor(ip):
if Settings._.IS_TOR is None:
res = False
nodes = []
if ip == '127.0.0.1': # Tor proxy address
res = True
else:
with open('tor.txt') as f:
nodes = [line.rstrip() for line in f]
if ip in nodes:
res = True
Settings._.IS_TOR = res
return res
else:
return Settings._.IS_TOR
def addressIsProxy(ip):
if Settings._.IS_PROXY is None:
res = False
proxies = []
with open('proxy.txt') as f:
proxies = [line.rstrip() for line in f]
if ip in proxies:
res = True
Settings._.IS_PROXY = res
return res
else:
return Settings._.IS_PROXY
def addressIsES(ip):
ES = ['AR', 'BO', 'CL', 'CO', 'CR', 'CU', 'EC', 'ES', 'GF',
'GY', 'GT', 'HN', 'MX', 'NI', 'PA', 'PE', 'PY', 'PR', 'SR', 'UY', 'VE'] # 'BR',
return getCountry(ip) in ES
def getCountry(ip):
import geoip
return geoip.country(ip)
def getHost(ip):
if Settings._.HOST is None:
try:
Settings._.HOST = socket.gethostbyaddr(ip)[0]
return Settings._.HOST
except socket.herror:
return None
else:
return Settings._.HOST
def hostIsBanned(ip):
host = getHost(ip)
if host:
banned_hosts = []
for banned_host in banned_hosts:
if host.endswith(banned_host):
return True
return False
else:
return False
def updateBoardSettings():
"""
Pickle the board's settings and store it in the configuration field
"""
board = Settings._.BOARD
#UpdateDb("UPDATE `boards` SET `configuration` = '%s' WHERE `id` = %s LIMIT 1" % (_mysql.escape_string(configuration), board["id"]))
del board["filetypes"]
del board["filetypes_ext"]
post_values = ["`" + _mysql.escape_string(str(key)) + "` = '" + _mysql.escape_string(str(value)) + "'" for key, value in board.iteritems()]
UpdateDb("UPDATE `boards` SET %s WHERE `id` = '%s' LIMIT 1" % (", ".join(post_values), board["id"]))
def timestamp(t=None):
"""
Create MySQL-safe timestamp from the datetime t if provided, otherwise create
the timestamp from datetime.now()
"""
if not t:
t = datetime.datetime.now()
return int(time.mktime(t.timetuple()))
def formatDate(t=None, home=False):
"""
Format a datetime to a readable date
"""
if not t:
t = datetime.datetime.now()
days = {'en': ['mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun'],
'es': ['lun', 'mar', 'mie', 'jue', 'vie', 'sab', 'dom'],
'jp': ['月', '火', '水', '木', '金', '土', '日']}
daylist = days[Settings.LANG]
format = "%d/%m/%y(%a)%H:%M:%S"
if not home:
try:
board = Settings._.BOARD
if board["dir"] == 'world':
daylist = days['en']
elif board["dir"] == '2d':
daylist = days['jp']
except:
pass
t = t.strftime(format)
t = re.compile(r"mon", re.DOTALL | re.IGNORECASE).sub(daylist[0], t)
t = re.compile(r"tue", re.DOTALL | re.IGNORECASE).sub(daylist[1], t)
t = re.compile(r"wed", re.DOTALL | re.IGNORECASE).sub(daylist[2], t)
t = re.compile(r"thu", re.DOTALL | re.IGNORECASE).sub(daylist[3], t)
t = re.compile(r"fri", re.DOTALL | re.IGNORECASE).sub(daylist[4], t)
t = re.compile(r"sat", re.DOTALL | re.IGNORECASE).sub(daylist[5], t)
t = re.compile(r"sun", re.DOTALL | re.IGNORECASE).sub(daylist[6], t)
return t
def formatTimestamp(t, home=False):
"""
Format a timestamp to a readable date
"""
return formatDate(datetime.datetime.fromtimestamp(int(t)), home)
def timeTaken(time_start, time_finish):
return str(round(time_finish - time_start, 3))
def parseIsoPeriod(t_str):
m = re.match('P(?:(\d+)D)?T(?:(\d+)H)?(?:(\d+)M)?(\d+)S', t_str)
if m:
grps = [x for x in m.groups() if x]
if len(grps) == 1:
grps.insert(0, '0')
grps[-1] = grps[-1].zfill(2)
return ':'.join(grps)
else:
return '???'
def getFormData(self):
"""
Process input sent to WSGI through a POST method and output it in an easy to
retrieve format: dictionary of dictionaries in the format of {key: value}
"""
# This must be done to avoid a bug in cgi.FieldStorage
self.environ.setdefault("QUERY_STRING", "")
if self.environ["QUERY_STRING"] == "rawpost":
return None
wsgi_input = self.environ["wsgi.input"]
post_form = self.environ.get("wsgi.post_form")
if (post_form is not None
and post_form[0] is wsgi_input):
return post_form[2]
fs = cgi.FieldStorage(fp=wsgi_input,
environ=self.environ,
keep_blank_values=1)
new_input = InputProcessed()
post_form = (new_input, wsgi_input, fs)
self.environ["wsgi.post_form"] = post_form
self.environ["wsgi.input"] = new_input
try:
formdata = {}
for key in dict(fs):
try:
formdata.update({key: fs[key].value})
if key == "file":
formdata.update({"file_original": secure_filename(fs[key].filename)})
except AttributeError:
formdata.update({key: fs[key]})
return formdata
except TypeError:
return fs
class InputProcessed(object):
def read(self):
raise EOFError("El stream de wsgi.input ya se ha consumido.")
readline = readlines = __iter__ = read
class UserError(Exception):
pass
def secure_filename(path):
split = re.compile(r'[\0%s]' % re.escape(''.join([os.path.sep, os.path.altsep or ''])))
return cgi.escape(split.sub('', path))
def getMD5(data):
m = hashlib.md5()
m.update(data)
return m.hexdigest()
def nullstr(len): return "\0" * len
def hide_data(data, length, key, secret):
"""
Encrypts data, useful for tripcodes and IDs
"""
crypt = rc4(nullstr(length), rc4(nullstr(32), key + secret) + data).encode('base64')
return crypt.rstrip('\n')
def rc4(data, key):
"""
rc4 implementation
"""
x = 0
box = range(256)
for i in range(256):
x = (x + box[i] + ord(key[i % len(key)])) % 256
box[i], box[x] = box[x], box[i]
x = 0
y = 0
out = []
for char in data:
x = (x + 1) % 256
y = (y + box[x]) % 256
box[x], box[y] = box[y], box[x]
out.append(chr(ord(char) ^ box[(box[x] + box[y]) % 256]))
return ''.join(out)
def getRandomLine(filename):
import random
f = open(filename, 'r')
lines = f.readlines()
num = random.randint(0, len(lines) - 1)
return lines[num]
def getRandomIco():
from glob import glob
from random import choice
icons = glob("../static/ico/*")
if icons:
return choice(icons).lstrip('..')
else:
return ''
def N_(message): return message
def getCookie(self, value=""):
try:
return urllib.unquote_plus(self._cookies[value].value)
except KeyError:
return None
def reCookie(self, key, value=""):
board = Settings._.BOARD
setCookie(self, key, value)
def setCookie(self, key, value="", max_age=None, expires=None, path="/", domain=None, secure=None):
"""
Copied from Colubrid
"""
if self._newcookies is None:
self._newcookies = SimpleCookie()
self._newcookies[key] = urllib.quote_plus(value)
if not max_age is None:
self._newcookies[key]["max-age"] = max_age
if not expires is None:
if isinstance(expires, basestring):
self._newcookies[key]["expires"] = expires
expires = None
elif isinstance(expires, datetime):
expires = expires.utctimetuple()
elif not isinstance(expires, (int, long)):
expires = datetime.datetime.gmtime(expires)
else:
raise ValueError("Se requiere de un entero o un datetime")
if not expires is None:
now = datetime.datetime.gmtime()
month = _([N_("Jan"), N_("Feb"), N_("Mar"), N_("Apr"), N_("May"), N_("Jun"), N_("Jul"),
N_("Aug"), N_("Sep"), N_("Oct"), N_("Nov"), N_("Dec")][now.tm_mon - 1])
day = _([N_("Monday"), N_("Tuesday"), N_("Wednesday"), N_("Thursday"),
N_("Friday"), N_("Saturday"), N_("Sunday")][expires.tm_wday])
date = "%02d-%s-%s" % (
now.tm_mday, month, str(now.tm_year)[-2:]
)
d = "%s, %s %02d:%02d:%02d GMT" % (day, date, now.tm_hour,
now.tm_min, now.tm_sec)
self._newcookies[key]["expires"] = d
if not path is None:
self._newcookies[key]["path"] = path
if not domain is None:
if domain != "THIS":
self._newcookies[key]["domain"] = domain
if not secure is None:
self._newcookies[key]["secure"] = secure
def deleteCookie(self, key):
"""
Copied from Colubrid
"""
if key not in self._cookies:
return # Cookie doesn't exist
if self._newcookies is None:
self._newcookies = SimpleCookie()
self._newcookies[key] = ""
if self._cookies[key]["path"]:
self._newcookies[key]["path"] = self._cookies[key]["path"]
else:
self._newcookies[key]["path"] = "/"
self._newcookies[key]["domain"] = self._cookies[key]["domain"]
self._newcookies[key]["expires"] = "Thu, 01 Jan 1970 00:00:00 GMT"
def elapsed_time(seconds, suffixes=['y','w','d','h','m','s'], add_s=False, separator=' '):
"""
Takes an amount of seconds and turns it into a human-readable amount of time.
"""
# the formatted time string to be returned
time = []
# the pieces of time to iterate over (days, hours, minutes, etc)
# - the first piece in each tuple is the suffix (d, h, w)
# - the second piece is the length in seconds (a day is 60s * 60m * 24h)
parts = [(suffixes[0], 60 * 60 * 24 * 7 * 52),
(suffixes[1], 60 * 60 * 24 * 7),
(suffixes[2], 60 * 60 * 24),
(suffixes[3], 60 * 60),
(suffixes[4], 60),
(suffixes[5], 1)]
# for each time piece, grab the value and remaining seconds, and add it to
# the time string
for suffix, length in parts:
value = seconds / length
if value > 0:
seconds = seconds % length
time.append('%s%s' % (str(value),
(suffix, (suffix, suffix + 's')[value > 1])[add_s]))
if seconds < 1:
break
return separator.join(time)
def inet_aton(ip_string):
import socket, struct
return struct.unpack('!L',socket.inet_aton(ip_string))[0]
def inet_ntoa(packed_ip):
import socket, struct
return socket.inet_ntoa(struct.pack('!L',packed_ip))
def is_bad_proxy(pip):
import urllib2
import socket
socket.setdefaulttimeout(3)
try:
proxy_handler = urllib2.ProxyHandler({'http': pip})
opener = urllib2.build_opener(proxy_handler)
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
urllib2.install_opener(opener)
req=urllib2.Request('http://bienvenidoainternet.org')
sock=urllib2.urlopen(req)
except urllib2.HTTPError, e:
return e.code
except Exception, detail:
return True
return False
def send_mail(subject, srcmsg):
import smtplib
from email.mime.text import MIMEText
msg = MIMEText(srcmsg)
me = 'weabot@bienvenidoainternet.org'
you = 'burocracia@bienvenidoainternet.org'
msg['Subject'] = 'The contents of %s' % textfile
msg['From'] = me
msg['To'] = you
s = smtplib.SMTP('localhost')
s.sendmail(me, [you], msg.as_string())
s.quit()
class weabotLogger:
def __init__(self):
self.times = []
def log(self, message):
self.times.append([time.time(), message])
def allTimes(self):
output = "Time Logged action\n--------------------------\n"
start = self.times[0][0]
for time in self.times:
difference = str(time[0] - start)
difference_split = difference.split(".")
if len(difference_split[0]) < 2:
difference_split[0] = "0" + difference_split[0]
if len(difference_split[1]) < 7:
difference_split[1] = ("0" * (7 - len(difference_split[1]))) + difference_split[1]
elif len(difference_split[1]) > 7:
difference_split[1] = difference_split[1][:7]
output += ".".join(difference_split) + " " + time[1] + "\n"
return output
logger = weabotLogger()
def logTime(message):
global logger
logger.log(message)
def logTimes():
global logger
return logger.allTimes()
