diff --git a/sdk/fidl/fuchsia.net.dhcp/fuchsia.net.dhcp.api b/sdk/fidl/fuchsia.net.dhcp/fuchsia.net.dhcp.api
index 47be32e..02d004c 100644
--- a/sdk/fidl/fuchsia.net.dhcp/fuchsia.net.dhcp.api
+++ b/sdk/fidl/fuchsia.net.dhcp/fuchsia.net.dhcp.api
@@ -1,5 +1,5 @@
 {
   "fidl/fuchsia.net.dhcp/client.fidl": "ed712ac30e34dd3900d88e730a346ce6",
   "fidl/fuchsia.net.dhcp/options.fidl": "dab189ad92092bfaa3c910fe34f9609d",
-  "fidl/fuchsia.net.dhcp/server.fidl": "5d4d1dd038043a108f08bcca7aa00924"
+  "fidl/fuchsia.net.dhcp/server.fidl": "f85984b657e00e24424697f7ce414ee8"
 }
\ No newline at end of file
diff --git a/sdk/fidl/fuchsia.net.dhcp/server.fidl b/sdk/fidl/fuchsia.net.dhcp/server.fidl
index 1f912bc..8b30bf2 100644
--- a/sdk/fidl/fuchsia.net.dhcp/server.fidl
+++ b/sdk/fidl/fuchsia.net.dhcp/server.fidl
@@ -106,37 +106,61 @@
     /// * error a zx.status indicating why the value could not be retrieved.
     GetParameter(ParameterName name) -> (Parameter value) error zx.status;
 
-    /// Sets the Option to the argument. Each SetOption call is treated as its own atomic
-    /// transaction. On success, a SetOption will take effect immediately.
+    /// Sets the Option to the argument. On success, a SetOption will take
+    /// effect immediately.
     ///
-    /// + request `value` an Option whose value will be set to the value of this argument.
+    /// + request `value` an Option whose value will be set to the value of this
+    /// argument.
     /// * error a zx.status indicating the cause of failure.
     SetOption(Option value) -> () error zx.status;
 
-    /// Sets the Parameter to the argument. Each SetParameter call is treated as its own atomic
-    /// transaction. On success, a SetParameter will take effect immediately.
+    /// Sets the Parameter to the argument. On success, the new parameter value
+    /// can be queried by GetParameter or ListParameter immediately. However,
+    /// the server may require a restart in order for the new Parameter value to
+    /// take effect. To ensure expected operation, administrators should restart
+    /// the server after mutating its parameters with SetParameter or
+    /// ResetParameters.
     ///
-    /// + request `value` a Parameter whose value will be set to the value of this argument.
+    /// + request `value` a Parameter whose value will be set to the value of
+    /// this argument.
     /// * error a zx.status indicating the cause of failure.
     SetParameter(Parameter value) -> () error zx.status;
 
-    /// Lists all DHCP options for which the Server has a value. Any option which does
-    /// not have a value will be omitted from the returned list. ListOptions provides administrators
-    /// a means to print a server's configuration as opposed to querying the value of a single
-    /// Option.
+    /// Lists all DHCP options for which the Server has a value. Any option
+    /// which does not have a value will be omitted from the returned list.
+    /// ListOptions provides administrators a means to print a server's
+    /// configuration as opposed to querying the value of a single Option.
     ///
-    /// - response `options` a vector containing all of the options for which the Server has a
-    /// value. Bounded to 256 as options are identified by a 1 octet code and 256 is the maximum
-    /// number of such codes.
+    /// - response `options` a vector containing all of the options for which
+    /// the Server has a value. Bounded to 256 as options are identified by a 1
+    /// octet code and 256 is the maximum number of such codes.
     /// * error a zx.status indicating the cause of failure.
     ListOptions() -> (vector<Option>:256 options) error zx.status;
 
-    /// Lists all DHCP server parameters. ListParameters provides administrators a means to print a
-    /// server's configuration as opposed to querying the value of a single Parameter.
+    /// Lists all DHCP server parameters. ListParameters provides administrators
+    /// a means to print a server's configuration as opposed to querying the
+    /// value of a single Parameter.
     ///
-    /// - response `parameter` a vector containing the values of all of the Server's parameters.
-    /// Bounded to 256 to provide a generous upper limit on the number of server parameters while
-    /// being of the same size as ListOptions.
+    /// - response `parameter` a vector containing the values of all of the
+    /// Server's parameters. Bounded to 256 to provide a generous upper limit
+    /// on the number of server parameters while being of the same size as
+    /// ListOptions.
     /// * error a zx.status indicating the cause of failure.
     ListParameters() -> (vector<Parameter>:256 parameters) error zx.status;
+
+    /// Resets all DHCP options to have no value. On success, ResetOptions will
+    /// take effect immediately.
+    ///
+    /// * error a zx.status indicating the cause of failure.
+    ResetOptions() -> () error zx.status;
+
+    /// Resets all DHCP server parameters to their default value. On success,
+    /// the reset parameter values can be queried immediately with GetParameter
+    /// or ListParameters. However, the server must be restarted before all new
+    /// parameter values take effect. To ensure expected operation,
+    /// administrators should restart the server after mutating its parameters
+    /// with SetParameter or ResetParameters.
+    ///
+    /// * error a zx.status indicating the cause of failure.
+    ResetParameters() -> () error zx.status;
 };
diff --git a/src/connectivity/network/dhcp/src/configuration.rs b/src/connectivity/network/dhcp/src/configuration.rs
index 2638b05..e0d1f2e 100644
--- a/src/connectivity/network/dhcp/src/configuration.rs
+++ b/src/connectivity/network/dhcp/src/configuration.rs
@@ -21,7 +21,7 @@
 }
 
 /// A collection of the basic configuration parameters needed by the server.
-#[derive(Debug, Deserialize, PartialEq, Serialize)]
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 pub struct ServerParameters {
     /// The IPv4 addresses of the host running the server.
     pub server_ips: Vec<Ipv4Addr>,
diff --git a/src/connectivity/network/dhcp/src/main.rs b/src/connectivity/network/dhcp/src/main.rs
index 6f2876d..b8c3f3a 100644
--- a/src/connectivity/network/dhcp/src/main.rs
+++ b/src/connectivity/network/dhcp/src/main.rs
@@ -14,7 +14,6 @@
     },
     fuchsia_async::{self as fasync, net::UdpSocket, Interval},
     fuchsia_component::server::ServiceFs,
-    fuchsia_syslog::{self as fx_syslog, fx_log_err, fx_log_info},
     fuchsia_zircon::DurationNum,
     futures::{Future, FutureExt, StreamExt, TryFutureExt, TryStreamExt},
     net2::unix::UnixUdpBuilderExt,
@@ -58,16 +57,17 @@
 
 #[fasync::run_singlethreaded]
 async fn main() -> Result<(), Error> {
-    fx_syslog::init_with_tags(&["dhcpd"])?;
+    fuchsia_syslog::init_with_tags(&["dhcpd"])?;
 
     let Args { config, stash } = argh::from_env();
     let stash = dhcp::stash::Stash::new(&stash, DEFAULT_STASH_PREFIX)
         .context("failed to instantiate stash")?;
-    let params = stash.load_parameters().await.or_else(|e| {
-        fx_syslog::fx_log_warn!("failed to load parameters from stash: {}", e);
-        configuration::load_server_params_from_file(&config)
-            .context("failed to load server parameters from configuration file")
-    })?;
+    let default_params = configuration::load_server_params_from_file(&config)
+        .context("failed to load default server parameters from configuration file")?;
+    let params = stash.load_parameters().await.unwrap_or_else(|e| {
+        log::warn!("failed to load parameters from stash: {:?}", e);
+        default_params.clone()
+    });
     let socks = if params.bound_device_names.len() > 0 {
         params.bound_device_names.iter().map(String::as_str).try_fold::<_, _, Result<_, Error>>(
             Vec::new(),
@@ -81,14 +81,14 @@
         vec![create_socket(None)?]
     };
     if socks.len() == 0 {
-        return Err(anyhow::format_err!("no valid sockets to receive messages from"));
+        return Err(anyhow::Error::msg("no valid sockets to receive messages from"));
     }
     let options = stash.load_options().await.unwrap_or_else(|e| {
-        fx_syslog::fx_log_warn!("failed to load options from stash: {}", e);
+        log::warn!("failed to load options from stash: {:?}", e);
         std::collections::HashMap::new()
     });
     let cache = stash.load_client_configs().await.unwrap_or_else(|e| {
-        fx_syslog::fx_log_warn!("failed to load cached client config from stash: {}", e);
+        log::warn!("failed to load cached client config from stash: {:?}", e);
         std::collections::HashMap::new()
     });
     let server = RefCell::new(Server::new(stash, params, options, cache));
@@ -100,21 +100,23 @@
         fs.then(futures::future::ok).try_for_each_concurrent(None, |incoming_service| async {
             match incoming_service {
                 IncomingService::Server(stream) => {
-                    run_server(stream, &server).inspect_err(|e| log::info!("{:?}", e)).await?;
+                    run_server(stream, &server, &default_params)
+                        .inspect_err(|e| log::warn!("run_server failed: {:?}", e))
+                        .await?;
                     Ok(())
                 }
             }
         });
 
     if !server.borrow().is_serving() {
-        fx_log_info!("starting server in configuration only mode");
+        log::info!("starting server in configuration only mode");
         let () = admin_fut.await?;
     } else {
         let msg_loops = socks
             .into_iter()
             .map(|sock| define_msg_handling_loop_future(sock, &server).boxed_local());
         let lease_expiration_handler = define_lease_expiration_handler_future(&server);
-        fx_log_info!("starting server");
+        log::info!("starting server");
         let (_void, (), ()) = futures::try_join!(
             futures::future::select_ok(msg_loops),
             admin_fut,
@@ -163,18 +165,18 @@
     loop {
         let (received, mut sender) =
             sock.recv_from(&mut buf).await.context("failed to read from socket")?;
-        fx_log_info!("received message from: {}", sender);
+        log::info!("received message from: {}", sender);
         let msg = Message::from_buffer(&buf[..received])?;
-        fx_log_info!("parsed message: {:?}", msg);
+        log::info!("parsed message: {:?}", msg);
 
         // This call should not block because the server is single-threaded.
         let result = server.borrow_mut().dispatch(msg);
         match result {
-            Err(e) => fx_log_err!("error processing client message: {}", e),
-            Ok(ServerAction::AddressRelease(addr)) => fx_log_info!("released address: {}", addr),
-            Ok(ServerAction::AddressDecline(addr)) => fx_log_info!("allocated address: {}", addr),
+            Err(e) => log::error!("error processing client message: {:?}", e),
+            Ok(ServerAction::AddressRelease(addr)) => log::info!("released address: {}", addr),
+            Ok(ServerAction::AddressDecline(addr)) => log::info!("allocated address: {}", addr),
             Ok(ServerAction::SendResponse(message, dest)) => {
-                fx_log_info!("generated response: {:?}", message);
+                log::info!("generated response: {:?}", message);
 
                 // Check if server returned an explicit destination ip.
                 if let Some(addr) = dest {
@@ -183,7 +185,7 @@
 
                 let response_buffer = message.serialize();
                 sock.send_to(&response_buffer, sender).await.context("unable to send response")?;
-                fx_log_info!("response sent to: {}", sender);
+                log::info!("response sent to: {}", sender);
             }
         }
     }
@@ -202,6 +204,7 @@
 async fn run_server<S: ServerDispatcher>(
     stream: fidl_fuchsia_net_dhcp::Server_RequestStream,
     server: &RefCell<S>,
+    default_params: &dhcp::configuration::ServerParameters,
 ) -> Result<(), fidl::Error> {
     stream
         .try_for_each(|request| async {
@@ -229,6 +232,15 @@
                 fidl_fuchsia_net_dhcp::Server_Request::ListParameters { responder: r } => r.send(
                     &mut server.borrow().dispatch_list_parameters().map_err(|e| e.into_raw()),
                 ),
+                fidl_fuchsia_net_dhcp::Server_Request::ResetOptions { responder: r } => r.send(
+                    &mut server.borrow_mut().dispatch_reset_options().map_err(|e| e.into_raw()),
+                ),
+                fidl_fuchsia_net_dhcp::Server_Request::ResetParameters { responder: r } => r.send(
+                    &mut server
+                        .borrow_mut()
+                        .dispatch_reset_parameters(&default_params)
+                        .map_err(|e| e.into_raw()),
+                ),
             }
         })
         .await
@@ -237,6 +249,7 @@
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::convert::TryFrom;
 
     struct CannedDispatcher {}
 
@@ -280,6 +293,38 @@
         ) -> Result<Vec<fidl_fuchsia_net_dhcp::Parameter>, fuchsia_zircon::Status> {
             Ok(vec![])
         }
+        fn dispatch_reset_options(&mut self) -> Result<(), fuchsia_zircon::Status> {
+            Ok(())
+        }
+        fn dispatch_reset_parameters(
+            &mut self,
+            _defaults: &dhcp::configuration::ServerParameters,
+        ) -> Result<(), fuchsia_zircon::Status> {
+            Ok(())
+        }
+    }
+
+    fn default_params() -> dhcp::configuration::ServerParameters {
+        dhcp::configuration::ServerParameters {
+            server_ips: vec![Ipv4Addr::from([192, 168, 0, 1])],
+            lease_length: dhcp::configuration::LeaseLength {
+                default_seconds: 86400,
+                max_seconds: 86400,
+            },
+            managed_addrs: dhcp::configuration::ManagedAddresses {
+                network_id: Ipv4Addr::from([192, 168, 0, 0]),
+                broadcast: Ipv4Addr::from([192, 168, 0, 128]),
+                mask: dhcp::configuration::SubnetMask::try_from(25).unwrap(),
+                pool_range_start: Ipv4Addr::from([192, 168, 0, 0]),
+                pool_range_stop: Ipv4Addr::from([192, 168, 0, 0]),
+            },
+            permitted_macs: dhcp::configuration::PermittedMacs(vec![]),
+            static_assignments: dhcp::configuration::StaticAssignments(
+                std::collections::HashMap::new(),
+            ),
+            arp_probe: false,
+            bound_device_names: vec![],
+        }
     }
 
     #[fasync::run_singlethreaded(test)]
@@ -288,11 +333,11 @@
             fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
         let server = RefCell::new(CannedDispatcher {});
 
-        let res = proxy.get_option(fidl_fuchsia_net_dhcp::OptionCode::SubnetMask);
-        fasync::spawn_local(async move {
-            let () = run_server(stream, &server).await.unwrap_or(());
-        });
-        let res = res.await?;
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.get_option(fidl_fuchsia_net_dhcp::OptionCode::SubnetMask).fuse() => res.context("get_option failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
 
         let expected_result =
             Ok(fidl_fuchsia_net_dhcp::Option_::SubnetMask(fidl_fuchsia_net::Ipv4Address {
@@ -308,12 +353,11 @@
             fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
         let server = RefCell::new(CannedDispatcher {});
 
-        let res = proxy.get_parameter(fidl_fuchsia_net_dhcp::ParameterName::LeaseLength);
-        fasync::spawn_local(async move {
-            let () = run_server(stream, &server).await.unwrap_or(());
-        });
-        let res = res.await?;
-
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.get_parameter(fidl_fuchsia_net_dhcp::ParameterName::LeaseLength).fuse() => res.context("get_parameter failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
         let expected_result =
             Ok(fidl_fuchsia_net_dhcp::Parameter::Lease(fidl_fuchsia_net_dhcp::LeaseLength {
                 default: None,
@@ -329,14 +373,13 @@
             fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
         let server = RefCell::new(CannedDispatcher {});
 
-        let res = proxy.set_option(&mut fidl_fuchsia_net_dhcp::Option_::SubnetMask(
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.set_option(&mut fidl_fuchsia_net_dhcp::Option_::SubnetMask(
             fidl_fuchsia_net::Ipv4Address { addr: [0, 0, 0, 0] },
-        ));
-        fasync::spawn_local(async move {
-            let () = run_server(stream, &server).await.unwrap_or(());
-        });
-        let res = res.await?;
-
+        )).fuse() => res.context("set_option failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
         assert_eq!(res, Ok(()));
         Ok(())
     }
@@ -347,14 +390,13 @@
             fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
         let server = RefCell::new(CannedDispatcher {});
 
-        let res = proxy.set_parameter(&mut fidl_fuchsia_net_dhcp::Parameter::Lease(
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.set_parameter(&mut fidl_fuchsia_net_dhcp::Parameter::Lease(
             fidl_fuchsia_net_dhcp::LeaseLength { default: None, max: None },
-        ));
-        fasync::spawn_local(async move {
-            let () = run_server(stream, &server).await.unwrap_or(());
-        });
-        let res = res.await?;
-
+        )).fuse() => res.context("set_parameter failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
         assert_eq!(res, Ok(()));
         Ok(())
     }
@@ -365,12 +407,11 @@
             fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
         let server = RefCell::new(CannedDispatcher {});
 
-        let res = proxy.list_options();
-        fasync::spawn_local(async move {
-            let () = run_server(stream, &server).await.unwrap_or(());
-        });
-        let res = res.await?;
-
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.list_options().fuse() => res.context("list_options failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
         assert_eq!(res, Ok(vec![]));
         Ok(())
     }
@@ -381,13 +422,44 @@
             fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
         let server = RefCell::new(CannedDispatcher {});
 
-        let res = proxy.list_parameters();
-        fasync::spawn_local(async move {
-            let () = run_server(stream, &server).await.unwrap_or(());
-        });
-        let res = res.await?;
-
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.list_parameters().fuse() => res.context("list_parameters failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
         assert_eq!(res, Ok(vec![]));
         Ok(())
     }
+
+    #[fasync::run_singlethreaded(test)]
+    async fn reset_options_returns_unit() -> Result<(), Error> {
+        let (proxy, stream) =
+            fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
+        let server = RefCell::new(CannedDispatcher {});
+
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.reset_options().fuse() => res.context("reset_options failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
+
+        assert_eq!(res, Ok(()));
+        Ok(())
+    }
+
+    #[fasync::run_singlethreaded(test)]
+    async fn reset_parameters_returns_unit() -> Result<(), Error> {
+        let (proxy, stream) =
+            fidl::endpoints::create_proxy_and_stream::<fidl_fuchsia_net_dhcp::Server_Marker>()?;
+        let server = RefCell::new(CannedDispatcher {});
+
+        let defaults = default_params();
+        let res = futures::select! {
+            res = proxy.reset_parameters().fuse() => res.context("reset_parameters failed"),
+            server_fut = run_server(stream, &server, &defaults).fuse() => Err(anyhow::Error::msg("server finished before request")),
+        }?;
+
+        assert_eq!(res, Ok(()));
+        Ok(())
+    }
 }
diff --git a/src/connectivity/network/dhcp/src/server.rs b/src/connectivity/network/dhcp/src/server.rs
index b858143..52ac266 100644
--- a/src/connectivity/network/dhcp/src/server.rs
+++ b/src/connectivity/network/dhcp/src/server.rs
@@ -655,6 +655,10 @@
     fn dispatch_list_options(&self) -> Result<Vec<fidl_fuchsia_net_dhcp::Option_>, Status>;
     /// Retrieves all of the stored DHCP parameter values.
     fn dispatch_list_parameters(&self) -> Result<Vec<fidl_fuchsia_net_dhcp::Parameter>, Status>;
+    /// Resets all DHCP options to have no value.
+    fn dispatch_reset_options(&mut self) -> Result<(), Status>;
+    /// Resets all DHCP server parameters to their default values in `defaults`.
+    fn dispatch_reset_parameters(&mut self, defaults: &ServerParameters) -> Result<(), Status>;
 }
 
 impl ServerDispatcher for Server {
@@ -844,6 +848,25 @@
             fidl_fuchsia_net_dhcp::Parameter::BoundDeviceNames(bound_device_names.clone()),
         ])
     }
+
+    fn dispatch_reset_options(&mut self) -> Result<(), Status> {
+        let () = self.options_repo.clear();
+        let opts: Vec<DhcpOption> = self.options_repo.values().cloned().collect();
+        let () = self.stash.store_options(&opts).map_err(|e| {
+            log::warn!("store_options({:?}) in stash failed: {}", opts, e);
+            fuchsia_zircon::Status::INTERNAL
+        })?;
+        Ok(())
+    }
+
+    fn dispatch_reset_parameters(&mut self, defaults: &ServerParameters) -> Result<(), Status> {
+        self.params = defaults.clone();
+        let () = self.stash.store_parameters(&self.params).map_err(|e| {
+            log::warn!("store_parameters({:?}) in stash failed: {}", self.params, e);
+            fuchsia_zircon::Status::INTERNAL
+        })?;
+        Ok(())
+    }
 }
 
 /// A cache mapping clients to their configuration data.
@@ -3040,4 +3063,42 @@
         assert!(result.contains(&expected));
         Ok(())
     }
+
+    #[fuchsia_async::run_singlethreaded(test)]
+    async fn test_server_dispatcher_reset_options() -> Result<(), Error> {
+        let mut server = new_test_minimal_server().await?;
+        let empty_map = HashMap::new();
+        assert_ne!(empty_map, server.options_repo);
+        let () = server.dispatch_reset_options()?;
+        assert_eq!(empty_map, server.options_repo);
+        let stored_opts = server.stash.load_options().await?;
+        assert_eq!(empty_map, stored_opts);
+        Ok(())
+    }
+
+    #[fuchsia_async::run_singlethreaded(test)]
+    async fn test_server_dispatcher_reset_parameters() -> Result<(), Error> {
+        let mut server = new_test_minimal_server().await?;
+        let default_params = ServerParameters {
+            server_ips: vec![Ipv4Addr::from([192, 168, 0, 1])],
+            lease_length: LeaseLength { default_seconds: 86400, max_seconds: 86400 },
+            managed_addrs: crate::configuration::ManagedAddresses {
+                network_id: Ipv4Addr::from([192, 168, 0, 0]),
+                broadcast: Ipv4Addr::from([192, 168, 0, 128]),
+                mask: crate::configuration::SubnetMask::try_from(25).unwrap(),
+                pool_range_start: Ipv4Addr::from([192, 168, 0, 0]),
+                pool_range_stop: Ipv4Addr::from([192, 168, 0, 0]),
+            },
+            permitted_macs: crate::configuration::PermittedMacs(vec![]),
+            static_assignments: crate::configuration::StaticAssignments(HashMap::new()),
+            arp_probe: false,
+            bound_device_names: vec![],
+        };
+        assert_ne!(default_params, server.params);
+        let () = server.dispatch_reset_parameters(&default_params)?;
+        assert_eq!(default_params, server.params);
+        let stored_params = server.stash.load_parameters().await?;
+        assert_eq!(default_params, stored_params);
+        Ok(())
+    }
 }
diff --git a/src/connectivity/network/dhcpd-cli/src/args.rs b/src/connectivity/network/dhcpd-cli/src/args.rs
index 5e2b535..d33108c 100644
--- a/src/connectivity/network/dhcpd-cli/src/args.rs
+++ b/src/connectivity/network/dhcpd-cli/src/args.rs
@@ -25,6 +25,8 @@
     Set(Set),
     /// a primary command to list the values of all DHCP options or server parameters.
     List(List),
+    /// a primary command to reset the values of all DHCP options or server parameters.
+    Reset(Reset),
 }
 
 /// A primary command to retrieve the value of a DHCP option or server parameter.
@@ -51,6 +53,14 @@
     pub arg: ListArg,
 }
 
+/// A primary command to reset the values of all DHCP options or server parameters.
+#[derive(Debug, FromArgs)]
+#[argh(subcommand, name = "reset")]
+pub struct Reset {
+    #[argh(subcommand)]
+    pub arg: ResetArg,
+}
+
 #[derive(Debug, FromArgs)]
 #[argh(subcommand)]
 pub enum GetArg {
@@ -75,6 +85,14 @@
     Parameter(ParameterToken),
 }
 
+/// A primary command argument to reset the values of all DHCP options or server parameters.
+#[derive(Debug, FromArgs)]
+#[argh(subcommand)]
+pub enum ResetArg {
+    Option(OptionToken),
+    Parameter(ParameterToken),
+}
+
 /// A secondary command indicating a DHCP option argument.
 #[derive(Debug, FromArgs)]
 #[argh(subcommand, name = "option")]
diff --git a/src/connectivity/network/dhcpd-cli/src/lib.rs b/src/connectivity/network/dhcpd-cli/src/lib.rs
index fcf616e..37831f2 100644
--- a/src/connectivity/network/dhcpd-cli/src/lib.rs
+++ b/src/connectivity/network/dhcpd-cli/src/lib.rs
@@ -234,3 +234,77 @@
     }])
     .await
 }
+
+#[fuchsia_async::run_singlethreaded(test)]
+async fn test_reset_option() {
+    test_cli(vec![
+        Command {
+            args: vec!["set", "option", "subnet-mask", "--mask", "255.255.255.0"],
+            expected_stdout: "",
+            expected_stderr: "",
+        },
+        Command {
+            args: vec!["list", "option"],
+            expected_stdout: r#"[
+    SubnetMask(
+        Ipv4Address {
+            addr: [
+                255,
+                255,
+                255,
+                0,
+            ],
+        },
+    ),
+]
+"#,
+            expected_stderr: "",
+        },
+        Command { args: vec!["reset", "option"], expected_stdout: "", expected_stderr: "" },
+        Command { args: vec!["list", "option"], expected_stdout: "[]\n", expected_stderr: "" },
+    ])
+    .await
+}
+
+#[fuchsia_async::run_singlethreaded(test)]
+async fn test_reset_parameter() {
+    test_cli(vec![
+        Command {
+            args: vec!["set", "parameter", "lease-length", "--default", "42"],
+            expected_stdout: "",
+            expected_stderr: "",
+        },
+        Command {
+            args: vec!["get", "parameter", "lease-length"],
+            expected_stdout: r#"Lease(
+    LeaseLength {
+        default: Some(
+            42,
+        ),
+        max: Some(
+            42,
+        ),
+    },
+)
+"#,
+            expected_stderr: "",
+        },
+        Command { args: vec!["reset", "parameter"], expected_stdout: "", expected_stderr: "" },
+        Command {
+            args: vec!["get", "parameter", "lease-length"],
+            expected_stdout: r#"Lease(
+    LeaseLength {
+        default: Some(
+            86400,
+        ),
+        max: Some(
+            86400,
+        ),
+    },
+)
+"#,
+            expected_stderr: "",
+        },
+    ])
+    .await
+}
diff --git a/src/connectivity/network/dhcpd-cli/src/main.rs b/src/connectivity/network/dhcpd-cli/src/main.rs
index 925e1eb..2287012 100644
--- a/src/connectivity/network/dhcpd-cli/src/main.rs
+++ b/src/connectivity/network/dhcpd-cli/src/main.rs
@@ -20,6 +20,7 @@
         Cli { cmd: Command::Get(get_arg) } => do_get(get_arg, server).await?,
         Cli { cmd: Command::Set(set_arg) } => do_set(set_arg, server).await?,
         Cli { cmd: Command::List(list_arg) } => do_list(list_arg, server).await?,
+        Cli { cmd: Command::Reset(reset_arg) } => do_reset(reset_arg, server).await?,
     };
 
     Ok(())
@@ -74,7 +75,7 @@
                 .list_options()
                 .await?
                 .map_err(|e| fuchsia_zircon::Status::from_raw(e))
-                .with_context(|| "list_options() failed")?;
+                .context("list_options() failed")?;
 
             println!("{:#?}", res);
         }
@@ -83,9 +84,29 @@
                 .list_parameters()
                 .await?
                 .map_err(|e| fuchsia_zircon::Status::from_raw(e))
-                .with_context(|| "list_parameters() failed")?;
+                .context("list_parameters() failed")?;
             println!("{:#?}", res);
         }
     };
     Ok(())
 }
+
+async fn do_reset(reset_arg: Reset, server: Server_Proxy) -> Result<(), Error> {
+    match reset_arg.arg {
+        ResetArg::Option(OptionToken {}) => {
+            let () = server
+                .reset_options()
+                .await?
+                .map_err(fuchsia_zircon::Status::from_raw)
+                .context("reset_options() failed")?;
+        }
+        ResetArg::Parameter(ParameterToken {}) => {
+            let () = server
+                .reset_parameters()
+                .await?
+                .map_err(fuchsia_zircon::Status::from_raw)
+                .context("reset_parameters() failed")?;
+        }
+    };
+    Ok(())
+}