[wrw.git] / wrw / proto.py

import time

statusinfo = {
    400: ("Bad Request", "Invalid HTTP request."),
    401: ("Unauthorized", "Authentication must be provided for the requested resource."),
    403: ("Forbidden", "You are not authorized to request the requested resource."),
    404: ("Not Found", "The requested resource was not found."),
    405: ("Method Not Allowed", "The request method is not recognized or permitted by the requested resource."),
    500: ("Server Error", "An internal error occurred."),
    501: ("Not Implemented", "The requested functionality has not been implemented."),
    503: ("Service Unavailable", "Service is being denied at this time."),
    }

def httpdate(ts):
    return time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(ts))

def phttpdate(dstr):
    tz = dstr[-6:]
    dstr = dstr[:-6]
    if tz[0] != " " or (tz[1] != "+" and tz[1] != "-") or not tz[2:].isdigit():
        return None
    tz = int(tz[1:])
    tz = (((tz / 100) * 60) + (tz % 100)) * 60
    return time.mktime(time.strptime(dstr, "%a, %d %b %Y %H:%M:%S")) - tz - time.altzone

def pmimehead(hstr):
    def pws(p):
        while p < len(hstr) and hstr[p].isspace():
            p += 1
        return p
    def token(p, sep):
        buf = ""
        p = pws(p)
        if p >= len(hstr):
            return "", p
        if hstr[p] == '"':
            p += 1
            while p < len(hstr):
                if hstr[p] == '\\':
                    p += 1
                    if p < len(hstr):
                        buf += hstr[p]
                        p += 1
                    else:
                        break
                elif hstr[p] == '"':
                    p += 1
                    break
                else:
                    buf += hstr[p]
                    p += 1
            return buf, pws(p)
        else:
            while p < len(hstr):
                if hstr[p] in sep:
                    break
                buf += hstr[p]
                p += 1
            return buf.strip(), pws(p)
    p = 0
    val, p = token(p, ";")
    pars = {}
    while p < len(hstr):
        if hstr[p] != ';':
            break
        p += 1
        k, p = token(p, "=")
        if k == "" or hstr[p:p + 1] != '=':
            break
        p += 1
        v, p = token(p, ';')
        pars[k.lower()] = v
    return val, pars

def htmlq(html):
    ret = ""
    for c in html:
        if c == "&":
            ret += "&amp;"
        elif c == "<":
            ret += "&lt;"
        elif c == ">":
            ret += "&gt;"
        else:
            ret += c
    return ret

def simpleerror(env, startreq, code, title, msg):
    buf = """<?xml version="1.0" encoding="US-ASCII"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
<head>
<title>%s</title>
</head>
<body>
<h1>%s</h1>
<p>%s</p>
</body>
</html>
""" % (title, title, htmlq(msg))
    buf = buf.encode("us-ascii")
    startreq("%i %s" % (code, title), [("Content-Type", "text/html"), ("Content-Length", str(len(buf)))])
    return [buf]

def urlq(url):
    ret = ""
    invalid = "&=#?/\"'"
    for c in url:
        if c in invalid or (ord(c) <= 32):
            ret += "%%%02X" % ord(c)
        else:
            ret += c
    return ret

class urlerror(ValueError):
    pass

def parseurl(url):
    p = url.find("://")
    if p < 0:
        raise urlerror("Protocol not found in absolute URL `%s'" % url)
    proto = url[:p]
    l = url.find("/", p + 3)
    if l < 0:
        raise urlerror("Local part not found in absolute URL `%s'" % url)
    host = url[p + 3:l]
    local = url[l:]
    q = local.find("?")
    if q < 0:
        query = ""
    else:
        query = local[q + 1:]
        local = local[:q]
    return proto, host, local, query

def consurl(proto, host, local, query=""):
    if len(local) < 1 and local[0] != '/':
        raise urlerror("Local part of URL must begin with a slash")
    ret = "%s://%s%s" % (proto, host, local)
    if len(query) > 0:
        ret += "?" + query
    return ret

def appendurl(url, other):
    if "://" in other:
        return other
    proto, host, local, query = parseurl(url)
    if len(other) > 0 and other[0] == '/':
        return consurl(proto, host, other)
    else:
        p = local.rfind('/')
        return consurl(proto, host, local[:p + 1] + other)

def siteurl(req):
    host = req.ihead.get("Host", None)
    if host is None:
        raise Exception("Could not reconstruct URL because no Host header was sent")
    proto = "http"
    if req.https:
        proto = "https"
    return "%s://%s/" % (proto, host)

def scripturl(req):
    s = siteurl(req)
    if req.uriname[0] != '/':
        raise Exception("Malformed local part when reconstructing URL")
    return siteurl(req) + req.uriname[1:]

def requrl(req):
    s = siteurl(req)
    if req.uri[0] != '/':
        raise Exception("Malformed local part when reconstructing URL")
    return siteurl(req) + req.uri[1:]

def parstring(pars={}, **augment):
    buf = ""
    for key in pars:
        if key in augment:
            val = augment[key]
            del augment[key]
        else:
            val = pars[key]
        if buf != "": buf += "&"
        buf += urlq(key) + "=" + urlq(str(val))
    for key in augment:
        if buf != "": buf += "&"
        buf += urlq(key) + "=" + urlq(str(augment[key]))
    return buf

def parurl(url, pars={}, **augment):
    qs = parstring(pars, **augment)
    if qs != "":
        return url + "?" + qs
    else:
        return url
Commit	Line	Data
3ba5e96c FT	1	import time
3ba5e96c FT	2
5ef9e488	3	statusinfo = {
001ec99e FT	4	400: ("Bad Request", "Invalid HTTP request."),
	5	401: ("Unauthorized", "Authentication must be provided for the requested resource."),
	6	403: ("Forbidden", "You are not authorized to request the requested resource."),
5ef9e488	7	404: ("Not Found", "The requested resource was not found."),
001ec99e FT	8	405: ("Method Not Allowed", "The request method is not recognized or permitted by the requested resource."),
	9	500: ("Server Error", "An internal error occurred."),
	10	501: ("Not Implemented", "The requested functionality has not been implemented."),
	11	503: ("Service Unavailable", "Service is being denied at this time."),
5ef9e488 FT	12	}
	13
	14	def httpdate(ts):
	15	return time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime(ts))
	16
	17	def phttpdate(dstr):
	18	tz = dstr[-6:]
	19	dstr = dstr[:-6]
	20	if tz[0] != " " or (tz[1] != "+" and tz[1] != "-") or not tz[2:].isdigit():
	21	return None
	22	tz = int(tz[1:])
	23	tz = (((tz / 100) * 60) + (tz % 100)) * 60
	24	return time.mktime(time.strptime(dstr, "%a, %d %b %Y %H:%M:%S")) - tz - time.altzone
	25
eed3cf12 FT	26	def pmimehead(hstr):
	27	def pws(p):
	28	while p < len(hstr) and hstr[p].isspace():
	29	p += 1
	30	return p
	31	def token(p, sep):
	32	buf = ""
	33	p = pws(p)
	34	if p >= len(hstr):
	35	return "", p
	36	if hstr[p] == '"':
	37	p += 1
	38	while p < len(hstr):
	39	if hstr[p] == '\\':
	40	p += 1
	41	if p < len(hstr):
	42	buf += hstr[p]
	43	p += 1
	44	else:
	45	break
	46	elif hstr[p] == '"':
	47	p += 1
	48	break
	49	else:
	50	buf += hstr[p]
	51	p += 1
	52	return buf, pws(p)
	53	else:
	54	while p < len(hstr):
	55	if hstr[p] in sep:
	56	break
	57	buf += hstr[p]
	58	p += 1
	59	return buf.strip(), pws(p)
	60	p = 0
	61	val, p = token(p, ";")
	62	pars = {}
	63	while p < len(hstr):
	64	if hstr[p] != ';':
	65	break
	66	p += 1
	67	k, p = token(p, "=")
	68	if k == "" or hstr[p:p + 1] != '=':
	69	break
	70	p += 1
	71	v, p = token(p, ';')
ea18777a	72	pars[k.lower()] = v
eed3cf12 FT	73	return val, pars
eed3cf12 FT	74
5ef9e488 FT	75	def htmlq(html):
	76	ret = ""
	77	for c in html:
	78	if c == "&":
	79	ret += "&"
	80	elif c == "<":
	81	ret += "<"
	82	elif c == ">":
	83	ret += ">"
	84	else:
	85	ret += c
	86	return ret
	87
d740aa68 FT	88	def simpleerror(env, startreq, code, title, msg):
	89	buf = """<?xml version="1.0" encoding="US-ASCII"?>
	90	<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
	91	<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
	92	<head>
	93	<title>%s</title>
	94	</head>
	95	<body>
	96	<h1>%s</h1>
	97	<p>%s</p>
	98	</body>
	99	</html>
	100	""" % (title, title, htmlq(msg))
cb8bb5ed	101	buf = buf.encode("us-ascii")
d740aa68 FT	102	startreq("%i %s" % (code, title), [("Content-Type", "text/html"), ("Content-Length", str(len(buf)))])
	103	return [buf]
	104
5ef9e488 FT	105	def urlq(url):
5ef9e488 FT	106	ret = ""
3985f4bb	107	invalid = "&=#?/\"'"
5ef9e488	108	for c in url:
3985f4bb	109	if c in invalid or (ord(c) <= 32):
5ef9e488 FT	110	ret += "%%%02X" % ord(c)
	111	else:
	112	ret += c
	113	return ret
	114
bb80acbd FT	115	class urlerror(ValueError):
	116	pass
	117
	118	def parseurl(url):
	119	p = url.find("://")
	120	if p < 0:
	121	raise urlerror("Protocol not found in absolute URL `%s'" % url)
	122	proto = url[:p]
	123	l = url.find("/", p + 3)
	124	if l < 0:
	125	raise urlerror("Local part not found in absolute URL `%s'" % url)
	126	host = url[p + 3:l]
	127	local = url[l:]
	128	q = local.find("?")
	129	if q < 0:
	130	query = ""
	131	else:
	132	query = local[q + 1:]
	133	local = local[:q]
	134	return proto, host, local, query
	135
e21c4382	136	def consurl(proto, host, local, query=""):
bb80acbd FT	137	if len(local) < 1 and local[0] != '/':
	138	raise urlerror("Local part of URL must begin with a slash")
	139	ret = "%s://%s%s" % (proto, host, local)
	140	if len(query) > 0:
	141	ret += "?" + query
	142	return ret
	143
	144	def appendurl(url, other):
	145	if "://" in other:
	146	return other
	147	proto, host, local, query = parseurl(url)
	148	if len(other) > 0 and other[0] == '/':
	149	return consurl(proto, host, other)
	150	else:
	151	p = local.rfind('/')
	152	return consurl(proto, host, local[:p + 1] + other)
	153
31d48e69	154	def siteurl(req):
bb80acbd FT	155	host = req.ihead.get("Host", None)
	156	if host is None:
	157	raise Exception("Could not reconstruct URL because no Host header was sent")
	158	proto = "http"
	159	if req.https:
	160	proto = "https"
31d48e69 FT	161	return "%s://%s/" % (proto, host)
	162
	163	def scripturl(req):
	164	s = siteurl(req)
	165	if req.uriname[0] != '/':
	166	raise Exception("Malformed local part when reconstructing URL")
	167	return siteurl(req) + req.uriname[1:]
	168
	169	def requrl(req):
	170	s = siteurl(req)
bb80acbd FT	171	if req.uri[0] != '/':
bb80acbd FT	172	raise Exception("Malformed local part when reconstructing URL")
31d48e69	173	return siteurl(req) + req.uri[1:]
bb80acbd	174
e21c4382	175	def parstring(pars={}, **augment):
5ef9e488 FT	176	buf = ""
	177	for key in pars:
	178	if key in augment:
	179	val = augment[key]
	180	del augment[key]
	181	else:
	182	val = pars[key]
	183	if buf != "": buf += "&"
	184	buf += urlq(key) + "=" + urlq(str(val))
	185	for key in augment:
	186	if buf != "": buf += "&"
	187	buf += urlq(key) + "=" + urlq(str(augment[key]))
	188	return buf
08a4b741	189
e21c4382	190	def parurl(url, pars={}, **augment):
08a4b741 FT	191	qs = parstring(pars, **augment)
	192	if qs != "":
	193	return url + "?" + qs
	194	else:
	195	return url