# This file has been extracted from the abandoned TwistedWeb2 project

# http://twistedmatrix.com/trac/wiki/TwistedWeb2

import types, time

from calendar import timegm

import base64

import re

import urlparse

def dashCapitalize(s):

    ''' Capitalize a string, making sure to treat - as a word seperator '''

    return '-'.join([ x.capitalize() for x in s.split('-')])

# datetime parsing and formatting

weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']

weekdayname_lower = [name.lower() for name in weekdayname]

monthname = [None,

             'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',

             'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']

monthname_lower = [name and name.lower() for name in monthname]

# HTTP Header parsing API

header_case_mapping = {}

def casemappingify(d):

    global header_case_mapping

    newd = dict([(key.lower(), key) for key in d])

    header_case_mapping.update(newd)

def lowerify(d):

    return dict([(key.lower(), value) for key, value in d.items()])

class HeaderHandler(object):

    """HeaderHandler manages header generating and parsing functions.

    """

    HTTPParsers = {}

    HTTPGenerators = {}

    def __init__(self, parsers=None, generators=None):

        """

        @param parsers: A map of header names to parsing functions.

        @type parsers: L{dict}

        @param generators: A map of header names to generating functions.

        @type generators: L{dict}

        """

        if parsers:

            self.HTTPParsers.update(parsers)

        if generators:

            self.HTTPGenerators.update(generators)

    def parse(self, name, header):

        """

        Parse the given header based on its given name.

        @param name: The header name to parse.

        @type name: C{str}

        @param header: A list of unparsed headers.

        @type header: C{list} of C{str}

        @return: The return value is the parsed header representation,

            it is dependent on the header.  See the HTTP Headers document.

        """

        parser = self.HTTPParsers.get(name, None)

        if parser is None:

            raise ValueError("No header parser for header '%s', either add one or use getHeaderRaw." % (name,))

        try:

            for p in parser:

                #print "==> Parsing %s: %s(%s)" % (name, repr(p), repr(header))

                header = p(header)

                # if isinstance(h, types.GeneratorType):

                #     h = list(h)

        except ValueError as v:

            # print v

            header = None

        return header

    def generate(self, name, header):

        """

        Generate the given header based on its given name.

        @param name: The header name to generate.

        @type name: C{str}

        @param header: A parsed header, such as the output of

            L{HeaderHandler}.parse.

        @return: C{list} of C{str} each representing a generated HTTP header.

        """

        generator = self.HTTPGenerators.get(name, None)

        if generator is None:

            # print self.generators

            raise ValueError("No header generator for header '%s', either add one or use setHeaderRaw." % (name,))

        for g in generator:

            header = g(header)

        #self._raw_headers[name] = h

        return header

    def updateParsers(self, parsers):

        """Update en masse the parser maps.

        @param parsers: Map of header names to parser chains.

        @type parsers: C{dict}

        """

        casemappingify(parsers)

        self.HTTPParsers.update(lowerify(parsers))

    def addParser(self, name, value):

        """Add an individual parser chain for the given header.

        @param name: Name of the header to add

        @type name: C{str}

        @param value: The parser chain

        @type value: C{str}

        """

        self.updateParsers({name: value})

    def updateGenerators(self, generators):

        """Update en masse the generator maps.

        @param parsers: Map of header names to generator chains.

        @type parsers: C{dict}

        """

        casemappingify(generators)

        self.HTTPGenerators.update(lowerify(generators))

    def addGenerators(self, name, value):

        """Add an individual generator chain for the given header.

        @param name: Name of the header to add

        @type name: C{str}

        @param value: The generator chain

        @type value: C{str}

        """

        self.updateGenerators({name: value})

    def update(self, parsers, generators):

        """Conveniently update parsers and generators all at once.

        """

        self.updateParsers(parsers)

        self.updateGenerators(generators)

DefaultHTTPHandler = HeaderHandler()

## HTTP DateTime parser

def parseDateTime(dateString):

    """Convert an HTTP date string (one of three formats) to seconds since epoch."""

    parts = dateString.split()

    if not parts[0][0:3].lower() in weekdayname_lower:

        # Weekday is stupid. Might have been omitted.

        try:

            return parseDateTime("Sun, "+dateString)

        except ValueError:

            # Guess not.

            pass

    partlen = len(parts)

    if (partlen == 5 or partlen == 6) and parts[1].isdigit():

        # 1st date format: Sun, 06 Nov 1994 08:49:37 GMT

        # (Note: "GMT" is literal, not a variable timezone)

        # (also handles without "GMT")

        # This is the normal format

        day = parts[1]

        month = parts[2]

        year = parts[3]

        time = parts[4]

    elif (partlen == 3 or partlen == 4) and parts[1].find('-') != -1:

        # 2nd date format: Sunday, 06-Nov-94 08:49:37 GMT

        # (Note: "GMT" is literal, not a variable timezone)

        # (also handles without without "GMT")

        # Two digit year, yucko.

        day, month, year = parts[1].split('-')

        time = parts[2]

        year = int(year)

        if year < 69:

            year = year + 2000

        elif year < 100:

            year = year + 1900

    elif len(parts) == 5:

        # 3rd date format: Sun Nov  6 08:49:37 1994

        # ANSI C asctime() format.

        day = parts[2]

        month = parts[1]

        year = parts[4]

        time = parts[3]

    else:

        raise ValueError("Unknown datetime format %r" % dateString)

    day = int(day)

    month = int(monthname_lower.index(month.lower()))

    year = int(year)

    hour, min, sec = map(int, time.split(':'))

    return int(timegm((year, month, day, hour, min, sec)))

##### HTTP tokenizer

class Token(str):

    __slots__=[]

    tokens = {}

    def __new__(self, char):

        token = Token.tokens.get(char)

        if token is None:

            Token.tokens[char] = token = str.__new__(self, char)

        return token

    def __repr__(self):

        return "Token(%s)" % str.__repr__(self)

http_tokens = " \t\"()<>@,;:\\/[]?={}"

http_ctls = "\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x7f"

def tokenize(header, foldCase=True):

    """Tokenize a string according to normal HTTP header parsing rules.

    In particular:

     - Whitespace is irrelevant and eaten next to special separator tokens.

       Its existance (but not amount) is important between character strings.

     - Quoted string support including embedded backslashes.

     - Case is insignificant (and thus lowercased), except in quoted strings.

        (unless foldCase=False)

     - Multiple headers are concatenated with ','

    NOTE: not all headers can be parsed with this function.

    Takes a raw header value (list of strings), and

    Returns a generator of strings and Token class instances.

    """

    tokens = http_tokens

    ctls = http_ctls

    string = ",".join(header)

    list = []

    start = 0

    cur = 0

    quoted = False

    qpair = False

    inSpaces = -1

    qstring = None

    for x in string:

        if quoted:

            if qpair:

                qpair = False

                qstring = qstring+string[start:cur-1]+x

                start = cur+1

            elif x == '\\':

                qpair = True

            elif x == '"':

                quoted = False

                yield qstring+string[start:cur]

                qstring = None

                start = cur+1

        elif x in tokens:

            if start != cur:

                if foldCase:

                    yield string[start:cur].lower()

                else:

                    yield string[start:cur]

            start = cur+1

            if x == '"':

                quoted = True

                qstring = ""

                inSpaces = False

            elif x in " \t":

                if inSpaces is False:

                    inSpaces = True

            else:

                inSpaces = -1

                yield Token(x)

        elif x in ctls:

            raise ValueError("Invalid control character: %d in header" % ord(x))

        else:

            if inSpaces is True:

                yield Token(' ')

                inSpaces = False

            inSpaces = False

        cur = cur+1

    if qpair:

        raise ValueError("Missing character after '\\'")

    if quoted:

        raise ValueError("Missing end quote")

    if start != cur:

        if foldCase:

            yield string[start:cur].lower()

        else:

            yield string[start:cur]

def split(seq, delim):

    """The same as str.split but works on arbitrary sequences.

    Too bad it's not builtin to python!"""

    cur = []

    for item in seq:

        if item == delim:

            yield cur

            cur = []

        else:

            cur.append(item)

    yield cur

# def find(seq, *args):

#     """The same as seq.index but returns -1 if not found, instead

#     Too bad it's not builtin to python!"""

#     try:

#         return seq.index(value, *args)

#     except ValueError:

#         return -1

def filterTokens(seq):

    """Filter out instances of Token, leaving only a list of strings.

    Used instead of a more specific parsing method (e.g. splitting on commas)

    when only strings are expected, so as to be a little lenient.

    Apache does it this way and has some comments about broken clients which

    forget commas (?), so I'm doing it the same way. It shouldn't

    hurt anything, in any case.

    """

    l = []

    for x in seq:

        if not isinstance(x, Token):

            l.append(x)

    return l

##### parser utilities:

def checkSingleToken(tokens):

    if len(tokens) != 1:

        raise ValueError("Expected single token, not %s." % (tokens,))

    return tokens[0]

def parseKeyValue(val):

    if len(val) == 1:

        return val[0], None

    elif len(val) == 3 and val[1] == Token('='):

        return val[0], val[2]

    raise ValueError("Expected key or key=value, but got %s." % (val,))

def parseArgs(field):

    args = split(field, Token(';'))

    val = args.next()

    args = [parseKeyValue(arg) for arg in args]

    return val, args

def listParser(fun):

    """Return a function which applies 'fun' to every element in the

    comma-separated list"""

    def listParserHelper(tokens):

        fields = split(tokens, Token(','))

        for field in fields:

            if len(field) != 0:

                yield fun(field)

    return listParserHelper

def last(seq):

    """Return seq[-1]"""

    return seq[-1]

def unique(seq):

    '''if seq is not a string, check it's a sequence of one element and return it'''

    if isinstance(seq, basestring):

        return seq

    if len(seq) != 1:

        raise ValueError('single value required, not %s' % seq)

    return seq[0]

def parseHTTPMethod(method):

    """Ensure a HTTP method is valid according the rfc2616, but extension-method ones"""

    method = method.strip()

    if method not in ("OPTIONS", "GET", "HEAD", "POST", "PUT", "DELETE",

                      "TRACE", "CONNECT"):

        raise ValueError('Unsupported HTTP method %s' % method)

    return method

def parseAllowOrigin(origin):

    """Ensure origin is a valid URL-base stuff, or null"""

    if origin == 'null':

        return origin

    p = urlparse.urlparse(origin)

    if p.params or p.query or p.username or p.path not in ('', '/'):

        raise ValueError('Incorrect Accept-Control-Allow-Origin value %s' % origin)

    if p.scheme not in ('http', 'https'):

        raise ValueError('Unsupported Accept-Control-Allow-Origin URL scheme %s' % origin)

    if not p.netloc:

        raise ValueError('Accept-Control-Allow-Origin: host name cannot be unset  (%s)' % origin)

    return origin

def parseAllowCreds(cred):

    """Can be "true" """

    if cred:

        cred = cred.lower()

    if cred and cred != 'true':

        raise ValueError('Accept-Control-Allow-Credentials can only be "true" (%s)' % cred)

    return cred