diff --git a/dev/core/src/com/google/gwt/core/ext/ServletContainerLauncher.java b/dev/core/src/com/google/gwt/core/ext/ServletContainerLauncher.java
index 185e7cd..c433f64 100644
--- a/dev/core/src/com/google/gwt/core/ext/ServletContainerLauncher.java
+++ b/dev/core/src/com/google/gwt/core/ext/ServletContainerLauncher.java
@@ -17,17 +17,37 @@
 
 import java.io.File;
 import java.net.BindException;
+import java.net.InetAddress;
 
 /**
  * Defines the service provider interface for launching servlet containers that
  * can be used by the GWT development mode.
+ * <p>
+ * Subclasses should be careful about calling any methods defined on this class
+ * or else they risk failing when used with a version of GWT that did not have
+ * those methods.
  */
 public abstract class ServletContainerLauncher {
+  /*
+   * NOTE: Any new methods must have default implementations, and any users of
+   * this class must be prepared to handle LinkageErrors when calling new
+   * methods.
+   */
+
+  /**
+   * @return byte array containing an icon (fitting into 24x24) to
+   *     use for the server, or null if only the name should be used
+   */
+  public byte[] getIconBytes() {
+    return null;
+  }
 
   /**
    * @return a path to a 24-pixel high image file (relative to the classpath) to
    *     be used for this servlet container, or null if none.
+   * @deprecated see {@link #getIconBytes} instead.
    */
+  @Deprecated
   public String getIconPath() {
     return null;
   }
@@ -41,6 +61,36 @@
   }
 
   /**
+   * Process any supplied arguments.
+   * <p>
+   * Will be called before {@link #start(TreeLogger, int, File)}, if at all.
+   * 
+   * @param logger logger to use for warnings/errors
+   * @param arguments single string containing the arguments for this SCL, the
+   *     format to be defined by the SCL
+   * @return true if the arguments were processed successfully
+   */
+  public boolean processArguments(TreeLogger logger, String arguments) {
+    return false;
+  }
+
+  /**
+   * Set the bind address for the web server socket.
+   * <p>
+   * Will be called before {@link #start(TreeLogger, int, File)}, if at all.
+   * If not called, the SCL should listen on all addresses.
+   * 
+   * @param bindAddress host name or IP address, suitable for use with
+   *     {@link InetAddress#getByName(String)}
+   */
+  public void setBindAddress(String bindAddress) {
+    /*
+     * By default, we do nothing, which means that old SCL implementations
+     * will bind to all addresses.
+     */
+  }
+  
+  /**
    * Start an embedded HTTP servlet container.
    * 
    * @param logger the server logger
diff --git a/dev/core/src/com/google/gwt/dev/DevMode.java b/dev/core/src/com/google/gwt/dev/DevMode.java
index e26c86d..255759f 100644
--- a/dev/core/src/com/google/gwt/dev/DevMode.java
+++ b/dev/core/src/com/google/gwt/dev/DevMode.java
@@ -81,19 +81,30 @@
 
     @Override
     public String[] getTagArgs() {
-      return new String[] {"servletContainerLauncher"};
+      return new String[] {"servletContainerLauncher[:args]"};
     }
 
     @Override
-    public boolean setString(String sclClassName) {
+    public boolean setString(String arg) {
       // Supercedes -noserver.
       options.setNoServer(false);
+      String sclClassName;
+      String sclArgs;
+      int idx = arg.indexOf(':');
+      if (idx >= 0) {
+        sclArgs = arg.substring(idx + 1);
+        sclClassName = arg.substring(0, idx);
+      } else {
+        sclArgs = null;
+        sclClassName = arg;
+      }
       Throwable t;
       try {
         Class<?> clazz = Class.forName(sclClassName, true,
             Thread.currentThread().getContextClassLoader());
         Class<? extends ServletContainerLauncher> sclClass = clazz.asSubclass(ServletContainerLauncher.class);
         options.setServletContainerLauncher(sclClass.newInstance());
+        options.setServletContainerLauncherArgs(sclArgs);
         return true;
       } catch (ClassCastException e) {
         t = e;
@@ -167,7 +178,11 @@
   interface HostedModeOptions extends HostedModeBaseOptions, CompilerOptions {
     ServletContainerLauncher getServletContainerLauncher();
 
+    String getServletContainerLauncherArgs();
+
     void setServletContainerLauncher(ServletContainerLauncher scl);
+
+    void setServletContainerLauncherArgs(String args);
   }
 
   /**
@@ -179,6 +194,7 @@
     private int localWorkers;
     private File outDir;
     private ServletContainerLauncher scl;
+    private String sclArgs;
     private File warDir;
 
     public File getExtraDir() {
@@ -198,6 +214,10 @@
       return scl;
     }
 
+    public String getServletContainerLauncherArgs() {
+      return sclArgs;
+    }
+
     @Override
     public File getShellBaseWorkDir(ModuleDef moduleDef) {
       return new File(new File(getWorkDir(), moduleDef.getName()), "shell");
@@ -224,6 +244,10 @@
       this.scl = scl;
     }
 
+    public void setServletContainerLauncherArgs(String args) {
+      sclArgs = args;
+    }
+
     public void setWarDir(File warDir) {
       this.warDir = warDir;
     }
@@ -359,46 +383,53 @@
 
   @Override
   protected int doStartUpServer() {
+    boolean clearCallback = true;
     try {
       ui.setCallback(RestartServerEvent.getType(), this);
-      // TODO(jat): find a safe way to get an icon for the servlet container
-      TreeLogger serverLogger = ui.getWebServerLogger(getWebServerName(), null);
-      serverLogger.log(TreeLogger.TRACE, "Starting HTTP on port " + getPort(),
-          null);
 
       ServletContainerLauncher scl = options.getServletContainerLauncher();
+
+      TreeLogger serverLogger = ui.getWebServerLogger(getWebServerName(), 
+          scl.getIconBytes());
+
+      String sclArgs = options.getServletContainerLauncherArgs();
+      if (sclArgs != null) {
+        if (!scl.processArguments(serverLogger, sclArgs)) {
+          return -1;
+        }
+      }
+
       /*
        * TODO: This is a hack to pass the base log level to the SCL. We'll have
        * to figure out a better way to do this for SCLs in general.
        */
       if (scl instanceof JettyLauncher) {
-        ((JettyLauncher) scl).setBaseLogLevel(getBaseLogLevelForUI());
+        JettyLauncher jetty = (JettyLauncher) scl;
+        jetty.setBaseRequestLogLevel(getBaseLogLevelForUI());
       }
+      scl.setBindAddress(bindAddress);
 
+      serverLogger.log(TreeLogger.TRACE, "Starting HTTP on port " + getPort(),
+          null);
       server = scl.start(serverLogger, getPort(), options.getWarDir());
       assert (server != null);
+      clearCallback = false;
       return server.getPort();
     } catch (BindException e) {
-      System.err.println("Port "
-          + getPort()
+      System.err.println("Port " + bindAddress + ':' + getPort()
           + " is already is use; you probably still have another session active");
     } catch (Exception e) {
       System.err.println("Unable to start embedded HTTP server");
       e.printStackTrace();
+    } finally {
+      if (clearCallback) {
+        // Clear the callback if we failed to start the server
+        ui.setCallback(RestartServerEvent.getType(), null);
+      }
     }
-    // Clear the callback if we failed to start the server
-    ui.setCallback(RestartServerEvent.getType(), null);
     return -1;
   }
 
-  @Override
-  protected String getHost() {
-    if (server != null) {
-      return server.getHost();
-    }
-    return super.getHost();
-  }
-
   protected String getWebServerName() {
     return options.getServletContainerLauncher().getName();
   }
diff --git a/dev/core/src/com/google/gwt/dev/DevModeBase.java b/dev/core/src/com/google/gwt/dev/DevModeBase.java
index 33b169c..da8fc37 100644
--- a/dev/core/src/com/google/gwt/dev/DevModeBase.java
+++ b/dev/core/src/com/google/gwt/dev/DevModeBase.java
@@ -47,8 +47,10 @@
 import com.google.gwt.util.tools.ArgHandlerString;
 
 import java.io.File;
+import java.net.InetAddress;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -106,6 +108,63 @@
   }
 
   /**
+   * Handles the -bindAddress command line flag.
+   */
+  protected static class ArgHandlerBindAddress extends ArgHandlerString {
+
+    private static final String BIND_ADDRESS_TAG = "-bindAddress";
+    private static final String DEFAULT_BIND_ADDRESS = "127.0.0.1";
+
+    private final OptionBindAddress options;
+
+    public ArgHandlerBindAddress(OptionBindAddress options) {
+      this.options = options;
+    }
+
+    @Override
+    public String[] getDefaultArgs() {
+      return new String[] {BIND_ADDRESS_TAG, DEFAULT_BIND_ADDRESS};
+    }
+
+    @Override
+    public String getPurpose() {
+      return "Specifies the bind address for the code server and web server "
+          + "(defaults to " + DEFAULT_BIND_ADDRESS + ")";
+    }
+
+    @Override
+    public String getTag() {
+      return BIND_ADDRESS_TAG;
+    }
+
+    @Override
+    public String[] getTagArgs() {
+      return new String[] {"host-name-or-address"};
+    }
+
+    @Override
+    public boolean setString(String value) {
+      try {
+        InetAddress address = InetAddress.getByName(value);
+        options.setBindAddress(value);
+        if (address.isAnyLocalAddress()) {
+          // replace a wildcard address with our machine's local address
+          // this isn't fully accurate, as there is no guarantee we will get
+          // the right one on a multihomed host
+          options.setConnectAddress(
+              InetAddress.getLocalHost().getHostAddress());
+        } else {
+          options.setConnectAddress(value);
+        }
+        return true;
+      } catch (UnknownHostException e) {
+        System.err.println("-bindAddress host \"" + value + "\" unknown");
+        return false;
+      }
+    }
+  }
+
+  /**
    * Handles the -blacklist command line argument.
    */
   protected static class ArgHandlerBlacklist extends ArgHandlerString {
@@ -131,7 +190,7 @@
   }
 
   /**
-   * Handles the -portHosted command line flag.
+   * Handles the -codeServerPort command line flag.
    */
   protected static class ArgHandlerCodeServerPort extends ArgHandlerString {
 
@@ -374,7 +433,8 @@
 
   protected interface HostedModeBaseOptions extends JJSOptions, OptionLogDir,
       OptionLogLevel, OptionGenDir, OptionNoServer, OptionPort,
-      OptionCodeServerPort, OptionStartupURLs, OptionRemoteUI {
+      OptionCodeServerPort, OptionStartupURLs, OptionRemoteUI,
+      OptionBindAddress {
 
     /**
      * The base shell work directory.
@@ -392,10 +452,12 @@
   protected static class HostedModeBaseOptionsImpl extends
       PrecompileOptionsImpl implements HostedModeBaseOptions {
 
+    private String bindAddress;
+    private int codeServerPort;
+    private String connectAddress;
     private boolean isNoServer;
     private File logDir;
     private int port;
-    private int portHosted;
     private String remoteUIClientId;
     private String remoteUIHost;
     private int remoteUIHostPort;
@@ -409,12 +471,20 @@
       return logDir != null;
     }
 
+    public String getBindAddress() {
+      return bindAddress;
+    }
+
     public String getClientId() {
       return remoteUIClientId;
     }
 
     public int getCodeServerPort() {
-      return portHosted;
+      return codeServerPort;
+    }
+
+    public String getConnectAddress() {
+      return connectAddress;
     }
 
     public File getLogDir() {
@@ -452,12 +522,20 @@
       return isNoServer;
     }
 
+    public void setBindAddress(String bindAddress) {
+      this.bindAddress = bindAddress;
+    }
+
     public void setClientId(String clientId) {
       this.remoteUIClientId = clientId;
     }
 
     public void setCodeServerPort(int port) {
-      portHosted = port;
+      codeServerPort = port;
+    }
+
+    public void setConnectAddress(String connectAddress) {
+      this.connectAddress = connectAddress;
     }
 
     public void setLogFile(String filename) {
@@ -485,6 +563,16 @@
     }
   }
 
+  protected interface OptionBindAddress {
+    String getBindAddress();
+    
+    String getConnectAddress();
+
+    void setBindAddress(String bindAddress);
+
+    void setConnectAddress(String connectAddress);
+  }
+
   protected interface OptionCodeServerPort {
     int getCodeServerPort();
 
@@ -564,6 +652,7 @@
       registerHandler(new ArgHandlerLogDir(options));
       registerHandler(new ArgHandlerLogLevel(options));
       registerHandler(new ArgHandlerGenDir(options));
+      registerHandler(new ArgHandlerBindAddress(options));
       registerHandler(new ArgHandlerCodeServerPort(options));
       registerHandler(new ArgHandlerRemoteUI(options));
     }
@@ -617,8 +706,12 @@
     return buf.toString();
   }
 
+  protected String bindAddress;
+
   protected int codeServerPort;
 
+  protected String connectAddress;
+
   protected BrowserListener listener;
 
   protected final HostedModeBaseOptions options;
@@ -766,6 +859,9 @@
    * @return true if startup was successful
    */
   protected boolean doStartup() {
+    bindAddress = options.getBindAddress();
+    connectAddress = options.getConnectAddress();
+
     // Create the main app window.
     ui.initialize(options.getLogLevel());
     topLogger = ui.getTopLogger();
@@ -799,8 +895,8 @@
   protected void ensureCodeServerListener() {
     if (listener == null) {
       codeServerPort = options.getCodeServerPort();
-      listener = new BrowserListener(getTopLogger(), codeServerPort,
-          new OophmSessionHandler(getTopLogger(), browserHost));
+      listener = new BrowserListener(getTopLogger(), bindAddress,
+          codeServerPort, new OophmSessionHandler(getTopLogger(), browserHost));
       listener.start();
       try {
         // save the port we actually used if it was auto
@@ -812,7 +908,7 @@
   }
 
   protected String getHost() {
-    return "localhost";
+    return connectAddress;
   }
 
   /**
@@ -881,7 +977,8 @@
       String path = parsedUrl.getPath();
       String query = parsedUrl.getQuery();
       String hash = parsedUrl.getRef();
-      String hostedParam = BrowserListener.getDevModeURLParams(listener.getEndpointIdentifier());
+      String hostedParam = BrowserListener.getDevModeURLParams(connectAddress,
+          listener.getSocketPort());
       if (query == null) {
         query = hostedParam;
       } else {
diff --git a/dev/core/src/com/google/gwt/dev/shell/BrowserListener.java b/dev/core/src/com/google/gwt/dev/shell/BrowserListener.java
index 340b7df..02b10c4 100644
--- a/dev/core/src/com/google/gwt/dev/shell/BrowserListener.java
+++ b/dev/core/src/com/google/gwt/dev/shell/BrowserListener.java
@@ -26,38 +26,23 @@
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketException;
-import java.net.UnknownHostException;
 
 /**
  * Listens for connections from OOPHM clients.
  */
 public class BrowserListener {
 
-  /**
-   * Get the endpoint identifier (in form host:port) for this listener.
-   * 
-   * @param browserChannelPort
-   * @throws RuntimeException if the local host's address cannot be determined
-   * @return a string of the form host:port
-   */
-  public static String computeEndpointIdentifier(int browserChannelPort) {
-    try {
-      return InetAddress.getLocalHost().getHostAddress() + ":"
-          + browserChannelPort;
-    } catch (UnknownHostException e) {
-      throw new RuntimeException("Unable to determine my ip", e);
-    }
-  }
 
   /**
    * Get a query parameter to be added to the URL that specifies the address
    * of this listener.
    * 
-   * @param endpointIdentifier
+   * @param address address of host to use for connections
+   * @param port TCP port number to use for connection
    * @return a query parameter
    */
-  public static String getDevModeURLParams(String endpointIdentifier) {
-    return "gwt.codesvr=" + endpointIdentifier;
+  public static String getDevModeURLParams(String address, int port) {
+    return "gwt.codesvr=" + address + ":" + port;
   }
 
   private ServerSocket listenSocket;
@@ -73,12 +58,13 @@
    * @param port 
    * @param handler 
    */
-  public BrowserListener(final TreeLogger logger, int port,
-      final SessionHandler handler) {
+  public BrowserListener(final TreeLogger logger, String bindAddress,
+      int port, final SessionHandler handler) {
     try {
       listenSocket = new ServerSocket();
       listenSocket.setReuseAddress(true);
-      listenSocket.bind(new InetSocketAddress(port));
+      InetAddress address = InetAddress.getByName(bindAddress);
+      listenSocket.bind(new InetSocketAddress(address, port));
 
       logger.log(TreeLogger.TRACE, "Started code server on port "
           + listenSocket.getLocalPort(), null);
@@ -126,20 +112,6 @@
   }
 
   /**
-   * @return the endpoint identifier of the listener, of the form host:port
-   *         (where host may be an IP address as well).
-   * 
-   * @throws UnableToCompleteException if the listener is not running
-   */
-  public String getEndpointIdentifier() throws UnableToCompleteException {
-    if (listenSocket == null) {
-      // If we failed to initialize our socket, just bail here.
-      throw new UnableToCompleteException();
-    }
-    return computeEndpointIdentifier(listenSocket.getLocalPort());
-  }
-
-  /**
    * @return the port number of the listening socket.
    * 
    * @throws UnableToCompleteException if the listener is not running
diff --git a/dev/core/src/com/google/gwt/dev/shell/jetty/JettyLauncher.java b/dev/core/src/com/google/gwt/dev/shell/jetty/JettyLauncher.java
index a4c60c0..03fced5 100644
--- a/dev/core/src/com/google/gwt/dev/shell/jetty/JettyLauncher.java
+++ b/dev/core/src/com/google/gwt/dev/shell/jetty/JettyLauncher.java
@@ -480,22 +480,24 @@
   // default value used if setBaseLogLevel isn't called
   private TreeLogger.Type baseLogLevel = TreeLogger.INFO;
 
-  @Override
-  public String getIconPath() {
-    return null;
-  }
+  private String bindAddress = null;
 
   @Override
   public String getName() {
     return "Jetty";
   }
 
+  @Override
+  public void setBindAddress(String bindAddress) {
+    this.bindAddress = bindAddress;
+  }
+
   /*
    * TODO: This is a hack to pass the base log level to the SCL. We'll have to
    * figure out a better way to do this for SCLs in general. Please do not
    * depend on this method, as it is subject to change.
    */
-  public void setBaseLogLevel(TreeLogger.Type baseLogLevel) {
+  public void setBaseRequestLogLevel(TreeLogger.Type baseLogLevel) {
     synchronized (privateInstanceLock) {
       this.baseLogLevel = baseLogLevel;
     }
@@ -516,6 +518,9 @@
     System.setProperty("org.mortbay.xml.XmlParser.Validating", "false");
 
     AbstractConnector connector = getConnector();
+    if (bindAddress != null) {
+      connector.setHost(bindAddress.toString());
+    }
     connector.setPort(port);
 
     // Don't share ports with an existing process.