Update cookie

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "iron-sessionstorage"
-version = "0.6.6"
+version = "0.7.0"
 
 authors = ["Markus Unterwaditzer <[email protected]>"]
 license = "MIT"
@@ -13,7 +13,7 @@ homepage = "https://github.com/iron/iron-sessionstorage"
 
 [dependencies]
 iron = "0.6"
-cookie = { version = "0.5.0", features = ["secure"] }
+cookie = { version = "0.12.0", features = ["secure"] }
 error-chain = "0.11"
 rand = "0.4"
 

examples/basic.rs

@@ -35,7 +35,7 @@ fn handler(req: &mut Request) -> IronResult<Response> {
 }
 
 fn main() {
-    let my_secret = b"verysecret".to_vec();
+    let my_secret = b"verysecretkeyatleast32byteslong.".to_vec();
     let mut ch = Chain::new(handler);
     ch.link_around(SessionStorage::new(SignedCookieBackend::new(my_secret)));
     let _res = Iron::new(ch).http("localhost:8080");

examples/login.rs

@@ -89,7 +89,7 @@ fn main() {
         logout: post "/logout" => logout,
     );
 
-    let my_secret = b"verysecret".to_vec();
+    let my_secret = b"verysecretkeyatleast32byteslong.".to_vec();
     let mut ch = Chain::new(router);
     ch.link_around(SessionStorage::new(SignedCookieBackend::new(my_secret)));
     let _res = Iron::new(ch).http("localhost:8080");

src/backends/signedcookie.rs

@@ -9,39 +9,36 @@ use SessionBackend;
 use get_default_cookie;
 
 pub struct SignedCookieSession {
-    unsigned_jar: cookie::CookieJar<'static>,
+    unsigned_jar: std::cell::RefCell<cookie::CookieJar>,
+    signing_key: cookie::Key,
     cookie_modifier: Option<Arc<Box<Fn(cookie::Cookie) -> cookie::Cookie + Send + Sync>>>
 }
 
-impl SignedCookieSession {
-    fn jar<'a>(&'a self) -> cookie::CookieJar<'a> {
-        self.unsigned_jar.signed()
-    }
-}
 
 impl RawSession for SignedCookieSession {
     fn get_raw(&self, key: &str) -> IronResult<Option<String>> {
-        Ok(self.jar().find(key).map(|c| c.value))
+        Ok(self.unsigned_jar.borrow_mut().signed(&self.signing_key).get(key).map(|c| c.value().to_owned()))
     }
 
     fn set_raw(&mut self, key: &str, value: String) -> IronResult<()> {
         let mut c = get_default_cookie(key.to_owned(), value);
         if let Some(ref modifier) = self.cookie_modifier {
             c = modifier(c);
         }
-        self.jar().add(c);
+        self.unsigned_jar.borrow_mut().signed(&self.signing_key).add(c);
         Ok(())
     }
 
     fn clear(&mut self) -> IronResult<()> {
-        self.jar().clear();
+        self.unsigned_jar.borrow_mut().clear();
         Ok(())
     }
 
     fn write(&self, res: &mut Response) -> IronResult<()> {
         debug_assert!(!res.headers.has::<iron::headers::SetCookie>());
         res.headers.set(iron::headers::SetCookie(
-            self.jar()
+            self.unsigned_jar
+            .borrow()
             .delta()
             .into_iter()
             .map(|c| format!("{}", c))
@@ -82,17 +79,18 @@ impl SessionBackend for SignedCookieBackend {
     type S = SignedCookieSession;
 
     fn from_request(&self, req: &mut Request) -> Self::S {
-        let mut jar = cookie::CookieJar::new(&self.signing_key);
+        let mut jar = cookie::CookieJar::new();
         if let Some(cookies) = req.headers.get::<iron::headers::Cookie>() {
             for cookie in cookies.iter() {
-                if let Ok(cookie) = cookie::Cookie::parse(&cookie) {
+                if let Ok(cookie) = cookie::Cookie::parse(cookie.clone()) {
                     jar.add_original(cookie);
                 }
             }
         };
 
         SignedCookieSession {
-            unsigned_jar: jar,
+            unsigned_jar: std::cell::RefCell::new(jar),
+            signing_key: cookie::Key::from_master(&self.signing_key),
             cookie_modifier: self.cookie_modifier.clone(),
         }
     }

src/lib.rs

@@ -132,11 +132,11 @@ impl<'a, 'b> SessionRequestExt for Request<'a, 'b> {
     }
 }
 
-fn get_default_cookie(key: String, value: String) -> cookie::Cookie {
-    let mut rv = cookie::Cookie::new(key, value);
-    rv.httponly = true;
-    rv.path = Some("/".to_owned());
-    rv
+fn get_default_cookie(key: String, value: String) -> cookie::Cookie<'static> {
+    cookie::Cookie::build(key, value)
+        .http_only(true)
+        .path("/")
+        .finish()
 }
 
 /// A module with some important traits to star-import.