diff --git a/lib/flags/doc.go b/lib/flags/doc.go
new file mode 100644
index 0000000..8681ac4
--- /dev/null
+++ b/lib/flags/doc.go
@@ -0,0 +1,3 @@
+// Package flags provides implementations of the flag.Value interface
+// that are commonly used.
+package flags
diff --git a/lib/flags/listen.go b/lib/flags/listen.go
new file mode 100644
index 0000000..de2855f
--- /dev/null
+++ b/lib/flags/listen.go
@@ -0,0 +1,120 @@
+package flags
+
+import (
+	"fmt"
+	"net"
+	"strconv"
+)
+
+// TCPProtocolFlag implements flag.Value to provide validation of the
+// command line values passed to it: tcp, tcp4 or tcp6 being the
+// only allowed values.
+type TCPProtocolFlag struct{ Protocol string }
+
+// Implements flag.Value.Get
+func (t TCPProtocolFlag) Get() interface{} {
+	return t.Protocol
+}
+
+// Implements flag.Value.Set
+func (t *TCPProtocolFlag) Set(s string) error {
+	switch s {
+	case "tcp", "tcp4", "tcp6":
+		t.Protocol = s
+		return nil
+	default:
+		return fmt.Errorf("%q is not a tcp protocol", s)
+	}
+
+}
+
+// Implements flag.Value.String
+func (t TCPProtocolFlag) String() string {
+	return t.Protocol
+}
+
+// IPHostPortFlag implements flag.Value to provide validation of the
+// command line value it is set to. The allowed format is <host>:<port> in
+// ip4 and ip6 formats. The host may be specified as a hostname or as an IP
+// address (v4 or v6). If a hostname is used and it resolves to multiple IP
+// addresses then all of those addresses are stored in IPHostPort.
+type IPHostPortFlag struct {
+	Address string
+	Host    string
+	IP      []*net.IPAddr
+	Port    string
+}
+
+// Implements flag.Value.Get
+func (ip IPHostPortFlag) Get() interface{} {
+	return ip.String()
+}
+
+// Implements flag.Value.Set
+func (ip *IPHostPortFlag) Set(s string) error {
+	ip.Address = s
+	host, port, err := net.SplitHostPort(s)
+	if err != nil {
+		// no port number in s.
+		host = s
+		ip.Port = "0"
+	} else {
+		// have a port in s.
+		if _, err := strconv.ParseUint(port, 10, 16); err != nil {
+			return fmt.Errorf("failed to parse port number from %s", s)
+		}
+		ip.Port = port
+	}
+	// if len(host) == 0 then we have no host, just a port.
+	if len(host) > 0 {
+		if addr := net.ParseIP(host); addr == nil {
+			// Could be a hostname.
+			addrs, err := net.LookupIP(host)
+			if err != nil {
+				return fmt.Errorf("%s is neither an IP address nor a host name:%s", host, err)
+			}
+			for _, a := range addrs {
+				ip.IP = append(ip.IP, &net.IPAddr{IP: a})
+			}
+			ip.Host = host
+		} else {
+			ip.IP = []*net.IPAddr{{IP: addr}}
+		}
+		return nil
+	}
+	return nil
+}
+
+// Implements flag.Value.String
+func (ip IPHostPortFlag) String() string {
+	host := ip.Host
+	if len(ip.Host) == 0 && ip.IP != nil && len(ip.IP) > 0 {
+		// We don't have a hostname, so there should be at most one IP address.
+		host = ip.IP[0].String()
+	}
+	return net.JoinHostPort(host, ip.Port)
+}
+
+// IPFlag implements flag.Value in order to provide validation of
+// IP addresses in the flag package.
+type IPFlag struct{ net.IP }
+
+// Implements flag.Value.Get
+func (ip IPFlag) Get() interface{} {
+	return ip.IP
+}
+
+// Implements flag.Value.Set
+func (ip *IPFlag) Set(s string) error {
+	t := net.ParseIP(s)
+	if t == nil {
+		return fmt.Errorf("failed to parse %s as an IP address", s)
+	}
+	ip.IP = t
+	return nil
+}
+
+// Implements flag.Value.String
+func (ip IPFlag) String() string {
+	return ip.IP.String()
+}
diff --git a/lib/flags/listen_test.go b/lib/flags/listen_test.go
new file mode 100644
index 0000000..572fd99
--- /dev/null
+++ b/lib/flags/listen_test.go
@@ -0,0 +1,91 @@
+package flags_test
+
+import (
+	"net"
+	"reflect"
+	"strings"
+	"testing"
+
+	"veyron/lib/flags"
+)
+
+func TestIPFlag(t *testing.T) {
+	ip := &flags.IPFlag{}
+	if err := ip.Set("172.16.1.22"); err != nil {
+		t.Errorf("unexpected error %s", err)
+	}
+	if got, want := ip.IP, net.ParseIP("172.16.1.22"); !got.Equal(want) {
+		t.Errorf("got %s, expected %s", got, want)
+	}
+	if err := ip.Set("172.16"); err == nil || err.Error() != "failed to parse 172.16 as an IP address" {
+		t.Errorf("expected error %v", err)
+	}
+}
+
+func TestTCPFlag(t *testing.T) {
+	tcp := &flags.TCPProtocolFlag{}
+	if err := tcp.Set("tcp6"); err != nil {
+		t.Errorf("unexpected error %s", err)
+	}
+	if got, want := tcp.Protocol, "tcp6"; got != want {
+		t.Errorf("got %s, expected %s", got, want)
+	}
+	if err := tcp.Set("foo"); err == nil || !strings.Contains(err.Error(), "not a tcp protocol") {
+		t.Errorf("expected error %v", err)
+	}
+}
+
+func TestIPHostPortFlag(t *testing.T) {
+	lh := []*net.IPAddr{{IP: net.ParseIP("127.0.0.1")}}
+	ip6 := []*net.IPAddr{{IP: net.ParseIP("FE80:0000:0000:0000:0202:B3FF:FE1E:8329")}}
+	cases := []struct {
+		input string
+		want  flags.IPHostPortFlag
+		str   string
+	}{
+		{"", flags.IPHostPortFlag{Port: "0"}, ":0"},
+		{":0", flags.IPHostPortFlag{Port: "0"}, ":0"},
+		{":22", flags.IPHostPortFlag{Port: "22"}, ":22"},
+		{"127.0.0.1", flags.IPHostPortFlag{IP: lh, Port: "0"}, "127.0.0.1:0"},
+		{"127.0.0.1:10", flags.IPHostPortFlag{IP: lh, Port: "10"}, "127.0.0.1:10"},
+		{"[]:0", flags.IPHostPortFlag{Port: "0"}, ":0"},
+		{"[FE80:0000:0000:0000:0202:B3FF:FE1E:8329]:100", flags.IPHostPortFlag{IP: ip6, Port: "100"}, "[fe80::202:b3ff:fe1e:8329]:100"},
+	}
+	for _, c := range cases {
+		got, want := &flags.IPHostPortFlag{}, &c.want
+		c.want.Address = c.input
+		if err := got.Set(c.input); err != nil || !reflect.DeepEqual(got, want) {
+			if err != nil {
+				t.Errorf("%q: unexpected error %s", c.input, err)
+			} else {
+				t.Errorf("%q: got %#v, want %#v", c.input, got, want)
+			}
+		}
+		if got.String() != c.str {
+			t.Errorf("%q: got %#v, want %#v", c.input, got.String(), c.str)
+		}
+	}
+
+	host := &flags.IPHostPortFlag{}
+	if err := host.Set("localhost:122"); err != nil {
+		t.Errorf("unexpected error: %s", err)
+	}
+	if len(host.IP) == 0 {
+		t.Errorf("localhost should have resolved to at least one address")
+	}
+	if got, want := host.Port, "122"; got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+	if got, want := host.String(), "localhost:122"; got != want {
+		t.Errorf("got %q, want %q", got, want)
+	}
+
+	for _, s := range []string{
+		":", ":59999999", "nohost.invalid", "nohost.invalid:"} {
+		f := &flags.IPHostPortFlag{}
+		if err := f.Set(s); err == nil {
+			t.Errorf("expected an error for %q", s)
+		}
+	}
+
+}