Merge lp:~pedronis/ubuntu-push/unicast-preps into lp:ubuntu-push

[Samuele Pedroni]

reorganize things such that GetChannelSnapshot returns a bunch of Notification (with optional AppId, MsgId) so that it can be used together with the underlying store to store unicast notification user/device channels

reorganize things such that GetChannelSnapshot returns a bunch of Notification (with optional AppId, MsgId) so that it can be used together with the underlying store to store unicast notification user/device channels

Unmerged revisions

=== modified file 'Makefile'
--- Makefile	2014-03-31 17:58:54 +0000
+++ Makefile	2014-04-29 18:02:00 +0000
@@ -11,10 +11,13 @@
 GODEPS += launchpad.net/go-dbus/v1
 GODEPS += launchpad.net/go-xdg/v0
 GODEPS += code.google.com/p/gosqlite/sqlite3
+GODEPS += gopkg.in/qml.v0
+GODEPS += gopkg.in/niemeyer/uoneauth.v1
 
 TOTEST = $(shell env GOPATH=$(GOPATH) go list $(PROJECT)/...|grep -v acceptance|grep -v http13client )
 
 bootstrap:
+	$(RM) -r $(GOPATH)/pkg
 	mkdir -p $(GOPATH)/bin
 	mkdir -p $(GOPATH)/pkg
 	go get -u launchpad.net/godeps
 
=== modified file 'README'
--- README	2014-03-31 17:58:54 +0000
+++ README	2014-04-29 18:02:00 +0000
@@ -6,11 +6,21 @@
 The code expects to be checked out as launchpad.net/ubuntu-push in a Go
 workspace, see "go help gopath".
 
-To setup Go dependencies, install libsqlite3-dev and run:
+To setup Go dependencies, install the following dependencies:
+
+               build-essential
+               libsqlite3-dev
+               qtbase5-private-dev
+               qtdeclarative5-dev
+               libqt5opengl5-dev
+               libubuntuoneauth-2.0-dev
+
+and run:
 
    make bootstrap
 
-To run tests, install libgcrypt11-dev and libwhoopsie-dev and run:
+To run tests, install libglib2.0-dev, libgcrypt11-dev, libwhoopsie-dev,
+and run:
 
    make check
 
 
=== modified file 'bus/connectivity/connectivity.go'
--- bus/connectivity/connectivity.go	2014-04-04 11:08:28 +0000
+++ bus/connectivity/connectivity.go	2014-04-29 18:02:00 +0000
@@ -72,19 +72,20 @@
 		cs.connAttempts += ar.Redial()
 		nm := networkmanager.New(cs.endp, cs.log)
 
+		// set up the watch
+		stateCh, err = nm.WatchState()
+		if err != nil {
+			cs.log.Debugf("failed to set up the state watch: %s", err)
+			goto Continue
+		}
+
 		// Get the current state.
 		initial = nm.GetState()
 		if initial == networkmanager.Unknown {
 			cs.log.Debugf("Failed to get state.")
 			goto Continue
 		}
-
-		// set up the watch
-		stateCh, err = nm.WatchState()
-		if err != nil {
-			cs.log.Debugf("failed to set up the state watch: %s", err)
-			goto Continue
-		}
+		cs.log.Debugf("got initial state of %s", initial)
 
 		primary = nm.GetPrimaryConnection()
 		cs.log.Debugf("primary connection starts as %#v", primary)
 
=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2014-04-04 12:01:42 +0000
+++ bus/connectivity/connectivity_test.go	2014-04-29 18:02:00 +0000
@@ -17,8 +17,15 @@
 package connectivity
 
 import (
+	"net/http/httptest"
+	"sync"
+	"testing"
+	"time"
+
 	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/bus/networkmanager"
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/config"
@@ -26,9 +33,6 @@
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"launchpad.net/ubuntu-push/util"
-	"net/http/httptest"
-	"testing"
-	"time"
 )
 
 // hook up gocheck
@@ -115,6 +119,76 @@
 	c.Check(<-cs.networkStateCh, Equals, networkmanager.ConnectedGlobal)
 }
 
+// a racyEndpoint is an endpoint that behaves differently depending on
+// how much time passes between getting the state and setting up the
+// watch
+type racyEndpoint struct {
+	stateGot bool
+	maxTime  time.Time
+	delta    time.Duration
+	lock     sync.RWMutex
+}
+
+func (rep *racyEndpoint) GetProperty(prop string) (interface{}, error) {
+	switch prop {
+	case "state":
+		rep.lock.Lock()
+		defer rep.lock.Unlock()
+		rep.stateGot = true
+		rep.maxTime = time.Now().Add(rep.delta)
+		return uint32(networkmanager.Connecting), nil
+	case "PrimaryConnection":
+		return dbus.ObjectPath("/something"), nil
+	default:
+		return nil, nil
+	}
+}
+
+func (rep *racyEndpoint) WatchSignal(member string, f func(...interface{}), d func()) error {
+	if member == "StateChanged" {
+		// we count never having gotten the state as happening "after" now.
+		rep.lock.RLock()
+		defer rep.lock.RUnlock()
+		ok := !rep.stateGot || time.Now().Before(rep.maxTime)
+		go func() {
+			if ok {
+				f(uint32(networkmanager.ConnectedGlobal))
+			}
+			d()
+		}()
+	}
+	return nil
+}
+
+func (*racyEndpoint) Close()                                           {}
+func (*racyEndpoint) Dial() error                                      { return nil }
+func (*racyEndpoint) String() string                                   { return "racyEndpoint" }
+func (*racyEndpoint) Call(string, []interface{}, ...interface{}) error { return nil }
+
+var _ bus.Endpoint = (*racyEndpoint)(nil)
+
+// takeNext takes a value from given channel with a 1s timeout
+func takeNext(ch <-chan networkmanager.State) networkmanager.State {
+	select {
+	case <-time.After(time.Second):
+		panic("channel stuck: too long waiting")
+	case v := <-ch:
+		return v
+	}
+}
+
+// test that if the nm state goes from connecting to connected very
+// shortly after calling GetState, we don't lose the event.
+func (s *ConnSuite) TestStartAvoidsRace(c *C) {
+	for delta := time.Second; delta > 1; delta /= 2 {
+		rep := &racyEndpoint{delta: delta}
+		cs := connectedState{config: ConnectivityConfig{}, log: s.log, endp: rep}
+		f := Commentf("when delta=%s", delta)
+		c.Assert(cs.start(), Equals, networkmanager.Connecting, f)
+		c.Assert(takeNext(cs.networkStateCh), Equals, networkmanager.ConnectedGlobal, f)
+	}
+}
+
 /*
    tests for connectedStateStep()
 */
 
=== modified file 'client/client.go'
--- client/client.go	2014-04-11 16:37:48 +0000
+++ client/client.go	2014-04-29 18:02:00 +0000
@@ -26,6 +26,7 @@
 	"os"
 	"strings"
 
+	"gopkg.in/qml.v0"
 	"launchpad.net/go-dbus/v1"
 
 	"launchpad.net/ubuntu-push/bus"
@@ -57,7 +58,7 @@
 	// The PEM-encoded server certificate
 	CertPEMFile string `json:"cert_pem_file"`
 	// The logging level (one of "debug", "info", "error")
-	LogLevel string `json:"log_level"`
+	LogLevel logger.ConfigLogLevel `json:"log_level"`
 }
 
 // PushClient is the Ubuntu Push Notifications client-side daemon.
@@ -95,13 +96,13 @@
 
 // configure loads its configuration, and sets it up.
 func (client *PushClient) configure() error {
-	f, err := os.Open(client.configPath)
+	_, err := os.Stat(client.configPath)
 	if err != nil {
-		return fmt.Errorf("opening config: %v", err)
+		return fmt.Errorf("config: %v", err)
 	}
-	err = config.ReadConfig(f, &client.config)
+	err = config.ReadFiles(&client.config, client.configPath, "<flags>")
 	if err != nil {
-		return fmt.Errorf("reading config: %v", err)
+		return fmt.Errorf("config: %v", err)
 	}
 	// ignore spaces
 	client.config.Addr = strings.Replace(client.config.Addr, " ", "", -1)
@@ -110,7 +111,8 @@
 	}
 
 	// later, we'll be specifying more logging options in the config file
-	client.log = logger.NewSimpleLogger(os.Stderr, client.config.LogLevel)
+	client.log = logger.NewSimpleLogger(os.Stderr, client.config.LogLevel.Level())
+	qml.SetLogger(client.log)
 
 	// overridden for testing
 	client.idder = identifier.New()
@@ -285,9 +287,6 @@
 	h := map[string]*dbus.Variant{"x-canonical-switch-to-application": &dbus.Variant{true}}
 	nots := notifications.Raw(client.notificationsEndp, client.log)
 	body := "Tap to open the system updater."
-	if msg != nil {
-		body = fmt.Sprintf("[%d] %s", msg.TopLevel, body)
-	}
 	not_id, err := nots.Notify(
 		"ubuntu-push-client",               // app name
 		uint32(0),                          // id
 
=== modified file 'client/client_test.go'
--- client/client_test.go	2014-04-11 16:21:45 +0000
+++ client/client_test.go	2014-04-29 18:02:00 +0000
@@ -19,10 +19,12 @@
 import (
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
+	"os"
 	"path/filepath"
 	"reflect"
 	"testing"
@@ -37,6 +39,7 @@
 	testibus "launchpad.net/ubuntu-push/bus/testing"
 	"launchpad.net/ubuntu-push/client/session"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
+	"launchpad.net/ubuntu-push/config"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
 	"launchpad.net/ubuntu-push/util"
@@ -79,6 +82,7 @@
 }
 
 func (cs *clientSuite) SetUpSuite(c *C) {
+	config.IgnoreParsedFlags = true // because configure() uses <flags>
 	cs.timeouts = util.SwapTimeouts([]time.Duration{0})
 	cs.leveldbPath = ""
 }
@@ -142,6 +146,16 @@
 	c.Check(cli.config.ExchangeTimeout.TimeDuration(), Equals, time.Duration(10*time.Millisecond))
 }
 
+func (cs *clientSuite) TestConfigureWorksWithFlags(c *C) {
+	flag.CommandLine = flag.NewFlagSet("client", flag.ContinueOnError)
+	os.Args = []string{"client", "-addr", "foo:7777"}
+	cli := NewPushClient(cs.configPath, cs.leveldbPath)
+	err := cli.configure()
+	c.Assert(err, IsNil)
+	c.Assert(cli.config, NotNil)
+	c.Check(cli.config.Addr, Equals, "foo:7777")
+}
+
 func (cs *clientSuite) TestConfigureSetsUpLog(c *C) {
 	cli := NewPushClient(cs.configPath, cs.leveldbPath)
 	c.Check(cli.log, IsNil)
@@ -163,7 +177,7 @@
 	c.Check(cli.idder, IsNil)
 	err := cli.configure()
 	c.Assert(err, IsNil)
-	c.Assert(cli.idder, DeepEquals, identifier.New())
+	c.Assert(cli.idder, FitsTypeOf, identifier.New())
 }
 
 func (cs *clientSuite) TestConfigureSetsUpEndpoints(c *C) {
 
=== modified file 'client/gethosts/gethost.go'
--- client/gethosts/gethost.go	2014-03-24 15:32:29 +0000
+++ client/gethosts/gethost.go	2014-04-29 18:02:00 +0000
@@ -49,8 +49,10 @@
 	}
 }
 
-type expected struct {
-	Hosts []string
+// Host contains the domain and hosts returned by the remote endpoint
+type Host struct {
+	Domain string
+	Hosts  []string
 }
 
 var (
@@ -60,7 +62,7 @@
 )
 
 // Get gets a list of hosts consulting the endpoint.
-func (gh *GetHost) Get() ([]string, error) {
+func (gh *GetHost) Get() (*Host, error) {
 	resp, err := gh.cli.Get(gh.endpointUrl + "?h=" + gh.hash)
 	if err != nil {
 		return nil, err
@@ -80,7 +82,7 @@
 	if err != nil {
 		return nil, err
 	}
-	var parsed expected
+	var parsed Host
 	err = json.Unmarshal(body, &parsed)
 	if err != nil {
 		return nil, ErrTemporary
@@ -88,5 +90,5 @@
 	if len(parsed.Hosts) == 0 {
 		return nil, ErrTemporary
 	}
-	return parsed.Hosts, nil
+	return &parsed, nil
 }
 
=== modified file 'client/gethosts/gethost_test.go'
--- client/gethosts/gethost_test.go	2014-03-31 14:31:07 +0000
+++ client/gethosts/gethost_test.go	2014-04-29 18:02:00 +0000
@@ -45,7 +45,8 @@
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		x := r.FormValue("h")
 		b, err := json.Marshal(map[string]interface{}{
-			"hosts": []string{"http://" + x},
+			"domain": "example.com",
+			"hosts":  []string{"http://" + x},
 		})
 		if err != nil {
 			panic(err)
@@ -57,7 +58,8 @@
 	gh := New("foobar", ts.URL, 1*time.Second)
 	res, err := gh.Get()
 	c.Assert(err, IsNil)
-	c.Check(res, DeepEquals, []string{"http://c1130408a700afe0"})
+	c.Check(*res, DeepEquals,
+		Host{Domain: "example.com", Hosts: []string{"http://c1130408a700afe0"}})
 }
 
 func (s *getHostsSuite) TestGetTimeout(c *C) {
@@ -97,4 +99,6 @@
 
 	scenario(http.StatusOK, "{", ErrTemporary)
 	scenario(http.StatusOK, "{}", ErrTemporary)
+	scenario(http.StatusOK, `{"domain": "example.com"}`, ErrTemporary)
+	scenario(http.StatusOK, `{"hosts": ["one"]}`, nil)
 }
 
=== modified file 'client/session/session.go'
--- client/session/session.go	2014-04-04 13:55:00 +0000
+++ client/session/session.go	2014-04-29 18:02:00 +0000
@@ -38,7 +38,11 @@
 	"launchpad.net/ubuntu-push/util"
 )
 
-var wireVersionBytes = []byte{protocol.ProtocolWireVersion}
+var (
+	wireVersionBytes = []byte{protocol.ProtocolWireVersion}
+	getAuthorization = util.GetAuthorization
+	shouldGetAuth    = false
+)
 
 type Notification struct {
 	TopLevel int64
@@ -73,7 +77,7 @@
 )
 
 type hostGetter interface {
-	Get() ([]string, error)
+	Get() (*gethosts.Host, error)
 }
 
 // ClientSessionConfig groups the client session configuration.
@@ -115,6 +119,28 @@
 	stateP *uint32
 	ErrCh  chan error
 	MsgCh  chan *Notification
+	// authorization
+	auth string
+	// autoredial knobs
+	shouldDelayP    *uint32
+	lastAutoRedial  time.Time
+	redialDelay     func(*ClientSession) time.Duration
+	redialJitter    func(time.Duration) time.Duration
+	redialDelays    []time.Duration
+	redialDelaysIdx int
+}
+
+func redialDelay(sess *ClientSession) time.Duration {
+	if sess.ShouldDelay() {
+		t := sess.redialDelays[sess.redialDelaysIdx]
+		if len(sess.redialDelays) > sess.redialDelaysIdx+1 {
+			sess.redialDelaysIdx++
+		}
+		return t + sess.redialJitter(t)
+	} else {
+		sess.redialDelaysIdx = 0
+		return 0
+	}
 }
 
 func NewSession(serverAddrSpec string, conf ClientSessionConfig,
@@ -131,6 +157,7 @@
 	if hostsEndpoint != "" {
 		getHost = gethosts.New(deviceId, hostsEndpoint, conf.ExchangeTimeout)
 	}
+	var shouldDelay uint32 = 0
 	sess := &ClientSession{
 		ClientSessionConfig: conf,
 		getHost:             getHost,
@@ -139,10 +166,14 @@
 		Log:                 log,
 		Protocolator:        protocol.NewProtocol0,
 		Levels:              levels,
-		TLS:                 &tls.Config{InsecureSkipVerify: true}, // XXX
+		TLS:                 &tls.Config{},
 		stateP:              &state,
 		timeSince:           time.Since,
+		shouldDelayP:        &shouldDelay,
+		redialDelay:         redialDelay,
+		redialDelays:        util.Timeouts(),
 	}
+	sess.redialJitter = sess.Jitter
 	if sess.PEM != nil {
 		cp := x509.NewCertPool()
 		ok := cp.AppendCertsFromPEM(sess.PEM)
@@ -154,6 +185,18 @@
 	return sess, nil
 }
 
+func (sess *ClientSession) ShouldDelay() bool {
+	return atomic.LoadUint32(sess.shouldDelayP) != 0
+}
+
+func (sess *ClientSession) setShouldDelay() {
+	atomic.StoreUint32(sess.shouldDelayP, uint32(1))
+}
+
+func (sess *ClientSession) clearShouldDelay() {
+	atomic.StoreUint32(sess.shouldDelayP, uint32(0))
+}
+
 func (sess *ClientSession) State() ClientSessionState {
 	return ClientSessionState(atomic.LoadUint32(sess.stateP))
 }
@@ -180,20 +223,38 @@
 		if sess.deliveryHosts != nil && sess.timeSince(sess.deliveryHostsTimestamp) < sess.HostsCachingExpiryTime {
 			return nil
 		}
-		hosts, err := sess.getHost.Get()
+		host, err := sess.getHost.Get()
 		if err != nil {
 			sess.Log.Errorf("getHosts: %v", err)
 			sess.setState(Error)
 			return err
 		}
 		sess.deliveryHostsTimestamp = time.Now()
-		sess.deliveryHosts = hosts
+		sess.deliveryHosts = host.Hosts
+		if sess.TLS != nil {
+			sess.TLS.ServerName = host.Domain
+		}
 	} else {
 		sess.deliveryHosts = sess.fallbackHosts
 	}
 	return nil
 }
 
+// checkAuthorization checks the authorization within the phone
+func (sess *ClientSession) checkAuthorization() error {
+	// grab the authorization string from the accounts
+	// TODO: remove this condition when we have a way to deal with failing authorizations
+	if shouldGetAuth {
+		auth, err := getAuthorization()
+		if err != nil {
+			// For now we just log the error, as we don't want to block unauthorized users
+			sess.Log.Errorf("unable to get the authorization token from the account: %v", err)
+		}
+		sess.auth = auth
+	}
+	return nil
+}
+
 func (sess *ClientSession) resetHosts() {
 	sess.deliveryHosts = nil
 }
@@ -234,6 +295,7 @@
 // connect to a server using the configuration in the ClientSession
 // and set up the connection.
 func (sess *ClientSession) connect() error {
+	sess.setShouldDelay()
 	sess.startConnectionAttempt()
 	var err error
 	var conn net.Conn
@@ -263,7 +325,12 @@
 
 func (sess *ClientSession) AutoRedial(doneCh chan uint32) {
 	sess.stopRedial()
+	if time.Since(sess.lastAutoRedial) < 2*time.Second {
+		sess.setShouldDelay()
+	}
+	time.Sleep(sess.redialDelay(sess))
 	sess.retrier = util.NewAutoRedialer(sess)
+	sess.lastAutoRedial = time.Now()
 	go func() { doneCh <- sess.retrier.Redial() }()
 }
 
@@ -289,6 +356,7 @@
 	err := sess.proto.WriteMessage(protocol.PingPongMsg{Type: "pong"})
 	if err == nil {
 		sess.Log.Debugf("ping.")
+		sess.clearShouldDelay()
 	} else {
 		sess.setState(Error)
 		sess.Log.Errorf("unable to pong: %s", err)
@@ -330,6 +398,7 @@
 		sess.Log.Errorf("unable to ack broadcast: %s", err)
 		return err
 	}
+	sess.clearShouldDelay()
 	sess.Log.Debugf("broadcast chan:%v app:%v topLevel:%d payloads:%s",
 		bcast.ChanId, bcast.AppId, bcast.TopLevel, bcast.Payloads)
 	if bcast.ChanId == protocol.SystemChannelId {
@@ -409,10 +478,9 @@
 		return err
 	}
 	err = proto.WriteMessage(protocol.ConnectMsg{
-		Type:     "connect",
-		DeviceId: sess.DeviceId,
-		// xxx get the SSO Authorization string from the phone
-		Authorization: "",
+		Type:          "connect",
+		DeviceId:      sess.DeviceId,
+		Authorization: sess.auth,
 		Levels:        levels,
 		Info:          sess.Info,
 	})
@@ -447,13 +515,15 @@
 
 // run calls connect, and if it works it calls start, and if it works
 // it runs loop in a goroutine, and ships its return value over ErrCh.
-func (sess *ClientSession) run(closer func(), hostGetter, connecter, starter, looper func() error) error {
+func (sess *ClientSession) run(closer func(), authChecker, hostGetter, connecter, starter, looper func() error) error {
 	closer()
-	err := hostGetter()
-	if err != nil {
-		return err
-	}
-	err = connecter()
+	if err := authChecker(); err != nil {
+		return err
+	}
+	if err := hostGetter(); err != nil {
+		return err
+	}
+	err := connecter()
 	if err == nil {
 		err = starter()
 		if err == nil {
@@ -483,7 +553,7 @@
 		// keep on trying.
 		panic("can't Dial() without a protocol constructor.")
 	}
-	return sess.run(sess.doClose, sess.getHosts, sess.connect, sess.start, sess.loop)
+	return sess.run(sess.doClose, sess.checkAuthorization, sess.getHosts, sess.connect, sess.start, sess.loop)
 }
 
 func init() {
 
=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2014-04-04 13:55:00 +0000
+++ client/session/session_test.go	2014-04-29 18:02:00 +0000
@@ -32,12 +32,12 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/client/gethosts"
 	"launchpad.net/ubuntu-push/client/session/levelmap"
-	//"launchpad.net/ubuntu-push/client/gethosts"
-	"launchpad.net/ubuntu-push/logger"
 	"launchpad.net/ubuntu-push/protocol"
 	helpers "launchpad.net/ubuntu-push/testing"
 	"launchpad.net/ubuntu-push/testing/condition"
+	"launchpad.net/ubuntu-push/util"
 )
 
 func TestSession(t *testing.T) { TestingT(t) }
@@ -165,14 +165,26 @@
 /////
 
 type clientSessionSuite struct {
-	log  logger.Logger
+	log  *helpers.TestLogger
 	lvls func() (levelmap.LevelMap, error)
 }
 
+func (cs *clientSessionSuite) SetUpSuite(c *C) {
+	getAuthorization = func() (string, error) {
+		return "some auth", nil
+	}
+	shouldGetAuth = true
+}
+
 func (cs *clientSessionSuite) SetUpTest(c *C) {
 	cs.log = helpers.NewTestLogger(c, "debug")
 }
 
+func (cs *clientSessionSuite) TearDownSuite(c *C) {
+	getAuthorization = util.GetAuthorization
+	shouldGetAuth = false
+}
+
 // in-memory level map testing
 var _ = Suite(&clientSessionSuite{lvls: levelmap.NewLevelMap})
 
@@ -182,6 +194,7 @@
 var _ = Suite(&clientSqlevelsSessionSuite{})
 
 func (cs *clientSqlevelsSessionSuite) SetUpSuite(c *C) {
+	cs.clientSessionSuite.SetUpSuite(c)
 	cs.lvls = func() (levelmap.LevelMap, error) { return levelmap.NewSqliteLevelMap(":memory:") }
 }
 
@@ -214,6 +227,10 @@
 	c.Check(sess, NotNil)
 	c.Check(err, IsNil)
 	c.Check(sess.fallbackHosts, DeepEquals, []string{"foo:443"})
+	// the session is happy and redial delayer is default
+	c.Check(sess.ShouldDelay(), Equals, false)
+	c.Check(fmt.Sprintf("%#v", sess.redialDelay), Equals, fmt.Sprintf("%#v", redialDelay))
+	c.Check(sess.redialDelays, DeepEquals, util.Timeouts())
 	// but no root CAs set
 	c.Check(sess.TLS.RootCAs, IsNil)
 	c.Check(sess.State(), Equals, Disconnected)
@@ -264,16 +281,17 @@
 }
 
 type testHostGetter struct {
-	hosts []string
-	err   error
+	domain string
+	hosts  []string
+	err    error
 }
 
-func (thg *testHostGetter) Get() ([]string, error) {
-	return thg.hosts, thg.err
+func (thg *testHostGetter) Get() (*gethosts.Host, error) {
+	return &gethosts.Host{thg.domain, thg.hosts}, thg.err
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemote(c *C) {
-	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
 	sess := &ClientSession{getHost: hostGetter, timeSince: time.Since}
 	err := sess.getHosts()
 	c.Assert(err, IsNil)
@@ -284,7 +302,7 @@
 	sess, err := NewSession("", dummyConf, "", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	hostsErr := errors.New("failed")
-	hostGetter := &testHostGetter{nil, hostsErr}
+	hostGetter := &testHostGetter{"", nil, hostsErr}
 	sess.getHost = hostGetter
 	err = sess.getHosts()
 	c.Assert(err, Equals, hostsErr)
@@ -293,7 +311,7 @@
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemoteCaching(c *C) {
-	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
 	sess := &ClientSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
@@ -318,7 +336,7 @@
 }
 
 func (cs *clientSessionSuite) TestGetHostsRemoteCachingReset(c *C) {
-	hostGetter := &testHostGetter{[]string{"foo:443", "bar:443"}, nil}
+	hostGetter := &testHostGetter{"example.com", []string{"foo:443", "bar:443"}, nil}
 	sess := &ClientSession{
 		getHost: hostGetter,
 		ClientSessionConfig: ClientSessionConfig{
@@ -341,6 +359,18 @@
 }
 
 /****************************************************************
+  checkAuthorization() tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestChecksAuthorizationFromServer(c *C) {
+	sess := &ClientSession{}
+	c.Assert(sess.auth, Equals, "")
+	err := sess.checkAuthorization()
+	c.Assert(err, IsNil)
+	c.Check(sess.auth, Equals, "some auth")
+}
+
+/****************************************************************
   startConnectionAttempt()/nextHostToTry()/started tests
 ****************************************************************/
 
@@ -427,7 +457,9 @@
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere"}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, ErrorMatches, ".*connect.*address.*")
 	c.Check(sess.State(), Equals, Error)
 }
@@ -439,7 +471,9 @@
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, IsNil)
 	c.Check(sess.Connection, NotNil)
 	c.Check(sess.State(), Equals, Connected)
@@ -452,7 +486,9 @@
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{"nowhere", srv.Addr().String()}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, IsNil)
 	c.Check(sess.Connection, NotNil)
 	c.Check(sess.State(), Equals, Connected)
@@ -466,7 +502,9 @@
 	srv.Close()
 	c.Assert(err, IsNil)
 	sess.deliveryHosts = []string{srv.Addr().String()}
+	sess.clearShouldDelay()
 	err = sess.connect()
+	c.Check(sess.ShouldDelay(), Equals, true)
 	c.Check(err, ErrorMatches, ".*connection refused")
 	c.Check(sess.State(), Equals, Error)
 }
@@ -548,6 +586,27 @@
 	c.Check(<-ch, Not(Equals), 0)
 }
 
+func (cs *clientSessionSuite) TestAutoRedialCallsRedialDelay(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	flag := false
+	sess.redialDelay = func(sess *ClientSession) time.Duration { flag = true; return 0 }
+	sess.AutoRedial(nil)
+	c.Check(flag, Equals, true)
+}
+
+func (cs *clientSessionSuite) TestAutoRedialSetsRedialDelayIfTooQuick(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.redialDelay = func(sess *ClientSession) time.Duration { return 0 }
+	sess.AutoRedial(nil)
+	c.Check(sess.ShouldDelay(), Equals, false)
+	sess.stopRedial()
+	sess.clearShouldDelay()
+	sess.AutoRedial(nil)
+	c.Check(sess.ShouldDelay(), Equals, true)
+}
+
 /****************************************************************
   handlePing() tests
 ****************************************************************/
@@ -594,6 +653,24 @@
 	c.Check(s.sess.State(), Equals, Error)
 }
 
+func (s *msgSuite) TestHandlePingClearsDelay(c *C) {
+	s.sess.setShouldDelay()
+	s.upCh <- nil // no error
+	c.Check(s.sess.handlePing(), IsNil)
+	c.Assert(len(s.downCh), Equals, 1)
+	c.Check(<-s.downCh, Equals, protocol.PingPongMsg{Type: "pong"})
+	c.Check(s.sess.ShouldDelay(), Equals, false)
+}
+
+func (s *msgSuite) TestHandlePingDoesNotClearsDelayOnError(c *C) {
+	s.sess.setShouldDelay()
+	s.upCh <- errors.New("Pong")
+	c.Check(s.sess.handlePing(), NotNil)
+	c.Assert(len(s.downCh), Equals, 1)
+	c.Check(<-s.downCh, Equals, protocol.PingPongMsg{Type: "pong"})
+	c.Check(s.sess.ShouldDelay(), Equals, true)
+}
+
 /****************************************************************
   handleBroadcast() tests
 ****************************************************************/
@@ -687,6 +764,32 @@
 	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"nak"})
 }
 
+func (s *msgSuite) TestHandleBroadcastClearsDelay(c *C) {
+	s.sess.setShouldDelay()
+
+	msg := serverMsg{"broadcast", protocol.BroadcastMsg{},
+		protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
+	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
+	s.upCh <- nil // ack ok
+	c.Check(<-s.errCh, IsNil)
+
+	c.Check(s.sess.ShouldDelay(), Equals, false)
+}
+
+func (s *msgSuite) TestHandleBroadcastDoesNotClearDelayOnError(c *C) {
+	s.sess.setShouldDelay()
+
+	msg := serverMsg{"broadcast", protocol.BroadcastMsg{},
+		protocol.NotificationsMsg{}, protocol.ConnBrokenMsg{}}
+	go func() { s.errCh <- s.sess.handleBroadcast(&msg) }()
+	c.Check(takeNext(s.downCh), Equals, protocol.AckMsg{"ack"})
+	s.upCh <- errors.New("bcast")
+	c.Check(<-s.errCh, NotNil)
+
+	c.Check(s.sess.ShouldDelay(), Equals, true)
+}
+
 /****************************************************************
   handleConnBroken() tests
 ****************************************************************/
@@ -852,9 +955,10 @@
 
 	c.Check(takeNext(downCh), Equals, "deadline 0")
 	c.Check(takeNext(downCh), DeepEquals, protocol.ConnectMsg{
-		Type:     "connect",
-		DeviceId: sess.DeviceId,
-		Levels:   map[string]int64{},
+		Type:          "connect",
+		DeviceId:      sess.DeviceId,
+		Levels:        map[string]int64{},
+		Authorization: "",
 	})
 	upCh <- errors.New("Overflow error in /dev/null")
 	err = <-errCh
@@ -959,6 +1063,7 @@
 	msg, ok := takeNext(downCh).(protocol.ConnectMsg)
 	c.Check(ok, Equals, true)
 	c.Check(msg.DeviceId, Equals, "wah")
+	c.Check(msg.Authorization, Equals, "")
 	c.Check(msg.Info, DeepEquals, info)
 	upCh <- nil // no error
 	upCh <- protocol.ConnAckMsg{
@@ -975,6 +1080,22 @@
   run() tests
 ****************************************************************/
 
+func (cs *clientSessionSuite) TestRunBailsIfAuthCheckFails(c *C) {
+	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	failure := errors.New("TestRunBailsIfAuthCheckFails")
+	has_closed := false
+	err = sess.run(
+		func() { has_closed = true },
+		func() error { return failure },
+		nil,
+		nil,
+		nil,
+		nil)
+	c.Check(err, Equals, failure)
+	c.Check(has_closed, Equals, true)
+}
+
 func (cs *clientSessionSuite) TestRunBailsIfHostGetterFails(c *C) {
 	sess, err := NewSession("", dummyConf, "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
@@ -982,6 +1103,7 @@
 	has_closed := false
 	err = sess.run(
 		func() { has_closed = true },
+		func() error { return nil },
 		func() error { return failure },
 		nil,
 		nil,
@@ -997,6 +1119,7 @@
 	err = sess.run(
 		func() {},
 		func() error { return nil },
+		func() error { return nil },
 		func() error { return failure },
 		nil,
 		nil)
@@ -1011,6 +1134,7 @@
 		func() {},
 		func() error { return nil },
 		func() error { return nil },
+		func() error { return nil },
 		func() error { return failure },
 		nil)
 	c.Check(err, Equals, failure)
@@ -1030,6 +1154,7 @@
 		func() error { return nil },
 		func() error { return nil },
 		func() error { return nil },
+		func() error { return nil },
 		func() error { sess.MsgCh <- notf; return <-failureCh })
 	c.Check(err, Equals, nil)
 	// if run doesn't error it sets up the channels
@@ -1087,9 +1212,64 @@
 
 var (
 	dialTestTimeout = 100 * time.Millisecond
-	dialTestConf    = ClientSessionConfig{ExchangeTimeout: dialTestTimeout}
+	dialTestConf    = ClientSessionConfig{
+		ExchangeTimeout: dialTestTimeout,
+		PEM:             helpers.TestCertPEMBlock,
+	}
 )
 
+func (cs *clientSessionSuite) TestDialBadServerName(c *C) {
+	// a borked server name
+	cert, err := tls.X509KeyPair(helpers.TestCertPEMBlock, helpers.TestKeyPEMBlock)
+	c.Assert(err, IsNil)
+	tlsCfg := &tls.Config{
+		Certificates:           []tls.Certificate{cert},
+		SessionTicketsDisabled: true,
+	}
+
+	lst, err := tls.Listen("tcp", "localhost:0", tlsCfg)
+	c.Assert(err, IsNil)
+	// advertise
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, err := json.Marshal(map[string]interface{}{
+			"domain": "xyzzy", // <-- *** THIS *** is the bit that'll break it
+			"hosts":  []string{"nowhere", lst.Addr().String()},
+		})
+		if err != nil {
+			panic(err)
+		}
+		w.Header().Set("Content-Type", "application/json")
+		w.Write(b)
+	}))
+	defer ts.Close()
+
+	sess, err := NewSession(ts.URL, dialTestConf, "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	tconn := &testConn{}
+	sess.Connection = tconn
+
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	errCh := make(chan error, 1)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(net.Conn) protocol.Protocol { return proto }
+
+	go func() {
+		errCh <- sess.Dial()
+	}()
+
+	srv, err := lst.Accept()
+	c.Assert(err, IsNil)
+
+	// connect done
+
+	_, err = protocol.ReadWireFormatVersion(srv, dialTestTimeout)
+	c.Check(err, NotNil)
+
+	c.Check(<-errCh, NotNil)
+	c.Check(sess.State(), Equals, Error)
+}
+
 func (cs *clientSessionSuite) TestDialWorks(c *C) {
 	// happy path thoughts
 	cert, err := tls.X509KeyPair(helpers.TestCertPEMBlock, helpers.TestKeyPEMBlock)
@@ -1104,7 +1284,8 @@
 	// advertise
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		b, err := json.Marshal(map[string]interface{}{
-			"hosts": []string{"nowhere", lst.Addr().String()},
+			"domain": "localhost",
+			"hosts":  []string{"nowhere", lst.Addr().String()},
 		})
 		if err != nil {
 			panic(err)
@@ -1223,3 +1404,38 @@
 	c.Assert(err, IsNil)
 	// connect done
 }
+
+/****************************************************************
+  redialDelay() tests
+****************************************************************/
+
+func (cs *clientSessionSuite) TestShouldDelay(c *C) {
+	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	c.Check(sess.ShouldDelay(), Equals, false)
+	sess.setShouldDelay()
+	c.Check(sess.ShouldDelay(), Equals, true)
+	sess.clearShouldDelay()
+	c.Check(sess.ShouldDelay(), Equals, false)
+}
+
+func (cs *clientSessionSuite) TestRedialDelay(c *C) {
+	sess, err := NewSession("foo:443", dummyConf, "", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	sess.redialDelays = []time.Duration{17, 42}
+	n := 0
+	sess.redialJitter = func(time.Duration) time.Duration { n++; return 0 }
+	// we get increasing delays while we're unhappy
+	sess.setShouldDelay()
+	c.Check(redialDelay(sess), Equals, time.Duration(17))
+	c.Check(redialDelay(sess), Equals, time.Duration(42))
+	c.Check(redialDelay(sess), Equals, time.Duration(42))
+	// once we're happy, delays drop to 0
+	sess.clearShouldDelay()
+	c.Check(redialDelay(sess), Equals, time.Duration(0))
+	// and start again from the top if we become unhappy again
+	sess.setShouldDelay()
+	c.Check(redialDelay(sess), Equals, time.Duration(17))
+	// and redialJitter got called every time shouldDelay was true
+	c.Check(n, Equals, 4)
+}
 
=== modified file 'config/config.go'
--- config/config.go	2014-03-25 18:49:18 +0000
+++ config/config.go	2014-04-29 18:02:00 +0000
@@ -20,6 +20,7 @@
 import (
 	"encoding/json"
 	"errors"
+	"flag"
 	"fmt"
 	"io"
 	"io/ioutil"
@@ -27,6 +28,7 @@
 	"os"
 	"path/filepath"
 	"reflect"
+	"strconv"
 	"strings"
 	"time"
 )
@@ -118,6 +120,22 @@
 	return fillDestConfig(destValue, p1)
 }
 
+// FromString are config holders that can be set by parsing a string.
+type FromString interface {
+	SetFromString(enc string) error
+}
+
+// UnmarshalJSONViaString helps unmarshalling from JSON for FromString
+// supporting config holders.
+func UnmarshalJSONViaString(dest FromString, b []byte) error {
+	var enc string
+	err := json.Unmarshal(b, &enc)
+	if err != nil {
+		return err
+	}
+	return dest.SetFromString(enc)
+}
+
 // ConfigTimeDuration can hold a time.Duration in a configuration struct,
 // that is parsed from a string as supported by time.ParseDuration.
 type ConfigTimeDuration struct {
@@ -125,13 +143,11 @@
 }
 
 func (ctd *ConfigTimeDuration) UnmarshalJSON(b []byte) error {
-	var enc string
-	var v time.Duration
-	err := json.Unmarshal(b, &enc)
-	if err != nil {
-		return err
-	}
-	v, err = time.ParseDuration(enc)
+	return UnmarshalJSONViaString(ctd, b)
+}
+
+func (ctd *ConfigTimeDuration) SetFromString(enc string) error {
+	v, err := time.ParseDuration(enc)
 	if err != nil {
 		return err
 	}
@@ -148,12 +164,11 @@
 type ConfigHostPort string
 
 func (chp *ConfigHostPort) UnmarshalJSON(b []byte) error {
-	var enc string
-	err := json.Unmarshal(b, &enc)
-	if err != nil {
-		return err
-	}
-	_, _, err = net.SplitHostPort(enc)
+	return UnmarshalJSONViaString(chp, b)
+}
+
+func (chp *ConfigHostPort) SetFromString(enc string) error {
+	_, _, err := net.SplitHostPort(enc)
 	if err != nil {
 		return err
 	}
@@ -198,23 +213,117 @@
 	return ioutil.ReadFile(p)
 }
 
-// ReadFiles reads configuration from a set of files. Uses ReadConfig internally.
+// used to implement getting config values with flag.Parse()
+type val struct {
+	destField destField
+	accu      map[string]json.RawMessage
+}
+
+func (v *val) String() string { // used to show default
+	return string(v.accu[v.destField.configName()])
+}
+
+func (v *val) IsBoolFlag() bool {
+	return v.destField.fld.Type.Kind() == reflect.Bool
+}
+
+func (v *val) marshalAsNeeded(s string) (json.RawMessage, error) {
+	var toMarshal interface{}
+	switch v.destField.dest.(type) {
+	case *string, FromString:
+		toMarshal = s
+	case *bool:
+		bit, err := strconv.ParseBool(s)
+		if err != nil {
+			return nil, err
+		}
+		toMarshal = bit
+	default:
+		return json.RawMessage(s), nil
+	}
+	return json.Marshal(toMarshal)
+}
+
+func (v *val) Set(s string) error {
+	marshalled, err := v.marshalAsNeeded(s)
+	if err != nil {
+		return err
+	}
+	v.accu[v.destField.configName()] = marshalled
+	return nil
+}
+
+func readOneConfig(accu map[string]json.RawMessage, cfgPath string) error {
+	r, err := os.Open(cfgPath)
+	if err != nil {
+		return err
+	}
+	defer r.Close()
+	err = json.NewDecoder(r).Decode(&accu)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+// used to implement -cfg@=
+type readConfigAtVal struct {
+	accu map[string]json.RawMessage
+}
+
+func (v *readConfigAtVal) String() string {
+	return "<config.json>"
+}
+
+func (v *readConfigAtVal) Set(path string) error {
+	return readOneConfig(v.accu, path)
+}
+
+// readUsingFlags gets config values from command line flags.
+func readUsingFlags(accu map[string]json.RawMessage, destValue reflect.Value) error {
+	if flag.Parsed() {
+		if IgnoreParsedFlags {
+			return nil
+		}
+		return fmt.Errorf("too late, flags already parsed")
+	}
+	destStruct := destValue.Elem()
+	for destField := range traverseStruct(destStruct) {
+		help := destField.fld.Tag.Get("help")
+		flag.Var(&val{destField, accu}, destField.configName(), help)
+	}
+	flag.Var(&readConfigAtVal{accu}, "cfg@", "get config values from file")
+	flag.Parse()
+	return nil
+}
+
+// IgnoreParsedFlags will just have ReadFiles ignore <flags> if the
+// command line was already parsed.
+var IgnoreParsedFlags = false
+
+// ReadFiles reads configuration from a set of files. The string
+// "<flags>" can be used as a pseudo file-path, it will consider
+// command line flags, invoking flag.Parse(). Among those the flag
+// -cfg@=FILE can be used to get further config values from FILE.
 func ReadFiles(destConfig interface{}, cfgFpaths ...string) error {
 	destValue, err := checkDestConfig("destConfig", destConfig)
 	if err != nil {
 		return err
 	}
 	// do the parsing in two phases for better error handling
-	var p1 map[string]json.RawMessage
+	p1 := make(map[string]json.RawMessage)
 	readOne := false
 	for _, cfgPath := range cfgFpaths {
+		if cfgPath == "<flags>" {
+			err := readUsingFlags(p1, destValue)
+			if err != nil {
+				return err
+			}
+			readOne = true
+			continue
+		}
 		if _, err := os.Stat(cfgPath); err == nil {
-			r, err := os.Open(cfgPath)
-			if err != nil {
-				return err
-			}
-			defer r.Close()
-			err = json.NewDecoder(r).Decode(&p1)
+			err := readOneConfig(p1, cfgPath)
 			if err != nil {
 				return err
 			}
 
=== modified file 'config/config_test.go'
--- config/config_test.go	2014-03-25 18:49:18 +0000
+++ config/config_test.go	2014-04-29 18:02:00 +0000
@@ -18,6 +18,9 @@
 
 import (
 	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
 	"io/ioutil"
 	"os"
 	"path/filepath"
@@ -230,3 +233,105 @@
 	c.Check(res, DeepEquals, []string{"b", "c_list", "d"})
 
 }
+
+type testConfig3 struct {
+	A bool
+	B string
+	C []string           `json:"c_list"`
+	D ConfigTimeDuration `help:"duration"`
+	E ConfigHostPort
+	F string
+}
+
+type configFlagsSuite struct{}
+
+var _ = Suite(&configFlagsSuite{})
+
+func (s *configFlagsSuite) SetUpTest(c *C) {
+	flag.CommandLine = flag.NewFlagSet("cmd", flag.PanicOnError)
+	// supress outputs
+	flag.Usage = func() { flag.PrintDefaults() }
+	flag.CommandLine.SetOutput(ioutil.Discard)
+}
+
+func (s *configFlagsSuite) TestReadUsingFlags(c *C) {
+	os.Args = []string{"cmd", "-a=1", "-b=foo", "-c_list", `["x","y"]`, "-d", "10s", "-e=localhost:80"}
+	var cfg testConfig3
+	p := make(map[string]json.RawMessage)
+	err := readUsingFlags(p, reflect.ValueOf(&cfg))
+	c.Assert(err, IsNil)
+	c.Check(p, DeepEquals, map[string]json.RawMessage{
+		"a":      json.RawMessage("true"),
+		"b":      json.RawMessage(`"foo"`),
+		"c_list": json.RawMessage(`["x","y"]`),
+		"d":      json.RawMessage(`"10s"`),
+		"e":      json.RawMessage(`"localhost:80"`),
+	})
+}
+
+func (s *configFlagsSuite) TestReadUsingFlagsBoolError(c *C) {
+	os.Args = []string{"cmd", "-a=zoo"}
+	var cfg testConfig3
+	p := make(map[string]json.RawMessage)
+	c.Check(func() { readUsingFlags(p, reflect.ValueOf(&cfg)) }, PanicMatches, ".*invalid boolean.*-a.*")
+}
+
+func (s *configFlagsSuite) TestReadFilesAndFlags(c *C) {
+	// test <flags> pseudo file
+	os.Args = []string{"cmd", "-b=x"}
+	tmpDir := c.MkDir()
+	cfgPath := filepath.Join(tmpDir, "cfg.json")
+	err := ioutil.WriteFile(cfgPath, []byte(`{"a": 42, "c_list": ["y", "z"]}`), os.ModePerm)
+	c.Assert(err, IsNil)
+	var cfg testConfig1
+	err = ReadFiles(&cfg, cfgPath, "<flags>")
+	c.Assert(err, IsNil)
+	c.Check(cfg.A, Equals, 42)
+	c.Check(cfg.B, Equals, "x")
+	c.Check(cfg.C, DeepEquals, []string{"y", "z"})
+}
+
+func (s *configFlagsSuite) TestReadFilesAndFlagsConfigAtSupport(c *C) {
+	// test <flags> pseudo file
+	tmpDir := c.MkDir()
+	cfgPath := filepath.Join(tmpDir, "cfg.json")
+	os.Args = []string{"cmd", "-a=42", fmt.Sprintf("-cfg@=%s", cfgPath)}
+	err := ioutil.WriteFile(cfgPath, []byte(`{"b": "x", "c_list": ["y", "z"]}`), os.ModePerm)
+	c.Assert(err, IsNil)
+	var cfg testConfig1
+	err = ReadFiles(&cfg, "<flags>")
+	c.Assert(err, IsNil)
+	c.Check(cfg.A, Equals, 42)
+	c.Check(cfg.B, Equals, "x")
+	c.Check(cfg.C, DeepEquals, []string{"y", "z"})
+}
+
+func (s *configFlagsSuite) TestReadUsingFlagsHelp(c *C) {
+	os.Args = []string{"cmd", "-h"}
+	buf := bytes.NewBufferString("")
+	flag.CommandLine.Init("cmd", flag.ContinueOnError)
+	flag.CommandLine.SetOutput(buf)
+	var cfg testConfig3
+	p := map[string]json.RawMessage{
+		"d": json.RawMessage(`"2s"`),
+	}
+	readUsingFlags(p, reflect.ValueOf(&cfg))
+	c.Check(buf.String(), Matches, `(?s).*-cfg@=<config.json>: get config values from file\n.*-d="2s": duration.*`)
+}
+
+func (s *configFlagsSuite) TestReadUsingFlagsAlreadyParsed(c *C) {
+	os.Args = []string{"cmd"}
+	flag.Parse()
+	var cfg struct{}
+	p := make(map[string]json.RawMessage)
+	err := readUsingFlags(p, reflect.ValueOf(&cfg))
+	c.Assert(err, ErrorMatches, "too late, flags already parsed")
+	err = ReadFiles(&cfg, "<flags>")
+	c.Assert(err, ErrorMatches, "too late, flags already parsed")
+	IgnoreParsedFlags = true
+	defer func() {
+		IgnoreParsedFlags = false
+	}()
+	err = ReadFiles(&cfg, "<flags>")
+	c.Assert(err, IsNil)
+}
 
=== modified file 'debian/changelog'
--- debian/changelog	2014-04-11 18:31:57 +0000
+++ debian/changelog	2014-04-29 18:02:00 +0000
@@ -1,3 +1,9 @@
+ubuntu-push (0.21-0.ubuntu1) UNRELEASED; urgency=medium
+
+  * New upstream release: first auth bits, and Qt dependency.
+
+ -- John Lenton <[e-mail]>  Tue, 15 Apr 2014 14:04:35 +0100
+
 ubuntu-push (0.2+14.04.20140411-0ubuntu1) trusty; urgency=medium
 
   [ John Lenton ]
 
=== modified file 'debian/control'
--- debian/control	2014-03-25 16:26:20 +0000
+++ debian/control	2014-04-29 18:02:00 +0000
@@ -14,6 +14,10 @@
                libgcrypt11-dev,
                libglib2.0-dev (>= 2.31.6),
                libwhoopsie-dev,
+               qtbase5-private-dev,
+               qtdeclarative5-dev,
+               libqt5opengl5-dev,
+               libubuntuoneauth-2.0-dev,
 Standards-Version: 3.9.5
 Homepage: http://launchpad.net/ubuntu-push
 Vcs-Bzr: lp:ubuntu-push
 
=== modified file 'debian/rules'
--- debian/rules	2014-03-24 12:22:55 +0000
+++ debian/rules	2014-04-29 18:02:00 +0000
@@ -2,9 +2,12 @@
 # -*- makefile -*-
 
 export DH_GOPKG := launchpad.net/ubuntu-push
-export DEB_BUILD_OPTIONS := nostrip
 export UBUNTU_PUSH_TEST_RESOURCES_ROOT := $(CURDIR)
 
+override_dh_auto_build:
+	cd $$( find ./ -type d -regex '\./[^/]*/src/launchpad.net' -printf "%h\n" | head -n1) && tar xvzf ../../externals.tgz
+	dh_auto_build --buildsystem=golang
+
 override_dh_install:
 	dh_install -Xusr/bin/cmd -Xusr/bin/dev --fail-missing
 
 
=== modified file 'dependencies.tsv'
--- dependencies.tsv	2014-03-12 13:23:26 +0000
+++ dependencies.tsv	2014-04-29 18:02:00 +0000
@@ -2,3 +2,5 @@
 launchpad.net/go-dbus/v1	bzr	[e-mail]-20140206110213-pbzcr6ucaz3rqmnw	125
 launchpad.net/go-xdg/v0	bzr	[e-mail]-20140208094800-gubd5md7cro3mtxa	10
 launchpad.net/gocheck	bzr	[e-mail]-20140127131816-zshobk1qqme626xw	86
+gopkg.in/qml.v0	git	master	8adbc8c2bf2da9f609df366683ad0f47a89c3d49
+gopkg.in/niemeyer/uoneauth.v1	git	v1	0758ba882a143ad2862dbcac85a7ca145750b640
 
=== added file 'externals.tgz'
 Binary files externals.tgz	1970-01-01 00:00:00 +0000 and externals.tgz	2014-04-29 18:02:00 +0000 differ
=== modified file 'logger/logger.go'
--- logger/logger.go	2014-02-24 10:27:38 +0000
+++ logger/logger.go	2014-04-29 18:02:00 +0000
@@ -23,6 +23,8 @@
 	"log"
 	"os"
 	"runtime"
+
+	"launchpad.net/ubuntu-push/config"
 )
 
 // Logger is a simple logger interface with logging at levels.
@@ -119,3 +121,28 @@
 		lg.outputFunc(2, fmt.Sprintf("DEBUG "+format, v...))
 	}
 }
+
+// config bits
+
+// ConfigLogLevel can hold a log level in a configuration struct.
+type ConfigLogLevel string
+
+func (cll *ConfigLogLevel) ConfigFromJSONString() {}
+
+func (cll *ConfigLogLevel) UnmarshalJSON(b []byte) error {
+	return config.UnmarshalJSONViaString(cll, b)
+}
+
+func (cll *ConfigLogLevel) SetFromString(enc string) error {
+	_, ok := levelToNLevel[enc]
+	if !ok {
+		return fmt.Errorf("not a log level: %s", enc)
+	}
+	*cll = ConfigLogLevel(enc)
+	return nil
+}
+
+// Level returns the log level string held in cll.
+func (cll ConfigLogLevel) Level() string {
+	return string(cll)
+}
 
=== modified file 'logger/logger_test.go'
--- logger/logger_test.go	2014-02-10 22:51:43 +0000
+++ logger/logger_test.go	2014-04-29 18:02:00 +0000
@@ -25,6 +25,8 @@
 	"testing"
 
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/config"
 )
 
 func TestLogger(t *testing.T) { TestingT(t) }
@@ -138,3 +140,26 @@
 	logger.Output(1, "foobaz")
 	c.Check(buf.String(), Matches, "logger_test.go:[0-9]+: foobar\nlogger_test.go:[0-9]+: foobaz\n")
 }
+
+type testLogLevelConfig struct {
+	Lvl ConfigLogLevel
+}
+
+func (s *loggerSuite) TestReadConfigLogLevel(c *C) {
+	buf := bytes.NewBufferString(`{"lvl": "debug"}`)
+	var cfg testLogLevelConfig
+	err := config.ReadConfig(buf, &cfg)
+	c.Assert(err, IsNil)
+	c.Check(cfg.Lvl.Level(), Equals, "debug")
+}
+
+func (s *loggerSuite) TestReadConfigLogLevelErrors(c *C) {
+	var cfg testLogLevelConfig
+	checkError := func(jsonCfg string, expectedError string) {
+		buf := bytes.NewBufferString(jsonCfg)
+		err := config.ReadConfig(buf, &cfg)
+		c.Check(err, ErrorMatches, expectedError)
+	}
+	checkError(`{"lvl": 1}`, "lvl:.*type string")
+	checkError(`{"lvl": "foo"}`, "lvl: not a log level: foo")
+}
 
=== modified file 'protocol/messages.go'
--- protocol/messages.go	2014-04-04 13:54:45 +0000
+++ protocol/messages.go	2014-04-29 18:02:00 +0000
@@ -54,6 +54,14 @@
 	Split() (done bool)
 }
 
+// OnewayMsg are messages that are not to be followed by a response,
+// after sending them the session either aborts or continues.
+type OnewayMsg interface {
+	SplittableMsg
+	// continue session after the message?
+	OnewayContinue() bool
+}
+
 // CONNBROKEN message, server side is breaking the connection for reason.
 type ConnBrokenMsg struct {
 	Type string `json:"T"`
@@ -65,11 +73,35 @@
 	return true
 }
 
+func (m *ConnBrokenMsg) OnewayContinue() bool {
+	return false
+}
+
 // CONNBROKEN reasons
 const (
 	BrokenHostMismatch = "host-mismatch"
 )
 
+// CONNWARN message, server side is warning about partial functionality
+// because reason.
+type ConnWarnMsg struct {
+	Type string `json:"T"`
+	// reason
+	Reason string
+}
+
+func (m *ConnWarnMsg) Split() bool {
+	return true
+}
+func (m *ConnWarnMsg) OnewayContinue() bool {
+	return true
+}
+
+// CONNWARN reasons
+const (
+	WarnUnauthorized = "unauthorized"
+)
+
 // PING/PONG messages
 type PingPongMsg struct {
 	Type string `json:"T"`
@@ -130,6 +162,19 @@
 	Payload json.RawMessage `json:"P"`
 }
 
+// ExtractPayloads gets only the payloads out of a slice of notications.
+func ExtractPayloads(notifications []Notification) []json.RawMessage {
+	n := len(notifications)
+	if n == 0 {
+		return nil
+	}
+	payloads := make([]json.RawMessage, n)
+	for i := 0; i < n; i++ {
+		payloads[i] = notifications[i].Payload
+	}
+	return payloads
+}
+
 // ACKnowledgement message
 type AckMsg struct {
 	Type string `json:"T"`
 
=== modified file 'protocol/messages_test.go'
--- protocol/messages_test.go	2014-04-04 13:19:10 +0000
+++ protocol/messages_test.go	2014-04-29 18:02:00 +0000
@@ -104,6 +104,22 @@
 	c.Check(b.splitting, Equals, 0)
 }
 
-func (s *messagesSuite) TestSplitConnBrokenMsg(c *C) {
-	c.Check((&ConnBrokenMsg{}).Split(), Equals, true)
+func (s *messagesSuite) TestConnBrokenMsg(c *C) {
+	m := &ConnBrokenMsg{}
+	c.Check(m.Split(), Equals, true)
+	c.Check(m.OnewayContinue(), Equals, false)
+}
+
+func (s *messagesSuite) TestConnWarnMsg(c *C) {
+	m := &ConnWarnMsg{}
+	c.Check(m.Split(), Equals, true)
+	c.Check(m.OnewayContinue(), Equals, true)
+}
+
+func (s *messagesSuite) TestExtractPayloads(c *C) {
+	c.Check(ExtractPayloads(nil), IsNil)
+	p1 := json.RawMessage(`{"a":1}`)
+	p2 := json.RawMessage(`{"b":2}`)
+	ns := []Notification{Notification{Payload: p1}, Notification{Payload: p2}}
+	c.Check(ExtractPayloads(ns), DeepEquals, []json.RawMessage{p1, p2})
 }
 
=== modified file 'protocol/state-diag-client.gv'
--- protocol/state-diag-client.gv	2014-01-16 20:07:13 +0000
+++ protocol/state-diag-client.gv	2014-04-29 18:02:00 +0000
@@ -2,7 +2,7 @@
         label = "State diagram for client";
         size="12,6";
         rankdir=LR;
-        node [shape = doublecircle]; pingTimeout;
+        node [shape = doublecircle]; pingTimeout; connBroken;
         node [shape = circle];
         start1 -> start2 [ label = "Write wire version" ];
         start2 -> start3 [ label = "Write CONNECT" ];
@@ -13,4 +13,7 @@
         broadcast -> loop [label = "Write ACK"];
         loop -> pingTimeout [
              label = "Elapsed ping interval + exchange interval"];
+        loop -> connBroken [label = "Read CONNBROKEN"];
+        loop -> warn [label = "Read CONNWARN"];
+        warn -> loop;
 }
 
=== modified file 'protocol/state-diag-client.svg'
--- protocol/state-diag-client.svg	2014-01-16 19:37:57 +0000
+++ protocol/state-diag-client.svg	2014-04-29 18:02:00 +0000
@@ -4,95 +4,123 @@
 <!-- Generated by graphviz version 2.26.3 (20100126.1600)
  -->
 <!-- Title: state_diagram_client Pages: 1 -->
-<svg width="864pt" height="279pt"
- viewBox="0.00 0.00 864.00 278.89" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<g id="graph1" class="graph" transform="scale(0.683544 0.683544) rotate(0) translate(4 404)">
+<svg width="822pt" height="432pt"
+ viewBox="0.00 0.00 822.36 432.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph1" class="graph" transform="scale(0.650602 0.650602) rotate(0) translate(4 660)">
 <title>state_diagram_client</title>
-<polygon fill="white" stroke="white" points="-4,5 -4,-404 1261,-404 1261,5 -4,5"/>
+<polygon fill="white" stroke="white" points="-4,5 -4,-660 1261,-660 1261,5 -4,5"/>
 <text text-anchor="middle" x="628" y="-9.4" font-family="Times Roman,serif" font-size="14.00">State diagram for client</text>
 <!-- pingTimeout -->
 <g id="node1" class="node"><title>pingTimeout</title>
-<ellipse fill="none" stroke="black" cx="1180" cy="-324" rx="72.1249" ry="72.1249"/>
-<ellipse fill="none" stroke="black" cx="1180" cy="-324" rx="76.1249" ry="76.1249"/>
-<text text-anchor="middle" x="1180" y="-320.4" font-family="Times Roman,serif" font-size="14.00">pingTimeout</text>
+<ellipse fill="none" stroke="black" cx="1180" cy="-580" rx="72.1249" ry="72.1249"/>
+<ellipse fill="none" stroke="black" cx="1180" cy="-580" rx="76.1249" ry="76.1249"/>
+<text text-anchor="middle" x="1180" y="-576.4" font-family="Times Roman,serif" font-size="14.00">pingTimeout</text>
+</g>
+<!-- connBroken -->
+<g id="node2" class="node"><title>connBroken</title>
+<ellipse fill="none" stroke="black" cx="1180" cy="-413" rx="68.8251" ry="69.2965"/>
+<ellipse fill="none" stroke="black" cx="1180" cy="-413" rx="72.7978" ry="73.2965"/>
+<text text-anchor="middle" x="1180" y="-409.4" font-family="Times Roman,serif" font-size="14.00">connBroken</text>
 </g>
 <!-- start1 -->
-<g id="node2" class="node"><title>start1</title>
-<ellipse fill="none" stroke="black" cx="42" cy="-166" rx="41.2167" ry="41.7193"/>
-<text text-anchor="middle" x="42" y="-162.4" font-family="Times Roman,serif" font-size="14.00">start1</text>
+<g id="node3" class="node"><title>start1</title>
+<ellipse fill="none" stroke="black" cx="42" cy="-231" rx="41.2167" ry="41.7193"/>
+<text text-anchor="middle" x="42" y="-227.4" font-family="Times Roman,serif" font-size="14.00">start1</text>
 </g>
 <!-- start2 -->
-<g id="node4" class="node"><title>start2</title>
-<ellipse fill="none" stroke="black" cx="292" cy="-166" rx="41.2167" ry="41.7193"/>
-<text text-anchor="middle" x="292" y="-162.4" font-family="Times Roman,serif" font-size="14.00">start2</text>
+<g id="node5" class="node"><title>start2</title>
+<ellipse fill="none" stroke="black" cx="292" cy="-231" rx="41.2167" ry="41.7193"/>
+<text text-anchor="middle" x="292" y="-227.4" font-family="Times Roman,serif" font-size="14.00">start2</text>
 </g>
 <!-- start1&#45;&gt;start2 -->
 <g id="edge2" class="edge"><title>start1&#45;&gt;start2</title>
-<path fill="none" stroke="black" d="M83.5631,-166C126.547,-166 193.757,-166 240.181,-166"/>
-<polygon fill="black" stroke="black" points="240.338,-169.5 250.338,-166 240.338,-162.5 240.338,-169.5"/>
-<text text-anchor="middle" x="167" y="-171.4" font-family="Times Roman,serif" font-size="14.00">Write wire version</text>
+<path fill="none" stroke="black" d="M83.5631,-231C126.547,-231 193.757,-231 240.181,-231"/>
+<polygon fill="black" stroke="black" points="240.338,-234.5 250.338,-231 240.338,-227.5 240.338,-234.5"/>
+<text text-anchor="middle" x="167" y="-236.4" font-family="Times Roman,serif" font-size="14.00">Write wire version</text>
 </g>
 <!-- start3 -->
-<g id="node6" class="node"><title>start3</title>
-<ellipse fill="none" stroke="black" cx="526" cy="-166" rx="41.2167" ry="41.7193"/>
-<text text-anchor="middle" x="526" y="-162.4" font-family="Times Roman,serif" font-size="14.00">start3</text>
+<g id="node7" class="node"><title>start3</title>
+<ellipse fill="none" stroke="black" cx="526" cy="-231" rx="41.2167" ry="41.7193"/>
+<text text-anchor="middle" x="526" y="-227.4" font-family="Times Roman,serif" font-size="14.00">start3</text>
 </g>
 <!-- start2&#45;&gt;start3 -->
 <g id="edge4" class="edge"><title>start2&#45;&gt;start3</title>
-<path fill="none" stroke="black" d="M333.565,-166C372.875,-166 431.992,-166 474.321,-166"/>
-<polygon fill="black" stroke="black" points="474.429,-169.5 484.429,-166 474.429,-162.5 474.429,-169.5"/>
-<text text-anchor="middle" x="409" y="-171.4" font-family="Times Roman,serif" font-size="14.00">Write CONNECT</text>
+<path fill="none" stroke="black" d="M333.565,-231C372.875,-231 431.992,-231 474.321,-231"/>
+<polygon fill="black" stroke="black" points="474.429,-234.5 484.429,-231 474.429,-227.5 474.429,-234.5"/>
+<text text-anchor="middle" x="409" y="-236.4" font-family="Times Roman,serif" font-size="14.00">Write CONNECT</text>
 </g>
 <!-- loop -->
-<g id="node8" class="node"><title>loop</title>
-<ellipse fill="none" stroke="black" cx="746" cy="-166" rx="31.8198" ry="31.8198"/>
-<text text-anchor="middle" x="746" y="-162.4" font-family="Times Roman,serif" font-size="14.00">loop</text>
+<g id="node9" class="node"><title>loop</title>
+<ellipse fill="none" stroke="black" cx="746" cy="-231" rx="31.8198" ry="31.8198"/>
+<text text-anchor="middle" x="746" y="-227.4" font-family="Times Roman,serif" font-size="14.00">loop</text>
 </g>
 <!-- start3&#45;&gt;loop -->
 <g id="edge6" class="edge"><title>start3&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M567.639,-166C606.633,-166 664.616,-166 703.793,-166"/>
-<polygon fill="black" stroke="black" points="703.818,-169.5 713.818,-166 703.818,-162.5 703.818,-169.5"/>
-<text text-anchor="middle" x="641" y="-171.4" font-family="Times Roman,serif" font-size="14.00">Read CONNACK</text>
+<path fill="none" stroke="black" d="M567.639,-231C606.633,-231 664.616,-231 703.793,-231"/>
+<polygon fill="black" stroke="black" points="703.818,-234.5 713.818,-231 703.818,-227.5 703.818,-234.5"/>
+<text text-anchor="middle" x="641" y="-236.4" font-family="Times Roman,serif" font-size="14.00">Read CONNACK</text>
 </g>
 <!-- loop&#45;&gt;pingTimeout -->
 <g id="edge16" class="edge"><title>loop&#45;&gt;pingTimeout</title>
-<path fill="none" stroke="black" d="M763.666,-192.937C772.211,-204.042 783.361,-216.128 796,-224 888.06,-281.339 1012.12,-305.973 1094,-316.443"/>
-<polygon fill="black" stroke="black" points="1093.67,-319.928 1104.02,-317.68 1094.53,-312.981 1093.67,-319.928"/>
-<text text-anchor="middle" x="941" y="-319.4" font-family="Times Roman,serif" font-size="14.00">Elapsed ping interval + exchange interval</text>
+<path fill="none" stroke="black" d="M750.211,-262.971C757.458,-313.528 773.689,-408.79 796,-434 872.806,-520.784 1006.81,-556.22 1094.46,-570.528"/>
+<polygon fill="black" stroke="black" points="1093.96,-573.992 1104.39,-572.09 1095.05,-567.078 1093.96,-573.992"/>
+<text text-anchor="middle" x="941" y="-572.4" font-family="Times Roman,serif" font-size="14.00">Elapsed ping interval + exchange interval</text>
+</g>
+<!-- loop&#45;&gt;connBroken -->
+<g id="edge18" class="edge"><title>loop&#45;&gt;connBroken</title>
+<path fill="none" stroke="black" d="M755.1,-261.824C762.755,-282.438 775.756,-308.526 796,-324 883.382,-390.791 1012.39,-408.797 1096.33,-412.948"/>
+<polygon fill="black" stroke="black" points="1096.19,-416.445 1106.33,-413.388 1096.5,-409.452 1096.19,-416.445"/>
+<text text-anchor="middle" x="941" y="-417.4" font-family="Times Roman,serif" font-size="14.00">Read CONNBROKEN</text>
 </g>
 <!-- pong -->
-<g id="node10" class="node"><title>pong</title>
-<ellipse fill="none" stroke="black" cx="1180" cy="-195" rx="34.8574" ry="35.3553"/>
-<text text-anchor="middle" x="1180" y="-191.4" font-family="Times Roman,serif" font-size="14.00">pong</text>
+<g id="node11" class="node"><title>pong</title>
+<ellipse fill="none" stroke="black" cx="1180" cy="-287" rx="34.8574" ry="35.3553"/>
+<text text-anchor="middle" x="1180" y="-283.4" font-family="Times Roman,serif" font-size="14.00">pong</text>
 </g>
 <!-- loop&#45;&gt;pong -->
 <g id="edge8" class="edge"><title>loop&#45;&gt;pong</title>
-<path fill="none" stroke="black" d="M775.392,-179.044C782.046,-181.465 789.167,-183.653 796,-185 916.362,-208.722 1062.02,-203.515 1134.48,-198.706"/>
-<polygon fill="black" stroke="black" points="1134.89,-202.186 1144.62,-198.003 1134.4,-195.203 1134.89,-202.186"/>
-<text text-anchor="middle" x="941" y="-207.4" font-family="Times Roman,serif" font-size="14.00">Read PING</text>
+<path fill="none" stroke="black" d="M768.467,-253.959C776.476,-260.698 786.005,-267.259 796,-271 911.696,-314.31 1060.9,-303.343 1134.62,-293.955"/>
+<polygon fill="black" stroke="black" points="1135.49,-297.371 1144.94,-292.588 1134.57,-290.432 1135.49,-297.371"/>
+<text text-anchor="middle" x="941" y="-307.4" font-family="Times Roman,serif" font-size="14.00">Read PING</text>
 </g>
 <!-- broadcast -->
-<g id="node12" class="node"><title>broadcast</title>
-<ellipse fill="none" stroke="black" cx="1180" cy="-84" rx="58.1882" ry="58.6899"/>
-<text text-anchor="middle" x="1180" y="-80.4" font-family="Times Roman,serif" font-size="14.00">broadcast</text>
+<g id="node13" class="node"><title>broadcast</title>
+<ellipse fill="none" stroke="black" cx="1180" cy="-176" rx="58.1882" ry="58.6899"/>
+<text text-anchor="middle" x="1180" y="-172.4" font-family="Times Roman,serif" font-size="14.00">broadcast</text>
 </g>
 <!-- loop&#45;&gt;broadcast -->
 <g id="edge10" class="edge"><title>loop&#45;&gt;broadcast</title>
-<path fill="none" stroke="black" d="M770.52,-145.1C778.217,-139.607 787.053,-134.301 796,-131 917.482,-86.1746 957.924,-122.075 1086,-103 1094.61,-101.717 1103.63,-100.165 1112.53,-98.5074"/>
-<polygon fill="black" stroke="black" points="1113.34,-101.917 1122.5,-96.5998 1112.02,-95.0419 1113.34,-101.917"/>
-<text text-anchor="middle" x="941" y="-136.4" font-family="Times Roman,serif" font-size="14.00">Read BROADCAST</text>
+<path fill="none" stroke="black" d="M775.45,-218.228C782.1,-215.791 789.205,-213.528 796,-212 922.145,-183.64 957.464,-202.973 1086,-189 1094.36,-188.091 1103.12,-187.028 1111.79,-185.909"/>
+<polygon fill="black" stroke="black" points="1112.44,-189.353 1121.9,-184.574 1111.53,-182.413 1112.44,-189.353"/>
+<text text-anchor="middle" x="941" y="-217.4" font-family="Times Roman,serif" font-size="14.00">Read BROADCAST</text>
+</g>
+<!-- warn -->
+<g id="node19" class="node"><title>warn</title>
+<ellipse fill="none" stroke="black" cx="1180" cy="-63" rx="36.7696" ry="36.7696"/>
+<text text-anchor="middle" x="1180" y="-59.4" font-family="Times Roman,serif" font-size="14.00">warn</text>
+</g>
+<!-- loop&#45;&gt;warn -->
+<g id="edge20" class="edge"><title>loop&#45;&gt;warn</title>
+<path fill="none" stroke="black" d="M753.357,-199.767C760.401,-177.027 773.396,-147.441 796,-131 901.425,-54.3166 958.242,-112.935 1086,-87 1101.84,-83.7841 1119.02,-79.6061 1134.3,-75.6396"/>
+<polygon fill="black" stroke="black" points="1135.26,-79.0068 1144.04,-73.0757 1133.48,-72.2376 1135.26,-79.0068"/>
+<text text-anchor="middle" x="941" y="-136.4" font-family="Times Roman,serif" font-size="14.00">Read CONNWARN</text>
 </g>
 <!-- pong&#45;&gt;loop -->
 <g id="edge12" class="edge"><title>pong&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M1147.19,-180.867C1129.44,-173.986 1106.92,-166.463 1086,-163 980.081,-145.465 853.051,-154.36 788.368,-160.981"/>
-<polygon fill="black" stroke="black" points="787.736,-157.528 778.16,-162.06 788.472,-164.489 787.736,-157.528"/>
-<text text-anchor="middle" x="941" y="-168.4" font-family="Times Roman,serif" font-size="14.00">Write PONG</text>
+<path fill="none" stroke="black" d="M1148.22,-271.079C1130.39,-262.942 1107.48,-253.77 1086,-249 1030.54,-236.684 866.695,-232.715 788.482,-231.502"/>
+<polygon fill="black" stroke="black" points="788.085,-227.996 778.035,-231.348 787.982,-234.995 788.085,-227.996"/>
+<text text-anchor="middle" x="941" y="-254.4" font-family="Times Roman,serif" font-size="14.00">Write PONG</text>
 </g>
 <!-- broadcast&#45;&gt;loop -->
 <g id="edge14" class="edge"><title>broadcast&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M1123.8,-67.0114C1044.83,-46.6166 899.156,-22.0001 796,-81 778.946,-90.7538 767.135,-108.842 759.293,-125.833"/>
-<polygon fill="black" stroke="black" points="756.044,-124.528 755.336,-135.099 762.482,-127.277 756.044,-124.528"/>
-<text text-anchor="middle" x="941" y="-86.4" font-family="Times Roman,serif" font-size="14.00">Write ACK</text>
+<path fill="none" stroke="black" d="M1121.7,-168.205C1028.72,-156.837 851.665,-139.849 796,-167 784,-172.853 774.037,-183.132 766.245,-193.762"/>
+<polygon fill="black" stroke="black" points="763.182,-192.043 760.465,-202.284 768.975,-195.973 763.182,-192.043"/>
+<text text-anchor="middle" x="941" y="-172.4" font-family="Times Roman,serif" font-size="14.00">Write ACK</text>
+</g>
+<!-- warn&#45;&gt;loop -->
+<g id="edge22" class="edge"><title>warn&#45;&gt;loop</title>
+<path fill="none" stroke="black" d="M1144.07,-53.3553C1070.4,-35.8873 900.397,-7.71825 796,-87 779.313,-99.6722 764.14,-151.763 754.991,-189.659"/>
+<polygon fill="black" stroke="black" points="751.574,-188.904 752.686,-199.44 758.387,-190.51 751.574,-188.904"/>
 </g>
 </g>
 </svg>
 
=== modified file 'protocol/state-diag-session.gv'
--- protocol/state-diag-session.gv	2014-01-16 20:07:13 +0000
+++ protocol/state-diag-session.gv	2014-04-29 18:02:00 +0000
@@ -2,6 +2,7 @@
         label = "State diagram for session";
         size="12,6";
         rankdir=LR;
+        node [shape = doublecircle]; stop;
         node [shape = circle];
         start1 -> start2 [ label = "Read wire version" ];
         start2 -> start3 [ label = "Read CONNECT" ];
@@ -17,4 +18,13 @@
         split_broadcast -> split_ack_wait [label = "Write split BROADCAST"];
         split_ack_wait -> split_broadcast [label = "Read ACK"];
         split_broadcast -> loop [label = "All split msgs written"];
+        // other
+        loop -> conn_broken [label = "Receive connbroken request"];
+        loop -> conn_warn [label = "Receive connwarn request"];
+        conn_broken -> stop [label = "Write CONNBROKEN"];
+        conn_warn -> loop [label = "Write CONNWARN"];
+        // timeouts
+        ack_wait -> stop [label = "Elapsed exhange timeout"];
+        split_ack_wait -> stop [label = "Elapsed exhange timeout"];
+        pong_wait -> stop [label = "Elapsed exhange timeout"];
 }
 
=== modified file 'protocol/state-diag-session.svg'
--- protocol/state-diag-session.svg	2014-01-16 19:37:57 +0000
+++ protocol/state-diag-session.svg	2014-04-29 18:02:00 +0000
@@ -4,139 +4,197 @@
 <!-- Generated by graphviz version 2.26.3 (20100126.1600)
  -->
 <!-- Title: state_diagram_session Pages: 1 -->
-<svg width="864pt" height="208pt"
- viewBox="0.00 0.00 864.00 207.94" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<g id="graph1" class="graph" transform="scale(0.435923 0.435923) rotate(0) translate(4 473)">
+<svg width="864pt" height="266pt"
+ viewBox="0.00 0.00 864.00 265.73" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph1" class="graph" transform="scale(0.367035 0.367035) rotate(0) translate(4 720)">
 <title>state_diagram_session</title>
-<polygon fill="white" stroke="white" points="-4,5 -4,-473 1979,-473 1979,5 -4,5"/>
-<text text-anchor="middle" x="987" y="-9.4" font-family="Times Roman,serif" font-size="14.00">State diagram for session</text>
+<polygon fill="white" stroke="white" points="-4,5 -4,-720 2351,-720 2351,5 -4,5"/>
+<text text-anchor="middle" x="1173" y="-9.4" font-family="Times Roman,serif" font-size="14.00">State diagram for session</text>
+<!-- stop -->
+<g id="node1" class="node"><title>stop</title>
+<ellipse fill="none" stroke="black" cx="2309" cy="-335" rx="32.0813" ry="32.5269"/>
+<ellipse fill="none" stroke="black" cx="2309" cy="-335" rx="36.0265" ry="36.5269"/>
+<text text-anchor="middle" x="2309" y="-331.4" font-family="Times Roman,serif" font-size="14.00">stop</text>
+</g>
 <!-- start1 -->
-<g id="node1" class="node"><title>start1</title>
-<ellipse fill="none" stroke="black" cx="42" cy="-294" rx="41.2167" ry="41.7193"/>
-<text text-anchor="middle" x="42" y="-290.4" font-family="Times Roman,serif" font-size="14.00">start1</text>
+<g id="node2" class="node"><title>start1</title>
+<ellipse fill="none" stroke="black" cx="42" cy="-395" rx="41.2167" ry="41.7193"/>
+<text text-anchor="middle" x="42" y="-391.4" font-family="Times Roman,serif" font-size="14.00">start1</text>
 </g>
 <!-- start2 -->
-<g id="node3" class="node"><title>start2</title>
-<ellipse fill="none" stroke="black" cx="286" cy="-294" rx="41.2167" ry="41.7193"/>
-<text text-anchor="middle" x="286" y="-290.4" font-family="Times Roman,serif" font-size="14.00">start2</text>
+<g id="node4" class="node"><title>start2</title>
+<ellipse fill="none" stroke="black" cx="286" cy="-395" rx="41.2167" ry="41.7193"/>
+<text text-anchor="middle" x="286" y="-391.4" font-family="Times Roman,serif" font-size="14.00">start2</text>
 </g>
 <!-- start1&#45;&gt;start2 -->
 <g id="edge2" class="edge"><title>start1&#45;&gt;start2</title>
-<path fill="none" stroke="black" d="M83.6679,-294C125.213,-294 189.13,-294 233.981,-294"/>
-<polygon fill="black" stroke="black" points="234.096,-297.5 244.096,-294 234.096,-290.5 234.096,-297.5"/>
-<text text-anchor="middle" x="164" y="-299.4" font-family="Times Roman,serif" font-size="14.00">Read wire version</text>
+<path fill="none" stroke="black" d="M83.6679,-395C125.213,-395 189.13,-395 233.981,-395"/>
+<polygon fill="black" stroke="black" points="234.096,-398.5 244.096,-395 234.096,-391.5 234.096,-398.5"/>
+<text text-anchor="middle" x="164" y="-400.4" font-family="Times Roman,serif" font-size="14.00">Read wire version</text>
 </g>
 <!-- start3 -->
-<g id="node5" class="node"><title>start3</title>
-<ellipse fill="none" stroke="black" cx="516" cy="-294" rx="41.2167" ry="41.7193"/>
-<text text-anchor="middle" x="516" y="-290.4" font-family="Times Roman,serif" font-size="14.00">start3</text>
+<g id="node6" class="node"><title>start3</title>
+<ellipse fill="none" stroke="black" cx="537" cy="-395" rx="41.2167" ry="41.7193"/>
+<text text-anchor="middle" x="537" y="-391.4" font-family="Times Roman,serif" font-size="14.00">start3</text>
 </g>
 <!-- start2&#45;&gt;start3 -->
 <g id="edge4" class="edge"><title>start2&#45;&gt;start3</title>
-<path fill="none" stroke="black" d="M327.651,-294C365.959,-294 422.903,-294 464.145,-294"/>
-<polygon fill="black" stroke="black" points="464.271,-297.5 474.271,-294 464.271,-290.5 464.271,-297.5"/>
-<text text-anchor="middle" x="401" y="-299.4" font-family="Times Roman,serif" font-size="14.00">Read CONNECT</text>
+<path fill="none" stroke="black" d="M327.729,-395C370.886,-395 438.364,-395 484.973,-395"/>
+<polygon fill="black" stroke="black" points="485.171,-398.5 495.171,-395 485.171,-391.5 485.171,-398.5"/>
+<text text-anchor="middle" x="401" y="-400.4" font-family="Times Roman,serif" font-size="14.00">Read CONNECT</text>
 </g>
 <!-- loop -->
-<g id="node7" class="node"><title>loop</title>
-<ellipse fill="none" stroke="black" cx="740" cy="-294" rx="31.8198" ry="31.8198"/>
-<text text-anchor="middle" x="740" y="-290.4" font-family="Times Roman,serif" font-size="14.00">loop</text>
+<g id="node8" class="node"><title>loop</title>
+<ellipse fill="none" stroke="black" cx="790" cy="-395" rx="31.8198" ry="31.8198"/>
+<text text-anchor="middle" x="790" y="-391.4" font-family="Times Roman,serif" font-size="14.00">loop</text>
 </g>
 <!-- start3&#45;&gt;loop -->
 <g id="edge6" class="edge"><title>start3&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M557.608,-294C597.53,-294 657.517,-294 697.677,-294"/>
-<polygon fill="black" stroke="black" points="697.687,-297.5 707.687,-294 697.687,-290.5 697.687,-297.5"/>
-<text text-anchor="middle" x="633" y="-299.4" font-family="Times Roman,serif" font-size="14.00">Write CONNACK</text>
+<path fill="none" stroke="black" d="M578.778,-395C625.49,-395 700.728,-395 747.665,-395"/>
+<polygon fill="black" stroke="black" points="747.805,-398.5 757.805,-395 747.805,-391.5 747.805,-398.5"/>
+<text text-anchor="middle" x="675" y="-400.4" font-family="Times Roman,serif" font-size="14.00">Write CONNACK</text>
 </g>
 <!-- ping -->
-<g id="node9" class="node"><title>ping</title>
-<ellipse fill="none" stroke="black" cx="1063" cy="-416" rx="32.0265" ry="32.5269"/>
-<text text-anchor="middle" x="1063" y="-412.4" font-family="Times Roman,serif" font-size="14.00">ping</text>
+<g id="node10" class="node"><title>ping</title>
+<ellipse fill="none" stroke="black" cx="1135" cy="-593" rx="32.0265" ry="32.5269"/>
+<text text-anchor="middle" x="1135" y="-589.4" font-family="Times Roman,serif" font-size="14.00">ping</text>
 </g>
 <!-- loop&#45;&gt;ping -->
 <g id="edge8" class="edge"><title>loop&#45;&gt;ping</title>
-<path fill="none" stroke="black" d="M754.564,-322.853C763.046,-336.78 775.035,-352.491 790,-362 861.597,-407.491 963.396,-415.983 1020.29,-416.829"/>
-<polygon fill="black" stroke="black" points="1020.35,-420.33 1030.38,-416.906 1020.4,-413.33 1020.35,-420.33"/>
-<text text-anchor="middle" x="881" y="-418.4" font-family="Times Roman,serif" font-size="14.00">Elapsed ping interval</text>
+<path fill="none" stroke="black" d="M800.39,-425.317C809.609,-448.006 825.187,-478.237 848,-497 920.691,-556.785 1032.18,-579.907 1092.58,-588.403"/>
+<polygon fill="black" stroke="black" points="1092.15,-591.877 1102.53,-589.734 1093.08,-584.939 1092.15,-591.877"/>
+<text text-anchor="middle" x="946" y="-583.4" font-family="Times Roman,serif" font-size="14.00">Elapsed ping interval</text>
 </g>
 <!-- broadcast -->
-<g id="node11" class="node"><title>broadcast</title>
-<ellipse fill="none" stroke="black" cx="1063" cy="-200" rx="58.1882" ry="58.6899"/>
-<text text-anchor="middle" x="1063" y="-196.4" font-family="Times Roman,serif" font-size="14.00">broadcast</text>
+<g id="node12" class="node"><title>broadcast</title>
+<ellipse fill="none" stroke="black" cx="1135" cy="-281" rx="58.1882" ry="58.6899"/>
+<text text-anchor="middle" x="1135" y="-277.4" font-family="Times Roman,serif" font-size="14.00">broadcast</text>
 </g>
 <!-- loop&#45;&gt;broadcast -->
 <g id="edge10" class="edge"><title>loop&#45;&gt;broadcast</title>
-<path fill="none" stroke="black" d="M766.046,-274.934C773.498,-270.155 781.824,-265.421 790,-262 856.828,-234.035 938.382,-217.617 994.86,-208.779"/>
-<polygon fill="black" stroke="black" points="995.396,-212.238 1004.75,-207.269 994.34,-205.318 995.396,-212.238"/>
-<text text-anchor="middle" x="881" y="-267.4" font-family="Times Roman,serif" font-size="14.00">Receive broadcast request</text>
+<path fill="none" stroke="black" d="M811.332,-370.953C821.492,-360.892 834.388,-349.946 848,-343 917.32,-307.628 1006.03,-292.395 1066.35,-285.86"/>
+<polygon fill="black" stroke="black" points="1066.94,-289.319 1076.53,-284.811 1066.22,-282.355 1066.94,-289.319"/>
+<text text-anchor="middle" x="946" y="-348.4" font-family="Times Roman,serif" font-size="14.00">Receive broadcast request</text>
+</g>
+<!-- conn_broken -->
+<g id="node26" class="node"><title>conn_broken</title>
+<ellipse fill="none" stroke="black" cx="1361" cy="-99" rx="73.0388" ry="73.5391"/>
+<text text-anchor="middle" x="1361" y="-95.4" font-family="Times Roman,serif" font-size="14.00">conn_broken</text>
+</g>
+<!-- loop&#45;&gt;conn_broken -->
+<g id="edge28" class="edge"><title>loop&#45;&gt;conn_broken</title>
+<path fill="none" stroke="black" d="M793.216,-363.054C799.833,-304.219 817.014,-182.243 848,-155 967.196,-50.2026 1167.08,-63.6291 1278.91,-81.8408"/>
+<polygon fill="black" stroke="black" points="1278.34,-85.2954 1288.79,-83.4998 1279.5,-78.392 1278.34,-85.2954"/>
+<text text-anchor="middle" x="946" y="-160.4" font-family="Times Roman,serif" font-size="14.00">Receive connbroken request</text>
+</g>
+<!-- conn_warn -->
+<g id="node28" class="node"><title>conn_warn</title>
+<ellipse fill="none" stroke="black" cx="1135" cy="-477" rx="65.7609" ry="65.7609"/>
+<text text-anchor="middle" x="1135" y="-473.4" font-family="Times Roman,serif" font-size="14.00">conn_warn</text>
+</g>
+<!-- loop&#45;&gt;conn_warn -->
+<g id="edge30" class="edge"><title>loop&#45;&gt;conn_warn</title>
+<path fill="none" stroke="black" d="M814.092,-416.512C823.957,-424.185 835.89,-432.126 848,-437 915.942,-464.343 999.421,-473.523 1058.8,-476.355"/>
+<polygon fill="black" stroke="black" points="1058.71,-479.855 1068.85,-476.786 1059.01,-472.861 1058.71,-479.855"/>
+<text text-anchor="middle" x="946" y="-480.4" font-family="Times Roman,serif" font-size="14.00">Receive connwarn request</text>
 </g>
 <!-- pong_wait -->
-<g id="node13" class="node"><title>pong_wait</title>
-<ellipse fill="none" stroke="black" cx="1526" cy="-406" rx="62.9325" ry="62.9325"/>
-<text text-anchor="middle" x="1526" y="-402.4" font-family="Times Roman,serif" font-size="14.00">pong_wait</text>
+<g id="node14" class="node"><title>pong_wait</title>
+<ellipse fill="none" stroke="black" cx="537" cy="-653" rx="62.9325" ry="62.9325"/>
+<text text-anchor="middle" x="537" y="-649.4" font-family="Times Roman,serif" font-size="14.00">pong_wait</text>
 </g>
 <!-- ping&#45;&gt;pong_wait -->
 <g id="edge12" class="edge"><title>ping&#45;&gt;pong_wait</title>
-<path fill="none" stroke="black" d="M1095.56,-415.297C1169.19,-413.707 1350.04,-409.8 1452.36,-407.591"/>
-<polygon fill="black" stroke="black" points="1452.69,-411.084 1462.61,-407.369 1452.54,-404.086 1452.69,-411.084"/>
-<text text-anchor="middle" x="1289" y="-418.4" font-family="Times Roman,serif" font-size="14.00">Write PING</text>
+<path fill="none" stroke="black" d="M1103.4,-600.831C1035.81,-617.134 871.913,-654.261 732,-667 681.542,-671.594 668.481,-671.33 618,-667 615.134,-666.754 612.217,-666.46 609.275,-666.127"/>
+<polygon fill="black" stroke="black" points="609.573,-662.637 599.214,-664.858 608.697,-669.582 609.573,-662.637"/>
+<text text-anchor="middle" x="790" y="-670.4" font-family="Times Roman,serif" font-size="14.00">Write PING</text>
 </g>
 <!-- ack_wait -->
-<g id="node15" class="node"><title>ack_wait</title>
-<ellipse fill="none" stroke="black" cx="1526" cy="-269" rx="55.1543" ry="55.1543"/>
-<text text-anchor="middle" x="1526" y="-265.4" font-family="Times Roman,serif" font-size="14.00">ack_wait</text>
+<g id="node16" class="node"><title>ack_wait</title>
+<ellipse fill="none" stroke="black" cx="1598" cy="-373" rx="55.1543" ry="55.1543"/>
+<text text-anchor="middle" x="1598" y="-369.4" font-family="Times Roman,serif" font-size="14.00">ack_wait</text>
 </g>
 <!-- broadcast&#45;&gt;ack_wait -->
 <g id="edge14" class="edge"><title>broadcast&#45;&gt;ack_wait</title>
-<path fill="none" stroke="black" d="M1121.17,-208.669C1207.93,-221.599 1370.7,-245.856 1461.17,-259.339"/>
-<polygon fill="black" stroke="black" points="1460.9,-262.837 1471.3,-260.849 1461.93,-255.913 1460.9,-262.837"/>
-<text text-anchor="middle" x="1289" y="-257.4" font-family="Times Roman,serif" font-size="14.00">Write BROADCAST [fits one wire msg]</text>
+<path fill="none" stroke="black" d="M1193.25,-288.88C1264.95,-299.067 1390.23,-318.45 1496,-343 1508.9,-345.993 1522.57,-349.664 1535.58,-353.397"/>
+<polygon fill="black" stroke="black" points="1534.79,-356.813 1545.37,-356.254 1536.75,-350.093 1534.79,-356.813"/>
+<text text-anchor="middle" x="1361" y="-348.4" font-family="Times Roman,serif" font-size="14.00">Write BROADCAST [fits one wire msg]</text>
 </g>
 <!-- split_broadcast -->
-<g id="node17" class="node"><title>split_broadcast</title>
-<ellipse fill="none" stroke="black" cx="1526" cy="-110" rx="84.1457" ry="84.1457"/>
-<text text-anchor="middle" x="1526" y="-106.4" font-family="Times Roman,serif" font-size="14.00">split_broadcast</text>
+<g id="node18" class="node"><title>split_broadcast</title>
+<ellipse fill="none" stroke="black" cx="1598" cy="-216" rx="84.1457" ry="84.1457"/>
+<text text-anchor="middle" x="1598" y="-212.4" font-family="Times Roman,serif" font-size="14.00">split_broadcast</text>
 </g>
 <!-- broadcast&#45;&gt;split_broadcast -->
 <g id="edge16" class="edge"><title>broadcast&#45;&gt;split_broadcast</title>
-<path fill="none" stroke="black" d="M1120.7,-188.783C1199.06,-173.553 1340.01,-146.154 1433.29,-128.021"/>
-<polygon fill="black" stroke="black" points="1434.15,-131.421 1443.29,-126.077 1432.81,-124.549 1434.15,-131.421"/>
-<text text-anchor="middle" x="1289" y="-185.4" font-family="Times Roman,serif" font-size="14.00">BROADCAST does not fit one wire msg</text>
+<path fill="none" stroke="black" d="M1193.17,-272.834C1271.44,-261.846 1411.56,-242.174 1504.66,-229.104"/>
+<polygon fill="black" stroke="black" points="1505.23,-232.558 1514.65,-227.702 1504.26,-225.626 1505.23,-232.558"/>
+<text text-anchor="middle" x="1361" y="-272.4" font-family="Times Roman,serif" font-size="14.00">BROADCAST does not fit one wire msg</text>
+</g>
+<!-- pong_wait&#45;&gt;stop -->
+<g id="edge40" class="edge"><title>pong_wait&#45;&gt;stop</title>
+<path fill="none" stroke="black" d="M600.164,-653C651.344,-653 725.322,-653 790,-653 790,-653 790,-653 1972,-653 2131.11,-653 2245.53,-463.168 2289.33,-376.844"/>
+<polygon fill="black" stroke="black" points="2292.5,-378.343 2293.84,-367.834 2286.24,-375.212 2292.5,-378.343"/>
+<text text-anchor="middle" x="1361" y="-658.4" font-family="Times Roman,serif" font-size="14.00">Elapsed exhange timeout</text>
 </g>
 <!-- pong_wait&#45;&gt;loop -->
 <g id="edge18" class="edge"><title>pong_wait&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M1463.29,-398.59C1336,-383.27 1038.34,-346.004 790,-304 787.177,-303.523 784.269,-303.006 781.343,-302.468"/>
-<polygon fill="black" stroke="black" points="781.898,-299.011 771.42,-300.582 780.59,-305.888 781.898,-299.011"/>
-<text text-anchor="middle" x="1063" y="-359.4" font-family="Times Roman,serif" font-size="14.00">Read PONG</text>
+<path fill="none" stroke="black" d="M581.359,-607.765C632.774,-555.333 716.085,-470.376 760.273,-425.314"/>
+<polygon fill="black" stroke="black" points="762.774,-427.763 767.277,-418.172 757.776,-422.862 762.774,-427.763"/>
+<text text-anchor="middle" x="675" y="-574.4" font-family="Times Roman,serif" font-size="14.00">Read PONG</text>
+</g>
+<!-- ack_wait&#45;&gt;stop -->
+<g id="edge36" class="edge"><title>ack_wait&#45;&gt;stop</title>
+<path fill="none" stroke="black" d="M1653.02,-372.757C1765.96,-371.776 2032.03,-366.986 2254,-344 2256.89,-343.701 2259.85,-343.348 2262.84,-342.959"/>
+<polygon fill="black" stroke="black" points="2263.58,-346.389 2272.99,-341.517 2262.59,-339.459 2263.58,-346.389"/>
+<text text-anchor="middle" x="1972" y="-373.4" font-family="Times Roman,serif" font-size="14.00">Elapsed exhange timeout</text>
 </g>
 <!-- ack_wait&#45;&gt;loop -->
 <g id="edge20" class="edge"><title>ack_wait&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M1470.96,-271.898C1455.75,-272.644 1439.24,-273.404 1424,-274 1181.02,-283.507 889.323,-290.597 782.144,-293.057"/>
-<polygon fill="black" stroke="black" points="781.977,-289.56 772.059,-293.288 782.136,-296.558 781.977,-289.56"/>
-<text text-anchor="middle" x="1063" y="-292.4" font-family="Times Roman,serif" font-size="14.00">Read ACK</text>
+<path fill="none" stroke="black" d="M1542.83,-374.081C1445.66,-375.995 1237.64,-380.146 1062,-384 966.886,-386.087 942.947,-382.989 848,-389 842.829,-389.327 837.406,-389.764 832.04,-390.252"/>
+<polygon fill="black" stroke="black" points="831.485,-386.79 821.871,-391.242 832.163,-393.757 831.485,-386.79"/>
+<text text-anchor="middle" x="1135" y="-389.4" font-family="Times Roman,serif" font-size="14.00">Read ACK</text>
 </g>
 <!-- split_broadcast&#45;&gt;loop -->
 <g id="edge26" class="edge"><title>split_broadcast&#45;&gt;loop</title>
-<path fill="none" stroke="black" d="M1442.56,-99.9981C1336.06,-89.6718 1146.8,-79.5577 990,-115 894.383,-136.612 862.41,-141.921 790,-208 775.817,-220.943 764.522,-238.865 756.283,-254.999"/>
-<polygon fill="black" stroke="black" points="753.014,-253.718 751.785,-264.241 759.308,-256.781 753.014,-253.718"/>
-<text text-anchor="middle" x="1063" y="-120.4" font-family="Times Roman,serif" font-size="14.00">All split msgs written</text>
+<path fill="none" stroke="black" d="M1515.33,-201.109C1409.22,-184.681 1219.98,-164.458 1062,-196 960.985,-216.168 924.079,-215.554 848,-285 827.351,-303.849 812.751,-331.776 803.364,-354.774"/>
+<polygon fill="black" stroke="black" points="800.027,-353.699 799.658,-364.287 806.549,-356.24 800.027,-353.699"/>
+<text text-anchor="middle" x="1135" y="-201.4" font-family="Times Roman,serif" font-size="14.00">All split msgs written</text>
 </g>
 <!-- split_ack_wait -->
-<g id="node21" class="node"><title>split_ack_wait</title>
-<ellipse fill="none" stroke="black" cx="1893" cy="-110" rx="80.1095" ry="80.6102"/>
-<text text-anchor="middle" x="1893" y="-106.4" font-family="Times Roman,serif" font-size="14.00">split_ack_wait</text>
+<g id="node22" class="node"><title>split_ack_wait</title>
+<ellipse fill="none" stroke="black" cx="1972" cy="-257" rx="80.1095" ry="80.6102"/>
+<text text-anchor="middle" x="1972" y="-253.4" font-family="Times Roman,serif" font-size="14.00">split_ack_wait</text>
 </g>
 <!-- split_broadcast&#45;&gt;split_ack_wait -->
 <g id="edge22" class="edge"><title>split_broadcast&#45;&gt;split_ack_wait</title>
-<path fill="none" stroke="black" d="M1610.2,-110C1667.61,-110 1743.59,-110 1802.33,-110"/>
-<polygon fill="black" stroke="black" points="1802.35,-113.5 1812.35,-110 1802.34,-106.5 1802.35,-113.5"/>
-<text text-anchor="middle" x="1711" y="-115.4" font-family="Times Roman,serif" font-size="14.00">Write split BROADCAST</text>
+<path fill="none" stroke="black" d="M1680.55,-232.126C1687.12,-233.18 1693.66,-234.156 1700,-235 1760.22,-243.022 1828.36,-248.528 1881.38,-252.025"/>
+<polygon fill="black" stroke="black" points="1881.23,-255.523 1891.43,-252.676 1881.68,-248.537 1881.23,-255.523"/>
+<text text-anchor="middle" x="1783" y="-256.4" font-family="Times Roman,serif" font-size="14.00">Write split BROADCAST</text>
+</g>
+<!-- split_ack_wait&#45;&gt;stop -->
+<g id="edge38" class="edge"><title>split_ack_wait&#45;&gt;stop</title>
+<path fill="none" stroke="black" d="M2050.59,-275.189C2116.55,-290.456 2208.51,-311.74 2263.08,-324.372"/>
+<polygon fill="black" stroke="black" points="2262.62,-327.857 2273.15,-326.702 2264.2,-321.037 2262.62,-327.857"/>
+<text text-anchor="middle" x="2166" y="-327.4" font-family="Times Roman,serif" font-size="14.00">Elapsed exhange timeout</text>
 </g>
 <!-- split_ack_wait&#45;&gt;split_broadcast -->
 <g id="edge24" class="edge"><title>split_ack_wait&#45;&gt;split_broadcast</title>
-<path fill="none" stroke="black" d="M1814.64,-90.9448C1807.69,-89.7544 1800.74,-88.7397 1794,-88 1720.66,-79.9496 1701.36,-80.1783 1628,-88 1624.71,-88.3505 1621.38,-88.7628 1618.01,-89.2264"/>
-<polygon fill="black" stroke="black" points="1617.23,-85.8043 1607.87,-90.7602 1618.28,-92.7256 1617.23,-85.8043"/>
-<text text-anchor="middle" x="1711" y="-93.4" font-family="Times Roman,serif" font-size="14.00">Read ACK</text>
+<path fill="none" stroke="black" d="M1899.33,-222.493C1888.37,-218.573 1877.04,-215.2 1866,-213 1808.89,-201.617 1743.56,-202.081 1691.71,-205.529"/>
+<polygon fill="black" stroke="black" points="1691.25,-202.053 1681.52,-206.256 1691.74,-209.035 1691.25,-202.053"/>
+<text text-anchor="middle" x="1783" y="-218.4" font-family="Times Roman,serif" font-size="14.00">Read ACK</text>
+</g>
+<!-- conn_broken&#45;&gt;stop -->
+<g id="edge32" class="edge"><title>conn_broken&#45;&gt;stop</title>
+<path fill="none" stroke="black" d="M1434.61,-95.8477C1564.45,-92.5456 1841.16,-95.6985 2060,-168 2154.32,-199.163 2175.34,-218.326 2254,-279 2262.17,-285.305 2270.33,-292.782 2277.75,-300.185"/>
+<polygon fill="black" stroke="black" points="2275.42,-302.808 2284.91,-307.517 2280.43,-297.917 2275.42,-302.808"/>
+<text text-anchor="middle" x="1783" y="-127.4" font-family="Times Roman,serif" font-size="14.00">Write CONNBROKEN</text>
+</g>
+<!-- conn_warn&#45;&gt;loop -->
+<g id="edge34" class="edge"><title>conn_warn&#45;&gt;loop</title>
+<path fill="none" stroke="black" d="M1083.63,-435.301C1071.29,-427.246 1057.71,-419.822 1044,-415 972.758,-389.933 883.562,-389.406 832.05,-391.836"/>
+<polygon fill="black" stroke="black" points="831.758,-388.346 821.959,-392.373 832.131,-395.337 831.758,-388.346"/>
+<text text-anchor="middle" x="946" y="-420.4" font-family="Times Roman,serif" font-size="14.00">Write CONNWARN</text>
 </g>
 </g>
 </svg>
 
=== modified file 'server/acceptance/acceptanceclient.go'
--- server/acceptance/acceptanceclient.go	2014-04-09 19:30:53 +0000
+++ server/acceptance/acceptanceclient.go	2014-04-29 18:02:00 +0000
@@ -44,6 +44,7 @@
 	Levels          map[string]int64
 	Insecure        bool   // don't verify certs
 	Prefix          string // prefix for events
+	Auth            string
 	// connection
 	Connection net.Conn
 }
@@ -73,6 +74,7 @@
 	Type string `json:"T"`
 	protocol.BroadcastMsg
 	protocol.NotificationsMsg
+	protocol.ConnWarnMsg
 }
 
 // Run the session with the server, emits a stream of events.
@@ -93,6 +95,7 @@
 			"device":  sess.Model,
 			"channel": sess.ImageChannel,
 		},
+		Authorization: sess.Auth,
 	})
 	if err != nil {
 		return err
@@ -136,6 +139,8 @@
 				return err
 			}
 			events <- fmt.Sprintf("%sbroadcast chan:%v app:%v topLevel:%d payloads:%s", sess.Prefix, recv.ChanId, recv.AppId, recv.TopLevel, pack)
+		case "warn":
+			events <- fmt.Sprintf("%swarn %s", sess.Prefix, recv.Reason)
 		}
 	}
 	return nil
 
=== modified file 'server/acceptance/cmd/acceptanceclient.go'
--- server/acceptance/cmd/acceptanceclient.go	2014-04-10 13:52:31 +0000
+++ server/acceptance/cmd/acceptanceclient.go	2014-04-29 18:02:00 +0000
@@ -48,13 +48,18 @@
 		fmt.Fprintf(os.Stderr, "Usage: acceptancclient [options] <config.json> <device id>\n")
 		flag.PrintDefaults()
 	}
+	missingArg := func(what string) {
+		fmt.Fprintf(os.Stderr, "missing %s\n", what)
+		flag.Usage()
+		os.Exit(2)
+	}
 	flag.Parse()
 	narg := flag.NArg()
 	switch {
 	case narg < 1:
-		log.Fatal("missing config file")
+		missingArg("config file")
 	case narg < 2:
-		log.Fatal("missing device-id")
+		missingArg("device-id")
 	}
 	configFName := flag.Arg(0)
 	f, err := os.Open(configFName)
 
=== modified file 'server/acceptance/suites/broadcast.go'
--- server/acceptance/suites/broadcast.go	2014-04-07 19:39:19 +0000
+++ server/acceptance/suites/broadcast.go	2014-04-29 18:02:00 +0000
@@ -265,7 +265,11 @@
 
 func (s *BroadcastAcceptanceSuite) TestGetHosts(c *C) {
 	gh := gethosts.New("", s.ServerAPIURL+"/delivery-hosts", 2*time.Second)
-	hosts, err := gh.Get()
+	host, err := gh.Get()
 	c.Assert(err, IsNil)
-	c.Check(hosts, DeepEquals, []string{s.ServerAddr})
+	expected := &gethosts.Host{
+		Domain: "localhost",
+		Hosts:  []string{s.ServerAddr},
+	}
+	c.Check(host, DeepEquals, expected)
 }
 
=== modified file 'server/acceptance/suites/suite.go'
--- server/acceptance/suites/suite.go	2014-04-03 16:47:47 +0000
+++ server/acceptance/suites/suite.go	2014-04-29 18:02:00 +0000
@@ -44,10 +44,19 @@
 
 // Start a client.
 func (h *ServerHandle) StartClient(c *C, devId string, levels map[string]int64) (events <-chan string, errorCh <-chan error, stop func()) {
+	return h.StartClientAuth(c, devId, levels, "")
+}
+
+// Start a client with auth.
+func (h *ServerHandle) StartClientAuth(c *C, devId string, levels map[string]int64, auth string) (events <-chan string, errorCh <-chan error, stop func()) {
 	errCh := make(chan error, 1)
 	cliEvents := make(chan string, 10)
 	sess := testClientSession(h.ServerAddr, devId, "m1", "img1", false)
 	sess.Levels = levels
+	sess.Auth = auth
+	if auth != "" {
+		sess.ExchangeTimeout = 5 * time.Second
+	}
 	err := sess.Dial()
 	c.Assert(err, IsNil)
 	clientShutdown := make(chan bool, 1) // abused as an atomic flag
 
=== modified file 'server/api/handlers_test.go'
--- server/api/handlers_test.go	2014-02-21 11:32:38 +0000
+++ server/api/handlers_test.go	2014-04-29 18:02:00 +0000
@@ -30,6 +30,7 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/server/store"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
@@ -142,11 +143,11 @@
 }
 
 func (cbsend *checkBrokerSending) Broadcast(chanId store.InternalChannelId) {
-	top, payloads, err := cbsend.store.GetChannelSnapshot(chanId)
+	top, notifications, err := cbsend.store.GetChannelSnapshot(chanId)
 	cbsend.err = err
 	cbsend.chanId = chanId
 	cbsend.top = top
-	cbsend.payloads = payloads
+	cbsend.payloads = protocol.ExtractPayloads(notifications)
 }
 
 func (s *handlersSuite) TestDoBroadcast(c *C) {
 
=== modified file 'server/broker/broker.go'
--- server/broker/broker.go	2014-04-04 09:58:34 +0000
+++ server/broker/broker.go	2014-04-29 18:02:00 +0000
@@ -30,7 +30,7 @@
 // through them.
 type Broker interface {
 	// Register the session.
-	Register(*protocol.ConnectMsg) (BrokerSession, error)
+	Register(connMsg *protocol.ConnectMsg, sessionId string) (BrokerSession, error)
 	// Unregister the session.
 	Unregister(BrokerSession)
 }
 
=== modified file 'server/broker/exchanges.go'
--- server/broker/exchanges.go	2014-04-04 13:19:10 +0000
+++ server/broker/exchanges.go	2014-04-29 18:02:00 +0000
@@ -28,18 +28,17 @@
 
 // Scratch area for exchanges, sessions should hold one of these.
 type ExchangesScratchArea struct {
-	broadcastMsg  protocol.BroadcastMsg
-	ackMsg        protocol.AckMsg
-	connBrokenMsg protocol.ConnBrokenMsg
+	broadcastMsg protocol.BroadcastMsg
+	ackMsg       protocol.AckMsg
 }
 
 // BroadcastExchange leads a session through delivering a BROADCAST.
 // For simplicity it is fully public.
 type BroadcastExchange struct {
-	ChanId               store.InternalChannelId
-	TopLevel             int64
-	NotificationPayloads []json.RawMessage
-	Decoded              []map[string]interface{}
+	ChanId        store.InternalChannelId
+	TopLevel      int64
+	Notifications []protocol.Notification
+	Decoded       []map[string]interface{}
 }
 
 // check interface already here
@@ -47,18 +46,18 @@
 
 // Init ensures the BroadcastExchange is fully initialized for the sessions.
 func (sbe *BroadcastExchange) Init() {
-	decoded := make([]map[string]interface{}, len(sbe.NotificationPayloads))
+	decoded := make([]map[string]interface{}, len(sbe.Notifications))
 	sbe.Decoded = decoded
-	for i, p := range sbe.NotificationPayloads {
-		err := json.Unmarshal(p, &decoded[i])
+	for i, notif := range sbe.Notifications {
+		err := json.Unmarshal(notif.Payload, &decoded[i])
 		if err != nil {
 			decoded[i] = nil
 		}
 	}
 }
 
-func filterByLevel(clientLevel, topLevel int64, payloads []json.RawMessage) []json.RawMessage {
-	c := int64(len(payloads))
+func filterByLevel(clientLevel, topLevel int64, notifs []protocol.Notification) []protocol.Notification {
+	c := int64(len(notifs))
 	if c == 0 {
 		return nil
 	}
@@ -67,32 +66,32 @@
 		delta = 1
 	}
 	if delta < c {
-		return payloads[c-delta:]
+		return notifs[c-delta:]
 	} else {
-		return payloads
+		return notifs
 	}
 }
 
-func channelFilter(tag string, chanId store.InternalChannelId, payloads []json.RawMessage, decoded []map[string]interface{}) []json.RawMessage {
-	if len(payloads) != 0 && chanId == store.SystemInternalChannelId {
-		decoded := decoded[len(decoded)-len(payloads):]
+func channelFilter(tag string, chanId store.InternalChannelId, notifs []protocol.Notification, decoded []map[string]interface{}) []json.RawMessage {
+	if len(notifs) != 0 && chanId == store.SystemInternalChannelId {
+		decoded := decoded[len(decoded)-len(notifs):]
 		filtered := make([]json.RawMessage, 0)
 		for i, decoded1 := range decoded {
 			if _, ok := decoded1[tag]; ok {
-				filtered = append(filtered, payloads[i])
+				filtered = append(filtered, notifs[i].Payload)
 			}
 		}
-		payloads = filtered
+		return filtered
 	}
-	return payloads
+	return protocol.ExtractPayloads(notifs)
 }
 
 // Prepare session for a BROADCAST.
 func (sbe *BroadcastExchange) Prepare(sess BrokerSession) (outMessage protocol.SplittableMsg, inMessage interface{}, err error) {
 	clientLevel := sess.Levels()[sbe.ChanId]
-	payloads := filterByLevel(clientLevel, sbe.TopLevel, sbe.NotificationPayloads)
+	notifs := filterByLevel(clientLevel, sbe.TopLevel, sbe.Notifications)
 	tag := fmt.Sprintf("%s/%s", sess.DeviceImageChannel(), sess.DeviceImageModel())
-	payloads = channelFilter(tag, sbe.ChanId, payloads, sbe.Decoded)
+	payloads := channelFilter(tag, sbe.ChanId, notifs, sbe.Decoded)
 	if len(payloads) == 0 && sbe.TopLevel >= clientLevel {
 		// empty and don't need to force resync => do nothing
 		return nil, nil, ErrNop
@@ -119,23 +118,20 @@
 	return nil
 }
 
-// ConnBrokenExchange breaks a session giving a reason.
-type ConnBrokenExchange struct {
-	Reason string
+// ConnMetaExchange allows to send a CONNBROKEN or CONNWARN message.
+type ConnMetaExchange struct {
+	Msg protocol.OnewayMsg
 }
 
 // check interface already here
-var _ Exchange = (*ConnBrokenExchange)(nil)
+var _ Exchange = (*ConnMetaExchange)(nil)
 
-// Prepare session for a CONNBROKEN.
-func (cbe *ConnBrokenExchange) Prepare(sess BrokerSession) (outMessage protocol.SplittableMsg, inMessage interface{}, err error) {
-	scratchArea := sess.ExchangeScratchArea()
-	scratchArea.connBrokenMsg.Type = "connbroken"
-	scratchArea.connBrokenMsg.Reason = cbe.Reason
-	return &scratchArea.connBrokenMsg, nil, nil
+// Prepare session for a CONNBROKEN/WARN.
+func (cbe *ConnMetaExchange) Prepare(sess BrokerSession) (outMessage protocol.SplittableMsg, inMessage interface{}, err error) {
+	return cbe.Msg, nil, nil
 }
 
-// CONNBROKEN isn't acked
-func (cbe *ConnBrokenExchange) Acked(sess BrokerSession, done bool) error {
-	panic("Acked should not get invoked on ConnBrokenExchange")
+// CONNBROKEN/WARN aren't acked.
+func (cbe *ConnMetaExchange) Acked(sess BrokerSession, done bool) error {
+	panic("Acked should not get invoked on ConnMetaExchange")
 }
 
=== modified file 'server/broker/exchanges_test.go'
--- server/broker/exchanges_test.go	2014-04-04 13:19:10 +0000
+++ server/broker/exchanges_test.go	2014-04-29 18:02:00 +0000
@@ -24,9 +24,11 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/protocol"
 	"launchpad.net/ubuntu-push/server/broker"
 	"launchpad.net/ubuntu-push/server/broker/testing"
 	"launchpad.net/ubuntu-push/server/store"
+	help "launchpad.net/ubuntu-push/testing"
 )
 
 func TestBroker(t *stdtesting.T) { TestingT(t) }
@@ -39,11 +41,11 @@
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
-		NotificationPayloads: []json.RawMessage{
+		Notifications: help.Ns(
 			json.RawMessage(`{"a":"x"}`),
 			json.RawMessage(`[]`),
 			json.RawMessage(`{"a":"y"}`),
-		},
+		),
 	}
 	exchg.Init()
 	c.Check(exchg.Decoded, DeepEquals, []map[string]interface{}{
@@ -62,10 +64,10 @@
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
-		NotificationPayloads: []json.RawMessage{
+		Notifications: help.Ns(
 			json.RawMessage(`{"img1/m1":100}`),
 			json.RawMessage(`{"img2/m2":200}`),
-		},
+		),
 	}
 	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
@@ -88,9 +90,9 @@
 		ImageChannel: "img1",
 	}
 	exchg := &broker.BroadcastExchange{
-		ChanId:               store.SystemInternalChannelId,
-		TopLevel:             3,
-		NotificationPayloads: []json.RawMessage{},
+		ChanId:        store.SystemInternalChannelId,
+		TopLevel:      3,
+		Notifications: []protocol.Notification{},
 	}
 	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
@@ -108,9 +110,9 @@
 		ImageChannel: "img1",
 	}
 	exchg := &broker.BroadcastExchange{
-		ChanId:               store.SystemInternalChannelId,
-		TopLevel:             3,
-		NotificationPayloads: []json.RawMessage{},
+		ChanId:        store.SystemInternalChannelId,
+		TopLevel:      3,
+		Notifications: []protocol.Notification{},
 	}
 	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
@@ -133,9 +135,9 @@
 
 	topLevel := int64(len(needsSplitting))
 	exchg := &broker.BroadcastExchange{
-		ChanId:               store.SystemInternalChannelId,
-		TopLevel:             topLevel,
-		NotificationPayloads: needsSplitting,
+		ChanId:        store.SystemInternalChannelId,
+		TopLevel:      topLevel,
+		Notifications: help.Ns(needsSplitting...),
 	}
 	exchg.Init()
 	outMsg, _, err := exchg.Prepare(sess)
@@ -152,10 +154,10 @@
 	exchg = &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: topLevel + 2,
-		NotificationPayloads: []json.RawMessage{
+		Notifications: help.Ns(
 			json.RawMessage(`{"img1/m1":"x"}`),
 			json.RawMessage(`{"img1/m1":"y"}`),
-		},
+		),
 	}
 	exchg.Init()
 	outMsg, _, err = exchg.Prepare(sess)
@@ -173,9 +175,9 @@
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
-		NotificationPayloads: []json.RawMessage{
+		Notifications: help.Ns(
 			json.RawMessage(`{"img2/m1":1}`),
-		},
+		),
 	}
 	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
@@ -202,10 +204,10 @@
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 3,
-		NotificationPayloads: []json.RawMessage{
+		Notifications: help.Ns(
 			json.RawMessage(`{"img1/m1":100}`),
 			json.RawMessage(`{"img1/m1":101}`),
-		},
+		),
 	}
 	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
@@ -229,11 +231,11 @@
 	exchg := &broker.BroadcastExchange{
 		ChanId:   store.SystemInternalChannelId,
 		TopLevel: 5,
-		NotificationPayloads: []json.RawMessage{
+		Notifications: help.Ns(
 			json.RawMessage(`{"img1/m1":100}`),
 			json.RawMessage(`{"img2/m2":200}`),
 			json.RawMessage(`{"img1/m1":101}`),
-		},
+		),
 	}
 	exchg.Init()
 	outMsg, inMsg, err := exchg.Prepare(sess)
@@ -249,16 +251,18 @@
 	c.Check(sess.LevelsMap[store.SystemInternalChannelId], Equals, int64(5))
 }
 
-func (s *exchangesSuite) TestConnBrokenExchange(c *C) {
+func (s *exchangesSuite) TestConnMetaExchange(c *C) {
 	sess := &testing.TestBrokerSession{}
-	cbe := &broker.ConnBrokenExchange{"REASON"}
+	var msg protocol.OnewayMsg = &protocol.ConnWarnMsg{"connwarn", "REASON"}
+	cbe := &broker.ConnMetaExchange{msg}
 	outMsg, inMsg, err := cbe.Prepare(sess)
 	c.Assert(err, IsNil)
+	c.Check(msg, Equals, outMsg)
 	c.Check(inMsg, IsNil) // no answer is expected
 	// check
 	marshalled, err := json.Marshal(outMsg)
 	c.Assert(err, IsNil)
-	c.Check(string(marshalled), Equals, `{"T":"connbroken","Reason":"REASON"}`)
+	c.Check(string(marshalled), Equals, `{"T":"connwarn","Reason":"REASON"}`)
 
-	c.Check(func() { cbe.Acked(nil, true) }, PanicMatches, "Acked should not get invoked on ConnBrokenExchange")
+	c.Check(func() { cbe.Acked(nil, true) }, PanicMatches, "Acked should not get invoked on ConnMetaExchange")
 }
 
=== modified file 'server/broker/exchg_impl_test.go'
--- server/broker/exchg_impl_test.go	2014-04-03 16:00:53 +0000
+++ server/broker/exchg_impl_test.go	2014-04-29 18:02:00 +0000
@@ -22,6 +22,7 @@
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/server/store"
+	help "launchpad.net/ubuntu-push/testing"
 )
 
 type exchangesImplSuite struct{}
@@ -29,27 +30,27 @@
 var _ = Suite(&exchangesImplSuite{})
 
 func (s *exchangesImplSuite) TestFilterByLevel(c *C) {
-	payloads := []json.RawMessage{
+	notifs := help.Ns(
 		json.RawMessage(`{"a": 3}`),
 		json.RawMessage(`{"a": 4}`),
 		json.RawMessage(`{"a": 5}`),
-	}
-	res := filterByLevel(5, 5, payloads)
+	)
+	res := filterByLevel(5, 5, notifs)
 	c.Check(len(res), Equals, 0)
-	res = filterByLevel(4, 5, payloads)
+	res = filterByLevel(4, 5, notifs)
 	c.Check(len(res), Equals, 1)
-	c.Check(res[0], DeepEquals, json.RawMessage(`{"a": 5}`))
-	res = filterByLevel(3, 5, payloads)
+	c.Check(res[0].Payload, DeepEquals, json.RawMessage(`{"a": 5}`))
+	res = filterByLevel(3, 5, notifs)
 	c.Check(len(res), Equals, 2)
-	c.Check(res[0], DeepEquals, json.RawMessage(`{"a": 4}`))
-	res = filterByLevel(2, 5, payloads)
+	c.Check(res[0].Payload, DeepEquals, json.RawMessage(`{"a": 4}`))
+	res = filterByLevel(2, 5, notifs)
 	c.Check(len(res), Equals, 3)
-	res = filterByLevel(1, 5, payloads)
+	res = filterByLevel(1, 5, notifs)
 	c.Check(len(res), Equals, 3)
 	// too ahead, pick only last
-	res = filterByLevel(10, 5, payloads)
+	res = filterByLevel(10, 5, notifs)
 	c.Check(len(res), Equals, 1)
-	c.Check(res[0], DeepEquals, json.RawMessage(`{"a": 5}`))
+	c.Check(res[0].Payload, DeepEquals, json.RawMessage(`{"a": 5}`))
 }
 
 func (s *exchangesImplSuite) TestFilterByLevelEmpty(c *C) {
@@ -71,18 +72,19 @@
 		err := json.Unmarshal(p, &decoded[i])
 		c.Assert(err, IsNil)
 	}
+	notifs := help.Ns(payloads...)
 
 	other := store.InternalChannelId("1")
 
 	c.Check(channelFilter("", store.SystemInternalChannelId, nil, nil), IsNil)
-	c.Check(channelFilter("", other, payloads[1:], decoded), DeepEquals, payloads[1:])
+	c.Check(channelFilter("", other, notifs[1:], decoded), DeepEquals, payloads[1:])
 
 	// use tag when channel is the sytem channel
 
-	c.Check(channelFilter("c/z", store.SystemInternalChannelId, payloads, decoded), HasLen, 0)
-
-	c.Check(channelFilter("a/x", store.SystemInternalChannelId, payloads, decoded), DeepEquals, []json.RawMessage{payloads[0], payloads[3]})
-
-	c.Check(channelFilter("a/x", store.SystemInternalChannelId, payloads[1:], decoded), DeepEquals, []json.RawMessage{payloads[3]})
+	c.Check(channelFilter("c/z", store.SystemInternalChannelId, notifs, decoded), HasLen, 0)
+
+	c.Check(channelFilter("a/x", store.SystemInternalChannelId, notifs, decoded), DeepEquals, []json.RawMessage{payloads[0], payloads[3]})
+
+	c.Check(channelFilter("a/x", store.SystemInternalChannelId, notifs[1:], decoded), DeepEquals, []json.RawMessage{payloads[3]})
 
 }
 
=== modified file 'server/broker/simple/simple.go'
--- server/broker/simple/simple.go	2014-04-11 08:47:18 +0000
+++ server/broker/simple/simple.go	2014-04-29 18:02:00 +0000
@@ -144,7 +144,7 @@
 	// find relevant channels, for now only system
 	channels := []store.InternalChannelId{store.SystemInternalChannelId}
 	for _, chanId := range channels {
-		topLevel, payloads, err := b.sto.GetChannelSnapshot(chanId)
+		topLevel, notifications, err := b.sto.GetChannelSnapshot(chanId)
 		if err != nil {
 			// next broadcast will try again
 			b.logger.Errorf("unsuccessful feed pending, get channel snapshot for %v: %v", chanId, err)
@@ -153,9 +153,9 @@
 		clientLevel := sess.levels[chanId]
 		if clientLevel != topLevel {
 			broadcastExchg := &broker.BroadcastExchange{
-				ChanId:               chanId,
-				TopLevel:             topLevel,
-				NotificationPayloads: payloads,
+				ChanId:        chanId,
+				TopLevel:      topLevel,
+				Notifications: notifications,
 			}
 			broadcastExchg.Init()
 			sess.exchanges <- broadcastExchg
@@ -166,7 +166,7 @@
 
 // Register registers a session with the broker. It feeds the session
 // pending notifications as well.
-func (b *SimpleBroker) Register(connect *protocol.ConnectMsg) (broker.BrokerSession, error) {
+func (b *SimpleBroker) Register(connect *protocol.ConnectMsg, sessionId string) (broker.BrokerSession, error) {
 	// xxx sanity check DeviceId
 	model, err := broker.GetInfoString(connect, "device", "?")
 	if err != nil {
@@ -224,7 +224,7 @@
 			} else { // register
 				prev := b.registry[sess.deviceId]
 				if prev != nil { // kick it
-					close(prev.exchanges)
+					prev.exchanges <- nil
 				}
 				b.registry[sess.deviceId] = sess
 				sess.registered = true
@@ -233,16 +233,16 @@
 		case delivery := <-b.deliveryCh:
 			switch delivery.kind {
 			case broadcastDelivery:
-				topLevel, payloads, err := b.sto.GetChannelSnapshot(delivery.chanId)
+				topLevel, notifications, err := b.sto.GetChannelSnapshot(delivery.chanId)
 				if err != nil {
 					// next broadcast will try again
 					b.logger.Errorf("unsuccessful broadcast, get channel snapshot for %v: %v", delivery.chanId, err)
 					continue Loop
 				}
 				broadcastExchg := &broker.BroadcastExchange{
-					ChanId:               delivery.chanId,
-					TopLevel:             topLevel,
-					NotificationPayloads: payloads,
+					ChanId:        delivery.chanId,
+					TopLevel:      topLevel,
+					Notifications: notifications,
 				}
 				broadcastExchg.Init()
 				for _, sess := range b.registry {
 
=== modified file 'server/broker/simple/simple_test.go'
--- server/broker/simple/simple_test.go	2014-04-03 16:00:53 +0000
+++ server/broker/simple/simple_test.go	2014-04-29 18:02:00 +0000
@@ -26,6 +26,7 @@
 	"launchpad.net/ubuntu-push/server/broker"
 	"launchpad.net/ubuntu-push/server/broker/testing"
 	"launchpad.net/ubuntu-push/server/store"
+	help "launchpad.net/ubuntu-push/testing"
 )
 
 func TestSimple(t *stdtesting.T) { TestingT(t) }
@@ -58,10 +59,10 @@
 	c.Assert(len(sess.exchanges), Equals, 1)
 	exchg1 := <-sess.exchanges
 	c.Check(exchg1, DeepEquals, &broker.BroadcastExchange{
-		ChanId:               store.SystemInternalChannelId,
-		TopLevel:             1,
-		NotificationPayloads: []json.RawMessage{notification1},
-		Decoded:              []map[string]interface{}{decoded1},
+		ChanId:        store.SystemInternalChannelId,
+		TopLevel:      1,
+		Notifications: help.Ns(notification1),
+		Decoded:       []map[string]interface{}{decoded1},
 	})
 }
 
 
=== modified file 'server/broker/testsuite/suite.go'
--- server/broker/testsuite/suite.go	2014-04-11 08:47:18 +0000
+++ server/broker/testsuite/suite.go	2014-04-29 18:02:00 +0000
@@ -30,7 +30,7 @@
 	"launchpad.net/ubuntu-push/server/broker"
 	"launchpad.net/ubuntu-push/server/broker/testing"
 	"launchpad.net/ubuntu-push/server/store"
-	helpers "launchpad.net/ubuntu-push/testing"
+	help "launchpad.net/ubuntu-push/testing"
 )
 
 // The expected interface for tested brokers.
@@ -51,11 +51,11 @@
 	// Let us get to a broker.BroadcastExchange from an Exchange.
 	RevealBroadcastExchange func(broker.Exchange) *broker.BroadcastExchange
 	// private
-	testlog *helpers.TestLogger
+	testlog *help.TestLogger
 }
 
 func (s *CommonBrokerSuite) SetUpTest(c *C) {
-	s.testlog = helpers.NewTestLogger(c, "error")
+	s.testlog = help.NewTestLogger(c, "error")
 }
 
 var testBrokerConfig = &testing.TestBrokerConfig{10, 5}
@@ -89,7 +89,7 @@
 			"device":  "model",
 			"channel": "daily",
 		},
-	})
+	}, "s1")
 	c.Assert(err, IsNil)
 	c.Assert(s.RevealSession(b, "dev-1"), Equals, sess)
 	c.Assert(sess.DeviceIdentifier(), Equals, "dev-1")
@@ -101,7 +101,7 @@
 	}))
 	b.Unregister(sess)
 	// just to make sure the unregister was processed
-	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: ""})
+	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: ""}, "s2")
 	c.Assert(err, IsNil)
 	c.Check(s.RevealSession(b, "dev-1"), IsNil)
 }
@@ -111,7 +111,7 @@
 	b := s.MakeBroker(sto, testBrokerConfig, nil)
 	b.Start()
 	defer b.Stop()
-	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1", Levels: map[string]int64{"z": 5}})
+	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1", Levels: map[string]int64{"z": 5}}, "s1")
 	c.Check(err, FitsTypeOf, &broker.ErrAbort{})
 }
 
@@ -123,11 +123,11 @@
 	info := map[string]interface{}{
 		"device": -1,
 	}
-	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", Info: info})
+	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", Info: info}, "s1")
 	c.Check(err, Equals, broker.ErrUnexpectedValue)
 	info["device"] = "m"
 	info["channel"] = -1
-	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", Info: info})
+	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", Info: info}, "s2")
 	c.Check(err, Equals, broker.ErrUnexpectedValue)
 }
 
@@ -139,7 +139,7 @@
 	b := s.MakeBroker(sto, testBrokerConfig, nil)
 	b.Start()
 	defer b.Stop()
-	sess, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"})
+	sess, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"}, "s1")
 	c.Assert(err, IsNil)
 	c.Check(len(sess.SessionChannel()), Equals, 1)
 }
@@ -149,7 +149,7 @@
 	b := s.MakeBroker(sto, testBrokerConfig, s.testlog)
 	b.Start()
 	defer b.Stop()
-	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"})
+	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"}, "s1")
 	c.Assert(err, IsNil)
 	// but
 	c.Check(s.testlog.Captured(), Matches, "ERROR unsuccessful feed pending, get channel snapshot for 0: get channel snapshot fail\n")
@@ -160,22 +160,25 @@
 	b := s.MakeBroker(sto, testBrokerConfig, nil)
 	b.Start()
 	defer b.Stop()
-	sess1, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"})
-	c.Assert(err, IsNil)
-	sess2, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"})
-	c.Assert(err, IsNil)
-	checkAndFalse := false
-	// previous session got signaled by closing its channel
+	sess1, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"}, "s1")
+	c.Assert(err, IsNil)
+	sess2, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"}, "s2")
+	c.Assert(err, IsNil)
+	// previous session got signaled by sending nil on its channel
+	var sentinel broker.Exchange
+	got := false
 	select {
-	case _, ok := <-sess1.SessionChannel():
-		checkAndFalse = ok == false
-	default:
+	case sentinel = <-sess1.SessionChannel():
+		got = true
+	case <-time.After(5 * time.Second):
+		c.Fatal("taking too long to get sentinel")
 	}
-	c.Check(checkAndFalse, Equals, true)
+	c.Check(got, Equals, true)
+	c.Check(sentinel, IsNil)
 	c.Assert(s.RevealSession(b, "dev-1"), Equals, sess2)
 	b.Unregister(sess1)
 	// just to make sure the unregister was processed
-	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: ""})
+	_, err = b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: ""}, "s3")
 	c.Assert(err, IsNil)
 	c.Check(s.RevealSession(b, "dev-1"), Equals, sess2)
 }
@@ -187,9 +190,9 @@
 	b := s.MakeBroker(sto, testBrokerConfig, nil)
 	b.Start()
 	defer b.Stop()
-	sess1, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"})
+	sess1, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"}, "s1")
 	c.Assert(err, IsNil)
-	sess2, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-2"})
+	sess2, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-2"}, "s2")
 	c.Assert(err, IsNil)
 	// add notification to channel *after* the registrations
 	muchLater := time.Now().Add(10 * time.Minute)
@@ -200,10 +203,10 @@
 		c.Fatal("taking too long to get broadcast exchange")
 	case exchg1 := <-sess1.SessionChannel():
 		c.Check(s.RevealBroadcastExchange(exchg1), DeepEquals, &broker.BroadcastExchange{
-			ChanId:               store.SystemInternalChannelId,
-			TopLevel:             1,
-			NotificationPayloads: []json.RawMessage{notification1},
-			Decoded:              []map[string]interface{}{decoded1},
+			ChanId:        store.SystemInternalChannelId,
+			TopLevel:      1,
+			Notifications: help.Ns(notification1),
+			Decoded:       []map[string]interface{}{decoded1},
 		})
 	}
 	select {
@@ -211,10 +214,10 @@
 		c.Fatal("taking too long to get broadcast exchange")
 	case exchg2 := <-sess2.SessionChannel():
 		c.Check(s.RevealBroadcastExchange(exchg2), DeepEquals, &broker.BroadcastExchange{
-			ChanId:               store.SystemInternalChannelId,
-			TopLevel:             1,
-			NotificationPayloads: []json.RawMessage{notification1},
-			Decoded:              []map[string]interface{}{decoded1},
+			ChanId:        store.SystemInternalChannelId,
+			TopLevel:      1,
+			Notifications: help.Ns(notification1),
+			Decoded:       []map[string]interface{}{decoded1},
 		})
 	}
 }
@@ -224,7 +227,7 @@
 	countdownToFail int
 }
 
-func (sto *testFailingStore) GetChannelSnapshot(chanId store.InternalChannelId) (int64, []json.RawMessage, error) {
+func (sto *testFailingStore) GetChannelSnapshot(chanId store.InternalChannelId) (int64, []protocol.Notification, error) {
 	if sto.countdownToFail == 0 {
 		return 0, nil, errors.New("get channel snapshot fail")
 	}
@@ -241,7 +244,7 @@
 	b := s.MakeBroker(sto, testBrokerConfig, s.testlog)
 	b.Start()
 	defer b.Stop()
-	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"})
+	_, err := b.Register(&protocol.ConnectMsg{Type: "connect", DeviceId: "dev-1"}, "s1")
 	c.Assert(err, IsNil)
 	b.Broadcast(store.SystemInternalChannelId)
 	select {
 
=== modified file 'server/session/session.go'
--- server/session/session.go	2014-04-11 08:47:18 +0000
+++ server/session/session.go	2014-04-29 18:02:00 +0000
@@ -18,6 +18,7 @@
 package session
 
 import (
+	"errors"
 	"net"
 	"time"
 
@@ -35,7 +36,7 @@
 }
 
 // sessionStart manages the start of the protocol session.
-func sessionStart(proto protocol.Protocol, brkr broker.Broker, cfg SessionConfig) (broker.BrokerSession, error) {
+func sessionStart(proto protocol.Protocol, brkr broker.Broker, cfg SessionConfig, sessionId string) (broker.BrokerSession, error) {
 	var connMsg protocol.ConnectMsg
 	proto.SetDeadline(time.Now().Add(cfg.ExchangeTimeout()))
 	err := proto.ReadMessage(&connMsg)
@@ -52,9 +53,11 @@
 	if err != nil {
 		return nil, err
 	}
-	return brkr.Register(&connMsg)
+	return brkr.Register(&connMsg, sessionId)
 }
 
+var errOneway = errors.New("oneway")
+
 // exchange writes outMsg message, reads answer in inMsg
 func exchange(proto protocol.Protocol, outMsg, inMsg interface{}, exchangeTimeout time.Duration) error {
 	proto.SetDeadline(time.Now().Add(exchangeTimeout))
@@ -62,7 +65,10 @@
 	if err != nil {
 		return err
 	}
-	if inMsg == nil { // no answer expected, breaking connection
+	if inMsg == nil { // no answer expected
+		if outMsg.(protocol.OnewayMsg).OnewayContinue() {
+			return errOneway
+		}
 		return &broker.ErrAbort{"session broken for reason"}
 	}
 	err = proto.ReadMessage(inMsg)
@@ -78,6 +84,10 @@
 	exchangeTimeout := cfg.ExchangeTimeout()
 	pingTimer := time.NewTimer(pingInterval)
 	intervalStart := time.Now()
+	pingTimerReset := func() {
+		pingTimer.Reset(pingInterval)
+		intervalStart = time.Now()
+	}
 	ch := sess.SessionChannel()
 Loop:
 	for {
@@ -93,16 +103,15 @@
 			if pongMsg.Type != "pong" {
 				return &broker.ErrAbort{"expected PONG message"}
 			}
-			pingTimer.Reset(pingInterval)
-		case exchg, ok := <-ch:
+			pingTimerReset()
+		case exchg := <-ch:
 			pingTimer.Stop()
-			if !ok {
+			if exchg == nil {
 				return &broker.ErrAbort{"terminated"}
 			}
 			outMsg, inMsg, err := exchg.Prepare(sess)
 			if err == broker.ErrNop { // nothing to do
-				pingTimer.Reset(pingInterval)
-				intervalStart = time.Now()
+				pingTimerReset()
 				continue Loop
 			}
 			if err != nil {
@@ -111,12 +120,15 @@
 			for {
 				done := outMsg.Split()
 				err = exchange(proto, outMsg, inMsg, exchangeTimeout)
+				if err == errOneway {
+					pingTimerReset()
+					continue Loop
+				}
 				if err != nil {
 					return err
 				}
 				if done {
-					pingTimer.Reset(pingInterval)
-					intervalStart = time.Now()
+					pingTimerReset()
 				}
 				err = exchg.Acked(sess, done)
 				if err != nil {
@@ -142,7 +154,7 @@
 		return track.End(&broker.ErrAbort{"unexpected wire format version"})
 	}
 	proto := protocol.NewProtocol0(conn)
-	sess, err := sessionStart(proto, brkr, cfg)
+	sess, err := sessionStart(proto, brkr, cfg, track.SessionId())
 	if err != nil {
 		return track.End(err)
 	}
 
=== modified file 'server/session/session_test.go'
--- server/session/session_test.go	2014-04-11 08:47:18 +0000
+++ server/session/session_test.go	2014-04-29 18:02:00 +0000
@@ -130,8 +130,8 @@
 	return &testBroker{registration: make(chan interface{}, 2)}
 }
 
-func (tb *testBroker) Register(connect *protocol.ConnectMsg) (broker.BrokerSession, error) {
-	tb.registration <- "register " + connect.DeviceId
+func (tb *testBroker) Register(connect *protocol.ConnectMsg, sessionId string) (broker.BrokerSession, error) {
+	tb.registration <- fmt.Sprintf("register %s %s", connect.DeviceId, sessionId)
 	return &testing.TestBrokerSession{DeviceId: connect.DeviceId}, tb.err
 }
 
@@ -148,7 +148,7 @@
 	brkr := newTestBroker()
 	go func() {
 		var err error
-		sess, err = sessionStart(tp, brkr, cfg10msPingInterval5msExchangeTout)
+		sess, err = sessionStart(tp, brkr, cfg10msPingInterval5msExchangeTout, "s1")
 		errCh <- err
 	}()
 	c.Check(takeNext(down), Equals, "deadline 5ms")
@@ -160,7 +160,7 @@
 	up <- nil // no write error
 	err := <-errCh
 	c.Check(err, IsNil)
-	c.Check(takeNext(brkr.registration), Equals, "register dev-1")
+	c.Check(takeNext(brkr.registration), Equals, "register dev-1 s1")
 	c.Check(sess.DeviceIdentifier(), Equals, "dev-1")
 }
 
@@ -175,7 +175,7 @@
 	brkr.err = errRegister
 	go func() {
 		var err error
-		sess, err = sessionStart(tp, brkr, cfg10msPingInterval5msExchangeTout)
+		sess, err = sessionStart(tp, brkr, cfg10msPingInterval5msExchangeTout, "s2")
 		errCh <- err
 	}()
 	up <- protocol.ConnectMsg{Type: "connect", ClientVer: "1", DeviceId: "dev-1"}
@@ -190,7 +190,7 @@
 	down := make(chan interface{}, 5)
 	tp := &testProtocol{up, down}
 	up <- io.ErrUnexpectedEOF
-	_, err := sessionStart(tp, nil, cfg10msPingInterval5msExchangeTout)
+	_, err := sessionStart(tp, nil, cfg10msPingInterval5msExchangeTout, "s3")
 	c.Check(err, Equals, io.ErrUnexpectedEOF)
 }
 
@@ -200,7 +200,7 @@
 	tp := &testProtocol{up, down}
 	up <- protocol.ConnectMsg{Type: "connect"}
 	up <- io.ErrUnexpectedEOF
-	_, err := sessionStart(tp, nil, cfg10msPingInterval5msExchangeTout)
+	_, err := sessionStart(tp, nil, cfg10msPingInterval5msExchangeTout, "s4")
 	c.Check(err, Equals, io.ErrUnexpectedEOF)
 	// sanity
 	c.Check(takeNext(down), Matches, "deadline.*")
@@ -212,7 +212,7 @@
 	down := make(chan interface{}, 5)
 	tp := &testProtocol{up, down}
 	up <- protocol.ConnectMsg{Type: "what"}
-	_, err := sessionStart(tp, nil, cfg10msPingInterval5msExchangeTout)
+	_, err := sessionStart(tp, nil, cfg10msPingInterval5msExchangeTout, "s5")
 	c.Check(err, DeepEquals, &broker.ErrAbort{"expected CONNECT message"})
 }
 
@@ -222,14 +222,14 @@
 }
 
 func (s *sessionSuite) TestSessionLoop(c *C) {
-	nopTrack := NewTracker(s.testlog)
+	track := &testTracker{NewTracker(s.testlog), make(chan interface{}, 2)}
 	errCh := make(chan error, 1)
 	up := make(chan interface{}, 5)
 	down := make(chan interface{}, 5)
 	tp := &testProtocol{up, down}
 	sess := &testing.TestBrokerSession{}
 	go func() {
-		errCh <- sessionLoop(tp, sess, cfg5msPingInterval2msExchangeTout, nopTrack)
+		errCh <- sessionLoop(tp, sess, cfg5msPingInterval2msExchangeTout, track)
 	}()
 	c.Check(takeNext(down), Equals, "deadline 2ms")
 	c.Check(takeNext(down), DeepEquals, protocol.PingPongMsg{Type: "ping"})
@@ -241,6 +241,9 @@
 	up <- io.ErrUnexpectedEOF
 	err := <-errCh
 	c.Check(err, Equals, io.ErrUnexpectedEOF)
+	c.Check(track.interval, HasLen, 2)
+	c.Check((<-track.interval).(time.Duration) <= 8*time.Millisecond, Equals, true)
+	c.Check((<-track.interval).(time.Duration) <= 8*time.Millisecond, Equals, true)
 }
 
 func (s *sessionSuite) TestSessionLoopWriteError(c *C) {
@@ -357,7 +360,7 @@
 	go func() {
 		errCh <- sessionLoop(tp, sess, cfg5msPingInterval2msExchangeTout, nopTrack)
 	}()
-	close(exchanges)
+	exchanges <- nil
 	err := <-errCh
 	c.Check(err, DeepEquals, &broker.ErrAbort{"terminated"})
 }
@@ -477,18 +480,44 @@
 	down := make(chan interface{}, 5)
 	tp := &testProtocol{up, down}
 	exchanges := make(chan broker.Exchange, 1)
-	exchanges <- &broker.ConnBrokenExchange{"REASON"}
+	msg := &protocol.ConnBrokenMsg{"connbroken", "BREASON"}
+	exchanges <- &broker.ConnMetaExchange{msg}
 	sess := &testing.TestBrokerSession{Exchanges: exchanges}
 	go func() {
 		errCh <- sessionLoop(tp, sess, cfg5msPingInterval2msExchangeTout, nopTrack)
 	}()
 	c.Check(takeNext(down), Equals, "deadline 2ms")
-	c.Check(takeNext(down), DeepEquals, protocol.ConnBrokenMsg{"connbroken", "REASON"})
+	c.Check(takeNext(down), DeepEquals, protocol.ConnBrokenMsg{"connbroken", "BREASON"})
 	up <- nil // no write error
 	err := <-errCh
 	c.Check(err, DeepEquals, &broker.ErrAbort{"session broken for reason"})
 }
 
+func (s *sessionSuite) TestSessionLoopConnWarnExchange(c *C) {
+	nopTrack := NewTracker(s.testlog)
+	errCh := make(chan error, 1)
+	up := make(chan interface{}, 5)
+	down := make(chan interface{}, 5)
+	tp := &testProtocol{up, down}
+	exchanges := make(chan broker.Exchange, 1)
+	msg := &protocol.ConnWarnMsg{"connwarn", "WREASON"}
+	exchanges <- &broker.ConnMetaExchange{msg}
+	sess := &testing.TestBrokerSession{Exchanges: exchanges}
+	go func() {
+		errCh <- sessionLoop(tp, sess, cfg5msPingInterval2msExchangeTout, nopTrack)
+	}()
+	c.Check(takeNext(down), Equals, "deadline 2ms")
+	c.Check(takeNext(down), DeepEquals, protocol.ConnWarnMsg{"connwarn", "WREASON"})
+	up <- nil // no write error
+	// session continues
+	c.Check(takeNext(down), Equals, "deadline 2ms")
+	c.Check(takeNext(down), DeepEquals, protocol.PingPongMsg{Type: "ping"})
+	up <- nil // no write error
+	up <- io.EOF
+	err := <-errCh
+	c.Check(err, Equals, io.EOF)
+}
+
 type testTracker struct {
 	SessionTracker
 	interval chan interface{}
@@ -593,7 +622,7 @@
 	msg, err = downStream.ReadBytes(byte('}'))
 	c.Check(err, IsNil)
 	c.Check(msg, DeepEquals, []byte("\x00\x0c{\"T\":\"ping\"}"))
-	c.Check(takeNext(brkr.registration), Equals, "register DEV")
+	c.Check(takeNext(brkr.registration), Equals, "register DEV "+track.SessionId())
 	c.Check(len(brkr.registration), Equals, 0) // not yet unregistered
 	cli.Close()
 	err = <-errCh
 
=== modified file 'server/session/tracker.go'
--- server/session/tracker.go	2014-02-10 23:19:08 +0000
+++ server/session/tracker.go	2014-04-29 18:02:00 +0000
@@ -17,6 +17,7 @@
 package session
 
 import (
+	"fmt"
 	"net"
 	"time"
 
@@ -29,6 +30,8 @@
 	logger.Logger
 	// Session got started.
 	Start(WithRemoteAddr)
+	// SessionId
+	SessionId() string
 	// Session got registered with broker as sess BrokerSession.
 	Registered(sess broker.BrokerSession)
 	// Report effective elapsed ping interval.
@@ -47,7 +50,7 @@
 // Tracker implements SessionTracker simply.
 type tracker struct {
 	logger.Logger
-	sessionId int64 // xxx use timeuuid later
+	sessionId string
 }
 
 func NewTracker(logger logger.Logger) SessionTracker {
@@ -55,18 +58,22 @@
 }
 
 func (trk *tracker) Start(conn WithRemoteAddr) {
-	trk.sessionId = time.Now().UnixNano() - sessionsEpoch
-	trk.Debugf("session(%x) connected %v", trk.sessionId, conn.RemoteAddr())
+	trk.sessionId = fmt.Sprintf("%x", time.Now().UnixNano()-sessionsEpoch)
+	trk.Debugf("session(%s) connected %v", trk.sessionId, conn.RemoteAddr())
+}
+
+func (trk *tracker) SessionId() string {
+	return trk.sessionId
 }
 
 func (trk *tracker) Registered(sess broker.BrokerSession) {
-	trk.Infof("session(%x) registered %v", trk.sessionId, sess.DeviceIdentifier())
+	trk.Infof("session(%s) registered %v", trk.sessionId, sess.DeviceIdentifier())
 }
 
 func (trk *tracker) EffectivePingInterval(time.Duration) {
 }
 
 func (trk *tracker) End(err error) error {
-	trk.Debugf("session(%x) ended with: %v", trk.sessionId, err)
+	trk.Debugf("session(%s) ended with: %v", trk.sessionId, err)
 	return err
 }
 
=== modified file 'server/session/tracker_test.go'
--- server/session/tracker_test.go	2014-02-10 23:19:08 +0000
+++ server/session/tracker_test.go	2014-04-29 18:02:00 +0000
@@ -46,8 +46,8 @@
 func (s *trackerSuite) TestSessionTrackStart(c *C) {
 	track := NewTracker(s.testlog)
 	track.Start(&testRemoteAddrable{})
-	c.Check(track.(*tracker).sessionId, Not(Equals), 0)
-	regExpected := fmt.Sprintf(`DEBUG session\(%x\) connected 127\.0\.0\.1:9999\n`, track.(*tracker).sessionId)
+	c.Check(track.SessionId(), Not(Equals), "")
+	regExpected := fmt.Sprintf(`DEBUG session\(%s\) connected 127\.0\.0\.1:9999\n`, track.SessionId())
 	c.Check(s.testlog.Captured(), Matches, regExpected)
 }
 
@@ -55,7 +55,7 @@
 	track := NewTracker(s.testlog)
 	track.Start(&testRemoteAddrable{})
 	track.Registered(&testing.TestBrokerSession{DeviceId: "DEV-ID"})
-	regExpected := fmt.Sprintf(`.*connected.*\nINFO session\(%x\) registered DEV-ID\n`, track.(*tracker).sessionId)
+	regExpected := fmt.Sprintf(`.*connected.*\nINFO session\(%s\) registered DEV-ID\n`, track.SessionId())
 	c.Check(s.testlog.Captured(), Matches, regExpected)
 }
 
@@ -63,6 +63,6 @@
 	track := NewTracker(s.testlog)
 	track.Start(&testRemoteAddrable{})
 	track.End(&broker.ErrAbort{})
-	regExpected := fmt.Sprintf(`.*connected.*\nDEBUG session\(%x\) ended with: session aborted \(\)\n`, track.(*tracker).sessionId)
+	regExpected := fmt.Sprintf(`.*connected.*\nDEBUG session\(%s\) ended with: session aborted \(\)\n`, track.SessionId())
 	c.Check(s.testlog.Captured(), Matches, regExpected)
 }
 
=== modified file 'server/store/inmemory.go'
--- server/store/inmemory.go	2014-02-18 14:19:05 +0000
+++ server/store/inmemory.go	2014-04-29 18:02:00 +0000
@@ -20,11 +20,13 @@
 	"encoding/json"
 	"sync"
 	"time"
+
+	"launchpad.net/ubuntu-push/protocol"
 )
 
 // one stored notification
 type notification struct {
-	payload    json.RawMessage
+	protocol.Notification
 	expiration time.Time
 }
 
@@ -63,14 +65,14 @@
 	}
 	prev.topLevel++
 	prev.notifications = append(prev.notifications, notification{
-		payload:    notificationPayload,
-		expiration: expiration,
+		Notification: protocol.Notification{Payload: notificationPayload},
+		expiration:   expiration,
 	})
 	sto.store[chanId] = prev
 	return nil
 }
 
-func (sto *InMemoryPendingStore) GetChannelSnapshot(chanId InternalChannelId) (int64, []json.RawMessage, error) {
+func (sto *InMemoryPendingStore) GetChannelSnapshot(chanId InternalChannelId) (int64, []protocol.Notification, error) {
 	sto.lock.Lock()
 	defer sto.lock.Unlock()
 	channel, ok := sto.store[chanId]
@@ -79,13 +81,13 @@
 	}
 	topLevel := channel.topLevel
 	n := len(channel.notifications)
-	res := make([]json.RawMessage, 0, n)
+	res := make([]protocol.Notification, 0, n)
 	now := time.Now()
 	for _, notification := range channel.notifications {
 		if notification.expiration.Before(now) {
 			continue
 		}
-		res = append(res, notification.payload)
+		res = append(res, notification.Notification)
 	}
 	return topLevel, res, nil
 }
 
=== modified file 'server/store/inmemory_test.go'
--- server/store/inmemory_test.go	2014-02-14 12:38:38 +0000
+++ server/store/inmemory_test.go	2014-04-29 18:02:00 +0000
@@ -21,6 +21,9 @@
 	"time"
 
 	. "launchpad.net/gocheck"
+
+	"launchpad.net/ubuntu-push/protocol"
+	help "launchpad.net/ubuntu-push/testing"
 )
 
 type inMemorySuite struct{}
@@ -45,7 +48,7 @@
 	top, res, err := sto.GetChannelSnapshot(SystemInternalChannelId)
 	c.Assert(err, IsNil)
 	c.Check(top, Equals, int64(0))
-	c.Check(res, DeepEquals, []json.RawMessage(nil))
+	c.Check(res, DeepEquals, []protocol.Notification(nil))
 }
 
 func (s *inMemorySuite) TestAppendToChannelAndGetChannelSnapshot(c *C) {
@@ -61,7 +64,7 @@
 	top, res, err := sto.GetChannelSnapshot(SystemInternalChannelId)
 	c.Assert(err, IsNil)
 	c.Check(top, Equals, int64(2))
-	c.Check(res, DeepEquals, []json.RawMessage{notification1, notification2})
+	c.Check(res, DeepEquals, help.Ns(notification1, notification2))
 }
 
 func (s *inMemorySuite) TestAppendToChannelAndGetChannelSnapshotWithExpiration(c *C) {
@@ -81,5 +84,5 @@
 	top, res, err := sto.GetChannelSnapshot(SystemInternalChannelId)
 	c.Assert(err, IsNil)
 	c.Check(top, Equals, int64(2))
-	c.Check(res, DeepEquals, []json.RawMessage{notification1})
+	c.Check(res, DeepEquals, help.Ns(notification1))
 }
 
=== modified file 'server/store/store.go'
--- server/store/store.go	2014-02-18 13:43:07 +0000
+++ server/store/store.go	2014-04-29 18:02:00 +0000
@@ -22,6 +22,8 @@
 	"encoding/json"
 	"errors"
 	"time"
+
+	"launchpad.net/ubuntu-push/protocol"
 )
 
 type InternalChannelId string
@@ -70,7 +72,7 @@
 	AppendToChannel(chanId InternalChannelId, notification json.RawMessage, expiration time.Time) error
 	// GetChannelSnapshot gets all the current notifications and
 	// current top level in the channel.
-	GetChannelSnapshot(chanId InternalChannelId) (topLevel int64, payloads []json.RawMessage, err error)
+	GetChannelSnapshot(chanId InternalChannelId) (topLevel int64, notifications []protocol.Notification, err error)
 	// Close is to be called when done with the store.
 	Close()
 }
 
=== modified file 'testing/helpers.go'
--- testing/helpers.go	2014-02-21 16:04:44 +0000
+++ testing/helpers.go	2014-04-29 18:02:00 +0000
@@ -18,6 +18,7 @@
 package testing
 
 import (
+	"encoding/json"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -26,6 +27,7 @@
 	"sync"
 
 	"launchpad.net/ubuntu-push/logger"
+	"launchpad.net/ubuntu-push/protocol"
 )
 
 type captureHelper struct {
@@ -122,3 +124,12 @@
 	}
 	return filepath.Join(dir, relativePath)
 }
+
+// Ns makes a []Notification from just payloads.
+func Ns(payloads ...json.RawMessage) []protocol.Notification {
+	res := make([]protocol.Notification, len(payloads))
+	for i := 0; i < len(payloads); i++ {
+		res[i].Payload = payloads[i]
+	}
+	return res
+}
 
=== modified file 'ubuntu-push-client.go'
--- ubuntu-push-client.go	2014-03-12 13:25:20 +0000
+++ ubuntu-push-client.go	2014-04-29 18:02:00 +0000
@@ -19,12 +19,38 @@
 import (
 	"log"
 
+	"gopkg.in/qml.v0"
+	"launchpad.net/go-dbus/v1"
 	"launchpad.net/go-xdg/v0"
 
 	"launchpad.net/ubuntu-push/client"
 )
 
+const NAME = "com.ubuntu.PushNotifications"
+
+// grabName grabs ownership of the dbus name, and bails the client as
+// soon as somebody else grabs it.
+func grabName() {
+	conn, err := dbus.Connect(dbus.SessionBus)
+	if err != nil {
+		log.Fatalf("bus: %v", err)
+	}
+
+	flags := dbus.NameFlagAllowReplacement | dbus.NameFlagReplaceExisting
+	n := conn.RequestName(NAME, flags)
+	go func() {
+		for err := range n.C {
+			if err != nil {
+				log.Fatalf("FATAL: name channel got: %v", err)
+			}
+		}
+	}()
+}
+
 func main() {
+	// XXX: this is a quick hack to ensure unicity
+	grabName()
+
 	cfgFname, err := xdg.Config.Find("ubuntu-push-client/config.json")
 	if err != nil {
 		log.Fatalf("unable to find a configuration file: %v", err)
@@ -33,6 +59,9 @@
 	if err != nil {
 		log.Fatalf("unable to open the levels database: %v", err)
 	}
+
+	qml.Init(nil)
+
 	cli := client.NewPushClient(cfgFname, lvlFname)
 	err = cli.Start()
 	if err != nil {
 
=== added file 'util/auth.go'
--- util/auth.go	1970-01-01 00:00:00 +0000
+++ util/auth.go	2014-04-29 18:02:00 +0000
@@ -0,0 +1,36 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package util
+
+import (
+	"gopkg.in/niemeyer/uoneauth.v1"
+	"gopkg.in/qml.v0"
+)
+
+func GetAuthorization() (string, error) {
+	engine := qml.NewEngine()
+	defer engine.Destroy()
+	authService := uoneauth.NewService(engine)
+	var auth string
+	token, err := authService.Token()
+	if err != nil {
+		return "", err
+	} else {
+		auth = token.HeaderSignature("POST", "https://push.ubuntu.com")
+	}
+	return auth, nil
+}
 
=== added file 'util/auth_test.go'
--- util/auth_test.go	1970-01-01 00:00:00 +0000
+++ util/auth_test.go	2014-04-29 18:02:00 +0000
@@ -0,0 +1,53 @@
+/*
+ Copyright 2013-2014 Canonical Ltd.
+
+ This program is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License version 3, as published
+ by the Free Software Foundation.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranties of
+ MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+ PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package util
+
+import (
+	"os"
+
+	"gopkg.in/qml.v0"
+
+	. "launchpad.net/gocheck"
+)
+
+type authSuite struct{}
+
+var _ = Suite(&authSuite{})
+
+func (s *authSuite) SetUpSuite(c *C) {
+	if os.Getenv("PUSH_AUTH_TEST") == "1" {
+		qml.Init(nil)
+	}
+}
+
+func (s *authSuite) SetUpTest(c *C) {
+	qml.SetLogger(c)
+}
+
+func (s *authSuite) TestGetAuth(c *C) {
+	/*
+	 * This test is only useful when the PUSH_AUTH_TEST environment
+	 * variable is set to "1" - in which case the runner should have
+	 * a Ubuntu One account setup via system-settings.
+	 */
+	if os.Getenv("PUSH_AUTH_TEST") != "1" {
+		c.Skip("PUSH_AUTH_TEST not set to '1'")
+	}
+	auth, err := GetAuthorization()
+	c.Assert(err, IsNil)
+	c.Assert(auth, Matches, "OAuth .*oauth_consumer_key=.*")
+}
 
=== modified file 'whoopsie/identifier/identifier.go'
--- whoopsie/identifier/identifier.go	2014-02-21 16:17:28 +0000
+++ whoopsie/identifier/identifier.go	2014-04-29 18:02:00 +0000
@@ -27,6 +27,7 @@
 import "C"
 import "unsafe"
 import "errors"
+import "time"
 
 // an Id knows how to generate itself, and how to stringify itself.
 type Id interface {
@@ -36,12 +37,17 @@
 
 // Identifier is the default Id implementation.
 type Identifier struct {
-	value string
+	value     string
+	generator func(**C.char, **C.GError)
+}
+
+func generator(csp **C.char, errp **C.GError) {
+	C.whoopsie_identifier_generate(csp, errp)
 }
 
 // New creates an Identifier, but does not call Generate() on it.
 func New() Id {
-	return &Identifier{}
+	return &Identifier{generator: generator}
 }
 
 // Generate makes the Identifier create the identifier itself.
@@ -49,8 +55,18 @@
 	var gerr *C.GError
 	var cs *C.char
 	defer C.g_free((C.gpointer)(unsafe.Pointer(cs)))
-	C.whoopsie_identifier_generate(&cs, &gerr)
-
+
+	for i := 0; i < 200; i++ {
+		id.generator(&cs, &gerr)
+
+		if cs != nil || gerr != nil {
+			goto SuccessMaybe
+		}
+		time.Sleep(600 * time.Millisecond)
+	}
+	return errors.New("whoopsie_identifier_generate still bad after 2m; giving up")
+
+SuccessMaybe:
 	if gerr != nil {
 		return errors.New(C.GoString((*C.char)(gerr.message)))
 	} else {
 
=== modified file 'whoopsie/identifier/identifier_test.go'
--- whoopsie/identifier/identifier_test.go	2014-01-15 15:51:50 +0000
+++ whoopsie/identifier/identifier_test.go	2014-04-29 18:02:00 +0000
@@ -41,3 +41,18 @@
 func (s *IdentifierSuite) TestIdentifierInterface(c *C) {
 	_ = []Id{New()}
 }
+
+// TestFailure checks that Identifier survives whoopsie shenanigans
+func (s *IdentifierSuite) TestIdentifierSurvivesShenanigans(c *C) {
+	count := 0
+	// using _Ctype* as a workaround for gocheck also having a C
+	gen := func(csp **_Ctype_char, errp **_Ctype_GError) {
+		count++
+		if count > 3 {
+			generator(csp, errp)
+		}
+	}
+	id := &Identifier{generator: gen}
+	id.Generate()
+	c.Check(id.String(), HasLen, 128)
+}