Merge lp:~rsalveti/ubuntu-push/merge-automatic-branch into lp:ubuntu-push

[Ricardo Salveti]

[ Samuele Pedroni ]
* switch poller to use killswitch state for WLAN instead of misleading NM property (LP: #1446584)
* don't have goroutines from a previous test overlap with the next, races gets detected otherwise
* have the TestDialWorksDirect* tests quickly timeout, go1.3 wants a ServerName set in the tls config for them to work
* fix flaky test
* support sha384/512 certs, some exercizing of that
* let send a build number with acceptanceclient
* add helper to get int out of ConnectMsg Info

[ Samuele Pedroni ]
* switch poller to use killswitch state for WLAN instead of misleading NM property (LP: #1446584)
* don't have goroutines from a previous test overlap with the next, races gets detected otherwise
* have the TestDialWorksDirect* tests quickly timeout, go1.3 wants a ServerName set in the tls config for them to work
* fix flaky test
* support sha384/512 certs, some exercizing of that
* let send a build number with acceptanceclient
* add helper to get int out of ConnectMsg Info

[Samuele Pedroni (pedronis)]

review: Approve

[lp:~rsalveti/ubuntu-push/merge-automatic-branch]

147. By Ricardo Salveti on 2015-04-30

changelog: manually adding the changes for a better format

=== modified file 'LICENSE'
--- LICENSE	2014-01-14 15:35:20 +0000
+++ LICENSE	2015-04-30 15:00:25 +0000
@@ -1,5 +1,5 @@
 /*
- Copyright 2013-2014 Canonical Ltd.
+ Copyright 2013-2015 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

=== modified file 'bus/connectivity/connectivity_test.go'
--- bus/connectivity/connectivity_test.go	2015-03-02 16:45:30 +0000
+++ bus/connectivity/connectivity_test.go	2015-04-30 15:00:25 +0000
@@ -196,6 +196,10 @@
 	return nil, nil
 }
 
+func (rep *racyEndpoint) WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (bus.Cancellable, error) {
+	return nil, nil
+}
+
 func (*racyEndpoint) Close()                                                        {}
 func (*racyEndpoint) Dial() error                                                   { return nil }
 func (*racyEndpoint) String() string                                                { return "racyEndpoint" }

=== modified file 'bus/endpoint.go'
--- bus/endpoint.go	2015-02-26 19:36:57 +0000
+++ bus/endpoint.go	2015-04-30 15:00:25 +0000
@@ -49,6 +49,7 @@
 	Call(member string, args []interface{}, rvs ...interface{}) error
 	GetProperty(property string) (interface{}, error)
 	SetProperty(property string, suffix string, value interface{}) error
+	WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (Cancellable, error)
 	Dial() error
 	Close()
 	String() string
@@ -195,6 +196,48 @@
 	return err
 }
 
+// WatchProperties() sets up a watch for
+// org.freedesktop.DBus.Properties PropertiesChanged signal for the
+// path and interface provided when creating the endpoint, and then
+// calls f() with the unpacked value. If it's unable to set up the
+// watch it returns an error. If the watch fails once established, d()
+// is called. Typically f() sends the values over a channel, and d()
+// would close the channel.
+//
+// XXX: untested
+func (endp *endpoint) WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (Cancellable, error) {
+	watch, err := endp.proxy.WatchSignal("org.freedesktop.DBus.Properties", "PropertiesChanged")
+	if err != nil {
+		endp.log.Debugf("failed to set up the watch: %s", err)
+		return nil, err
+	}
+
+	go func() {
+		for {
+			msg, ok := <-watch.C
+			if !ok {
+				break
+			}
+			var intfName string
+			var changed map[string]dbus.Variant
+			var invalidated []string
+			if err := msg.Args(&intfName, &changed, &invalidated); err != nil {
+				endp.log.Errorf("unexpected values from Properties watch")
+				break
+			}
+			if intfName != endp.addr.Interface {
+				// ignore
+				continue
+			}
+			f(changed, invalidated)
+		}
+		endp.log.Debugf("got not-OK from Properties watch")
+		d()
+	}()
+
+	return watch, nil
+}
+
 // Close the connection to dbus.
 //
 // XXX: untested

=== modified file 'bus/testing/testing_endpoint.go'
--- bus/testing/testing_endpoint.go	2015-02-26 19:36:57 +0000
+++ bus/testing/testing_endpoint.go	2015-04-30 15:00:25 +0000
@@ -154,6 +154,16 @@
 	}
 }
 
+// See Endpoint's WatchProperties.
+func (tc *testingEndpoint) WatchProperties(f func(map[string]dbus.Variant, []string), d func()) (bus.Cancellable, error) {
+	translate := func(vals ...interface{}) {
+		changed := vals[0].(map[string]dbus.Variant)
+		invalidated := vals[1].([]string)
+		f(changed, invalidated)
+	}
+	return tc.WatchSignal("PropertiesChanged", translate, d)
+}
+
 // See Endpoint's Call. This Call will check its condition to decide whether
 // to return an error, or the first of its return values
 func (tc *testingEndpoint) Call(member string, args []interface{}, rvs ...interface{}) error {

=== modified file 'bus/testing/testing_endpoint_test.go'
--- bus/testing/testing_endpoint_test.go	2015-02-26 19:36:57 +0000
+++ bus/testing/testing_endpoint_test.go	2015-04-30 15:00:25 +0000
@@ -20,6 +20,7 @@
 	"testing"
 	"time"
 
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	"launchpad.net/ubuntu-push/bus"
@@ -203,6 +204,24 @@
 	c.Check(e, NotNil)
 }
 
+// Test that WatchProperties() with a positive condition sends the
+// provided return values over the channel.
+func (s *TestingEndpointSuite) TestWatchProperties(c *C) {
+	var m, n int32 = 42, 17
+	endp := NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{map[string]dbus.Variant{"s": dbus.Variant{m}}, []string{}},
+		[]interface{}{map[string]dbus.Variant{"s": dbus.Variant{n}}, []string{}},
+	)
+	ch := make(chan int32)
+	w, e := endp.WatchProperties(func(changed map[string]dbus.Variant, nvalited []string) {
+		ch <- changed["s"].Value.(int32)
+	}, func() { close(ch) })
+	c.Assert(e, IsNil)
+	defer w.Cancel()
+	c.Check(<-ch, Equals, m)
+	c.Check(<-ch, Equals, n)
+}
+
 // Test Dial() with a non-working bus fails
 func (s *TestingBusSuite) TestDialNoWork(c *C) {
 	endp := NewTestingEndpoint(condition.Work(false), nil)

=== modified file 'bus/urfkill/urfkill.go'
--- bus/urfkill/urfkill.go	2015-03-30 12:05:10 +0000
+++ bus/urfkill/urfkill.go	2015-04-30 15:00:25 +0000
@@ -19,7 +19,7 @@
 package urfkill
 
 import (
-	//"launchpad.net/go-dbus/v1"
+	"launchpad.net/go-dbus/v1"
 
 	"launchpad.net/ubuntu-push/bus"
 	"launchpad.net/ubuntu-push/logger"
@@ -32,26 +32,49 @@
 	Name:      "org.freedesktop.URfkill",
 }
 
+// URfkill lives on a well-knwon bus.Address
+var WLANKillswitchBusAddress bus.Address = bus.Address{
+	Interface: "org.freedesktop.URfkill.Killswitch",
+	Path:      "/org/freedesktop/URfkill/WLAN",
+	Name:      "org.freedesktop.URfkill",
+}
+
 /*****************************************************************
  *    URfkill (and its implementation)
  */
 
+type KillswitchState int32
+
+const (
+	KillswitchStateUnblocked   KillswitchState = 0
+	KillswitchStateSoftBlocked KillswitchState = 1
+	KillswitchStateHardBlocked KillswitchState = 2
+)
+
 type URfkill interface {
 	// IsFlightMode returns flight mode state.
 	IsFlightMode() bool
 	// WatchFlightMode listens for changes to URfkill's flight
 	// mode state, and sends them out over the channel returned.
 	WatchFlightMode() (<-chan bool, bus.Cancellable, error)
+	// GetWLANKillswitchState fetches and returns URfkill's
+	// WLAN killswitch state.
+	GetWLANKillswitchState() KillswitchState
+	// WatchWLANKillswitchState listens for changes of URfkill's
+	// WLAN killswtich state, and sends them out over the channel returned.
+	WatchWLANKillswitchState() (<-chan KillswitchState, bus.Cancellable, error)
 }
 
 type uRfkill struct {
-	bus bus.Endpoint
-	log logger.Logger
+	bus            bus.Endpoint
+	wlanKillswitch bus.Endpoint
+	log            logger.Logger
 }
 
-// New returns a new URfkill that'll use the provided bus.Endpoint
-func New(endp bus.Endpoint, log logger.Logger) URfkill {
-	return &uRfkill{endp, log}
+// New returns a new URfkill that'll use the provided bus.Endpoints
+// for BusAddress and WLANKillswitchBusAddress
+func New(endp bus.Endpoint, wlanKillswitch bus.Endpoint, log logger.Logger) URfkill {
+	return &uRfkill{endp, wlanKillswitch, log}
 }
 
 // ensure uRfkill implements URfkill
@@ -92,3 +115,44 @@
 
 	return ch, w, nil
 }
+
+func (ur *uRfkill) GetWLANKillswitchState() KillswitchState {
+	got, err := ur.wlanKillswitch.GetProperty("state")
+	if err != nil {
+		ur.log.Errorf("failed getting WLANKillswitchState: %s", err)
+		ur.log.Debugf("defaulting WLANKillswitchState to true")
+		return KillswitchStateUnblocked
+	}
+
+	v, ok := got.(int32)
+	if !ok {
+		ur.log.Errorf("got weird WLANKillswitchState: %#v", got)
+		return KillswitchStateUnblocked
+	}
+
+	return KillswitchState(v)
+}
+
+func (ur *uRfkill) WatchWLANKillswitchState() (<-chan KillswitchState, bus.Cancellable, error) {
+	ch := make(chan KillswitchState)
+	w, err := ur.wlanKillswitch.WatchProperties(
+		func(changed map[string]dbus.Variant, invalidated []string) {
+			v, ok := changed["state"]
+			if !ok {
+				return
+			}
+			st, ok := v.Value.(int32)
+			if !ok {
+				ur.log.Errorf("got weird WLANKillswitchState via PropertiesChanged: %#v", v)
+				return
+			}
+			ur.log.Debugf("got WLANKillswitchState change: %v", st)
+			ch <- KillswitchState(st)
+		}, func() { close(ch) })
+	if err != nil {
+		ur.log.Debugf("failed to set up the watch: %s", err)
+		return nil, nil, err
+	}
+
+	return ch, w, nil
+}

=== renamed file 'bus/urfkill/urfkill.go_test.go' => 'bus/urfkill/urfkill_test.go'
--- bus/urfkill/urfkill.go_test.go	2015-03-30 12:05:10 +0000
+++ bus/urfkill/urfkill_test.go	2015-04-30 15:00:25 +0000
@@ -19,7 +19,7 @@
 import (
 	"testing"
 
-	//"launchpad.net/go-dbus/v1"
+	"launchpad.net/go-dbus/v1"
 	. "launchpad.net/gocheck"
 
 	testingbus "launchpad.net/ubuntu-push/bus/testing"
@@ -42,14 +42,14 @@
 }
 
 func (s *URSuite) TestNew(c *C) {
-	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true)), s.log)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true)), nil, s.log)
 	c.Check(ur, NotNil)
 }
 
 // IsFlightMode returns the right state when everything works
 func (s *URSuite) TestIsFlightMode(c *C) {
 	endp := testingbus.NewTestingEndpoint(nil, condition.Work(true), true)
-	ur := New(endp, s.log)
+	ur := New(endp, nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, true)
 	callArgs := testingbus.GetCallArgs(endp)
@@ -60,7 +60,7 @@
 
 // IsFlightMode returns the right state when dbus fails
 func (s *URSuite) TestIsFlightModeFail(c *C) {
-	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, false)
 }
@@ -68,14 +68,14 @@
 // IsFlightMode returns the right state when dbus works but delivers
 // rubbish values
 func (s *URSuite) TestIsFlightModeRubbishValues(c *C) {
-	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, false)
 }
 
 // IsFlightMode returns the right state when dbus works but delivers a rubbish structure
 func (s *URSuite) TestIsFlightModeRubbishStructure(c *C) {
-	ur := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	ur := New(testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), nil, s.log)
 	state := ur.IsFlightMode()
 	c.Check(state, Equals, false)
 }
@@ -83,7 +83,7 @@
 // WatchFightMode sends a stream of states over the channel
 func (s *URSuite) TestWatchFlightMode(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), false, true, false)
-	ur := New(tc, s.log)
+	ur := New(tc, nil, s.log)
 	ch, w, err := ur.WatchFlightMode()
 	c.Assert(err, IsNil)
 	defer w.Cancel()
@@ -93,7 +93,7 @@
 
 // WatchFlightMode returns on error if the dbus call fails
 func (s *URSuite) TestWatchFlightModeFails(c *C) {
-	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	ur := New(testingbus.NewTestingEndpoint(nil, condition.Work(false)), nil, s.log)
 	_, _, err := ur.WatchFlightMode()
 	c.Check(err, NotNil)
 }
@@ -101,7 +101,7 @@
 // WatchFlightMode calls close on its channel when the watch bails
 func (s *URSuite) TestWatchFlightModeClosesOnWatchBail(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
-	ur := New(tc, s.log)
+	ur := New(tc, nil, s.log)
 	ch, w, err := ur.WatchFlightMode()
 	c.Assert(err, IsNil)
 	defer w.Cancel()
@@ -112,10 +112,107 @@
 // WatchFlightMode survives rubbish values
 func (s *URSuite) TestWatchFlightModeSurvivesRubbishValues(c *C) {
 	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true), "gorp")
-	ur := New(tc, s.log)
+	ur := New(tc, nil, s.log)
 	ch, w, err := ur.WatchFlightMode()
 	c.Assert(err, IsNil)
 	defer w.Cancel()
 	_, ok := <-ch
 	c.Check(ok, Equals, false)
 }
+
+// GetWLANKillState returns the right state when everything works
+func (s *URSuite) TestGetWLANKillState(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(true), KillswitchStateSoftBlocked), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateSoftBlocked)
+}
+
+// GetWLANKillswitchState returns the right state when dbus fails
+func (s *URSuite) TestGetWLANKillswitchStateFail(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateUnblocked)
+}
+
+// GetWLANKillswitchState returns the right state when dbus works but delivers rubbish values
+func (s *URSuite) TestGetWLANKillswitchStateRubbishValues(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(true), "broken"), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateUnblocked)
+}
+
+// GetWLANKillswitchState returns the right state when dbus works but delivers a rubbish structure
+func (s *URSuite) TestGetWLANKillswitchStateRubbishStructure(c *C) {
+	ur := New(nil, testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true), []interface{}{}), s.log)
+	st := ur.GetWLANKillswitchState()
+	c.Check(st, Equals, KillswitchStateUnblocked)
+}
+
+func mkWLANKillswitchStateMap(st KillswitchState) map[string]dbus.Variant {
+	m := make(map[string]dbus.Variant)
+	m["state"] = dbus.Variant{int32(st)}
+	return m
+}
+
+// WatchWLANKillswitchState sends a stream of WLAN killswitch states over the channel
+func (s *URSuite) TestWatchWLANKillswitchState(c *C) {
+	tc := testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateUnblocked), []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateHardBlocked), []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateUnblocked), []string{}},
+	)
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	l := []KillswitchState{<-ch, <-ch, <-ch}
+	c.Check(l, DeepEquals, []KillswitchState{KillswitchStateUnblocked, KillswitchStateHardBlocked, KillswitchStateUnblocked})
+}
+
+// WatchWLANKillswitchState returns on error if the dbus call fails
+func (s *URSuite) TestWatchWLANKillswitchStateFails(c *C) {
+	ur := New(nil, testingbus.NewTestingEndpoint(nil, condition.Work(false)), s.log)
+	_, _, err := ur.WatchWLANKillswitchState()
+	c.Check(err, NotNil)
+}
+
+// WatchWLANKillswitchState calls close on its channel when the watch bails
+func (s *URSuite) TestWatchWLANKillswitchStateClosesOnWatchBail(c *C) {
+	tc := testingbus.NewTestingEndpoint(nil, condition.Work(true))
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	_, ok := <-ch
+	c.Check(ok, Equals, false)
+}
+
+// WatchWLANKillswitchState ignores non-WLAN-killswitch PropertiesChanged
+func (s *URSuite) TestWatchWLANKillswitchStateIgnoresIrrelevant(c *C) {
+	tc := testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{map[string]dbus.Variant{"foo": dbus.Variant{}}, []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateUnblocked), []string{}},
+	)
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, KillswitchStateUnblocked)
+}
+
+// WatchWLANKillswitchState ignores rubbish WLAN killswitch state
+func (s *URSuite) TestWatchWLANKillswitchStateIgnoresRubbishValues(c *C) {
+	tc := testingbus.NewMultiValuedTestingEndpoint(nil, condition.Work(true),
+		[]interface{}{map[string]dbus.Variant{"state": dbus.Variant{-12}}, []string{}},
+		[]interface{}{mkWLANKillswitchStateMap(KillswitchStateSoftBlocked), []string{}},
+	)
+	ur := New(nil, tc, s.log)
+	ch, w, err := ur.WatchWLANKillswitchState()
+	c.Assert(err, IsNil)
+	defer w.Cancel()
+	v, ok := <-ch
+	c.Check(ok, Equals, true)
+	c.Check(v, Equals, KillswitchStateSoftBlocked)
+}

=== modified file 'click/cclick/cclick.go'
--- click/cclick/cclick.go	2015-02-06 17:01:15 +0000
+++ click/cclick/cclick.go	2015-04-30 15:00:25 +0000
@@ -51,7 +51,7 @@
 	}
 	ccu.cref = cref
 	runtime.SetFinalizer(holder, func(interface{}) {
-		ccu.cref = nil // 1.3 gc gets confused otherwise
+		ccu.cref = nil // blocks gc really for now, 1.3 otherwise panics
 		C.g_object_unref((C.gpointer)(cref))
 	})
 	return nil

=== modified file 'client/service/postal_test.go'
--- client/service/postal_test.go	2015-03-05 14:09:54 +0000
+++ client/service/postal_test.go	2015-04-30 15:00:25 +0000
@@ -592,14 +592,17 @@
 
 func (ps *postalSuite) TestMessageHandlerReportsFailedNotifies(c *C) {
 	endp := testibus.NewTestingEndpoint(condition.Work(true), condition.Work(true), 1)
+	nopTicker := make(chan []interface{})
+	testibus.SetWatchSource(endp, "ActionInvoked", nopTicker)
+	defer close(nopTicker)
 	svc := ps.replaceBuses(NewPostalService(ps.cfg, ps.log))
 	svc.NotificationsEndp = endp
 	c.Assert(svc.Start(), IsNil)
 	card := &launch_helper.Card{Icon: "icon-value", Summary: "summary-value", Body: "body-value", Popup: true}
 	notif := &launch_helper.Notification{Card: card}
 	output := &launch_helper.HelperOutput{Notification: notif}
-	err := svc.messageHandler(&click.AppId{}, "", output)
-	c.Assert(err, NotNil)
+	b := svc.messageHandler(&click.AppId{}, "", output)
+	c.Check(b, Equals, false)
 }
 
 func (ps *postalSuite) TestMessageHandlerInhibition(c *C) {

=== modified file 'client/session/session.go'
--- client/session/session.go	2015-03-24 17:32:13 +0000
+++ client/session/session.go	2015-04-30 15:00:25 +0000
@@ -19,9 +19,11 @@
 package session
 
 import (
+	_ "crypto/sha512" // support sha384/512 certs
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/json"
+	"encoding/pem"
 	"errors"
 	"fmt"
 	"math/rand"
@@ -246,6 +248,22 @@
 			return nil, errors.New("could not parse certificate")
 		}
 		sess.TLS.RootCAs = cp
+		block, _ := pem.Decode(sess.PEM)
+		if block == nil {
+			panic(fmt.Errorf("unexpected error reparsing certificate"))
+		}
+		cert, err := x509.ParseCertificate(block.Bytes)
+		if err != nil {
+			panic(fmt.Errorf("unexpected error reparsing certificate: %v", err))
+		}
+		// good guess
+		var serverName string
+		if len(cert.DNSNames) > 0 {
+			serverName = cert.DNSNames[0]
+		} else {
+			serverName = cert.Subject.CommonName
+		}
+		sess.TLS.ServerName = serverName
 	}
 	sess.doneCh = make(chan uint32, 1)
 	sess.stopCh = make(chan struct{})

=== modified file 'client/session/session_test.go'
--- client/session/session_test.go	2015-03-24 15:28:24 +0000
+++ client/session/session_test.go	2015-04-30 15:00:25 +0000
@@ -259,10 +259,9 @@
 	c.Check(sess.getHost, NotNil)
 }
 
-var certfile string = helpers.SourceRelative("../../server/acceptance/ssl/testing.cert")
-var pem, _ = ioutil.ReadFile(certfile)
-
 func (cs *clientSessionSuite) TestNewSessionPEMWorks(c *C) {
+	pem, err := ioutil.ReadFile(helpers.SourceRelative("../../server/acceptance/ssl/testing.cert"))
+	c.Assert(err, IsNil)
 	conf := ClientSessionConfig{PEM: pem}
 	sess, err := NewSession("", conf, "wah", cs.lvls, cs.log)
 	c.Check(sess, NotNil)
@@ -1474,10 +1473,14 @@
 	dialTestTimeout = 300 * time.Millisecond
 )
 
-func dialTestConf() ClientSessionConfig {
+func dialTestConf(certPEM []byte) ClientSessionConfig {
 	conf := dummyConf()
 	conf.ExchangeTimeout = dialTestTimeout
-	conf.PEM = helpers.TestCertPEMBlock
+	if certPEM == nil {
+		conf.PEM = helpers.TestCertPEMBlock
+	} else {
+		conf.PEM = certPEM
+	}
 	return conf
 }
 
@@ -1499,7 +1502,7 @@
 	}))
 	defer ts.Close()
 
-	sess, err := NewSession(ts.URL, dialTestConf(), "wah", cs.lvls, cs.log)
+	sess, err := NewSession(ts.URL, dialTestConf(nil), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{}
 	sess.Connection = tconn
@@ -1544,7 +1547,7 @@
 	}))
 	defer ts.Close()
 
-	sess, err := NewSession(ts.URL, dialTestConf(), "wah", cs.lvls, cs.log)
+	sess, err := NewSession(ts.URL, dialTestConf(nil), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	tconn := &testConn{CloseCondition: condition.Fail2Work(10)}
 	sess.Connection = tconn
@@ -1631,7 +1634,7 @@
 	// happy path thoughts
 	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfig)
 	c.Assert(err, IsNil)
-	sess, err := NewSession(lst.Addr().String(), dialTestConf(), "wah", cs.lvls, cs.log)
+	sess, err := NewSession(lst.Addr().String(), dialTestConf(nil), "wah", cs.lvls, cs.log)
 	c.Assert(err, IsNil)
 	defer sess.StopKeepConnection()
 
@@ -1642,7 +1645,37 @@
 
 	go sess.Dial()
 
-	_, err = lst.Accept()
+	cli, err := lst.Accept()
+	c.Assert(err, IsNil)
+	cli.SetReadDeadline(time.Now().Add(2 * time.Second))
+	var buf [1]byte
+	_, err = cli.Read(buf[:])
+	c.Assert(err, IsNil)
+	// connect done
+}
+
+func (cs *clientSessionSuite) TestDialWorksDirectSHA512Cert(c *C) {
+	// happy path thoughts
+	lst, err := tls.Listen("tcp", "localhost:0", helpers.TestTLSServerConfigs["sha512"])
+	c.Assert(err, IsNil)
+	sess, err := NewSession(lst.Addr().String(), dialTestConf(helpers.TestCertPEMBlock512), "wah", cs.lvls, cs.log)
+	c.Assert(err, IsNil)
+	defer sess.StopKeepConnection()
+
+	upCh := make(chan interface{}, 5)
+	downCh := make(chan interface{}, 5)
+	proto := &testProtocol{up: upCh, down: downCh}
+	sess.Protocolator = func(conn net.Conn) protocol.Protocol {
+		return proto
+	}
+
+	go sess.Dial()
+
+	cli, err := lst.Accept()
+	c.Assert(err, IsNil)
+	cli.SetReadDeadline(time.Now().Add(2 * time.Second))
+	var buf [1]byte
+	_, err = cli.Read(buf[:])
 	c.Assert(err, IsNil)
 	// connect done
 }

=== modified file 'debian/changelog'
--- debian/changelog	2015-04-03 13:27:44 +0000
+++ debian/changelog	2015-04-30 15:00:25 +0000
@@ -1,3 +1,19 @@
+ubuntu-push (0.68+15.04.20150430-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Samuele Pedroni ]
+  * switch poller to use killswitch state for WLAN instead of
+    misleading NM property (LP: #1446584)
+  * don't have goroutines from a previous test overlap with the next,
+    races gets detected otherwise
+  * have the TestDialWorksDirect* tests quickly timeout, go1.3 wants a
+    ServerName set in the tls config for them to work
+  * fix flaky test
+  * support sha384/512 certs, some exercizing of that
+  * let send a build number with acceptanceclient
+  * add helper to get int out of ConnectMsg Info
+
+ -- Ricardo Salveti de Araujo <[e-mail]>  Thu, 30 Apr 2015 09:57:38 -0500
+
 ubuntu-push (0.68+15.04.20150403-0ubuntu1) vivid; urgency=medium
 
   [ Samuele Pedroni ]

=== modified file 'launch_helper/kindpool.go'
--- launch_helper/kindpool.go	2015-01-21 17:21:42 +0000
+++ launch_helper/kindpool.go	2015-04-30 15:00:25 +0000
@@ -61,6 +61,7 @@
 	chOut      chan *HelperResult
 	chIn       chan *HelperInput
 	chDone     chan *click.AppId
+	chStopped  chan struct{}
 	launchers  map[string]HelperLauncher
 	lock       sync.Mutex
 	hmap       map[string]*HelperArgs
@@ -91,6 +92,7 @@
 	pool.chOut = make(chan *HelperResult)
 	pool.chIn = make(chan *HelperInput, InputBufferSize)
 	pool.chDone = make(chan *click.AppId)
+	pool.chStopped = make(chan struct{})
 
 	for kind, launcher := range pool.launchers {
 		kind1 := kind
@@ -115,6 +117,7 @@
 		select {
 		case in, ok := <-pool.chIn:
 			if !ok {
+				close(pool.chStopped)
 				return
 			}
 			if len(running) >= pool.maxNum || running[in.App.Original()] {
@@ -176,6 +179,8 @@
 			panic(fmt.Errorf("failed to remove helper observer for &s: %v", kind, err))
 		}
 	}
+	// make Stop sync for tests
+	<-pool.chStopped
 }
 
 func (pool *kindHelperPool) Run(kind string, input *HelperInput) {

=== modified file 'poller/poller.go'
--- poller/poller.go	2015-03-30 20:48:00 +0000
+++ poller/poller.go	2015-04-30 15:00:25 +0000
@@ -25,7 +25,6 @@
 	"time"
 
 	"launchpad.net/ubuntu-push/bus"
-	"launchpad.net/ubuntu-push/bus/networkmanager"
 	"launchpad.net/ubuntu-push/bus/polld"
 	"launchpad.net/ubuntu-push/bus/powerd"
 	"launchpad.net/ubuntu-push/bus/urfkill"
@@ -68,7 +67,6 @@
 type poller struct {
 	times                Times
 	log                  logger.Logger
-	nm                   networkmanager.NetworkManager
 	powerd               powerd.Powerd
 	polld                polld.Polld
 	urfkill              urfkill.URfkill
@@ -103,18 +101,13 @@
 	if p.powerd != nil || p.polld != nil {
 		return ErrAlreadyStarted
 	}
-	nmEndp := bus.SystemBus.Endpoint(networkmanager.BusAddress, p.log)
 	powerdEndp := bus.SystemBus.Endpoint(powerd.BusAddress, p.log)
 	polldEndp := bus.SessionBus.Endpoint(polld.BusAddress, p.log)
 	urEndp := bus.SystemBus.Endpoint(urfkill.BusAddress, p.log)
+	urWLANKillswitchEndp := bus.SystemBus.Endpoint(urfkill.WLANKillswitchBusAddress, p.log)
 	var wg sync.WaitGroup
 	wg.Add(4)
 	go func() {
-		n := util.NewAutoRedialer(nmEndp).Redial()
-		p.log.Debugf("NetworkManager dialed on try %d", n)
-		wg.Done()
-	}()
-	go func() {
 		n := util.NewAutoRedialer(powerdEndp).Redial()
 		p.log.Debugf("powerd dialed on try %d", n)
 		wg.Done()
@@ -129,12 +122,16 @@
 		p.log.Debugf("URfkill dialed on try %d", n)
 		wg.Done()
 	}()
+	go func() {
+		n := util.NewAutoRedialer(urWLANKillswitchEndp).Redial()
+		p.log.Debugf("URfkill (WLAN killswitch) dialed on try %d", n)
+		wg.Done()
+	}()
 	wg.Wait()
 
-	p.nm = networkmanager.New(nmEndp, p.log)
 	p.powerd = powerd.New(powerdEndp, p.log)
 	p.polld = polld.New(polldEndp, p.log)
-	p.urfkill = urfkill.New(urEndp, p.log)
+	p.urfkill = urfkill.New(urEndp, urWLANKillswitchEndp, p.log)
 
 	// busy sleep loop to workaround go's timer/sleep
 	// not accounting for time when the system is suspended
@@ -157,7 +154,7 @@
 	if p.log == nil {
 		return ErrUnconfigured
 	}
-	if p.nm == nil || p.powerd == nil || p.polld == nil || p.urfkill == nil {
+	if p.powerd == nil || p.polld == nil || p.urfkill == nil {
 		return ErrNotStarted
 	}
 	wakeupCh, err := p.powerd.WatchWakeups()
@@ -169,18 +166,18 @@
 		return err
 	}
 	flightMode := p.urfkill.IsFlightMode()
-	wirelessEnabled := p.nm.GetWirelessEnabled()
+	wlanKillswitchState := p.urfkill.GetWLANKillswitchState()
 	flightModeCh, _, err := p.urfkill.WatchFlightMode()
 	if err != nil {
 		return err
 	}
-	wirelessEnabledCh, _, err := p.nm.WatchWirelessEnabled()
+	wlanKillswitchStateCh, _, err := p.urfkill.WatchWLANKillswitchState()
 	if err != nil {
 		return err
 	}
 
 	filteredWakeUpCh := make(chan bool)
-	go p.control(wakeupCh, filteredWakeUpCh, flightMode, flightModeCh, wirelessEnabled, wirelessEnabledCh)
+	go p.control(wakeupCh, filteredWakeUpCh, flightMode, flightModeCh, wlanKillswitchState, wlanKillswitchStateCh)
 	go p.run(filteredWakeUpCh, doneCh)
 	return nil
 }
@@ -198,7 +195,8 @@
 	return t, cookie, err
 }
 
-func (p *poller) control(wakeupCh <-chan bool, filteredWakeUpCh chan<- bool, flightMode bool, flightModeCh <-chan bool, wirelessEnabled bool, wirelessEnabledCh <-chan bool) {
+func (p *poller) control(wakeupCh <-chan bool, filteredWakeUpCh chan<- bool, flightMode bool, flightModeCh <-chan bool, wlanKillswitchState urfkill.KillswitchState, wlanKillswitchStateCh <-chan urfkill.KillswitchState) {
+	wirelessEnabled := wlanKillswitchState == urfkill.KillswitchStateUnblocked
 	dontPoll := flightMode && !wirelessEnabled
 	var t time.Time
 	cookie := ""
@@ -237,7 +235,8 @@
 				}
 			}
 		case flightMode = <-flightModeCh:
-		case wirelessEnabled = <-wirelessEnabledCh:
+		case wlanKillswitchState = <-wlanKillswitchStateCh:
+			wirelessEnabled = wlanKillswitchState == urfkill.KillswitchStateUnblocked
 		}
 		newDontPoll := flightMode && !wirelessEnabled
 		p.log.Debugf("control: flightMode:%v wirelessEnabled:%v prevDontPoll:%v dontPoll:%v wakeupReq:%v holdsWakeLock:%v", flightMode, wirelessEnabled, dontPoll, newDontPoll, !t.IsZero(), holdsWakeLock)

=== modified file 'poller/poller_test.go'
--- poller/poller_test.go	2015-03-30 15:59:19 +0000
+++ poller/poller_test.go	2015-04-30 15:00:25 +0000
@@ -21,6 +21,7 @@
 
 	. "launchpad.net/gocheck"
 
+	"launchpad.net/ubuntu-push/bus/urfkill"
 	"launchpad.net/ubuntu-push/client/session"
 	helpers "launchpad.net/ubuntu-push/testing"
 )
@@ -90,6 +91,11 @@
 	s.myd = &myD{}
 }
 
+const (
+	wlanOn  = urfkill.KillswitchStateUnblocked
+	wlanOff = urfkill.KillswitchStateSoftBlocked
+)
+
 func (s *PrSuite) TestStep(c *C) {
 	p := &poller{
 		times:                Times{},
@@ -111,7 +117,7 @@
 	ch := make(chan string)
 	// now, run
 	filteredWakeUpCh := make(chan bool)
-	go p.control(wakeupCh, filteredWakeUpCh, false, nil, true, nil)
+	go p.control(wakeupCh, filteredWakeUpCh, false, nil, wlanOn, nil)
 	go func() { ch <- p.step(filteredWakeUpCh, doneCh, "old cookie") }()
 	select {
 	case s := <-ch:
@@ -138,8 +144,8 @@
 	filteredWakeUpCh := make(chan bool)
 	s.myd.watchWakeCh = make(chan bool, 1)
 	flightModeCh := make(chan bool)
-	wirelessModeCh := make(chan bool)
-	go p.control(wakeUpCh, filteredWakeUpCh, false, flightModeCh, true, wirelessModeCh)
+	wlanKillswitchStateCh := make(chan urfkill.KillswitchState)
+	go p.control(wakeUpCh, filteredWakeUpCh, false, flightModeCh, wlanOn, wlanKillswitchStateCh)
 
 	// works
 	err := p.requestWakeup()
@@ -157,17 +163,17 @@
 
 	// flight mode
 	flightModeCh <- true
-	wirelessModeCh <- false
+	wlanKillswitchStateCh <- wlanOff
 	err = p.requestWakeup()
 	c.Assert(err, IsNil)
 	c.Check(s.myd.watchWakeCh, HasLen, 0)
 
 	// wireless on
-	wirelessModeCh <- true
+	wlanKillswitchStateCh <- wlanOn
 	c.Check(<-s.myd.watchWakeCh, Equals, true)
 
 	// wireless off
-	wirelessModeCh <- false
+	wlanKillswitchStateCh <- wlanOff
 	// pending wakeup was cleared
 	c.Check(<-s.myd.watchWakeCh, Equals, false)
 

=== modified file 'server/acceptance/acceptanceclient.go'
--- server/acceptance/acceptanceclient.go	2014-12-08 16:31:10 +0000
+++ server/acceptance/acceptanceclient.go	2015-04-30 15:00:25 +0000
@@ -18,6 +18,7 @@
 package acceptance
 
 import (
+	_ "crypto/sha512" // support sha384/512 certs
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
@@ -37,6 +38,7 @@
 	DeviceId        string
 	Model           string
 	ImageChannel    string
+	BuildNumber     int32
 	ServerAddr      string
 	ExchangeTimeout time.Duration
 	ReportPings     bool
@@ -106,14 +108,18 @@
 		return err
 	}
 	proto := protocol.NewProtocol0(conn)
+	info := map[string]interface{}{
+		"device":  sess.Model,
+		"channel": sess.ImageChannel,
+	}
+	if sess.BuildNumber != -1 {
+		info["build_number"] = sess.BuildNumber
+	}
 	err = proto.WriteMessage(protocol.ConnectMsg{
-		Type:     "connect",
-		DeviceId: sess.DeviceId,
-		Levels:   sess.Levels,
-		Info: map[string]interface{}{
-			"device":  sess.Model,
-			"channel": sess.ImageChannel,
-		},
+		Type:          "connect",
+		DeviceId:      sess.DeviceId,
+		Levels:        sess.Levels,
+		Info:          info,
 		Authorization: sess.Auth,
 		Cookie:        sess.GetCookie(),
 	})

=== modified file 'server/acceptance/kit/api.go'
--- server/acceptance/kit/api.go	2015-01-28 21:41:34 +0000
+++ server/acceptance/kit/api.go	2015-04-30 15:00:25 +0000
@@ -19,6 +19,7 @@
 
 import (
 	"bytes"
+	_ "crypto/sha512" // support sha384/512 certs
 	"crypto/tls"
 	"encoding/json"
 	"errors"

=== modified file 'server/acceptance/kit/cliloop.go'
--- server/acceptance/kit/cliloop.go	2014-08-20 19:48:59 +0000
+++ server/acceptance/kit/cliloop.go	2015-04-30 15:00:25 +0000
@@ -45,6 +45,7 @@
 	ReportPings  bool   `json:"reportPings" help:"report each Ping from the server"`
 	DeviceModel  string `json:"model" help:"device image model"`
 	ImageChannel string `json:"imageChannel" help:"image channel"`
+	BuildNumber  int32  `json:"buildNumber" help:"build number"`
 }
 
 func (cfg *Configuration) PickByTarget(what, productionValue, stagingValue string) (value string) {
@@ -75,6 +76,7 @@
 		"reportPings":      true,
 		"model":            "?",
 		"imageChannel":     "?",
+		"buildNumber":      -1,
 	}
 )
 
@@ -112,6 +114,7 @@
 		// flags
 		Model:        cfg.DeviceModel,
 		ImageChannel: cfg.ImageChannel,
+		BuildNumber:  cfg.BuildNumber,
 		ReportPings:  cfg.ReportPings,
 	}
 	cfgDir := filepath.Dir(flag.Lookup("cfg@").Value.String())

=== modified file 'server/acceptance/ssl/README'
--- server/acceptance/ssl/README	2014-09-01 14:48:03 +0000
+++ server/acceptance/ssl/README	2015-04-30 15:00:25 +0000
@@ -3,6 +3,6 @@
 
 Generated with:
 
-  go run /usr/lib/go/src/pkg/crypto/tls/generate_cert.go -ca -host push-delivery -rsa-bits 512 -duration 87600h
-
-and then renamed.
+  openssl req -x509 -nodes -newkey rsa:2048 -multivalue-rdn -sha384 -days 3650 -keyout testing.key -out testing.cert -subj "/O=Acme Co/CN=push-delivery/"
+
+

=== modified file 'server/acceptance/ssl/testing.cert'
--- server/acceptance/ssl/testing.cert	2014-09-01 14:48:03 +0000
+++ server/acceptance/ssl/testing.cert	2015-04-30 15:00:25 +0000
@@ -1,10 +1,19 @@
 -----BEGIN CERTIFICATE-----
-MIIBYzCCAQ+gAwIBAgIBADALBgkqhkiG9w0BAQUwEjEQMA4GA1UEChMHQWNtZSBD
-bzAeFw0xNDA4MjkxMjQyMDFaFw0yNDA4MjYxMjQyMDFaMBIxEDAOBgNVBAoTB0Fj
-bWUgQ28wXDANBgkqhkiG9w0BAQEFAANLADBIAkEA1FT6lkow0eky+Dnj2Z4nTrTF
-DgcKOt9Wr4B4gRH1bWmRqScOPxyHA5YodN7O1w8X8sdWko9puf59I1sWWr5LNwID
-AQABo1IwUDAOBgNVHQ8BAf8EBAMCAKQwEwYDVR0lBAwwCgYIKwYBBQUHAwEwDwYD
-VR0TAQH/BAUwAwEB/zAYBgNVHREEETAPgg1wdXNoLWRlbGl2ZXJ5MAsGCSqGSIb3
-DQEBBQNBABtWCdMFkhIO8+oM3vugOWle9WJZ1FCRWD+cMl76mI1lhmNF4lvEZG47
-xUjekA1+heU39WpOEzZSybrOdiEaGbI=
+MIIDJzCCAg+gAwIBAgIJAOFQ2INogVqRMA0GCSqGSIb3DQEBDAUAMCoxEDAOBgNV
+BAoMB0FjbWUgQ28xFjAUBgNVBAMMDXB1c2gtZGVsaXZlcnkwHhcNMTUwNDE1MTcx
+NjMyWhcNMjUwNDEyMTcxNjMyWjAqMRAwDgYDVQQKDAdBY21lIENvMRYwFAYDVQQD
+DA1wdXNoLWRlbGl2ZXJ5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+yPk8yurO/LVuzNE/BZy7katJt7V4exbr+pqUci4bLzPUNENJ+SsyZzvj0iwXtHG5
+JUM2F3zSe5XzGE+PqVuer2pN1ujgp3sVGVj/ZzLYbQo1xojTt8wHgJippWBczaq+
+IJ3lTQiAfjGyB1xMnpz97r/fpNLlLbpyYN9WyV60VVNExqMPQgBeXfjpZbSTcktu
+sC0522RC4nhManzdVP6PaSw1bUWdptvxBzar+kfL4rb3PqbfAQLn7fGplvZ86k8b
+sDeGT9Xa0oOAY9RGMxY6XdXzGmtd2DVGrynACgbalk4VWTre+7RtmFBIi+nmehWR
+rNu3GIXUWGx9K3+FRFSk1QIDAQABo1AwTjAdBgNVHQ4EFgQUjN2dS9quo9qDce5j
+RUpgh40OJhgwHwYDVR0jBBgwFoAUjN2dS9quo9qDce5jRUpgh40OJhgwDAYDVR0T
+BAUwAwEB/zANBgkqhkiG9w0BAQwFAAOCAQEAkyL9bA8KmEIdCso3uznPN6B+g9be
+kaxfWeskOHWDxq4h8sa2rcAIqP4uv60DKvE1QcJhXNJHKW35TXFB9a0bosc3eNVL
+Z28gEcie7yk04r2+h535CRtsgZUZ20Pr6qeNfiyrZeqGY3RHqkHfIztx0AxtYNXO
+N/dTikTVLKquHpMQs07rOgkRhr1lRVl1kAZ0fj7IdWpjvMsAo8RzfRJFom9TFFa+
+v3X6SAKwihDESPWRPzPtH6K/d8sRsiV3av2DlA20bUzhpi2S7FUXWAmzzzXk6wO3
+GoklmlJs5nuGebuDaQ2zKvHgNIaMJinMREdtDcVGf96HKdjgILvxjrdtyA==
 -----END CERTIFICATE-----

=== modified file 'server/acceptance/ssl/testing.key'
--- server/acceptance/ssl/testing.key	2014-09-01 14:48:03 +0000
+++ server/acceptance/ssl/testing.key	2015-04-30 15:00:25 +0000
@@ -1,9 +1,28 @@
------BEGIN RSA PRIVATE KEY-----
-MIIBOgIBAAJBANRU+pZKMNHpMvg549meJ060xQ4HCjrfVq+AeIER9W1pkaknDj8c
-hwOWKHTeztcPF/LHVpKPabn+fSNbFlq+SzcCAwEAAQJBAIOO+4xu/3yv/rKqO7C0
-Oyqa+pVMa1w60R0AfqmKFQTqiTgevM77uqjpW1+t0hpK20nyj6MUIPaL+9kZgp7t
-mnECIQDqw79PXSzudf10XGy9ve5bRazINHxQYgJ7FvlTT6JhdQIhAOeJxq9zcKni
-69ueO1ualz0hn8w6uHPsG9FlZ8C+7Jh7AiAWJgebjjfZ+4nA+6NKt2uQct9dOA5u
-awC+6ij1ojK4rQIgNEqAbcWDj0qpe8sLms+aEntSjJxCZiPP0IW3XeeApZsCIDwo
-x+YyxXQWJlf9L5TNYPRo+KFEdk3Cew0lv6QNs+xe
------END RSA PRIVATE KEY-----
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDI+TzK6s78tW7M
+0T8FnLuRq0m3tXh7Fuv6mpRyLhsvM9Q0Q0n5KzJnO+PSLBe0cbklQzYXfNJ7lfMY
+T4+pW56vak3W6OCnexUZWP9nMthtCjXGiNO3zAeAmKmlYFzNqr4gneVNCIB+MbIH
+XEyenP3uv9+k0uUtunJg31bJXrRVU0TGow9CAF5d+OlltJNyS26wLTnbZELieExq
+fN1U/o9pLDVtRZ2m2/EHNqv6R8vitvc+pt8BAuft8amW9nzqTxuwN4ZP1drSg4Bj
+1EYzFjpd1fMaa13YNUavKcAKBtqWThVZOt77tG2YUEiL6eZ6FZGs27cYhdRYbH0r
+f4VEVKTVAgMBAAECggEAZWViJ5qqTdOYEFwt6L334HnEGpzDKY8aBfkBlk3uxzTm
+BmxAoScLKgyMV9iJKTALUmKDovwGEfZIjOZvO+oOuL/wf9JErhsqPPyq9z0u9myl
+TwJvlxaoXlgnl1lz2QwhGsGvE9uLQKAACzilK41XjKJfyn/gwt6DoJ5t4fEXGMii
+Sw300qn41pb/5ZVCrELDrP1L97El6M2cjaE/bsspYUFGIPEY6NdVNovXmSW0L88X
+0r85WjsIq94sTyymx01QQrSz7HsihyKhYkh/BLd9rrGNPf/ztlTsXw71ebYCsowU
+coL46AsAkejosCawBDKEa1NCc0ojdNPXVb9eEoK7TQKBgQDm3BpbDsrLpmgTtuJQ
+2RzMgAqEVHHTq/GC89pPljfPLBsSRZU7BmSEXFTA4mulb81vUXmkBG+v7L2tzVSA
+PGaqz8qPfCgf09uN4mFDq51xaIpYrjYU5+YTsPpjYv0qwdXotDOcdkNKnx5CiZ7q
+A8KwJ4CrQ0EW9D9PA2DQt9XqOwKBgQDe2/gAM58HBpHYXW7K4er9RUmvLbNIils7
+ztZLkEGBENCCWGLwnx4R48HXO/XITlPb8oqv8EztTL0HceOoZZAerxl9QWUJpZ46
+Ba5uDY6lb1ntUMSRDmgX00JNooskolT0YGemCIMx2NwYMfmY+WWuqa1pK5k/z6FC
+fcKWph2sLwKBgEOrPKZ4PYVYL6Wns8rS+RgQaATF49+RxOcHp3Qwqgc1/HFsqAN3
+KjuJ/OXU+Iyzqtn4Xdlv23ULxcWOLDiye72RzuQkFnbN2MtMEgqN4UZ+yB6aYgva
+tZwMAjjjqSXBT3w4ZfB00eCrp2kFgelCVOzhh1usCQY7bdsxOE21tSRFAoGAFLPK
+bfpdo4FwuvCzAhXKhoyRM7zDEtIHd57XOV3FOAAf3nvndQLTAEZwE1Z2lozwLVZy
+m7Vu7/xY8wAZbeNBaBhL/d69TBAeirVMZtzLi4K0j98Y44C7Grt9RUj8NAMAcVMj
+TcEsrsy+ZWD/Fr7UO0131nU+Xzcie9LC6Mu1pfECgYEAh6G7eWd/TX26u9ZB0ZsS
+caFD+sut9nAWCTAR7KzZrumK5BiqcQwrKafQaKrl7RsEe0JlG9dEpJOnCG/CPkFj
+odfah1tuPYhk09QQRpSvTWlMQpyICd1ezsjDyZDQLsUSl7OxOoCmrzKieS8PdFYk
+OZ0Jl7ocnv+viqxetkictDM=
+-----END PRIVATE KEY-----

=== modified file 'server/broker/broker.go'
--- server/broker/broker.go	2014-09-25 11:16:38 +0000
+++ server/broker/broker.go	2015-04-30 15:00:25 +0000
@@ -60,7 +60,7 @@
 // LevelsMap is the type for holding channel levels for session.
 type LevelsMap map[store.InternalChannelId]int64
 
-// GetInfoString helps retrivieng a string out of a protocol.ConnectMsg.Info
+// GetInfoString helps retrieveng a string out of a protocol.ConnectMsg.Info.
 func GetInfoString(msg *protocol.ConnectMsg, name, defaultVal string) (string, error) {
 	v, ok := msg.Info[name]
 	if !ok {
@@ -73,6 +73,19 @@
 	return s, nil
 }
 
+// GetInfoInt helps retrieving an integer out of a protocol.ConnectMsg.Info.
+func GetInfoInt(msg *protocol.ConnectMsg, name string, defaultVal int) (int, error) {
+	v, ok := msg.Info[name]
+	if !ok {
+		return defaultVal, nil
+	}
+	n, ok := v.(float64)
+	if !ok {
+		return -1, ErrUnexpectedValue
+	}
+	return int(n), nil
+}
+
 // BrokerSession holds broker session state.
 type BrokerSession interface {
 	// SessionChannel returns the session control channel

=== modified file 'server/broker/broker_test.go'
--- server/broker/broker_test.go	2014-04-03 14:31:10 +0000
+++ server/broker/broker_test.go	2015-04-30 15:00:25 +0000
@@ -17,6 +17,7 @@
 package broker
 
 import (
+	"encoding/json"
 	"fmt"
 
 	. "launchpad.net/gocheck"
@@ -48,3 +49,20 @@
 	v, err = GetInfoString(connectMsg, "foo", "?")
 	c.Check(err, Equals, ErrUnexpectedValue)
 }
+
+func (s *brokerSuite) TestGetInfoInt(c *C) {
+	connectMsg := &protocol.ConnectMsg{}
+	v, err := GetInfoInt(connectMsg, "bar", -1)
+	c.Check(err, IsNil)
+	c.Check(v, Equals, -1)
+
+	err = json.Unmarshal([]byte(`{"bar": 233}`), &connectMsg.Info)
+	c.Assert(err, IsNil)
+	v, err = GetInfoInt(connectMsg, "bar", -1)
+	c.Check(err, IsNil)
+	c.Check(v, Equals, 233)
+
+	connectMsg.Info["bar"] = "garbage"
+	v, err = GetInfoInt(connectMsg, "bar", -1)
+	c.Check(err, Equals, ErrUnexpectedValue)
+}

=== modified file 'testing/tls.go'
--- testing/tls.go	2014-09-04 17:54:14 +0000
+++ testing/tls.go	2015-04-30 15:00:25 +0000
@@ -19,6 +19,7 @@
 import (
 	"crypto/tls"
 	"crypto/x509"
+	"io/ioutil"
 )
 
 // key&cert generated with go run /usr/lib/go/src/pkg/crypto/tls/generate_cert.go -ca -host push-delivery -rsa-bits 512 -duration 87600h
@@ -43,26 +44,112 @@
 DQEBBQNBABtWCdMFkhIO8+oM3vugOWle9WJZ1FCRWD+cMl76mI1lhmNF4lvEZG47
 xUjekA1+heU39WpOEzZSybrOdiEaGbI=
 -----END CERTIFICATE-----`)
-)
-
-// test tls server & client config
-var TestTLSServerConfig, TestTLSClientConfig *tls.Config
+
+	// key&cert generated with openssl req -x509 -nodes -newkey rsa:2048
+	// -multivalue-rdn -sha512 -days 3650 -keyout testing.key -out
+	// testing.cert -subj "/O=Acme Co/CN=push-delivery/"
+	TestKeyPEMBlock512 = []byte(`-----BEGIN PRIVATE KEY-----
+MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQC4ySO/avJFWps8
+AygUZ0dcylNr1UxZb4QPHuO93OXAkYX5ngw7TjnWIGHjvoLzLzPZCxlrGl7e+M1H
+GNZqFT3kFv/XYexp9Cx3MCDy0ZWkK9BAVDTAxMkjSR8ZwRjByQqniilDA/kr92NQ
+yaL0GlajsxpmcGMjDM0Dp5QF+inQM48ADJpJl0xlfFwE8CwfVVGM8G/ZtQpBJ3AN
+RelEG1iF8tsT9nVlWF37Zp9Wp/CxDDVTuzboZx9pkryOeJmm0l93x1aoSy6DTVyg
+zjdAOjKFjSsjY7we7x7GgpHuUtXymVH7OHdc0ji5+2O+yf9VEDxuym0fJJEgVLfX
+ungSHFxJAgMBAAECggEAeC2gyTqF7KM7+LDY3UQ6Plf8H1KvAC+txKPDXFURO8ep
+SaoHrH540RFoeNULl5uobc1xL54L+5n27/lwYbgE85YduHegaVx7mty7YRD78LTq
+ERxy3rhdVEyXJInYTxgwjLwnj8VCxdx0RDOPfpCurnKqhdssLryBjZHsjGKh1RzH
+bv5fNrqMhU0uH82cOKXy20uzyVo5zuLwWA+PxCEeOTMumpWgN4PmtMrjUot2t2/q
+jVoEkrB3B5Xs/s8OrEv10t90nNQPcKT89Kts/jdmgDNNg/dtILogiD4JshTG8fIB
+STUArRDCE0NXOmB0XuXRxk8YlZyBj2AsIUQcFRrOgQKBgQDrAkE77wIZcCJRYGxK
+KkB5zE5Lei44dKEHU5zIueOflsWFC+RZGWVn1+hTQw9Sk1kqm5atrDbfMZDOk62U
+bNcQLT+QqDRo3iSYLo9Q5hFNNxMGUm6RMHApr5iIZeoBFDZ7b4+zCEEFNtYukvjY
+DWyeTgUqftoOTDebHbHrk9w/0QKBgQDJSnnestarqjLXyF4RWzcFTsDjFgRv53Cq
+WrpiQUkk5JLlKliwoTAGTxzH2skJofT6OAQjrc5489mc5Gt6TVwWB49l+OzzG4H/
+QSe5X9I5BEEcdD27wDwsaO/NsusM9jZ4IjauTKR5XqGoepbrWrm7+lBgEe1DvBWx
+C71U7Eoq+QKBgQDNJT2+zMf/XrSGZu6A21tHN0KNfo2EeMLsu19clXCPKjUoDBZ8
+dL/ho0bKD/r7MWcf24vv9So9MW5f9egLbeta0rTvWPXPKUO2mMZAb2VhCxePaDve
+f/MZYJB9WMGpyXQ50kwVk7n2jETxiRiyuR09H4xA6VT+MChGPujGZV9ZUQKBgH7i
+06/uTCQqRaKAS8vlE+nkmvKLDoD8A6lfR95oCROYgoCzEPVGpl9Tv3C8Gb5YuXSB
+mxpilaTpEmQ0GQwfd8zrNxmwsK0OygN9ruzL2ljWtbSaEdAofcYA4Clqf4DMM8nG
+x3FYHtXjMURjAn+Z0TsNr1zf8BCin4nbPJ4r1RUBAoGBALFHLtEWwVxpm3MN4f08
+GtH2Phd289H0s5SaX/NaWYy44T+Q/d7LuYk72LWX1jZB/2V3OhiFzih0uK44PBM4
+Gaiu8c/vl+M1hixeOenTrapE4ORaYt76INIEC8JpqEvGi0DYkUH1D4F8zzAiejgF
+t+nz90UBRCRA8vtZ8fiwz8O0
+-----END PRIVATE KEY-----`)
+
+	TestCertPEMBlock512 = []byte(`-----BEGIN CERTIFICATE-----
+MIIDJzCCAg+gAwIBAgIJAP9ScfFaKlalMA0GCSqGSIb3DQEBDQUAMCoxEDAOBgNV
+BAoMB0FjbWUgQ28xFjAUBgNVBAMMDXB1c2gtZGVsaXZlcnkwHhcNMTUwNDE1MTYx
+MDM1WhcNMjUwNDEyMTYxMDM1WjAqMRAwDgYDVQQKDAdBY21lIENvMRYwFAYDVQQD
+DA1wdXNoLWRlbGl2ZXJ5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA
+uMkjv2ryRVqbPAMoFGdHXMpTa9VMWW+EDx7jvdzlwJGF+Z4MO0451iBh476C8y8z
+2QsZaxpe3vjNRxjWahU95Bb/12HsafQsdzAg8tGVpCvQQFQ0wMTJI0kfGcEYwckK
+p4opQwP5K/djUMmi9BpWo7MaZnBjIwzNA6eUBfop0DOPAAyaSZdMZXxcBPAsH1VR
+jPBv2bUKQSdwDUXpRBtYhfLbE/Z1ZVhd+2afVqfwsQw1U7s26GcfaZK8jniZptJf
+d8dWqEsug01coM43QDoyhY0rI2O8Hu8exoKR7lLV8plR+zh3XNI4uftjvsn/VRA8
+bsptHySRIFS317p4EhxcSQIDAQABo1AwTjAdBgNVHQ4EFgQUG2Qk9GbWWfSPXRTE
++cfOZMljydAwHwYDVR0jBBgwFoAUG2Qk9GbWWfSPXRTE+cfOZMljydAwDAYDVR0T
+BAUwAwEB/zANBgkqhkiG9w0BAQ0FAAOCAQEAUw36s8n8a39ECYUmSS5o+PdjmF1v
+6K6ld5n7IlFVwCtA1Rkz2L2AUrko/ao1/ZgKhHsIBFQ7mm5fkvuNd14ZEJ0F8LyI
+55Et63IYWYOPHl0oNmzTHex0WRL9nmNvxbQ5UytzGTE5amv/sZTOYH9qnpEes68O
+TPP+C3OoM+U6hjOXNGG73zb54JHQUZ4arMg2gbVzxNXU2ReoKYKrYexGGuqIlHcE
+XdOQp93oJfqWAj111YS6tIn63ccjx7bKzFzaufuVvCIsk0WrXG2rpuqx+0OYzRKc
+deU3hnONgWVXjCQdNysBzUXLeOWcv1KuqScETvGZe7D1UIk7HWsAgnQnYQ==
+-----END CERTIFICATE-----`)
+
+	// key&cert, same as server/acceptance/ssl/testing.*
+	TestKeyPEMBlockAcceptance []byte
+
+	TestCertPEMBlockAcceptance []byte
+)
+
+// test tls server & client configs
+var (
+	TestTLSServerConfigs                     = map[string]*tls.Config{}
+	TestTLSClientConfigs                     = map[string]*tls.Config{}
+	TestTLSServerConfig, TestTLSClientConfig *tls.Config
+)
 
 func init() {
-	cert, err := tls.X509KeyPair(TestCertPEMBlock, TestKeyPEMBlock)
-	if err != nil {
-		panic(err)
-	}
-	TestTLSServerConfig = &tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-	cp := x509.NewCertPool()
-	ok := cp.AppendCertsFromPEM(TestCertPEMBlock)
-	if !ok {
-		panic("failed to parse test cert")
-	}
-	TestTLSClientConfig = &tls.Config{
-		RootCAs:    cp,
-		ServerName: "push-delivery",
-	}
+	var err error
+	TestKeyPEMBlockAcceptance, err = ioutil.ReadFile(SourceRelative("../server/acceptance/ssl/testing.key"))
+	if err != nil {
+		panic(err)
+	}
+
+	TestCertPEMBlockAcceptance, err = ioutil.ReadFile(SourceRelative("../server/acceptance/ssl/testing.cert"))
+	if err != nil {
+		panic(err)
+	}
+
+	for _, cfgBits := range []struct {
+		label string
+		key   []byte
+		cert  []byte
+	}{
+		{"sha1", TestKeyPEMBlock, TestCertPEMBlock},
+		{"sha512", TestKeyPEMBlock512, TestCertPEMBlock512},
+		{"acceptance", TestKeyPEMBlockAcceptance, TestCertPEMBlockAcceptance},
+	} {
+		cert, err := tls.X509KeyPair(cfgBits.cert, cfgBits.key)
+		if err != nil {
+			panic(err)
+		}
+		tlsServerConfig := &tls.Config{
+			Certificates: []tls.Certificate{cert},
+		}
+		cp := x509.NewCertPool()
+		ok := cp.AppendCertsFromPEM(cfgBits.cert)
+		if !ok {
+			panic("failed to parse test cert")
+		}
+		tlsClientConfig := &tls.Config{
+			RootCAs:    cp,
+			ServerName: "push-delivery",
+		}
+		TestTLSClientConfigs[cfgBits.label] = tlsClientConfig
+		TestTLSServerConfigs[cfgBits.label] = tlsServerConfig
+	}
+	TestTLSClientConfig = TestTLSClientConfigs["sha1"]
+	TestTLSServerConfig = TestTLSServerConfigs["sha1"]
 }