diff --git a/THIRDPARTYLICENSE.txt b/THIRDPARTYLICENSE.txt
index ec97bc9..34dccfa 100644
--- a/THIRDPARTYLICENSE.txt
+++ b/THIRDPARTYLICENSE.txt
@@ -16,6 +16,11 @@
 
 xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
 
+lib/commons-daemon-1.0.15.jar
+Apache2
+
+xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
 lib/commons-lang-2.1.jar
 Apache2
 
diff --git a/build.xml b/build.xml
index ddf60c5..7452685 100644
--- a/build.xml
+++ b/build.xml
@@ -40,6 +40,7 @@
       <include name="jsr305.jar"/>
       <include name="gson-2.0.jar"/>
       <include name="velocity-1.5.jar"/>
+      <include name="commons-daemon-1.0.15.jar"/>
     </fileset>
   </path>
 
diff --git a/lib/commons-daemon-1.0.15.jar b/lib/commons-daemon-1.0.15.jar
new file mode 100644
index 0000000..2b6b9c6
--- /dev/null
+++ b/lib/commons-daemon-1.0.15.jar
Binary files differ
diff --git a/src/com/google/enterprise/adaptor/Application.java b/src/com/google/enterprise/adaptor/Application.java
index cb922a8..b980aec 100644
--- a/src/com/google/enterprise/adaptor/Application.java
+++ b/src/com/google/enterprise/adaptor/Application.java
@@ -60,18 +60,46 @@
    */
   public void start() throws IOException, InterruptedException {
     synchronized (this) {
-      if (primaryServer != null) {
-        throw new IllegalStateException("Already started");
-      }
+      daemonInit();
+
+      // The shutdown hook is purposefully not part of the deamon methods,
+      // because it should only be done when running from the command line.
       shutdownHook = new Thread(new ShutdownHook(), "gsacomm-shutdown");
       Runtime.getRuntime().addShutdownHook(shutdownHook);
-
-      primaryServer = createHttpServer();
-      dashboardServer = createDashboardHttpServer();
-      primaryServer.start();
-      dashboardServer.start();
     }
+
+    daemonStart();
+  }
+
+  /**
+   * Reserves resources for later use. This may be run with different
+   * permissions (like as root), to reserve ports or other things that need
+   * elevated privileges.
+   */
+  synchronized void daemonInit() throws IOException {
+    if (primaryServer != null) {
+      throw new IllegalStateException("Already started");
+    }
+    primaryServer = createHttpServer(config);
+    dashboardServer = createDashboardHttpServer(config);
+    // Because once stopped the server can't be reused, we can't reuse its
+    // bind()ed socket if we stop it. So although ideally we would start/stop in
+    // daemonStart/daemonStop, we instead must do it in
+    // daemonInit/daemonDestroy.
+    primaryServer.start();
+    dashboardServer.start();
+  }
+
+  /**
+   * Really start. This must be called after a successful {@link #daemonInit}.
+   */
+  void daemonStart() throws IOException, InterruptedException {
     gsa.start(primaryServer, dashboardServer);
+
+    if (config.isAdaptorPushDocIdsOnStartup()) {
+      log.info("Pushing once at program start");
+      gsa.checkAndScheduleImmediatePushOfDocIds();
+    }
   }
 
   /**
@@ -79,9 +107,8 @@
    * shutdown.
    */
   public synchronized void stop(long time, TimeUnit unit) {
-    if (primaryServer == null) {
-      throw new IllegalStateException("Already stopped");
-    }
+    daemonStop(time, unit);
+    daemonDestroy(time, unit);
     if (shutdownHook != null) {
       try {
         Runtime.getRuntime().removeShutdownHook(shutdownHook);
@@ -90,28 +117,44 @@
       }
       shutdownHook = null;
     }
+  }
 
+  /**
+   * Stop all the services we provide. This is the opposite of {@link
+   * #daemonStart}.
+   */
+  synchronized void daemonStop(long time, TimeUnit unit) {
+    if (primaryServer == null) {
+      throw new IllegalStateException("Already stopped");
+    }
     gsa.stop(time, unit);
-    SleepHandler sleepHandler = new SleepHandler(100 /* millis */);
-    // Workaround Java Bug 7105369.
-    primaryServer.createContext(SLEEP_PATH, sleepHandler);
-    issueSleepGetRequest(config.getServerPort());
+  }
 
-    primaryServer.stop((int) unit.toSeconds(time));
+  /**
+   * Release reserved resources. This is the opposite of {@link
+   * #daemonInit}.
+   */
+  synchronized void daemonDestroy(long time, TimeUnit unit) {
+    httpServerShutdown(primaryServer, time, unit);
     log.finer("Completed primary server stop");
-    ((ExecutorService) primaryServer.getExecutor()).shutdownNow();
     primaryServer = null;
 
-    // Workaround Java Bug 7105369.
-    dashboardServer.createContext(SLEEP_PATH, sleepHandler);
-    issueSleepGetRequest(config.getServerDashboardPort());
-
-    dashboardServer.stop((int) unit.toSeconds(time));
-    ((ExecutorService) dashboardServer.getExecutor()).shutdownNow();
+    httpServerShutdown(dashboardServer, time, unit);
     log.finer("Completed dashboard stop");
     dashboardServer = null;
   }
 
+  private static void httpServerShutdown(HttpServer server, long time,
+      TimeUnit unit) {
+    // Workaround Java Bug 7105369.
+    SleepHandler sleepHandler = new SleepHandler(100 /* millis */);
+    server.createContext(SLEEP_PATH, sleepHandler);
+    issueSleepGetRequest(server.getAddress(), server instanceof HttpsServer);
+
+    server.stop((int) unit.toSeconds(time));
+    ((ExecutorService) server.getExecutor()).shutdownNow();
+  }
+
   /**
    * Issues a GET request to a SleepHandler. This is used to workaround Java
    * Bug 7105369.
@@ -127,11 +170,12 @@
    * before calling stop(). In the event everything goes as planned, the request
    * completes after stop() has been called and allows stop() to exit quickly.
    */
-  private void issueSleepGetRequest(int port) {
+  private static void issueSleepGetRequest(InetSocketAddress address,
+      boolean isHttps) {
     URL url;
     try {
-      url = new URL(config.isServerSecure() ? "https" : "http",
-          config.getServerHostname(), port, SLEEP_PATH);
+      url = new URL(isHttps ? "https" : "http",
+          address.getAddress().getHostAddress(), address.getPort(), SLEEP_PATH);
     } catch (MalformedURLException ex) {
       log.log(Level.WARNING,
           "Unexpected error. Shutting down will be slow.", ex);
@@ -165,7 +209,7 @@
     }).start();
   }
 
-  private HttpServer createHttpServer() throws IOException {
+  private static HttpServer createHttpServer(Config config) throws IOException {
     HttpServer server;
     if (!config.isServerSecure()) {
       server = HttpServer.create();
@@ -206,7 +250,8 @@
     return server;
   }
 
-  private HttpServer createDashboardHttpServer() throws IOException {
+  private static HttpServer createDashboardHttpServer(Config config)
+      throws IOException {
     boolean secure = config.isServerSecure();
     HttpServer server;
     if (!secure) {
@@ -247,6 +292,11 @@
     return gsa;
   }
 
+  /** Returns the {@link Config} used by this instance. */
+  public Config getConfig() {
+    return config;
+  }
+
   /**
    * Main for adaptors to utilize when wanting to act as an application. This
    * method primarily parses arguments and creates an application instance
@@ -255,14 +305,7 @@
    * @return the application instance in use
    */
   public static Application main(Adaptor adaptor, String[] args) {
-    Config config = new Config();
-    adaptor.initConfig(config);
-    config.autoConfig(args);
-
-    if (config.useAdaptorAutoUnzip()) {
-      adaptor = new AutoUnzipAdaptor(adaptor);
-    }
-    Application app = new Application(adaptor, config);
+    Application app = daemonMain(adaptor, args);
 
     // Setup providing content.
     try {
@@ -274,14 +317,24 @@
       throw new RuntimeException("could not start serving", e);
     }
 
-    if (config.isAdaptorPushDocIdsOnStartup()) {
-      log.info("Pushing once at program start");
-      app.getGsaCommunicationHandler().checkAndScheduleImmediatePushOfDocIds();
-    }
-
     return app;
   }
 
+  /**
+   * Performs basic bootstrapping like normal {@link #main}, but does not start
+   * the application.
+   */
+  static Application daemonMain(Adaptor adaptor, String[] args) {
+    Config config = new Config();
+    adaptor.initConfig(config);
+    config.autoConfig(args);
+
+    if (config.useAdaptorAutoUnzip()) {
+      adaptor = new AutoUnzipAdaptor(adaptor);
+    }
+    return new Application(adaptor, config);
+  }
+
   private class ShutdownHook implements Runnable {
     @Override
     public void run() {
diff --git a/src/com/google/enterprise/adaptor/Daemon.java b/src/com/google/enterprise/adaptor/Daemon.java
new file mode 100644
index 0000000..6aa9406
--- /dev/null
+++ b/src/com/google/enterprise/adaptor/Daemon.java
@@ -0,0 +1,107 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.enterprise.adaptor;
+
+import com.google.common.annotations.VisibleForTesting;
+
+import org.apache.commons.daemon.DaemonContext;
+
+import java.util.Arrays;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Allows running an adaptor as a daemon when used in conjunction with procrun
+ * or jsvc.
+ *
+ * <p>Example execution with jsvc:
+ * <pre>jsvc -pidfile adaptor.pid -cp someadaptor-withlib.jar \
+ *    com.google.enterprise.adaptor.Daemon package.SomeAdaptor</pre>
+ */
+public class Daemon implements org.apache.commons.daemon.Daemon {
+  private Application app;
+  private DaemonContext context;
+
+  @Override
+  public synchronized void init(DaemonContext context) throws Exception {
+    if (this.context != null) {
+      throw new IllegalStateException("Already initialized");
+    }
+    this.context = context;
+    String[] args = context.getArguments();
+    if (args.length < 1) {
+      throw new IllegalArgumentException(
+          "Missing argument: adaptor class name");
+    }
+    Adaptor adaptor
+        = Class.forName(args[0]).asSubclass(Adaptor.class).newInstance();
+    args = Arrays.copyOfRange(args, 1, args.length);
+
+    app = Application.daemonMain(adaptor, args);
+    app.daemonInit();
+  }
+
+  @Override
+  public synchronized void destroy() {
+    if (app != null) {
+      app.daemonDestroy(5, TimeUnit.SECONDS);
+    }
+    context = null;
+    app = null;
+  }
+
+  @Override
+  public void start() throws Exception {
+    final Application savedApp;
+    final DaemonContext savedContext;
+    final CountDownLatch latch = new CountDownLatch(1);
+    // Save values so that there aren't any races with stop/destroy.
+    synchronized (this) {
+      savedApp = this.app;
+      savedContext = this.context;
+    }
+    // Run in a new thread so that stop() can be called before we complete
+    // starting (since starting can take a long time if the Adaptor keeps
+    // throwing an exception). However, we still try to wait for start to
+    // complete normally to ease testing and improve the user experience in the
+    // common case of starting being quick.
+    new Thread(new Runnable() {
+      @Override
+      public void run() {
+        try {
+          savedApp.daemonStart();
+        } catch (InterruptedException ex) {
+          // We must be shutting down.
+          Thread.currentThread().interrupt();
+        } catch (Exception ex) {
+          savedContext.getController().fail(ex);
+        } finally {
+          latch.countDown();
+        }
+      }
+    }).start();
+    latch.await(5, TimeUnit.SECONDS);
+  }
+
+  @Override
+  public synchronized void stop() throws Exception {
+    app.daemonStop(5, TimeUnit.SECONDS);
+  }
+
+  @VisibleForTesting
+  Application getApplication() {
+    return app;
+  }
+}
diff --git a/src/com/google/enterprise/adaptor/GsaCommunicationHandler.java b/src/com/google/enterprise/adaptor/GsaCommunicationHandler.java
index 7ef85c4..09749b8 100644
--- a/src/com/google/enterprise/adaptor/GsaCommunicationHandler.java
+++ b/src/com/google/enterprise/adaptor/GsaCommunicationHandler.java
@@ -539,6 +539,11 @@
     }
   }
 
+  /** The adaptor instance being used. */
+  public Adaptor getAdaptor() {
+    return adaptor;
+  }
+
   HttpContext addFilters(HttpContext context) {
     context.getFilters().add(waiter.filter());
     context.getFilters().addAll(commonFilters);
diff --git a/test/com/google/enterprise/adaptor/DaemonTest.java b/test/com/google/enterprise/adaptor/DaemonTest.java
new file mode 100644
index 0000000..bed6475
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/DaemonTest.java
@@ -0,0 +1,149 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.enterprise.adaptor;
+
+import static org.junit.Assert.*;
+
+import org.apache.commons.daemon.DaemonContext;
+import org.apache.commons.daemon.DaemonController;
+import org.junit.*;
+import org.junit.rules.ExpectedException;
+
+import java.io.*;
+import java.net.*;
+import java.nio.charset.Charset;
+
+/** Tests for {@link Daemon}. */
+public class DaemonTest {
+  private String[] arguments = new String[] {
+      SingleDocAdaptor.class.getName(), "-Dgsa.hostname=localhost",
+      "-Dserver.port=0", "-Dserver.dashboardPort=0"};
+
+  @Rule
+  public ExpectedException thrown = ExpectedException.none();
+
+  @Test
+  public void testNoArguments() throws Exception {
+    DaemonContext context = new Context(new String[0], null);
+    Daemon daemon = new Daemon();
+    thrown.expect(IllegalArgumentException.class);
+    daemon.init(context);
+  }
+
+  @Test
+  public void testDoubleInit() throws Exception {
+    DaemonContext context = new Context(arguments, null);
+    Daemon daemon = new Daemon();
+    daemon.init(context);
+    try {
+      thrown.expect(IllegalStateException.class);
+      daemon.init(context);
+    } finally {
+      daemon.destroy();
+    }
+  }
+
+  @Test
+  public void testAnyTimeDestroy() {
+    Daemon daemon = new Daemon();
+    // Destroy without init should still work.
+    daemon.destroy();
+  }
+
+  @Test
+  public void testBasicListen() throws Exception {
+    DaemonContext context = new Context(arguments, null);
+    Daemon daemon = new Daemon();
+    SingleDocAdaptor adaptor = null;
+    daemon.init(context);
+    try {
+      daemon.start();
+      try {
+        Adaptor tmpAdaptor = daemon.getApplication()
+            .getGsaCommunicationHandler().getAdaptor();
+        adaptor = (SingleDocAdaptor) tmpAdaptor;
+        assertTrue(adaptor.inited);
+        int port = daemon.getApplication().getConfig().getServerPort();
+        URL url = new URL("http", "localhost", port, "/doc/");
+        URLConnection conn = url.openConnection();
+        InputStream is = conn.getInputStream();
+        try {
+          String out
+              = IOHelper.readInputStreamToString(is, Charset.forName("UTF-8"));
+          assertEquals("success", out);
+        } finally {
+          is.close();
+        }
+      } finally {
+        daemon.stop();
+      }
+    } finally {
+      daemon.destroy();
+    }
+    assertFalse(adaptor.inited);
+  }
+
+  private static class Context implements DaemonContext {
+    private final String[] args;
+    private final DaemonController controller;
+
+    public Context(String[] args, DaemonController controller) {
+      this.args = args;
+      this.controller = controller;
+    }
+
+    @Override
+    public String[] getArguments() {
+      return args;
+    }
+
+    @Override
+    public DaemonController getController() {
+      return controller;
+    }
+  }
+
+  /**
+   * Adaptor with a single document. Marked public so that it can be loaded by
+   * Daemon.
+   */
+  public static class SingleDocAdaptor extends AbstractAdaptor {
+    private volatile boolean inited;
+
+    @Override
+    public void init(AdaptorContext context) {
+      inited = true;
+    }
+
+    @Override
+    public void destroy() {
+      inited = false;
+    }
+
+    @Override
+    public void getDocIds(DocIdPusher pusher) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void getDocContent(Request req, Response resp) throws IOException {
+      if ("".equals(req.getDocId().getUniqueId())) {
+        resp.getOutputStream().write("success".getBytes("UTF-8"));
+      } else {
+        resp.respondNotFound();
+      }
+    }
+  }
+}