diff --git a/contrib/src/templates/mod.rs b/contrib/src/templates/mod.rs
index 8e312f2a..86e66ba7 100644
--- a/contrib/src/templates/mod.rs
+++ b/contrib/src/templates/mod.rs
@@ -21,6 +21,7 @@ use rocket::request::Request;
 use rocket::fairing::{Fairing, AdHoc};
 use rocket::response::{self, Content, Responder};
 use rocket::http::{ContentType, Status};
+use rocket::config::ConfigError;
 
 const DEFAULT_TEMPLATE_DIR: &'static str = "templates";
 
@@ -158,10 +159,12 @@ impl Template {
     /// ```
     pub fn fairing() -> impl Fairing {
         AdHoc::on_attach(|rocket| {
-            let mut template_root = rocket.config().root().join(DEFAULT_TEMPLATE_DIR);
+            let mut template_root = rocket.config()
+                .root_relative(DEFAULT_TEMPLATE_DIR);
+
             match rocket.config().get_str("template_dir") {
-                Ok(dir) => template_root = rocket.config().root().join(dir),
-                Err(ref e) if !e.is_not_found() => {
+                Ok(dir) => template_root = rocket.config().root_relative(dir),
+                Err(e@ConfigError::NotFound) => {
                     e.pretty_print();
                     warn_!("Using default directory '{:?}'", template_root);
                 }
diff --git a/lib/Cargo.toml b/lib/Cargo.toml
index 9c53f7bc..2c38f6d9 100644
--- a/lib/Cargo.toml
+++ b/lib/Cargo.toml
@@ -33,7 +33,7 @@ pear_codegen = "0.0.11"
 rustls = { version = "0.11.0", optional = true }
 cookie = { version = "0.10.0", features = ["percent-encode", "secure"] }
 hyper = { version = "0.10.13", default-features = false }
-hyper-sync-rustls = { version = "0.2.1", features = ["server"], optional = true }
+hyper-sync-rustls = { version = "0.3.0-rc.1", features = ["server"], optional = true }
 ordermap = "0.2"
 isatty = "0.1"
 
diff --git a/lib/src/config/config.rs b/lib/src/config/config.rs
index 51d66125..695dba27 100644
--- a/lib/src/config/config.rs
+++ b/lib/src/config/config.rs
@@ -313,7 +313,12 @@ impl Config {
     /// # }
     /// ```
     pub fn set_root<P: AsRef<Path>>(&mut self, path: P) {
-        self.config_path = path.as_ref().join("Rocket.custom.toml")
+        let new_path = match self.config_path.file_name() {
+            Some(file) => path.as_ref().join(file),
+            None => path.as_ref().join("Rocket.custom.toml")
+        };
+
+        self.config_path = new_path
     }
 
     /// Sets the address of `self` to `address`.
@@ -495,14 +500,14 @@ impl Config {
         let pem_err = "malformed PEM file";
 
         // Load the certificates.
-        let certs = tls::load_certs(certs_path)
+        let certs = tls::load_certs(self.root_relative(certs_path))
             .map_err(|e| match e {
                 Io(e) => ConfigError::Io(e, "tls.certs"),
                 _ => self.bad_type("tls", pem_err, "a valid certificates file")
             })?;
 
         // And now the private key.
-        let key = tls::load_private_key(key_path)
+        let key = tls::load_private_key(self.root_relative(key_path))
             .map_err(|e| match e {
                 Io(e) => ConfigError::Io(e, "tls.key"),
                 _ => self.bad_type("tls", pem_err, "a valid private key file")
@@ -787,6 +792,35 @@ impl Config {
             None => panic!("root(): path {:?} has no parent", self.config_path)
         }
     }
+
+    /// If `path` is a relative path, `path` is appended to the [`root`] at
+    /// which the configuration file for `self` is stored and the new path is
+    /// returned. If `path` is absolute, `path` is returned unaltered.
+    ///
+    /// [`root`]: /rocket/struct.Config.html#method.root
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// use std::env::current_dir;
+    /// use std::path::Path;
+    /// use rocket::config::{Config, Environment};
+    ///
+    /// let config = Config::new(Environment::Staging)
+    ///     .expect("can retrieve current directory");
+    ///
+    /// assert_eq!(config.root(), current_dir().unwrap());
+    /// assert_eq!(config.root_relative("abc"), config.root().join("abc"));
+    /// assert_eq!(config.root_relative("/abc"), Path::new("/abc"));
+    /// ```
+    pub fn root_relative<P: AsRef<Path>>(&self, path: P) -> PathBuf {
+        let path = path.as_ref();
+        if path.is_absolute() {
+            path.into()
+        } else {
+            self.root().join(path)
+        }
+    }
 }
 
 impl fmt::Debug for Config {