def set_browser_info(self, info):
        """    sets the "state" info for the browser
        """

        #info = base64.encodestring(repr(info))
        info = repr(info)
        Cookie.add_cookie(self.req, Cookie.Cookie('browseinfo', info))

 def __init__(self, req):
     """get, extract info, and do upkeep on the session cookie. This determines what the sessid and user are 
          for this request."""
     #pass the request in making in so we can edit it later if requested (ACL for example)
     self.ip = req.connection.remote_ip
     c = Cookie.get_cookies(req)
     if not c.has_key('mps'):
         self.sessid = Uid().new_sid(req)
     else:
         c = c['mps']
         self.sessid = c.value
         
     #make new cookie so the cycle continues
     c = Cookie.Cookie('mps', self.sessid)
     c.path = '/'
     Cookie.add_cookie(req, c)
     
     self.session_path = "%s%s"%(path_to_sessions, self.sessid)
     self.full_session_path = "%s%s"%(self.session_path, db_extension)
     
     #use previous authenication until cookie is reevaluated, if they are officially logged in (in Instance)
     if os.path.exists(self.full_session_path):
         session = shelve.open(self.session_path, 'rw')
         self.user  = session['USER_']
         session.close()
     else:
         self.user = self.unauthorized

def general_authenhandler(req, req_type, anon_ok=False):
	pw = req.get_basic_auth_pw()
	cookies = Cookie.get_cookies(req)
	if not cookies.has_key('csrftoken'):
		cookie = Cookie.Cookie('csrftoken', hashlib.md5(str(random.randrange(0, 2<<63))).hexdigest())
		cookie.path = '/'
		if config.get('session', 'cookie_host') != '':
			cookie.domain = config.get('session', 'cookie_host')
		Cookie.add_cookie(req, cookie)
	if cookies.has_key('myemsl_session'):
		sql = "select user_name from myemsl.eus_auth where session_id = %(sid)s"
		cnx = myemsldb_connect(myemsl_schema_versions=['1.0'])
		cursor = cnx.cursor()
		cursor.execute(sql, {'sid':cookies['myemsl_session'].value})
		rows = cursor.fetchall()
		found = False
		for row in rows:
			req.user = row[0]
			found = True
		if found:
			logger.debug("Session: %s", str(cookies['myemsl_session'].value))
#FIXME outage_check seems to be in the wrong place for a myemsl database outage.
			return outage_check(req, req_type)
	elif anon_ok:
		req.user = ''
		return outage_check(req, req_type)
	url = urllib.quote(req.unparsed_uri)
	redirect(req, "/myemsl/auth?url=%s" %(url))
	return apache.HTTP_UNAUTHORIZED

    def _set_cookie(self, value, **attrs):
        """(session_id : string)

        Ensure that a session cookie with value 'session_id' will be
        returned to the client via the response object.

        Since Mod_Python has its own Cookie management system, we use it.
        """
        config = get_publisher().config
        name = config.session_cookie_name
        domain = config.session_cookie_domain

        if config.session_cookie_path:
            path = config.session_cookie_path
        else:
            path = get_request().get_environ('SCRIPT_NAME')
            if not path.endswith("/"):
                path += "/"

        expires = -1

        options = {'expires': expires,
                   'path': path }

        if domain is not None:
            options.update({'domain':domain})

        if value:
            Cookie.add_cookie(self.modpython_request, name, value, **options)

        return name

def logout(req):
    cookies = Cookie.get_cookies(req)
    Cookie.add_cookie(req, 'ogtvogh', '', expires=time.time(), path='/')
    req.status=apache.HTTP_MOVED_TEMPORARILY
    req.headers_out["Location"] = SITEURL
    req.send_http_header()
    return "You have successfully logged out"

def index(req):
 # check if cookie is set for respondent who already participated
 client_cookie = Cookie.get_cookie(req, 'rm-group-a')
 if client_cookie is None:
  Cookie.add_cookie(req, 'rm-group-a', 'true', expires=time.time()+31*24*3600) # expires after 1 month
 else:
  return 'You already participated.'
 
 # load current respondent conditions
 with open(PATH, 'r') as f:
  respondents = yaml.load(f)
  if respondents is None:
   respondents = []

  no_avatar_count = count_str_in_seq(NO_AVATAR, respondents)
  avatar_count = count_str_in_seq(AVATAR, respondents)

  if no_avatar_count <= MIN_RESPONDENTS and avatar_count >= MIN_RESPONDENTS:
   condition = NO_AVATAR
  elif no_avatar_count >= MIN_RESPONDENTS and avatar_count <= MIN_RESPONDENTS:
   condition = AVATAR
  else:
   condition = random.choice([NO_AVATAR, AVATAR])
 
 # write new condition entry
 with open(PATH, 'w') as f:
  respondents.append(condition)
  yaml.dump(respondents, f)
 util.redirect(req, 'welcome' + '-' + condition + '.html')

def _add_csrf_cookie_if_needed(req):
    signed_cookies = Cookie.get_cookies(req, Cookie.SignedCookie, secret=_get_secret())
    cookie = signed_cookies.get(settings.csrf_cookie_name, None)
    if cookie:
        # make sure we aren't altered
        if type(cookie) is Cookie.SignedCookie and cookie.value == _message_contents():
            return
    Cookie.add_cookie(req, _generate_csrf_cookie())

 def set(self,username):
     value = {
         "username": username
     }
     cookie = Cookie.MarshalCookie(self.cookie_key, value, secret=str(self.captureSettings["secretKey"]))
     cookie.path = "/"
     cookie.expires = time.time() + int(self.captureSettings["sessionCookiesTimeout"])
     Cookie.add_cookie(self.req, cookie)

 def send_cookies(self):
     """ sends the http headers for any cookies that need to be set
     """
     if self.req != None:
         for c in self._cookies:
             Cookie.add_cookie(self.req,c)
     else:
         for c in self._cookies:
             print c

    def set(self, var, val):

        ck = scs.encode(self.s, val, len(val))
        if ck is None:
            raise Exception, 'failed scs.encode()'
       
        c = Cookie.Cookie(var, ck)
        Cookie.add_cookie(self.req, c)
        
        return ck

def index(req):
    secret = 'my_secret'
    marshal_cookies = Cookie.get_cookies(req, Cookie.MarshalCookie, secret=secret)
    returned_marshal = marshal_cookies.get('marshal', None)
    if(returned_marshal):
        returned_marshal.expires= time.time()
        Cookie.add_cookie(req, returned_marshal)
        return '<html><body>return to main place <a href="./">here</a></body></html>'
    else:
        return '<html><title></title><body>there is nothing <a href="./">back</a></body></html>'

def Cookie_Cookie(req):

    from mod_python import Cookie

    cookies = Cookie.get_cookies(req)

    for k in cookies:
        Cookie.add_cookie(req, cookies[k])

    req.write("test ok")
    
    return apache.OK

def Cookie_MarshalCookie(req):

    from mod_python import Cookie

    cookies = Cookie.get_cookies(req, Cookie.MarshalCookie,
                                secret="secret")

    for k in cookies:
        Cookie.add_cookie(req, cookies[k])

    req.write("test ok")
    
    return apache.OK

    def logout(self, REQUEST):
        """    logs out and redirects to main page
        """

        Cookie.add_cookie(self.req, Cookie.Cookie("sessionkey", "", expires=0))
        Cookie.add_cookie(self.req, Cookie.Cookie("browseinfo", "", expires=0))
        self.info = {}

        links = {"banner": "menu", "leftcontent": "advertising"}

        page = self.tmpl("logout")
        page.staticlink(links)

        return page

	def setCookie(self,key,value,secret=None,expires=None,path=None):
		cookieType = Cookie.Cookie
		options = {}

		if expires != None: options['expires'] = expires
		if path != None: options['path'] = path
		if secret != None:
			cookieType = Cookie.MarshalCookie
			options['secret'] = secret

		Cookie.add_cookie(self.req, cookieType(key, value, **options))
		if expires==0 and not secret:
			self.cookieCache[key] = None
		elif not secret:
			self.cookieCache[key] = value

def save(req):
    # Get a list with all the values of the selected_shows[]
    selected_shows = req.form.getlist('selected_shows[]')
    # Escape the user input to avoid script injection attacks
    selected_shows = map(lambda show: cgi.escape(show), selected_shows)
    
    # Value of the cookie is the list of selected shows seperated by ','
    cookie_str = ','.join(selected_shows)
    c = Cookie.Cookie('selected_shows', cookie_str, path='/')
    c.expires = time.time() + 30 * 24 * 60 * 60
    
    # Add the cookie to the HTTP header
    Cookie.add_cookie(req, c)
    
    util.redirect(req, 'http://localhost/wwia')

 def __init__(self,req=None, form=None):
     self.req = req
     if self.req != None:
         # mod_python
         self.form = util.FieldStorage(self.req)
         self._cookies_in = Cookie.get_cookies(self.req)
     else:
         # if we have a form, don't get a new one
         if form:
            self.form=form
         # if we don't have a form, then get one
         else:
            self.form = cgi.FieldStorage()
         self._cookies_in = SimpleCookie()
         try:
             self._cookies_in.load(os.environ["HTTP_COOKIE"])
         except KeyError:
             pass
     self._dispatch      = {}
     self._header_sent   = 0
     self._header_props  = {"Content-Type" : "text/html;charset=UTF-8"}
     self._header_props  = {}
     self._header_type   = "header"
     self._cookies       = []
     self._url           = ""
     self._environ       = os.environ
     self.template_dir   = 'templates'
     self.run_mode_param = 'rm'
     self.start_mode     = ''
     self.__globals__    = {}
     self.setup()

 def get_cookie(cls, req, name):
     """Retreive cookie by name from request object."""
     #cookies = mod_python.Cookie.get_cookies(req)
     cookies = Cookie.get_cookies(req)
     this_cookie = cookies.get(name)
     value = cut(str(this_cookie), "{0}=".format(name))
     return value

 def __init__(self,req,appid=None):
     self.req = req
     if appid == None:
         args = split_args(self.req.args);
         appid = args['APPID']
     self.captureSettings = load_capture_settings(self.req,appid)
     self.cookie = Cookie.get_cookies(self.req, Cookie.MarshalCookie, secret=str(self.captureSettings["secretKey"]))

def accesshandler(request):

    cookies = Cookie.get_cookies(request)

    # if login ticket cookie does not exist, then deny
    if not cookies.has_key('login_ticket'):
        # just refuse access
        return apache.HTTP_FORBIDDEN

    ticket = cookies['login_ticket'].value
    if not ticket:
        return apache.HTTP_FORBIDDEN

    server = TacticServerStub.get(protocol='local')
    expr = "@SOBJECT(sthpw/ticket['ticket','%s'])" % ticket
    sobject = server.eval(expr, single=True)
    now = SPTDate.now()
    expiry = sobject.get("expiry")
    if expiry and expiry < str(now):
        return apache.HTTP_FORBIDDEN

    request.add_common_vars()
    path = str(request.subprocess_env['REQUEST_URI'])
    if path == None:
        return apache.HTTP_FORBIDDEN


    # FIXME: find some mechanism which is more acceptable ... like /icons
    #if path.find("_icon_") != -1:
    #    return apache.OK

    return apache.OK