def cookies(self): try: cookie = hcookies.BaseCookie() cookie.load(self.headers.get("cookie")) return cookie except Exception as e: return hcookies.BaseCookie()
def cookies(self): try: cookie = hcookies.BaseCookie() for _, v in self.headers.pairs('set-cookie'): cookie.load(v) return cookie except Exception as e: return hcookies.BaseCookie()
def InfoPage(self, uri): """ Renders an information page with the POST endpoint and cookie flag. Args: uri: a string containing the request URI Returns: A string with the contents of the info page to be displayed """ page = """ <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> <html><head> <title>Bulk Loader</title> </head><body>""" page += ('The bulk load endpoint is: <a href="%s">%s</a><br />\n' % (uri, uri)) cookies = os.environ.get('HTTP_COOKIE', None) if cookies: cookie = Cookie.BaseCookie(cookies) for param in ['ACSID', 'dev_appserver_login']: value = cookie.get(param) if value: page += ( "Pass this flag to the client: --cookie='%s=%s'\n" % (param, value.value)) break else: page += 'No cookie found!\n' page += '</body></html>' return page
def cookie_output(name, value): cookie = Cookie.BaseCookie() expiry = datetime.datetime.now() + datetime.timedelta(days=30) cookie[name] = value cookie[name]["path"] = "/" cookie[name]["expires"] = expiry.strftime("%a, %d-%b-%Y %H:%M:%S PST") return cookie[name].OutputString()
def set_cookie(self, name, value, domain=None, expires=None, path="/", expires_days=None): """Sets the given cookie name/value with the given options.""" name = _utf8(name) value = _utf8(value) if re.search(r"[\x00-\x20]", name + value): # Don't let us accidentally inject bad stuff raise ValueError("Invalid cookie %r:%r" % (name, value)) new_cookie = Cookie.BaseCookie() new_cookie[name] = value if domain: new_cookie[name]["domain"] = domain if expires_days is not None and not expires: expires = datetime.datetime.utcnow() + datetime.timedelta( days=expires_days) if expires: timestamp = calendar.timegm(expires.utctimetuple()) new_cookie[name]["expires"] = email.utils.formatdate( timestamp, localtime=False, usegmt=True) if path: new_cookie[name]["path"] = path for morsel in new_cookie.values(): self.response.headers.add_header('Set-Cookie', morsel.OutputString(None))
def get_cookie_value(key): cookies = None try: cookies = Cookie.BaseCookie(os.environ.get('HTTP_COOKIE', '')) except Cookie.CookieError, error: logging.debug("Ignoring Cookie Error, skipping get cookie: '%s'" % error)
def set_cookie_value(key, value='', max_age=None, path='/', domain=None, secure=None, httponly=False, version=None, comment=None): cookies = Cookie.BaseCookie() cookies[key] = value for var_name, var_value in [ ('max-age', max_age), ('path', path), ('domain', domain), ('secure', secure), #('HttpOnly', httponly), Python 2.6 is required for httponly cookies ('version', version), ('comment', comment), ]: if var_value is not None and var_value is not False: cookies[key][var_name] = str(var_value) if max_age is not None: cookies[key]['expires'] = max_age cookies_header = cookies[key].output(header='').lstrip() if httponly: # We have to manually add this part of the header until GAE uses Python 2.6. cookies_header += "; HttpOnly" return cookies_header
def __init__(self, proto='HTTP/1.0', host=None, method=None, uri=None, args=None, remote_ip=None, headers=None, body=None, body_file=None): self.proto = proto self.host = host self.method = method self.uri = uri self.remote_ip = remote_ip self.headers = headers self.body = body self.body_file = body_file self.path, _, self.query = uri.partition('?') self.query_args = urlparse.parse_qs(self.query, keep_blank_values=True) self.args = args self.cookies = {} for cookie in self.headers.get_list("cookie", []): try: for name, morsel in Cookie.BaseCookie(cookie).iteritems(): self.cookies[name] = morsel.value except Cookie.CookieError: pass
def request_details(self, request, response=None): view_name = getattr(request, '_stats_view_name', None) local_name = getattr(request, '_stats_local_name', None) if hasattr(request, 'device'): devid = request.device.devid else: devid = None if hasattr(request, 'session'): session_key = request.session.session_key else: try: session_key = Cookie.BaseCookie(request.META.get('HTTP_COOKIE', ''))['sessionid'].value except: session_key = '' requested = getattr(request, 'requested', time.time()) return { 'session_key': session_key, 'user_agent': request.META.get('HTTP_USER_AGENT'), 'device_id': devid, 'ip_address': request.META['REMOTE_ADDR'], 'referer': request.META.get('HTTP_REFERER'), 'full_path': request.get_full_path(), 'requested': time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(requested)) + ('%.6f' % (requested % 1))[1:], 'response_time': (time.time() - requested) if hasattr(request, 'requested') else None, 'local_name': local_name, 'view_name': view_name, 'status_code': response.status_code if response else 500, 'redirect_to': response.get('Location', None) if response else None, }
def get_profile_from_cookies(): """ Get Facebook profile data of current logged in Facebook user Returns: A dict of Facebook profile data of the current logged in Facebook user. For example, this would return the following for Mark Zuckerberg: { "id": "4", "name": "Mark Zuckerberg", "first_name": "Mark", "last_name": "Zuckerberg", "link": "https://www.facebook.com/zuck", "username": "******", "gender": "male", "locale": "en_US" } """ if App.facebook_app_secret is None: return None cookies = None try: cookies = Cookie.BaseCookie(os.environ.get('HTTP_COOKIE', '')) except Cookie.CookieError, error: logging.debug("Ignoring Cookie Error, skipping Facebook login: '******'" % error)
def get_phantom_user_id_from_cookies(): cookies = None try: cookies = Cookie.BaseCookie(os.environ.get('HTTP_COOKIE', '')) except Cookie.CookieError, error: logging.critical("Ignoring Cookie Error: '%s'" % error) return None
def parse_cookies(cookie_string, verbose, url=None, response_cookie=False): """ Parses the cookie string from an HTTP header into a query * Request 'Cookie' query = (name, value) * Response 'Set-Cookie' query = (name, value, domain, path, expires, max-age, httponly, secure, comment, version) """ queries = list() attrs = () try: if type(cookie_string) == unicode: cookie_string = cookie_string.encode('utf-8') cookie = Cookie.BaseCookie(cookie_string) # requires str type for key in cookie.keys(): name = encode_to_unicode(key) value = encode_to_unicode(cookie[key].coded_value) if response_cookie: attrs = parse_cookie_attributes(cookie, key, url) query = (name, value) + attrs queries.append(query) except Cookie.CookieError, e: if verbose: print "[ERROR] - Malformed cookie string" if verbose: print "--------- " + cookie_string if verbose: print e pass
def namespace_manager_default_namespace_for_request(): """Determine which namespace is to be used for a request. The value of _NAMESPACE_PICKER has the following effects: If _USE_SERVER_NAME, we read server name foo.guestbook-isv.appspot.com and set the namespace. If _USE_GOOGLE_APPS_DOMAIN, we allow the namespace manager to infer the namespace from the request. If _USE_COOKIE, then the ISV might have a gateway page that sets a cookie called 'namespace', and we set the namespace to the cookie's value """ name = None if _NAMESPACE_PICKER == _USE_SERVER_NAME: name = os.environ['SERVER_NAME'] elif _NAMESPACE_PICKER == _USE_GOOGLE_APPS_DOMAIN: name = namespace_manager.google_apps_namespace() elif _NAMESPACE_PICKER == _USE_COOKIE: cookies = os.environ.get('HTTP_COOKIE', None) if cookies: name = Cookie.BaseCookie(cookies).get('namespace') return name
def set_cookie(self, name, value, domain=None, expires=None, path="/", expires_days=None, **kwargs): """Sets the given cookie name/value with the given options. Additional keyword arguments are set on the Cookie.Morsel directly. See http://docs.python.org/library/cookie.html#morsel-objects for available attributes. """ name = LilCookies._utf8(name) value = LilCookies._utf8(value) if re.search(r"[\x00-\x20]", name + value): # Don't let us accidentally inject bad stuff raise ValueError("Invalid cookie %r: %r" % (name, value)) if not hasattr(self, "_new_cookies"): self._new_cookies = [] new_cookie = Cookie.BaseCookie() self._new_cookies.append(new_cookie) new_cookie[name] = value if domain: new_cookie[name]["domain"] = domain if expires_days is not None and not expires: expires = datetime.datetime.utcnow() + datetime.timedelta(days=expires_days) if expires: timestamp = calendar.timegm(expires.utctimetuple()) new_cookie[name]["expires"] = email.utils.formatdate( timestamp, localtime=False, usegmt=True) if path: new_cookie[name]["path"] = path for k, v in kwargs.iteritems(): new_cookie[name][k] = v # The 2 lines below were not in Tornado. Instead, they output all their cookies to the headers at once before a response flush. for vals in new_cookie.values(): self.response.headers._headers.append(('Set-Cookie', vals.OutputString(None)))
def get_rid_cookie(self): cookies = self.headers.get('Cookie') rid = "" if cookies: stub = Cookie.BaseCookie(cookies).get('rid') if stub: rid = stub.value return rid
def has_cookie(request): cookies = request.getHttp().get('HTTP_COOKIE', None) if cookies: morsel = Cookie.BaseCookie(cookies).get('openid_remembered') if morsel and morsel.value == 'yes': return True return False
def get_jsesh_cookie(self): cookies = self.headers.get('Cookie') jsesh = "" if cookies: stub = Cookie.BaseCookie(cookies).get('JSESSIONID') if stub: jsesh = stub.value return jsesh
def load_cookies(self, raw_cookies): # parse cookies base_cookies = Cookie.BaseCookie() base_cookies.load(raw_cookies) # rebuild proper simple dictionary self.cookies = dict() for key, morsel in base_cookies.items(): self.cookies[key] = morsel.value
def getresponse(self): rsp = super(SecureHTTPConnection, self).getresponse() for hdr in rsp.msg.headers: if hdr.startswith('Set-Cookie:'): c = Cookie.BaseCookie(hdr[11:]) for k in c: self.cookies[k] = c[k].value return rsp
def HasCookie(self, trust_root): cookies = os.environ.get('HTTP_COOKIE', None) if cookies: morsel = Cookie.BaseCookie(cookies).get('openid_remembered_%s' % digest(trust_root)) if morsel and morsel.value == 'yes': return True return False
def extractToken(response): info = response.info() # print "info:", info cookie = info['Set-Cookie'] cookie = Cookie.BaseCookie(cookie) # print "cookie:", cookie token = cookie['token'] # print "token:", token.value return token.value
def _get_cookie(self, name): """ Get a cookie from the request """ value = None cookie_string = ";".join(self.headers.getheaders('Cookie')) cookies = Cookie.BaseCookie(cookie_string) if cookies: if session_cookie_name in cookies: value = cookies[session_cookie_name].value return value
def set_cookies(self, c): self.headers.delete("set-cookie") if isinstance(c, hcookies.BaseCookie): cookies = c else: cookies = hcookies.BaseCookie() for k, v in c.items(): cookies[k] = v for _, m in c.items(): self.headers.add("Set-Cookie", m.OutputString())
def get_cookie(self, name): cookies = self.headers.get('Cookie') if cookies: authcookie = Cookie.BaseCookie(cookies).get(name) if authcookie: return authcookie.value else: return None else: return None
def cookies(self): if self._cookies is None: parser = Cookie.BaseCookie() cookie_headers = self.headers.get("cookie", "") parser.load(cookie_headers) cookies = Cookies() for key, value in parser.iteritems(): cookies[key] = CookieValue(value) self._cookies = cookies return self._cookies
def cookies(self): """A dictionary of Cookie.Morsel objects.""" if not hasattr(self, "_cookies"): self._cookies = Cookie.BaseCookie() if "Cookie" in self.request.headers: try: self._cookies.load(self.request.headers["Cookie"]) except: self.clear_all_cookies() return self._cookies
def _set_game_object(self): """Setting the game object to self._game using the cookies""" cookie = Cookie.BaseCookie(self._request.get_all_header()["cookie"]) if "pid" in cookie: pid = cookie["pid"].value if pid in self.common.pid_client: self._game = self.common.pid_client[pid] self.logger.debug("Set game as %s", self._game) else: self.logger.debug("Game object not found")
def get_profile_from_cookies(): if App.facebook_app_secret is None: return None cookies = None try: cookies = Cookie.BaseCookie(os.environ.get('HTTP_COOKIE', '')) except Cookie.CookieError, error: logging.debug("Ignoring Cookie Error, skipping Facebook login: '******'" % error)
def unset_cookie(self, name): """Remove a cookie from those that are being sent with the response""" cookies = self.headers.get("Set-Cookie") parser = Cookie.BaseCookie() for cookie in cookies: parser.load(cookie) if name in parser.keys(): del self.headers["Set-Cookie"] for m in parser.values(): if m.key != name: self.headers.append(("Set-Cookie", m.OutputString()))
def getresponse(self): try: rsp = super(SecureHTTPConnection, self).getresponse() for hdr in rsp.msg.headers: if hdr.startswith('Set-Cookie:'): c = Cookie.BaseCookie(hdr[11:]) for k in c: self.cookies[k] = c[k].value except httplib.BadStatusLine: self.broken = True raise return rsp