def party_make(self, environ, start_response):
content_type = 'text/html'
username = ''
if 'HTTP_COOKIE' in environ:
c = SimpleCookie(environ.get('HTTP_COOKIE', ''))
if 'name1' in c:
key = c.get('name1').value
name1_key = key
if key in usernames:
username = str(usernames[key])
if username == '':
username = "******"
data = """\
<html><head><title>Create a Party - Drinkz - Alex Lockwood</title>
<style type="text/css">
h1 {color:red;}
p {color:black;}
</style></head><body>
<h1>Create a Party!</h1>
<a href='/'>Return to Index</a><p>
"""
data += "<form action='party_make_submit'>Please input the following information:<br>"
data += "Party title: <input type='text' name='title'><br>Date: <input type='text' name='date'><br>Time: <input type='text' name='time'><br>Address: <input type='text' name='address'><br>"
data += "Enter up to three liquors you're bringing:<br>"
data += "Brand: <input type='text' name='m1'>Liquor: <input type='text' name='l1'>Amount (ml): <input type=number name='a1' min='0' max='5000'>"
data += "Brand: <input type='text' name='m2'>Liquor: <input type='text' name='l2'>Amount (ml): <input type=number name='a2' min='0' max='5000'>"
data += "Brand: <input type='text' name='m3'>Liquor: <input type='text' name='l3'>Amount (ml): <input type=number name='a3' min='0' max='5000'>"
data += "<input type='submit' value='CREATE PARTY!'><input name='user' type='hidden' value='%s'></form></p></body></html>"% username
start_response('200 OK', list(html_headers))
return [data]
def __init__(self, environ, backend, ttl, cookie_name, fp_use_ip, log):
self.handler = backend
self.ttl = ttl
self.cookie_name = cookie_name
self.sid = None
self.data = {}
self.log = log
self.clear_cookie = False
self.session_start = False
fingerprint = '%s%s%s' % (environ.get('HTTP_USER_AGENT'),
environ.get('HTTP_ACCEPT_ENCODING'),
environ.get('HTTP_ACCEPT_LANGUAGE'))
if fp_use_ip:
fingerprint += environ.get('REMOTE_ADDR')
self.fingerprint = hashlib.sha1(fingerprint).hexdigest()
if 'HTTP_COOKIE' in environ:
cookie = SimpleCookie(environ['HTTP_COOKIE'])
if cookie.get(self.cookie_name):
cookie_sid = cookie[self.cookie_name].value
if cookie_sid:
self.sid = cookie_sid
def start(self, cookies, cookieopts=None):
c = SimpleCookie(cookies)
sid = c.get(self.cookiename)
create = True
if sid is not None:
for m in self.get(sid.value):
yield m
if self.apiroutine.retvalue is not None:
self.apiroutine.retvalue = (self.SessionHandle(
self.apiroutine.retvalue, self.apiroutine), [])
create = False
if create:
for m in self.create():
yield m
sh = self.apiroutine.retvalue
m = Morsel()
m.key = self.cookiename
m.value = sh.id
m.coded_value = sh.id
opts = {'path': '/', 'httponly': True}
if cookieopts:
opts.update(cookieopts)
if not cookieopts['httponly']:
del cookieopts['httponly']
m.update(opts)
self.apiroutine.retvalue = (sh, [m])
def application(environ, start_response):
GET = parse_qs(environ['QUERY_STRING'])
path = environ['PATH_INFO']
cookies = SimpleCookie(environ.get('HTTP_COOKIE', ''))
headers = {'Content-Type': 'text/html'}
if path == '/':
response = base%{'contenido': form}
elif path == '/set':
cookies['sessionId'] = store.add(GET.get('name', ['NULL McNULL',])[0])
response = base%{'contenido': '<div style="background-color:green;color:white">Cookie establecida</div>'}
headers.update({'Set-Cookie': cookies['sessionId'].OutputString()})
else:
cookie = cookies.get('sessionId',None)
name = cookie and store.get(cookie.value, None) or None
response = base%{'contenido': "<p>El valor de la sesión es: %s</p>"%name if name else 'Ninguno'}
headers.update({'Content-Length': str(len(response))})
start_response(
"200 OK",
headers.items()
)
return [response]
def status(self, environ, start_response):
name1 = ''
name1_key = '*empty*'
if 'HTTP_COOKIE' in environ:
c = SimpleCookie(environ.get('HTTP_COOKIE', ''))
if 'name1' in c:
key = c.get('name1').value
name1 = usernames.get(key, '')
name1_key = key
data = """
<html>
<body>
Your username is """
data += name1
data += " and your key is "
data += name1_key
data += "<p><a href='/'>Home</a></body></html>"
else:
data = """
<html>
<body>
You're not Logged in.....<p>
<a href='/'>Home</a>
</body>
</html>
"""
start_response('200 OK', list(html_headers))
return [data]
def getSession(self):
"""Return the existing session or a new session"""
if self.session is not None:
return self.session
# Get value of cookie header that was sent
cookie_str = self.headers.get('Cookie')
if cookie_str:
cookie_obj = SimpleCookie(cookie_str)
sid_morsel = cookie_obj.get(self.SESSION_COOKIE_NAME, None)
if sid_morsel is not None:
sid = sid_morsel.value
else:
sid = None
else:
sid = None
# If a session id was not set, create a new one
if sid is None:
# Pure pragmatism: Use function for nonce salt to generate session ID.
sid = make_nonce_salt(16)
session = None
else:
session = self.server.sessions.get(sid)
# If no session exists for this session ID, create one
if session is None:
session = self.server.sessions[sid] = {}
session['id'] = sid
self.session = session
return session
def cookie_parts(name, kaka):
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name)
if morsel:
return morsel.value.split("|")
else:
return None
def parse_cookie(name, seed, kaka):
"""Parses and verifies a cookie value
:param seed: A seed used for the HMAC signature
:param kaka: The cookie
:return: A tuple consisting of (payload, timestamp)
"""
if not kaka:
return None
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name)
if morsel:
parts = morsel.value.split("|")
if len(parts) != 3:
return None
# verify the cookie signature
sig = cookie_signature(seed, parts[0], parts[1])
if sig != parts[2]:
raise Exception("Invalid cookie signature")
try:
return parts[0].strip(), parts[1]
except KeyError:
return None
else:
return None
def application(environ, start_response):
GET = parse_qs(environ['QUERY_STRING'])
path = environ['PATH_INFO']
cookies = SimpleCookie(environ.get('HTTP_COOKIE', ''))
headers = {'Content-Type': 'text/html'}
if path == '/':
response = base % {'contenido': form}
elif path == '/set':
cookies['sessionId'] = store.add(
GET.get('name', [
'NULL McNULL',
])[0])
response = base % {
'contenido':
'<div style="background-color:green;color:white">Cookie establecida</div>'
}
headers.update({'Set-Cookie': cookies['sessionId'].OutputString()})
else:
cookie = cookies.get('sessionId', None)
name = cookie and store.get(cookie.value, None) or None
response = base % {
'contenido':
"<p>El valor de la sesión es: %s</p>" % name if name else 'Ninguno'
}
headers.update({'Content-Length': str(len(response))})
start_response("200 OK", headers.items())
return [response]
def __call__(self, environ, start_response):
cookie = SimpleCookie(environ.get('HTTP_COOKIE', ''))
morsel = cookie.get(self.cookie_name, None)
if morsel is None:
session = self.store.new()
else:
session = self.store.get(morsel.value)
environ[self.environ_key] = session
def injecting_start_response(status, headers, exc_info=None):
if session.should_save:
morsel = Morsel()
morsel.key = self.cookie_name
morsel.coded_value = session.sid
if self.cookie_age is not None:
morsel['max-age'] = self.cookie_age
morsel['expires'] = cookie_date(time() + self.cookie_age)
if self.cookie_domain is not None:
morsel['domain'] = self.cookie_domain
if self.cookie_path is not None:
morsel['path'] = self.cookie_path
if self.cookie_secure is not None:
morsel['secure'] = self.cookie_secure
headers.append(tuple(str(morsel).split(':', 1)))
return start_response(status, headers, exc_info)
return ClosingIterator(self.app(environ, injecting_start_response),
lambda: self.store.save_if_modified(session))
def parse_cookie(name, seed, kaka):
"""Parses and verifies a cookie value
:param seed: A seed used for the HMAC signature
:param kaka: The cookie
:return: A tuple consisting of (payload, timestamp)
"""
if not kaka:
return None
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name)
if morsel:
parts = morsel.value.split("|")
if len(parts) != 3:
return None
# verify the cookie signature
sig = cookie_signature(seed, parts[0], parts[1])
if sig != parts[2]:
raise SAMLError("Invalid cookie signature")
try:
return parts[0].strip(), parts[1]
except KeyError:
return None
else:
return None
def start(self, cookies, cookieopts=None):
c = SimpleCookie(cookies)
sid = c.get(self.cookiename)
create = True
if sid is not None:
for m in self.get(sid.value):
yield m
if self.apiroutine.retvalue is not None:
self.apiroutine.retvalue = (self.SessionHandle(self.apiroutine.retvalue, self.apiroutine), [])
create = False
if create:
for m in self.create():
yield m
sh = self.apiroutine.retvalue
m = Morsel()
m.key = self.cookiename
m.value = sh.id
m.coded_value = sh.id
opts = {"path": "/", "httponly": True}
if cookieopts:
opts.update(cookieopts)
if not cookieopts["httponly"]:
del cookieopts["httponly"]
m.update(opts)
self.apiroutine.retvalue = (sh, [m])
def cookie_parts(name, kaka):
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name)
if morsel:
return morsel.value.split("|")
else:
return None
def getSession(self):
"""Return the existing session or a new session"""
if self.session is not None:
return self.session
# Get value of cookie header that was sent
cookie_str = self.headers.get('Cookie')
if cookie_str:
cookie_obj = SimpleCookie(cookie_str)
sid_morsel = cookie_obj.get(self.SESSION_COOKIE_NAME, None)
if sid_morsel is not None:
sid = sid_morsel.value
else:
sid = None
else:
sid = None
# If a session id was not set, create a new one
if sid is None:
# Pure pragmatism: Use function for nonce salt to generate session ID.
sid = make_nonce_salt(16)
session = None
else:
session = self.server.sessions.get(sid)
# If no session exists for this session ID, create one
if session is None:
session = self.server.sessions[sid] = {}
session['id'] = sid
self.session = session
return session
def parse_cookie(name, seed, kaka):
"""Parses and verifies a cookie value """
if not kaka:
return None
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name)
if morsel:
parts = morsel.value.split("|")
if len(parts) != 3: return None
# verify the cookie signature
#print >> sys.stderr, "COOKIE verify '%s' '%s' '%s'" % (seed,
# parts[0],
# parts[1])
sig = cookie_signature(seed, parts[0], parts[1])
#print >> sys.stderr, ">>", sig
if sig != parts[2]:
raise Exception("Invalid cookie signature")
try:
return parts[0].strip(), parts[1]
except KeyError:
return None
else:
return None
def getSession(self):
"""Return the existing session or a new session"""
if self.session is not None:
return self.session
# Get value of cookie header that was sent
cookie_str = self.headers.get('Cookie')
if cookie_str:
cookie_obj = SimpleCookie(cookie_str)
sid_morsel = cookie_obj.get(self.SESSION_COOKIE_NAME, None)
if sid_morsel is not None:
sid = sid_morsel.value
else:
sid = None
else:
sid = None
# If a session id was not set, create a new one
if sid is None:
sid = randomString(16, '0123456789abcdef')
session = None
else:
session = self.server.sessions.get(sid)
# If no session exists for this session ID, create one
if session is None:
session = self.server.sessions[sid] = {}
session['id'] = sid
self.session = session
return session
async def start(self, cookies, cookieopts=None):
"""
Session start operation. First check among the cookies to find existed sessions;
if there is not an existed session, create a new one.
:param cookies: cookie header from the client
:param cookieopts: extra options used when creating a new cookie
:return: ``(session_handle, cookies)`` where session_handle is a SessionHandle object,
and cookies is a list of created Set-Cookie headers (may be empty)
"""
c = SimpleCookie(cookies)
sid = c.get(self.cookiename)
create = True
if sid is not None:
sh = await self.get(sid.value)
if sh is not None:
return (self.SessionHandle(sh, self.apiroutine), [])
if create:
sh = await self.create()
m = Morsel()
m.key = self.cookiename
m.value = sh.id
m.coded_value = sh.id
opts = {'path': '/', 'httponly': True}
if cookieopts:
opts.update(cookieopts)
if not cookieopts['httponly']:
del cookieopts['httponly']
m.update(opts)
return (sh, [m])
def getSession(self):
"""Return the existing session or a new session"""
if self.session is not None:
return self.session
# Get value of cookie header that was sent
cookie_str = self.headers.get('Cookie')
if cookie_str:
cookie_obj = SimpleCookie(cookie_str)
sid_morsel = cookie_obj.get(self.SESSION_COOKIE_NAME, None)
if sid_morsel is not None:
sid = sid_morsel.value
else:
sid = None
else:
sid = None
# If a session id was not set, create a new one
if sid is None:
sid = randomString(16, '0123456789abcdef')
session = None
else:
session = self.server.sessions.get(sid)
# If no session exists for this session ID, create one
if session is None:
session = self.server.sessions[sid] = {}
session['id'] = sid
self.session = session
return session
def get_cookie(self, key):
in_cookies = SimpleCookie()
request_cookies = self.headers.get('Cookie')
if request_cookies:
in_cookies.load(request_cookies)
val = in_cookies.get(key)
return val.value if val else None
return None
def get_cookie(self, key):
in_cookies = SimpleCookie()
request_cookies = self.headers.get('Cookie')
if request_cookies:
in_cookies.load(request_cookies)
val = in_cookies.get(key)
return val.value if val else None
return None
def getCookie2(cookie_name):
cookiestr = doc().cookie
c = SimpleCookie(str(cookiestr))
cs = c.get(cookie_name, None)
print "getCookie2", cookiestr, "name", cookie_name, "val", cs
if cs:
return cs.value
return None
def getCookie2(cookie_name):
cookiestr = doc().cookie
c = SimpleCookie(str(cookiestr))
cs = c.get(cookie_name, None)
print "getCookie2", cookiestr, "name", cookie_name, "val", cs
if cs:
return cs.value
return None
def recv_make_party(self, environ, start_response):
formdata = environ['QUERY_STRING']
results = urlparse.parse_qs(formdata)
new_music = ""
new_crash_spots = 0
new_DDs = 0
try:
new_music = results['music'][0]
new_crash_spots = results['crash_spots'][0]
new_DDs = results['DD'][0]
except KeyError:
pass
name1 = ''
if 'HTTP_COOKIE' in environ:
c = SimpleCookie(environ.get('HTTP_COOKIE', ''))
if 'name1' in c:
key = c.get('name1').value
name1 = usernames.get(key, '')
p = party.Party(name1, new_music, int(new_crash_spots), int(new_DDs))
db.add_party(p)
content_type = 'text/html'
data = """\
<html>
<head>
<title>Party</title>
<style type='text/css'>
h1 {color:red;}
body {
font-size: 14px;
}
</style>
</head>
<body>
"""
data += "Liquors:"
data += "<p>"
for item in results['liquors']:
p.add_liquor(item[0:])
data += item[0:]
data += "<p>"
data += "Type of music: "+new_music
data += '<p>'
data += "Crash Spots: "+str(new_crash_spots)
data += '<p>'
data += "Desginated Drivers: "+str(new_DDs)
data += """\
<p>
<a href='./'>return to index</a>
</body>
</html>
"""
start_response('200 OK', list(html_headers))
return [data]
def readCookie(self, name):
cookie_str = self.headers.get('Cookie')
print 'cookie:', cookie_str
if cookie_str:
c = SimpleCookie(cookie_str)
cookie_morsel = c.get(name, None)
if cookie_morsel is not None:
return cookie_morsel.value
return None
def auth_wrapper(environ, start_response):
cookie = SimpleCookie(environ.get('HTTP_COOKIE'))
t = cookie.get(name)
tkt = None
if t:
tkt = SignedCookie.parse(t.value)
service = AuthService(tkt)
environ['shotweb.authservice'] = service
return app(environ, service.start_response_wrapper(start_response))
def parse_cookie(cookie):
if cookie == '':
return {}
c = SimpleCookie()
c.load(cookie)
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
def readCookie(self, name):
cookie_str = self.headers.get('Cookie')
print 'cookie:', cookie_str
if cookie_str:
c = SimpleCookie(cookie_str)
cookie_morsel = c.get(name, None)
if cookie_morsel is not None:
return cookie_morsel.value
return None
def __get__(self, item, cls):
if len(self) == 0:
c = SimpleCookie(app.request.get('HTTP_COOKIE', ''))
# TODO Fix for GAE
for key in c.keys():
self[key] = c.get(key).value
return self
def parse_cookie(cookie):
if cookie == '':
return {}
c = SimpleCookie()
c.load(cookie)
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
def authPloneUser(self, username, password, loginurl):
http = httplib2.Http()
headers = {}
headers['Content-type'] = 'application/x-www-form-urlencoded'
headers[
'User-Agent'] = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers[LEOCORNUS_HTTP_HEADER_KEY] = LEOCORNUS_HTTP_HEADER_VALUE
login_form = {}
login_form['__ac_name'] = username
login_form['__ac_password'] = password
login_form['cookies_enabled'] = '1'
login_form['js_enabled'] = '0'
login_form['form.submitted'] = '1'
body = urllib.urlencode(login_form)
try:
res, cont = http.request(loginurl,
'POST',
headers=headers,
body=body)
except Exception:
# not valid login url!
return None
if res.has_key('set-cookie'):
cookie = SimpleCookie()
cookie.load(res['set-cookie'])
cookieName = settings.PLONEPROXY_COOKIE_NAME
defaultCookieName = '__ac'
if cookie.has_key(cookieName):
cookieValue = cookie.get(cookieName).value
return (cookieName, cookieValue)
elif cookie.has_key(defaultCookieName):
# try the default Plone cookie name in case.
cookieValue = cookie.get(defaultCookieName).value
return (defaultCookieName, cookieValue)
# no valid cookie found!
return None
def _loadSessionFromCookie(self, environ):
"""
Attempt to load the associated session using the identifier from
the cookie.
"""
C = SimpleCookie(environ.get('HTTP_COOKIE'))
morsel = C.get(self._cookieName, None)
if morsel is not None:
self._session = self._store.checkOutSession(morsel.value)
self._expired = self._session is None
def delete_cookie(environ, name):
kaka = environ.get("HTTP_COOKIE", "")
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name, None)
cookie = SimpleCookie()
cookie[name] = morsel
cookie[name]["expires"] = _expiration("now", "%a, %d-%b-%Y %H:%M:%S CET")
return tuple(cookie.output().split(": ", 1))
return None
def _fromcookie(self, environ):
'''Attempt to load the associated session using the identifier from
the cookie.
'''
cookie = SimpleCookie(environ.get('HTTP_COOKIE'))
morsel = cookie.get(self._fieldname, None)
if morsel is not None:
self._sid, self.session = self._cache.checkout(morsel.value)
self._csid = morsel.value
if self._csid != self._sid: self.new = True
def kaka2user(kaka):
logger.debug("KAKA: %s" % kaka)
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get("idpauthn", None)
if morsel:
return IDP.authn[morsel.value]
else:
logger.debug()
return None
def get_id(self, cookie_str=""):
if cookie_str:
#print "-connection by cookie-"
cookie_obj = SimpleCookie(cookie_str)
morsel = cookie_obj.get(self.name)
if morsel is not None:
self.sid = self.parse_cookie(morsel.value)
if not self.sid:
#print "-New connection-"
self.sid = self._sid()
def get_id(self, cookie_str):
"""
:param cookie_str:
:return:
"""
cookie_obj = SimpleCookie(cookie_str)
morsel = cookie_obj.get(self.name)
if morsel is not None:
return self.parse_cookie(morsel.value)
return None
def index(self, environ, start_response):
data = open('index.html').read()
start_response('200 OK', list(html_headers))
if 'HTTP_COOKIE' in environ:
c = SimpleCookie(environ.get('HTTP_COOKIE', ''))
if 'name1' in c:
data += "<br><br> Logged in as: " + str(usernames.get(c.get('name1').value, "")) + "<br><br>"
data += "<a href='logout'>Logout</a> "
else:
data +="<p><form action='login1_process'> Username: <input type='text' name='name' size='15'> <input type='submit' value='log in'> </form>"
return [data]
def get_id(self, cookie_str):
"""
:param cookie_str:
:return:
"""
cookie_obj = SimpleCookie(cookie_str)
morsel = cookie_obj.get(self.name)
if morsel is not None:
return self.parse_cookie(morsel.value)
return None
def _get_cookie(self, request, name):
cookie_str = request.environ.get('HTTP_COOKIE')
if not cookie_str:
return
cookie = SimpleCookie()
cookie.load(cookie_str)
if name not in cookie:
return
value = cookie.get(name).value
if value != 'unset_%s' % name:
return json.loads(base64.b64decode(value))
def get_id(self, cookie_str=""):
if cookie_str:
#print "-connection by cookie-"
cookie_obj = SimpleCookie(cookie_str)
morsel = cookie_obj.get(self.name)
if morsel is not None:
self.sid = self.parse_cookie(morsel.value)
if not self.sid:
#print "-New connection-"
self.sid = self._sid()
def delete_cookie(environ, name):
kaka = environ.get("HTTP_COOKIE", '')
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name, None)
cookie = SimpleCookie()
cookie[name] = morsel
cookie[name]["expires"] = \
_expiration("now", "%a, %d-%b-%Y %H:%M:%S CET")
return tuple(cookie.output().split(": ", 1))
return None
def authPloneUser(self, username, password, loginurl):
http = httplib2.Http()
headers = {}
headers['Content-type'] = 'application/x-www-form-urlencoded'
headers['User-Agent'] = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)'
headers[LEOCORNUS_HTTP_HEADER_KEY] = LEOCORNUS_HTTP_HEADER_VALUE
login_form = {}
login_form['__ac_name'] = username
login_form['__ac_password'] = password
login_form['cookies_enabled'] = '1'
login_form['js_enabled'] = '0'
login_form['form.submitted'] = '1'
body = urllib.urlencode(login_form)
try:
res, cont = http.request(loginurl, 'POST',
headers=headers, body=body)
except Exception:
# not valid login url!
return None
if res.has_key('set-cookie'):
cookie = SimpleCookie()
cookie.load(res['set-cookie'])
cookieName = settings.PLONEPROXY_COOKIE_NAME
defaultCookieName = '__ac'
if cookie.has_key(cookieName):
cookieValue = cookie.get(cookieName).value
return (cookieName, cookieValue)
elif cookie.has_key(defaultCookieName):
# try the default Plone cookie name in case.
cookieValue = cookie.get(defaultCookieName).value
return (defaultCookieName, cookieValue)
# no valid cookie found!
return None
def delete_cookie(environ, name):
kaka = environ.get("HTTP_COOKIE", '')
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name, None)
cookie = SimpleCookie()
cookie[name] = ""
cookie[name]['path'] = "/"
logger.debug("Expire: %s" % morsel)
cookie[name]["expires"] = _expiration("dawn")
return tuple(cookie.output().split(": ", 1))
return None
def make_party(self, environ, start_response):
name1 = ''
name1_key = '*empty*'
if 'HTTP_COOKIE' in environ:
c = SimpleCookie(environ.get('HTTP_COOKIE', ''))
if 'name1' in c:
key = c.get('name1').value
name1 = usernames.get(key, '')
name1_key = key
if name1 == '':
headers = list(html_headers)
headers.append(('Location', '/login_1'))
start_response('302 Found', headers)
return ["Redirect to login_1..."]
content_type = 'text/html'
data = """\
<html>
<head>
<title>Party</title>
<style type='text/css'>
h1 {color:red;}
body {
font-size: 14px;
}
</style>
</head>
<body>
"""
data += "Liquor at party:"
data += "<p>"
data += """\
<form action='recv_make_party'>
"""
for mfg, liquor in db.get_liquor_inventory():
data += "<input type='checkbox' name='liquors' value='"+mfg+' '+liquor+"'>"+liquor
data += "<p>"
data += """\
<p>
Type of Music at Party: <input type='text' name='music' size='20'>
Crash Spots: <input type='text' name='crash_spots' size='2'>
Designated Drivers: <input type='text' name='DD' size='2'>
<p>
<input type='submit'>
</form>
<p>
<a href='./'>return to index</a>
"""
start_response('200 OK', list(html_headers))
return [data]
def delete_cookie(environ, name):
kaka = environ.get("HTTP_COOKIE", '')
logger.debug("delete KAKA: %s" % kaka)
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(name, None)
cookie = SimpleCookie()
cookie[name] = ""
cookie[name]['path'] = "/"
logger.debug("Expire: %s" % morsel)
cookie[name]["expires"] = _expiration("dawn")
return tuple(cookie.output().split(": ", 1))
return None
def on_auth_token_responded(self, callback, resp):
DEBUG(u'Auth token response code %s' % (resp.code, ))
if resp.code == 200:
headers = resp.headers
if headers.hasHeader('Set-Cookie'):
header = resp.headers.getRawHeaders('Set-Cookie')
if header:
header = '; '.join(header)
cookie = SimpleCookie(header)
login = cookie.get('Bugzilla_login')
token = cookie.get('Bugzilla_logincookie')
if not token or not login:
self.fail(ValueError(u'Auth token not found'))
else:
self.auth_login = login.value
self.auth_token = token.value
DEBUG(u'Issuing on_auth_token_responded callback')
callback()
else:
self.fail(ValueError(u'No cookie found'))
else:
self.fail(FetchException(u'Received response %s' % (resp.code, )))
def delete_cookie(self, environ, name):
cookie = environ.get("HTTP_COOKIE", '')
logger.debug("delete KAKA: %s" % cookie)
if cookie:
cookie_obj = SimpleCookie(cookie)
morsel = cookie_obj.get(name, None)
cookie = SimpleCookie()
cookie[name] = ""
cookie[name]['path'] = "/"
logger.debug("Expire: %s" % morsel)
cookie[name]["expires"] = self._expiration("dawn")
return tuple(cookie.output().split(": ", 1))
return None
def kaka2user(self, kaka):
logger.debug("KAKA: %s" % kaka)
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(self.cookie_name, None)
if morsel:
try:
return self.uid2user[morsel.value]
except KeyError:
return None
else:
logger.debug("No spauthn cookie")
return None
def kaka2user(self, kaka):
logger.debug("KAKA: %s" % kaka)
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get(self.cookie_name, None)
if morsel:
try:
return self.uid2user[morsel.value]
except KeyError:
return None
else:
logger.debug("No spauthn cookie")
return None
def _from_cookie(self, environ):
'''
Attempt to load the associated session using the identifier from the cookie
'''
#@@TODO: Use Webob.request
cookie = SimpleCookie(environ.get('HTTP_COOKIE'))
morsel = cookie.get(self._fieldname, None)
if morsel:
self._sid, self.session = self._cache.checkout(morsel.value)
cookie_sid = morsel.value
if cookie_sid != self._sid:
self.is_new = True
def kaka2user(kaka):
logger.debug("KAKA: %s" % kaka)
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get("idpauthn", None)
if morsel:
try:
return IDP.uid2user[morsel.value]
except KeyError:
return None
else:
logger.debug("No idpauthn cookie")
return None
def __init__(self, request):
self._options = _options
self.rd = None
self._master_rd = False
self.request = request
self._data = None
self.id = None
self._new_session = True
self._changed = False
cookie = self.request.headers.get('Cookie')
if cookie is None:
self.__create_id()
else:
c = SimpleCookie()
c.load(cookie)
session_cookie = c.get(self._options['_cookie_name'])
if session_cookie is None:
#new session!
self.__create_id()
else:
self.id = session_cookie.value
self._new_session = False
def session_callback(request, response):
exception = getattr(request, 'exception', None)
commit = self._changed
increase_expire_mod = _options['_increase_expire_mod']
if increase_expire_mod > 0:
rnd = round(random.random() * 1000000)
mod = rnd % increase_expire_mod
if not mod:
# print 'Saving due to increase_expire_mod'
commit = True
if exception is None and commit:
self.__save()
cookie = SimpleCookie()
_cname = self._options['_cookie_name']
cookie[_cname] = self.id
domain = self._options.get('cookie_domain')
cookie[_cname]['path'] = _options['_path']
if domain is not None:
cookie[_cname]['domain'] = domain
if self._options['_secure']:
cookie[_cname]['secure'] = True
header = cookie[_cname].output(header='')
# print 'Writing cookie header:',header
response.headerlist.append(('Set-Cookie', header))
request.add_response_callback(session_callback)
def parse_cookie(cookie):
if cookie == '':
return {}
try:
c = SimpleCookie()
c.load(cookie)
except CookieError:
# Invalid cookie
return {}
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
def delete_cookie(self, environ):
cookie = environ.get("HTTP_COOKIE", '')
logger.debug("delete cookie: %s" % cookie)
if cookie:
_name = self.cookie_name
cookie_obj = SimpleCookie(cookie)
morsel = cookie_obj.get(_name, None)
cookie = SimpleCookie()
cookie[_name] = ""
cookie[_name]['path'] = "/"
logger.debug("Expire: %s" % morsel)
cookie[_name]["expires"] = _expiration("now")
return cookie.output().split(": ", 1)
return None
def info_from_cookie(kaka):
logger.debug("KAKA: %s" % kaka)
if kaka:
cookie_obj = SimpleCookie(kaka)
morsel = cookie_obj.get("idpauthn", None)
if morsel:
try:
key, ref = base64.b64decode(morsel.value).split(":")
return IDP.cache.uid2user[key], ref
except KeyError:
return None, None
else:
logger.debug("No idpauthn cookie")
return None, None
def load_session(self, cookies):
from Cookie import SimpleCookie
from beaker.session import Session
from pyload.web.webinterface import session
cookies = SimpleCookie(cookies)
sid = cookies.get(session.options['key'])
if not sid:
return None
s = Session({}, use_cookies=False, id=sid.value, **session.options)
if s.is_new:
return None
return s
def parse_cookie(cookie):
if cookie == '':
return {}
if not isinstance(cookie, BaseCookie):
try:
c = SimpleCookie()
c.load(cookie)
except CookieError:
# Invalid cookie
return {}
else:
c = cookie
cookiedict = {}
for key in c.keys():
cookiedict[key] = c.get(key).value
return cookiedict
def get_user(self, environ):
cookie = environ.get("HTTP_COOKIE", '')
logger.debug("Cookie: %s" % cookie)
if cookie:
cookie_obj = SimpleCookie(cookie)
morsel = cookie_obj.get(self.cookie_name, None)
if morsel:
try:
return self.uid2user[morsel.value]
except KeyError:
return None
else:
logger.debug("No %s cookie", self.cookie_name)
return None
def server_id_validator(event):
request = event.request
server_id = event.request.registry.server_id
cookies = SimpleCookie(request.environ.get('HTTP_COOKIE'))
cookie_server_id = cookies.get('SERVER_ID', None)
if cookie_server_id:
value = cookie_server_id.value
decrypted = decrypt(server_id, value)
if not decrypted or not decrypted.startswith(server_id):
logger.info('Invalid cookie: {}'.format(
value, extra={'MESSAGE_ID': 'serverid_invalid'}))
response_cookie = SimpleCookie()
value, time = encrypt(server_id)
response_cookie['SERVER_ID'] = value
response_cookie['SERVER_ID']['path'] = '/'
request.response = HTTPPreconditionFailed(
headers={
'Set-Cookie': response_cookie['SERVER_ID'].OutputString()
})
request.response.empty_body = True
logger.info('New cookie: {} ({})'.format(value, time),
extra={'MESSAGE_ID': 'serverid_new'})
raise request.response
else:
time = decrypted[len(server_id):]
logger.debug('Valid cookie: {} ({})'.format(value, time),
extra={'MESSAGE_ID': 'serverid_valid'})
elif request.method in ['POST', 'PATCH', 'PUT', 'DELETE']:
value, time = encrypt(server_id)
response_cookie = SimpleCookie()
response_cookie['SERVER_ID'] = value
response_cookie['SERVER_ID']['path'] = '/'
request.response = HTTPPreconditionFailed(
headers={
'Set-Cookie': response_cookie['SERVER_ID'].OutputString()
})
request.response.empty_body = True
logger.info('New cookie: {} ({})'.format(value, time),
extra={'MESSAGE_ID': 'serverid_new'})
raise request.response
if not cookie_server_id:
value, time = encrypt(server_id)
request.response.set_cookie(name='SERVER_ID', value=value)
logger.info('New cookie: {} ({})'.format(value, time),
extra={'MESSAGE_ID': 'serverid_new'})
return request.response
def server_id_validator(event):
request = event.request
couchdb_server_id = request.registry.couchdb_server_id
cookies = SimpleCookie(request.environ.get("HTTP_COOKIE"))
cookie_server_id = cookies.get("SERVER_ID", None)
if cookie_server_id:
value = cookie_server_id.value
decrypted = decrypt(couchdb_server_id, value)
if not decrypted or not decrypted.startswith(b(couchdb_server_id)):
logger.info("Invalid cookie: {}".format(
value, extra={"MESSAGE_ID": "serverid_invalid"}))
raise server_id_response(request)
elif request.method in ["POST", "PATCH", "PUT", "DELETE"]:
raise server_id_response(request)
if not cookie_server_id:
request.add_response_callback(server_id_callback)
return request.response
