path: root/cgi/framework.py

# 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 *

class CLT(datetime.tzinfo):
  """
  Clase para zona horaria chilena.
  Como el gobierno nos tiene los horarios de verano para la pura cagá,
  por mientras dejo el DST como un boolean. Cuando lo fijen, dejarlo automático.
  """
  def __init__(self):
    self.isdst = False
    
  def utcoffset(self, dt):
    #return datetime.timedelta(hours=-3) + self.dst(dt)
    return datetime.timedelta(hours=Settings.TIME_ZONE)
    
  def dst(self, dt):
    if self.isdst:
      return datetime.timedelta(hours=1)
    else:
      return datetime.timedelta(0)
      
  def tzname(self,dt):
    return "GMT -3"

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(CLT())
  # Timezone fix
  #t += datetime.timedelta(hours=1)
  
  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), CLT()), 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()