Allow -http to accept host:port (#163)

* Allow -http to accept host:port

* Add serveWebInterface tests.

* Make sure serveWebInterface is serving on the URL.

* Avoid nil pointer dereference

* Simplify the -http flag test.

* Use the right capitalization for hostport.

* Fix the double escaping in regexps.

* Address review comments.

internal/driver/cli.go

@@ -30,10 +30,10 @@ type source struct {
 	Base      []string
 	Normalize bool
 
-	Seconds   int
-	Timeout   int
-	Symbolize string
-	HTTPPort  int
+	Seconds      int
+	Timeout      int
+	Symbolize    string
+	HTTPHostport string
 }
 
 // Parse parses the command lines through the specified flags package
@@ -60,7 +60,7 @@ func parseFlags(o *plugin.Options) (*source, []string, error) {
 	flagTools := flag.String("tools", os.Getenv("PPROF_TOOLS"), "Path for object tool pathnames")
 
 	flagTimeout := flag.Int("timeout", -1, "Timeout in seconds for fetching a profile")
-	flagHTTPPort := flag.Int("http", 0, "Present interactive web based UI at the specified http port")
+	flagHTTP := flag.String("http", "", "Present interactive web based UI at the specified http host:port")
 
 	// Flags used during command processing
 	installedFlags := installFlags(flag)
@@ -109,7 +109,7 @@ func parseFlags(o *plugin.Options) (*source, []string, error) {
 	if err != nil {
 		return nil, nil, err
 	}
-	if cmd != nil && *flagHTTPPort != 0 {
+	if cmd != nil && *flagHTTP != "" {
 		return nil, nil, fmt.Errorf("--http is not compatible with an output format on the command line")
 	}
 
@@ -128,13 +128,13 @@ func parseFlags(o *plugin.Options) (*source, []string, error) {
 	}
 
 	source := &source{
-		Sources:   args,
-		ExecName:  execName,
-		BuildID:   *flagBuildID,
-		Seconds:   *flagSeconds,
-		Timeout:   *flagTimeout,
-		Symbolize: *flagSymbolize,
-		HTTPPort:  *flagHTTPPort,
+		Sources:      args,
+		ExecName:     execName,
+		BuildID:      *flagBuildID,
+		Seconds:      *flagSeconds,
+		Timeout:      *flagTimeout,
+		Symbolize:    *flagSymbolize,
+		HTTPHostport: *flagHTTP,
 	}
 
 	for _, s := range *flagBase {
@@ -292,7 +292,7 @@ var usageMsgSrc = "\n\n" +
 
 var usageMsgVars = "\n\n" +
 	"  Misc options:\n" +
-	"   -http port             Provide web based interface at port\n" +
+	"   -http host:port        Provide web based interface at host:port\n" +
 	"   -tools                 Search path for object tools\n" +
 	"\n" +
 	"  Environment Variables:\n" +

internal/driver/driver.go

@@ -52,8 +52,8 @@ func PProf(eo *plugin.Options) error {
 		return generateReport(p, cmd, pprofVariables, o)
 	}
 
-	if src.HTTPPort > 0 {
-		return serveWebInterface(src.HTTPPort, p, o)
+	if src.HTTPHostport != "" {
+		return serveWebInterface(src.HTTPHostport, p, o)
 	}
 	return interactive(p, o)
 }

internal/driver/webui.go

@@ -21,7 +21,7 @@ import (
 	"io"
 	"net"
 	"net/http"
-	"net/url"
+	gourl "net/url"
 	"os"
 	"os/exec"
 	"regexp"
@@ -51,28 +51,62 @@ func (ec *errorCatcher) PrintErr(args ...interface{}) {
 	ec.UI.PrintErr(args...)
 }
 
-func serveWebInterface(port int, p *profile.Profile, o *plugin.Options) error {
+func serveWebInterface(hostport string, p *profile.Profile, o *plugin.Options) error {
 	interactiveMode = true
 	ui := &webInterface{
 		prof:    p,
 		options: o,
 	}
+
+	ln, url, isLocal, err := newListenerAndURL(hostport)
+	if err != nil {
+		return err
+	}
+
 	// authorization wrapper
 	wrap := o.HTTPWrapper
-	if wrap == nil {
-		// only allow requests from local host
+	if wrap == nil && isLocal {
+		// Only allow requests from local host.
 		wrap = checkLocalHost
 	}
-	http.Handle("/", wrap(http.HandlerFunc(ui.dot)))
-	http.Handle("/disasm", wrap(http.HandlerFunc(ui.disasm)))
-	http.Handle("/weblist", wrap(http.HandlerFunc(ui.weblist)))
-	go openBrowser(port, o)
-	return http.ListenAndServe(fmt.Sprint(":", port), nil)
+
+	mux := http.NewServeMux()
+	mux.Handle("/", wrap(http.HandlerFunc(ui.dot)))
+	mux.Handle("/disasm", wrap(http.HandlerFunc(ui.disasm)))
+	mux.Handle("/weblist", wrap(http.HandlerFunc(ui.weblist)))
+
+	s := &http.Server{Handler: mux}
+	go openBrowser(url, o)
+	return s.Serve(ln)
+}
+
+func newListenerAndURL(hostport string) (ln net.Listener, url string, isLocal bool, err error) {
+	host, _, err := net.SplitHostPort(hostport)
+	if err != nil {
+		return nil, "", false, err
+	}
+	if host == "" {
+		host = "localhost"
+	}
+	if ln, err = net.Listen("tcp", hostport); err != nil {
+		return nil, "", false, err
+	}
+	url = fmt.Sprint("http://", host, ":", ln.Addr().(*net.TCPAddr).Port)
+	return ln, url, isLocalhost(host), nil
+}
+
+func isLocalhost(host string) bool {
+	for _, v := range []string{"localhost", "127.0.0.1", "[::1]"} {
+		if host == v {
+			return true
+		}
+	}
+	return false
 }
 
-func openBrowser(port int, o *plugin.Options) {
+func openBrowser(url string, o *plugin.Options) {
 	// Construct URL.
-	u, _ := url.Parse(fmt.Sprint("http://localhost:", port))
+	u, _ := gourl.Parse(url)
 	q := u.Query()
 	for _, p := range []struct{ param, key string }{
 		{"f", "focus"},
@@ -107,7 +141,7 @@ func openBrowser(port int, o *plugin.Options) {
 func checkLocalHost(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		host, _, err := net.SplitHostPort(req.RemoteAddr)
-		if err != nil || ((host != "127.0.0.1") && (host != "::1")) {
+		if err != nil || !isLocalhost(host) {
 			http.Error(w, "permission denied", http.StatusForbidden)
 			return
 		}

internal/driver/webui_test.go

@@ -183,3 +183,58 @@ func makeFakeProfile() *profile.Profile {
 		Mapping:  mapping,
 	}
 }
+
+func TestNewListenerAndURL(t *testing.T) {
+	tests := []struct {
+		hostport  string
+		wantErr   bool
+		wantURLRe *regexp.Regexp
+		wantLocal bool
+	}{
+		{
+			hostport:  ":",
+			wantURLRe: regexp.MustCompile(`http://localhost:\d+`),
+			wantLocal: true,
+		},
+		{
+			hostport:  "localhost:",
+			wantURLRe: regexp.MustCompile(`http://localhost:\d+`),
+			wantLocal: true,
+		},
+		{
+			hostport:  "127.0.0.1:",
+			wantURLRe: regexp.MustCompile(`http://127\.0\.0\.1:\d+`),
+			wantLocal: true,
+		},
+		{
+			hostport:  "localhost:12344",
+			wantURLRe: regexp.MustCompile(`http://localhost:12344`),
+			wantLocal: true,
+		},
+		{
+			hostport: "http://localhost:12345",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.hostport, func(t *testing.T) {
+			_, url, isLocal, err := newListenerAndURL(tt.hostport)
+			if tt.wantErr {
+				if err == nil {
+					t.Fatalf("newListenerAndURL(%v) want error; got none", tt.hostport)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("newListenerAndURL(%v) = %v", tt.hostport, err)
+			}
+			if !tt.wantURLRe.MatchString(url) {
+				t.Errorf("newListenerAndURL(%v) URL = %v; want URL matching %v", tt.hostport, url, tt.wantURLRe)
+			}
+			if got, want := isLocal, tt.wantLocal; got != want {
+				t.Errorf("newListenerAndURL(%v) isLocal = %v; want %v", tt.hostport, got, want)
+			}
+		})
+	}
+}